fix(P.infer): Fix inference of array containing tuples

src/types/InvertPattern.ts

@@ -20,7 +20,6 @@ import {
   Call,
   Fn,
   ReadonlyArrayValue,
-  ExtractWithDefault,
   WithDefault,
 } from './helpers';
 import type { Matcher, Pattern, Override, AnyMatcher } from './Pattern';
@@ -141,7 +140,10 @@ type InvertPatternInternal<p, input> = 0 extends 1 & p
   : p extends Primitives
   ? p
   : p extends readonly any[]
-  ? InvertArrayPattern<p, ExtractWithDefault<input, readonly any[], unknown[]>>
+  ? InvertArrayPattern<
+      p,
+      WithDefault<Extract<input, readonly any[]>, unknown[]>
+    >
   : IsPlainObject<p> extends true
   ? OptionalKeys<p> extends infer optKeys
     ? [optKeys] extends [never]

src/types/helpers.ts

@@ -155,8 +155,6 @@ export type IntersectObjects<a> = (
 
 export type WithDefault<a, def> = [a] extends [never] ? def : a;
 
-export type ExtractWithDefault<a, b, def> = a extends b ? a : def;
-
 export type IsLiteral<a> = [a] extends [null | undefined]
   ? true
   : [a] extends [string]

tests/infer.test.ts

@@ -0,0 +1,25 @@
+import { P } from '../src';
+import { Equal, Expect } from '../src/types/helpers';
+
+describe('P.infer', () => {
+  describe('array', () => {
+    it('should correctly narrow types of arrays containing tuples', () => {
+      const QuizValue = P.union('initial', 'correct', 'incorrect');
+      const QuizState = {
+        answerEntries: P.array([P.string, QuizValue]),
+        appendOnlyAnswerEntries: P.array([P.string, P.array(QuizValue)]),
+      };
+
+      type QuizValue = P.infer<typeof QuizValue>;
+      type expected1 = 'initial' | 'correct' | 'incorrect';
+      type test1 = Expect<Equal<QuizValue, expected1>>;
+
+      type QuizState = P.infer<typeof QuizState>;
+      type expected2 = {
+        answerEntries: [string, QuizValue][];
+        appendOnlyAnswerEntries: [string, QuizValue[]][];
+      };
+      type test2 = Expect<Equal<QuizState, expected2>>;
+    });
+  });
+});

tests/readonly.test.ts

@@ -1,16 +1,5 @@
 import { match } from '../src';
-import { DeepExclude } from '../src/types/DeepExclude';
-import {
-  InvertPattern,
-  InvertPatternForExclude,
-} from '../src/types/InvertPattern';
-import { MatchedValue } from '../src/types/Pattern';
-import {
-  Equal,
-  Expect,
-  ExtractWithDefault,
-  IsReadonlyArray,
-} from '../src/types/helpers';
+import { Equal, Expect } from '../src/types/helpers';
 
 describe('readonly', () => {
   describe('exhaustive', () => {