Merge pull request #305 from gvergnaud/gvergnaud/fix-is-matching-union

fix(isMatching): Allow unknown properties in pattern

Author: gvergnaud

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-pattern",
-  "version": "5.6.0",
+  "version": "5.6.1",
   "description": " The exhaustive Pattern Matching library for TypeScript.",
   "type": "module",
   "source": "src/index.ts",
@@ -78,4 +78,4 @@
     "ts-jest": "^29.1.2",
     "typescript": "^5.7.2"
   }
-}
+}

package.json

@@ -1,4 +1,9 @@
-import { MatchedValue, Pattern } from './types/Pattern';
+import {
+  MatchedValue,
+  Pattern,
+  UnknownPattern,
+  UnknownProperties,
+} from './types/Pattern';
 import * as P from './patterns';
 import { matchPattern } from './internals/helpers';
 
@@ -33,10 +38,10 @@ export function isMatching<const p extends Pattern<unknown>>(
  *    return input.name
  *  }
  */
-export function isMatching<const T, const P extends P.Pattern<NoInfer<T>>>(
-  pattern: P,
-  value: T
-): value is P.infer<P>;
+export function isMatching<
+  const T,
+  const P extends P.Pattern<T> & UnknownProperties
+>(pattern: P, value: T): value is P.infer<P>;
 
 export function isMatching<const p extends Pattern<any>>(
   ...args: [pattern: p, value?: any]

src/is-matching.ts

@@ -126,11 +126,13 @@ export interface Override<a> {
   [symbols.override]: a;
 }
 
+export type UnknownProperties = { readonly [k: PropertyKey]: unknown };
+
 export type UnknownPattern =
   | readonly []
   | readonly [unknown, ...unknown[]]
   | readonly [...unknown[], unknown]
-  | { readonly [k: string]: unknown }
+  | UnknownProperties
   | Primitives
   | UnknownMatcher;
 

src/types/Pattern.ts

@@ -82,11 +82,28 @@ describe('isMatching', () => {
     const food = { type: 'pizza', topping: 'cheese' } as Food;
 
     isMatching(
-      {
-        // @ts-expect-error
-        type: 'oops',
-      },
+      // @ts-expect-error
+      { type: 'oops' },
       food
     );
   });
+
+  it('should allow patterns targetting one member of a union type', () => {
+    const food = { type: 'pizza', topping: 'cheese' } as Food;
+    expect(isMatching({ topping: 'cheese' }, food)).toBe(true);
+
+    if (isMatching({ topping: 'cheese' }, food)) {
+      type t = Expect<Equal<typeof food, Food & { topping: 'cheese' }>>;
+    }
+  });
+
+  it('should allow targetting unknown properties', () => {
+    const food = { type: 'pizza', topping: 'cheese' } as Food;
+
+    expect(isMatching({ unknownProp: P.instanceOf(Error) }, food)).toBe(false);
+
+    if (isMatching({ unknownProp: P.instanceOf(Error) }, food)) {
+      type t = Expect<Equal<typeof food, Food & { unknownProp: Error }>>;
+    }
+  });
 });