npm - @cjser/ts-pattern - Versions diffs - 5.9.0-cjser.2 - Mend

@cjser/ts-pattern 5.9.0-cjser.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/LICENSE +21 -0
package/README.md +1776 -0
package/dist/errors.d.cts +8 -0
package/dist/errors.d.ts +8 -0
package/dist/index.cjs +2 -0
package/dist/index.cjs.map +1 -0
package/dist/index.d.cts +5 -0
package/dist/index.d.ts +5 -0
package/dist/index.js +2 -0
package/dist/index.js.map +1 -0
package/dist/index.umd.js +2 -0
package/dist/index.umd.js.map +1 -0
package/dist/internals/helpers.d.cts +12 -0
package/dist/internals/helpers.d.ts +12 -0
package/dist/internals/symbols.d.cts +24 -0
package/dist/internals/symbols.d.ts +24 -0
package/dist/is-matching.d.cts +40 -0
package/dist/is-matching.d.ts +40 -0
package/dist/match.d.cts +19 -0
package/dist/match.d.ts +19 -0
package/dist/patterns.d.cts +345 -0
package/dist/patterns.d.ts +345 -0
package/dist/types/BuildMany.d.cts +22 -0
package/dist/types/BuildMany.d.ts +22 -0
package/dist/types/DeepExclude.d.cts +2 -0
package/dist/types/DeepExclude.d.ts +2 -0
package/dist/types/DistributeUnions.d.cts +111 -0
package/dist/types/DistributeUnions.d.ts +111 -0
package/dist/types/ExtractPreciseValue.d.cts +27 -0
package/dist/types/ExtractPreciseValue.d.ts +27 -0
package/dist/types/FindSelected.d.cts +78 -0
package/dist/types/FindSelected.d.ts +78 -0
package/dist/types/InvertPattern.d.cts +104 -0
package/dist/types/InvertPattern.d.ts +104 -0
package/dist/types/IsMatching.d.cts +13 -0
package/dist/types/IsMatching.d.ts +13 -0
package/dist/types/Match.d.cts +171 -0
package/dist/types/Match.d.ts +171 -0
package/dist/types/Pattern.d.cts +401 -0
package/dist/types/Pattern.d.ts +401 -0
package/dist/types/helpers.d.cts +80 -0
package/dist/types/helpers.d.ts +80 -0
package/dist/types/index.d.cts +1 -0
package/dist/types/index.d.ts +1 -0
package/dist-cjser/index.cjs +319 -0
package/package.json +135 -0

package/dist/types/BuildMany.d.cts ADDED Viewed

@@ -0,0 +1,22 @@
+import { Iterator, IsOptionalKeysOf, UpdateAt, ValueOf } from './helpers.cjs';
+export type BuildMany<data, xs extends readonly any[]> = xs extends any ? BuildOne<data, xs> : never;
+type BuildOne<data, xs extends readonly any[]> = xs extends [
+    [
+        infer value,
+        infer path
+    ],
+    ...infer tail
+] ? BuildOne<SetDeep<data, value, path>, tail> : data;
+export type SetDeep<data, value, path> = path extends readonly [
+    infer head,
+    ...infer tail
+] ? data extends readonly any[] ? data extends readonly [any, ...any] ? head extends number ? UpdateAt<data, Iterator<head>, SetDeep<data[head], value, tail>> : never : SetDeep<ValueOf<data>, value, tail>[] : data extends Set<infer a> ? Set<SetDeep<a, value, tail>> : data extends Map<infer k, infer v> ? Map<k, SetDeep<v, value, tail>> : head extends keyof data ? [
+    IsOptionalKeysOf<data, head>,
+    tail,
+    undefined
+] extends [true, [], value] ? {
+    [k in keyof data]: k extends head ? value : data[k];
+} : {
+    [k in keyof data]-?: k extends head ? SetDeep<data[head], value, tail> : data[k];
+} : data : value;
+export {};

package/dist/types/BuildMany.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { Iterator, IsOptionalKeysOf, UpdateAt, ValueOf } from './helpers.js';
+export type BuildMany<data, xs extends readonly any[]> = xs extends any ? BuildOne<data, xs> : never;
+type BuildOne<data, xs extends readonly any[]> = xs extends [
+    [
+        infer value,
+        infer path
+    ],
+    ...infer tail
+] ? BuildOne<SetDeep<data, value, path>, tail> : data;
+export type SetDeep<data, value, path> = path extends readonly [
+    infer head,
+    ...infer tail
+] ? data extends readonly any[] ? data extends readonly [any, ...any] ? head extends number ? UpdateAt<data, Iterator<head>, SetDeep<data[head], value, tail>> : never : SetDeep<ValueOf<data>, value, tail>[] : data extends Set<infer a> ? Set<SetDeep<a, value, tail>> : data extends Map<infer k, infer v> ? Map<k, SetDeep<v, value, tail>> : head extends keyof data ? [
+    IsOptionalKeysOf<data, head>,
+    tail,
+    undefined
+] extends [true, [], value] ? {
+    [k in keyof data]: k extends head ? value : data[k];
+} : {
+    [k in keyof data]-?: k extends head ? SetDeep<data[head], value, tail> : data[k];
+} : data : value;
+export {};

package/dist/types/DeepExclude.d.cts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { DistributeMatchingUnions } from './DistributeUnions.cjs';
2	+ export type DeepExclude<a, b> = Exclude<DistributeMatchingUnions<a, b>, b>;

package/dist/types/DeepExclude.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { DistributeMatchingUnions } from './DistributeUnions.js';
2	+ export type DeepExclude<a, b> = Exclude<DistributeMatchingUnions<a, b>, b>;

package/dist/types/DistributeUnions.d.cts ADDED Viewed

@@ -0,0 +1,111 @@
+import { BuildMany } from './BuildMany.cjs';
+import type { IsAny, Values, Flatten, IsUnion, IsPlainObject, Length, UnionToTuple, IsReadonlyArray, ValueOf, MaybeAddReadonly, IsStrictArray } from './helpers.cjs';
+import { IsMatching } from './IsMatching.cjs';
+/**
+ * DistributeMatchingUnions takes two arguments:
+ * - a data structure of type `a` containing unions
+ * - a pattern `p`, matching this data structure
+ * and turns it into a union of all possible
+ * combination of each unions contained in `a` that matches `p`.
+ *
+ * It does this in 3 main steps:
+ *  - 1. Find all unions contained in the data structure, that matches `p`
+ *    with `FindUnions<a, p>`. It returns a tree of [union, path] pairs.
+ *  - 2. this tree is passed to the `Distribute` type level function,
+ *    Which turns it into a union of list of `[singleValue, path]` pairs.
+ *    Each list correspond to one of the possible combination of the unions
+ *    found in `a`.
+ *  - 3. build a data structure with the same shape as `a` for each combination
+ *    and return the union of these data structures.
+ *
+ * @example
+ * type t1 = DistributeMatchingUnions<['a' | 'b', 1 | 2], ['a', 1]>;
+ * // => ['a', 1] | ['a', 2] | ['b', 1] | ['b', 2]
+ *
+ * type t2 = DistributeMatchingUnions<['a' | 'b', 1 | 2], ['a', unknown]>;
+ * // => ['a', 1 | 2] | ['b', 1 | 2]
+ */
+export type DistributeMatchingUnions<a, p> = IsAny<a> extends true ? any : BuildMany<a, Distribute<FindUnionsMany<a, p>>>;
+export type FindUnionsMany<a, p, path extends PropertyKey[] = []> = UnionToTuple<(p extends any ? IsMatching<a, p> extends true ? FindUnions<a, p, path> : [] : never) extends readonly (infer T)[] ? T : never>;
+/**
+ * The reason we don't look further down the tree with lists,
+ * Set and Maps is that they can be heterogeneous,
+ * so matching on a A[] for a in input of (A|B)[]
+ * doesn't rule anything out. You can still have
+ * a (A|B)[] afterward. The same logic goes for Set and Maps.
+ *
+ * Kinds are types of types.
+ *
+ * kind UnionConfig = {
+ *  cases: Union<{
+ *    value: b,
+ *    subUnions: UnionConfig[]
+ *  }>,
+ *  path: string[]
+ * }
+ * FindUnions :: Pattern a p => a -> p -> UnionConfig[]
+ */
+export type FindUnions<a, p, path extends PropertyKey[] = []> = unknown extends p ? [] : IsAny<p> extends true ? [] : Length<path> extends 5 ? [] : IsUnion<a> extends true ? [
+    {
+        cases: a extends any ? {
+            value: a;
+            subUnions: FindUnionsMany<a, p, path>;
+        } : never;
+        path: path;
+    }
+] : [a, p] extends [readonly any[], readonly any[]] ? [a, p] extends [
+    readonly [infer a1, infer a2, infer a3, infer a4, infer a5],
+    readonly [infer p1, infer p2, infer p3, infer p4, infer p5]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>,
+    ...FindUnions<a4, p4, [...path, 3]>,
+    ...FindUnions<a5, p5, [...path, 4]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2, infer a3, infer a4],
+    readonly [infer p1, infer p2, infer p3, infer p4]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>,
+    ...FindUnions<a4, p4, [...path, 3]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2, infer a3],
+    readonly [infer p1, infer p2, infer p3]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2],
+    readonly [infer p1, infer p2]
+] ? [...FindUnions<a1, p1, [...path, 0]>, ...FindUnions<a2, p2, [...path, 1]>] : [a, p] extends [readonly [infer a1], readonly [infer p1]] ? FindUnions<a1, p1, [...path, 0]> : p extends readonly [] | readonly [any, ...any] | readonly [...any, any] ? IsStrictArray<Extract<a, readonly any[]>> extends false ? [] : [
+    ArrayToVariadicUnion<a, p> extends infer aUnion ? {
+        cases: aUnion extends any ? {
+            value: aUnion;
+            subUnions: [];
+        } : never;
+        path: path;
+    } : never
+] : [] : a extends Set<any> ? [] : a extends Map<any, any> ? [] : [IsPlainObject<a>, IsPlainObject<p>] extends [true, true] ? Flatten<Values<{
+    [k in keyof a & keyof p]: FindUnions<a[k], p[k], [...path, k]>;
+}>> : [];
+export type ArrayToVariadicUnion<input, excluded> = MaybeAddReadonly<(input extends readonly [any, ...any] | readonly [...any, any] ? never : []) | (excluded extends readonly [...any, any] ? [...Extract<input, readonly any[]>, ValueOf<input>] : [ValueOf<input>, ...Extract<input, readonly any[]>]), IsReadonlyArray<input>>;
+export type Distribute<unions extends readonly any[]> = unions extends readonly [
+    {
+        cases: infer cases;
+        path: infer path;
+    },
+    ...infer tail
+] ? cases extends {
+    value: infer value;
+    subUnions: infer subUnions;
+} ? [
+    [
+        value,
+        path
+    ],
+    ...Distribute<Extract<subUnions, readonly any[]>>,
+    ...Distribute<tail>
+] : never : [];

package/dist/types/DistributeUnions.d.ts ADDED Viewed

@@ -0,0 +1,111 @@
+import { BuildMany } from './BuildMany.js';
+import type { IsAny, Values, Flatten, IsUnion, IsPlainObject, Length, UnionToTuple, IsReadonlyArray, ValueOf, MaybeAddReadonly, IsStrictArray } from './helpers.js';
+import { IsMatching } from './IsMatching.js';
+/**
+ * DistributeMatchingUnions takes two arguments:
+ * - a data structure of type `a` containing unions
+ * - a pattern `p`, matching this data structure
+ * and turns it into a union of all possible
+ * combination of each unions contained in `a` that matches `p`.
+ *
+ * It does this in 3 main steps:
+ *  - 1. Find all unions contained in the data structure, that matches `p`
+ *    with `FindUnions<a, p>`. It returns a tree of [union, path] pairs.
+ *  - 2. this tree is passed to the `Distribute` type level function,
+ *    Which turns it into a union of list of `[singleValue, path]` pairs.
+ *    Each list correspond to one of the possible combination of the unions
+ *    found in `a`.
+ *  - 3. build a data structure with the same shape as `a` for each combination
+ *    and return the union of these data structures.
+ *
+ * @example
+ * type t1 = DistributeMatchingUnions<['a' | 'b', 1 | 2], ['a', 1]>;
+ * // => ['a', 1] | ['a', 2] | ['b', 1] | ['b', 2]
+ *
+ * type t2 = DistributeMatchingUnions<['a' | 'b', 1 | 2], ['a', unknown]>;
+ * // => ['a', 1 | 2] | ['b', 1 | 2]
+ */
+export type DistributeMatchingUnions<a, p> = IsAny<a> extends true ? any : BuildMany<a, Distribute<FindUnionsMany<a, p>>>;
+export type FindUnionsMany<a, p, path extends PropertyKey[] = []> = UnionToTuple<(p extends any ? IsMatching<a, p> extends true ? FindUnions<a, p, path> : [] : never) extends readonly (infer T)[] ? T : never>;
+/**
+ * The reason we don't look further down the tree with lists,
+ * Set and Maps is that they can be heterogeneous,
+ * so matching on a A[] for a in input of (A|B)[]
+ * doesn't rule anything out. You can still have
+ * a (A|B)[] afterward. The same logic goes for Set and Maps.
+ *
+ * Kinds are types of types.
+ *
+ * kind UnionConfig = {
+ *  cases: Union<{
+ *    value: b,
+ *    subUnions: UnionConfig[]
+ *  }>,
+ *  path: string[]
+ * }
+ * FindUnions :: Pattern a p => a -> p -> UnionConfig[]
+ */
+export type FindUnions<a, p, path extends PropertyKey[] = []> = unknown extends p ? [] : IsAny<p> extends true ? [] : Length<path> extends 5 ? [] : IsUnion<a> extends true ? [
+    {
+        cases: a extends any ? {
+            value: a;
+            subUnions: FindUnionsMany<a, p, path>;
+        } : never;
+        path: path;
+    }
+] : [a, p] extends [readonly any[], readonly any[]] ? [a, p] extends [
+    readonly [infer a1, infer a2, infer a3, infer a4, infer a5],
+    readonly [infer p1, infer p2, infer p3, infer p4, infer p5]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>,
+    ...FindUnions<a4, p4, [...path, 3]>,
+    ...FindUnions<a5, p5, [...path, 4]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2, infer a3, infer a4],
+    readonly [infer p1, infer p2, infer p3, infer p4]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>,
+    ...FindUnions<a4, p4, [...path, 3]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2, infer a3],
+    readonly [infer p1, infer p2, infer p3]
+] ? [
+    ...FindUnions<a1, p1, [...path, 0]>,
+    ...FindUnions<a2, p2, [...path, 1]>,
+    ...FindUnions<a3, p3, [...path, 2]>
+] : [a, p] extends [
+    readonly [infer a1, infer a2],
+    readonly [infer p1, infer p2]
+] ? [...FindUnions<a1, p1, [...path, 0]>, ...FindUnions<a2, p2, [...path, 1]>] : [a, p] extends [readonly [infer a1], readonly [infer p1]] ? FindUnions<a1, p1, [...path, 0]> : p extends readonly [] | readonly [any, ...any] | readonly [...any, any] ? IsStrictArray<Extract<a, readonly any[]>> extends false ? [] : [
+    ArrayToVariadicUnion<a, p> extends infer aUnion ? {
+        cases: aUnion extends any ? {
+            value: aUnion;
+            subUnions: [];
+        } : never;
+        path: path;
+    } : never
+] : [] : a extends Set<any> ? [] : a extends Map<any, any> ? [] : [IsPlainObject<a>, IsPlainObject<p>] extends [true, true] ? Flatten<Values<{
+    [k in keyof a & keyof p]: FindUnions<a[k], p[k], [...path, k]>;
+}>> : [];
+export type ArrayToVariadicUnion<input, excluded> = MaybeAddReadonly<(input extends readonly [any, ...any] | readonly [...any, any] ? never : []) | (excluded extends readonly [...any, any] ? [...Extract<input, readonly any[]>, ValueOf<input>] : [ValueOf<input>, ...Extract<input, readonly any[]>]), IsReadonlyArray<input>>;
+export type Distribute<unions extends readonly any[]> = unions extends readonly [
+    {
+        cases: infer cases;
+        path: infer path;
+    },
+    ...infer tail
+] ? cases extends {
+    value: infer value;
+    subUnions: infer subUnions;
+} ? [
+    [
+        value,
+        path
+    ],
+    ...Distribute<Extract<subUnions, readonly any[]>>,
+    ...Distribute<tail>
+] : never : [];

package/dist/types/ExtractPreciseValue.d.cts ADDED Viewed

@@ -0,0 +1,27 @@
+import type { Override } from './Pattern.cjs';
+import type { BuiltInObjects, Compute, Contains, IsPlainObject, IsReadonlyArray, LeastUpperBound, MaybeAddReadonly, ValueOf } from './helpers.cjs';
+export type ExtractPreciseValue<a, b> = b extends Override<infer b1> ? b1 : unknown extends b ? a : 0 extends 1 & b ? a : 0 extends 1 & a ? b : b extends readonly any[] ? ExtractPreciseArrayValue<a, b, IsReadonlyArray<a>> : b extends Map<infer bk, infer bv> ? a extends Map<infer ak, infer av> ? Map<ExtractPreciseValue<ak, bk>, ExtractPreciseValue<av, bv>> : LeastUpperBound<a, b> : b extends Set<infer bv> ? a extends Set<infer av> ? Set<ExtractPreciseValue<av, bv>> : LeastUpperBound<a, b> : IsPlainObject<b, BuiltInObjects | Error> extends true ? a extends object ? a extends b ? a : b extends a ? Contains<b, never> extends true ? never : Contains<Omit<b, keyof a>, {}> extends true ? never : [
+    Exclude<keyof a, keyof b>
+] extends [never] ? b : Compute<b & Omit<a, keyof b>> : [keyof a & keyof b] extends [never] ? never : Compute<{
+    [k in keyof a as k extends keyof b ? never : k]: a[k];
+} & {
+    [k in keyof b]: k extends keyof a ? ExtractPreciseValue<a[k], b[k]> : b[k];
+}> extends infer result ? Contains<Pick<result, keyof result & keyof b>, never> extends true ? never : result : never : LeastUpperBound<a, b> : LeastUpperBound<a, b>;
+type ExtractPreciseArrayValue<a, b, isReadonly extends boolean, startOutput extends any[] = [], endOutput extends any[] = []> = a extends readonly (infer aItem)[] ? b extends readonly [] ? MaybeAddReadonly<[...startOutput, ...endOutput], isReadonly> : b extends readonly [infer b1, ...infer bRest] ? a extends readonly [infer a1, ...infer aRest] ? ExtractPreciseValue<a1, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aRest, bRest, isReadonly, [
+    ...startOutput,
+    currentValue
+], endOutput> : never : ExtractPreciseValue<aItem, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aItem[], bRest, isReadonly, [
+    ...startOutput,
+    currentValue
+], endOutput> : never : b extends readonly [...infer bInit, infer b1] ? a extends readonly [...infer aInit, infer a1] ? ExtractPreciseValue<a1, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aInit, bInit, isReadonly, startOutput, [
+    ...endOutput,
+    currentValue
+]> : never : ExtractPreciseValue<aItem, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aItem[], bInit, isReadonly, startOutput, [
+    ...endOutput,
+    currentValue
+]> : never : ExtractPreciseValue<aItem, ValueOf<b>> extends infer currentValue ? [currentValue] extends [never] ? never : MaybeAddReadonly<[
+    ...startOutput,
+    ...currentValue[],
+    ...endOutput
+], isReadonly> : never : LeastUpperBound<a, b>;
+export {};

package/dist/types/ExtractPreciseValue.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import type { Override } from './Pattern.js';
+import type { BuiltInObjects, Compute, Contains, IsPlainObject, IsReadonlyArray, LeastUpperBound, MaybeAddReadonly, ValueOf } from './helpers.js';
+export type ExtractPreciseValue<a, b> = b extends Override<infer b1> ? b1 : unknown extends b ? a : 0 extends 1 & b ? a : 0 extends 1 & a ? b : b extends readonly any[] ? ExtractPreciseArrayValue<a, b, IsReadonlyArray<a>> : b extends Map<infer bk, infer bv> ? a extends Map<infer ak, infer av> ? Map<ExtractPreciseValue<ak, bk>, ExtractPreciseValue<av, bv>> : LeastUpperBound<a, b> : b extends Set<infer bv> ? a extends Set<infer av> ? Set<ExtractPreciseValue<av, bv>> : LeastUpperBound<a, b> : IsPlainObject<b, BuiltInObjects | Error> extends true ? a extends object ? a extends b ? a : b extends a ? Contains<b, never> extends true ? never : Contains<Omit<b, keyof a>, {}> extends true ? never : [
+    Exclude<keyof a, keyof b>
+] extends [never] ? b : Compute<b & Omit<a, keyof b>> : [keyof a & keyof b] extends [never] ? never : Compute<{
+    [k in keyof a as k extends keyof b ? never : k]: a[k];
+} & {
+    [k in keyof b]: k extends keyof a ? ExtractPreciseValue<a[k], b[k]> : b[k];
+}> extends infer result ? Contains<Pick<result, keyof result & keyof b>, never> extends true ? never : result : never : LeastUpperBound<a, b> : LeastUpperBound<a, b>;
+type ExtractPreciseArrayValue<a, b, isReadonly extends boolean, startOutput extends any[] = [], endOutput extends any[] = []> = a extends readonly (infer aItem)[] ? b extends readonly [] ? MaybeAddReadonly<[...startOutput, ...endOutput], isReadonly> : b extends readonly [infer b1, ...infer bRest] ? a extends readonly [infer a1, ...infer aRest] ? ExtractPreciseValue<a1, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aRest, bRest, isReadonly, [
+    ...startOutput,
+    currentValue
+], endOutput> : never : ExtractPreciseValue<aItem, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aItem[], bRest, isReadonly, [
+    ...startOutput,
+    currentValue
+], endOutput> : never : b extends readonly [...infer bInit, infer b1] ? a extends readonly [...infer aInit, infer a1] ? ExtractPreciseValue<a1, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aInit, bInit, isReadonly, startOutput, [
+    ...endOutput,
+    currentValue
+]> : never : ExtractPreciseValue<aItem, b1> extends infer currentValue ? [currentValue] extends [never] ? never : ExtractPreciseArrayValue<aItem[], bInit, isReadonly, startOutput, [
+    ...endOutput,
+    currentValue
+]> : never : ExtractPreciseValue<aItem, ValueOf<b>> extends infer currentValue ? [currentValue] extends [never] ? never : MaybeAddReadonly<[
+    ...startOutput,
+    ...currentValue[],
+    ...endOutput
+], isReadonly> : never : LeastUpperBound<a, b>;
+export {};

package/dist/types/FindSelected.d.cts ADDED Viewed

@@ -0,0 +1,78 @@
+import type * as symbols from '../internals/symbols.cjs';
+import type { AnyMatcher, Matcher, Pattern } from './Pattern.cjs';
+import type { Equal, Primitives, ValueOf, MergeUnion, IsUnion } from './helpers.cjs';
+type SelectionsRecord = Record<string, [unknown, unknown[]]>;
+export type None = {
+    type: 'none';
+};
+export type Some<key extends string> = {
+    type: 'some';
+    key: key;
+};
+export type SelectionType = None | Some<string>;
+type MapOptional<selections> = {
+    [k in keyof selections]: selections[k] extends [infer v, infer subpath] ? [v | undefined, subpath] : never;
+};
+type MapList<selections> = {
+    [k in keyof selections]: selections[k] extends [infer v, infer subpath] ? [v[], subpath] : never;
+};
+type ReduceFindSelectionUnion<i, ps extends readonly any[], output = never> = ps extends readonly [infer head, ...infer tail] ? ReduceFindSelectionUnion<i, tail, output | FindSelectionUnion<i, head>> : output;
+type FindSelectionUnionInArray<i, p, path extends any[] = [], output = never> = i extends readonly (infer iItem)[] ? p extends readonly [] ? output : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? FindSelectionUnionInArray<iRest, pRest, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<i1, p1, [...path, p['length']]>> : FindSelectionUnionInArray<iItem[], pRest, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<iItem, p1, [...path, p['length']]>> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? FindSelectionUnionInArray<iInit, pInit, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<i1, p1, [...path, p['length']]>> : FindSelectionUnionInArray<iItem[], pInit, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<iItem, p1, [...path, p['length']]>> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? output | FindSelectionUnion<i, pRest, [...path, p['length']]> : output | FindSelectionUnion<iItem, ValueOf<p>, [
+    ...path,
+    Extract<p, readonly any[]>['length']
+]> : output;
+export type FindSelectionUnion<i, p, path extends any[] = []> = 0 extends 1 & i ? never : 0 extends 1 & p ? never : p extends Primitives ? never : p extends Matcher<any, infer pattern, infer matcherType, infer sel> ? {
+    select: sel extends Some<infer k> ? {
+        [kk in k]: [i, path];
+    } | FindSelectionUnion<i, pattern, path> : never;
+    array: i extends readonly (infer iItem)[] ? MapList<FindSelectionUnion<iItem, pattern>> : never;
+    record: [i, pattern] extends [
+        Record<infer k, infer v>,
+        [
+            infer pkey,
+            infer pvalue
+        ]
+    ] ? MapList<FindSelectionUnion<k, pkey, path>> | MapList<FindSelectionUnion<v, pvalue, path>> : never;
+    map: [i, pattern] extends [
+        Map<infer k, infer v>,
+        [
+            infer pkey,
+            infer pvalue
+        ]
+    ] ? MapList<FindSelectionUnion<k, pkey, path>> | MapList<FindSelectionUnion<v, pvalue, path>> : never;
+    set: i extends Set<infer v> ? MapList<FindSelectionUnion<v, pattern, path>> : never;
+    optional: MapOptional<FindSelectionUnion<i, pattern>>;
+    or: MapOptional<ReduceFindSelectionUnion<i, Extract<pattern, readonly any[]>>>;
+    and: ReduceFindSelectionUnion<i, Extract<pattern, readonly any[]>>;
+    not: never;
+    default: sel extends Some<infer k> ? {
+        [kk in k]: [i, path];
+    } : never;
+    custom: never;
+}[matcherType] : p extends readonly any[] ? FindSelectionUnionInArray<i, p> : p extends {} ? i extends {} ? {
+    [k in keyof p]: k extends keyof i ? FindSelectionUnion<i[k], p[k], [...path, k]> : never;
+}[keyof p] : never : never;
+export type SeveralAnonymousSelectError<a = 'You can only use a single anonymous selection (with `select()`) in your pattern. If you need to select multiple values, give them names with `select(<name>)` instead'> = {
+    __error: never;
+} & a;
+export type MixedNamedAndAnonymousSelectError<a = 'Mixing named selections (`select("name")`) and anonymous selections (`select()`) is forbiden. Please, only use named selections.'> = {
+    __error: never;
+} & a;
+export type SelectionToArgs<selections extends SelectionsRecord> = symbols.anonymousSelectKey extends keyof selections ? IsUnion<selections[symbols.anonymousSelectKey][1]> extends true ? SeveralAnonymousSelectError : keyof selections extends symbols.anonymousSelectKey ? selections[symbols.anonymousSelectKey][0] : MixedNamedAndAnonymousSelectError : {
+    [k in keyof selections]: selections[k][0];
+};
+export type Selections<i, p> = FindSelectionUnion<i, p> extends infer u ? [u] extends [never] ? i : SelectionToArgs<Extract<MergeUnion<u>, SelectionsRecord>> : i;
+export type FindSelected<i, p> = Equal<p, Pattern<i>> extends true ? i : Selections<i, p>;
+export {};

package/dist/types/FindSelected.d.ts ADDED Viewed

@@ -0,0 +1,78 @@
+import type * as symbols from '../internals/symbols.js';
+import type { AnyMatcher, Matcher, Pattern } from './Pattern.js';
+import type { Equal, Primitives, ValueOf, MergeUnion, IsUnion } from './helpers.js';
+type SelectionsRecord = Record<string, [unknown, unknown[]]>;
+export type None = {
+    type: 'none';
+};
+export type Some<key extends string> = {
+    type: 'some';
+    key: key;
+};
+export type SelectionType = None | Some<string>;
+type MapOptional<selections> = {
+    [k in keyof selections]: selections[k] extends [infer v, infer subpath] ? [v | undefined, subpath] : never;
+};
+type MapList<selections> = {
+    [k in keyof selections]: selections[k] extends [infer v, infer subpath] ? [v[], subpath] : never;
+};
+type ReduceFindSelectionUnion<i, ps extends readonly any[], output = never> = ps extends readonly [infer head, ...infer tail] ? ReduceFindSelectionUnion<i, tail, output | FindSelectionUnion<i, head>> : output;
+type FindSelectionUnionInArray<i, p, path extends any[] = [], output = never> = i extends readonly (infer iItem)[] ? p extends readonly [] ? output : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? FindSelectionUnionInArray<iRest, pRest, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<i1, p1, [...path, p['length']]>> : FindSelectionUnionInArray<iItem[], pRest, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<iItem, p1, [...path, p['length']]>> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? FindSelectionUnionInArray<iInit, pInit, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<i1, p1, [...path, p['length']]>> : FindSelectionUnionInArray<iItem[], pInit, [
+    ...path,
+    p['length']
+], output | FindSelectionUnion<iItem, p1, [...path, p['length']]>> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? output | FindSelectionUnion<i, pRest, [...path, p['length']]> : output | FindSelectionUnion<iItem, ValueOf<p>, [
+    ...path,
+    Extract<p, readonly any[]>['length']
+]> : output;
+export type FindSelectionUnion<i, p, path extends any[] = []> = 0 extends 1 & i ? never : 0 extends 1 & p ? never : p extends Primitives ? never : p extends Matcher<any, infer pattern, infer matcherType, infer sel> ? {
+    select: sel extends Some<infer k> ? {
+        [kk in k]: [i, path];
+    } | FindSelectionUnion<i, pattern, path> : never;
+    array: i extends readonly (infer iItem)[] ? MapList<FindSelectionUnion<iItem, pattern>> : never;
+    record: [i, pattern] extends [
+        Record<infer k, infer v>,
+        [
+            infer pkey,
+            infer pvalue
+        ]
+    ] ? MapList<FindSelectionUnion<k, pkey, path>> | MapList<FindSelectionUnion<v, pvalue, path>> : never;
+    map: [i, pattern] extends [
+        Map<infer k, infer v>,
+        [
+            infer pkey,
+            infer pvalue
+        ]
+    ] ? MapList<FindSelectionUnion<k, pkey, path>> | MapList<FindSelectionUnion<v, pvalue, path>> : never;
+    set: i extends Set<infer v> ? MapList<FindSelectionUnion<v, pattern, path>> : never;
+    optional: MapOptional<FindSelectionUnion<i, pattern>>;
+    or: MapOptional<ReduceFindSelectionUnion<i, Extract<pattern, readonly any[]>>>;
+    and: ReduceFindSelectionUnion<i, Extract<pattern, readonly any[]>>;
+    not: never;
+    default: sel extends Some<infer k> ? {
+        [kk in k]: [i, path];
+    } : never;
+    custom: never;
+}[matcherType] : p extends readonly any[] ? FindSelectionUnionInArray<i, p> : p extends {} ? i extends {} ? {
+    [k in keyof p]: k extends keyof i ? FindSelectionUnion<i[k], p[k], [...path, k]> : never;
+}[keyof p] : never : never;
+export type SeveralAnonymousSelectError<a = 'You can only use a single anonymous selection (with `select()`) in your pattern. If you need to select multiple values, give them names with `select(<name>)` instead'> = {
+    __error: never;
+} & a;
+export type MixedNamedAndAnonymousSelectError<a = 'Mixing named selections (`select("name")`) and anonymous selections (`select()`) is forbiden. Please, only use named selections.'> = {
+    __error: never;
+} & a;
+export type SelectionToArgs<selections extends SelectionsRecord> = symbols.anonymousSelectKey extends keyof selections ? IsUnion<selections[symbols.anonymousSelectKey][1]> extends true ? SeveralAnonymousSelectError : keyof selections extends symbols.anonymousSelectKey ? selections[symbols.anonymousSelectKey][0] : MixedNamedAndAnonymousSelectError : {
+    [k in keyof selections]: selections[k][0];
+};
+export type Selections<i, p> = FindSelectionUnion<i, p> extends infer u ? [u] extends [never] ? i : SelectionToArgs<Extract<MergeUnion<u>, SelectionsRecord>> : i;
+export type FindSelected<i, p> = Equal<p, Pattern<i>> extends true ? i : Selections<i, p>;
+export {};

package/dist/types/InvertPattern.d.cts ADDED Viewed

@@ -0,0 +1,104 @@
+import { DeepExclude } from './DeepExclude.cjs';
+import { IsPlainObject, Primitives, IsLiteral, ValueOf, Compute, Equal, Extends, Not, All, NonLiteralPrimitive, MaybeAddReadonly, IsReadonlyArray, MapKey, MapValue, SetValue, ExtractPlainObject, GetKey, Call, Fn, ReadonlyArrayValue, WithDefault, RecordKey, RecordValue } from './helpers.cjs';
+import type { Matcher, Pattern, Override, AnyMatcher } from './Pattern.cjs';
+type OptionalKeys<p> = ValueOf<{
+    [k in keyof p]: 0 extends 1 & p[k] ? never : p[k] extends Matcher<any, any, infer matcherType> ? matcherType extends 'optional' ? k : never : never;
+}>;
+type ReduceUnion<tuple extends readonly any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnion<tail, i, output | InvertPatternInternal<p, i>> : output;
+type ReduceIntersection<tuple extends readonly any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersection<tail, i, output & InvertPatternInternal<p, i>> : output;
+type InvertArrayPattern<p, i, startOutput extends any[] = [], endOutput extends any[] = []> = i extends readonly (infer ii)[] ? p extends readonly [] ? [...startOutput, ...endOutput] : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? InvertArrayPattern<pRest, iRest, [
+    ...startOutput,
+    InvertPatternInternal<p1, i1>
+], endOutput> : InvertArrayPattern<pRest, ii[], [
+    ...startOutput,
+    InvertPatternInternal<p1, ii>
+], endOutput> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? InvertArrayPattern<pInit, iInit, startOutput, [
+    ...endOutput,
+    InvertPatternInternal<p1, i1>
+]> : InvertArrayPattern<pInit, ii[], startOutput, [
+    ...endOutput,
+    InvertPatternInternal<p1, ii>
+]> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? [
+    ...startOutput,
+    ...Extract<InvertPatternInternal<pRest, i>, readonly any[]>,
+    ...endOutput
+] : [...startOutput, ...InvertPatternInternal<ValueOf<p>, ii>[], ...endOutput] : never;
+/**
+ * ### InvertPatternInternal
+ * Since patterns have special wildcard values, we need a way
+ * to transform a pattern into the type of value it represents
+ */
+export type InvertPattern<p, input> = Equal<Pattern<input>, p> extends true ? never : InvertPatternInternal<p, input>;
+type InvertPatternInternal<p, input> = 0 extends 1 & p ? never : p extends Matcher<infer _input, infer subpattern, infer matcherType, any, infer narrowedOrFn> ? {
+    not: DeepExclude<input, InvertPatternInternal<subpattern, input>>;
+    select: InvertPatternInternal<subpattern, input>;
+    array: InvertPatternInternal<subpattern, ReadonlyArrayValue<input>>[];
+    record: subpattern extends [infer pk, infer pv] ? Record<Extract<InvertPatternInternal<pk, RecordKey<input>>, PropertyKey>, InvertPatternInternal<pv, RecordValue<input>>> : never;
+    map: subpattern extends [infer pk, infer pv] ? Map<InvertPatternInternal<pk, MapKey<Extract<input, Map<any, any>>>>, InvertPatternInternal<pv, MapValue<Extract<input, Map<any, any>>>>> : never;
+    set: Set<InvertPatternInternal<subpattern, SetValue<Extract<input, Set<any>>>>>;
+    optional: InvertPatternInternal<subpattern, Exclude<input, undefined>> | undefined;
+    and: ReduceIntersection<Extract<subpattern, readonly any[]>, input>;
+    or: ReduceUnion<Extract<subpattern, readonly any[]>, input>;
+    default: [subpattern] extends [never] ? input : subpattern;
+    custom: Override<narrowedOrFn extends Fn ? Call<narrowedOrFn, input> : narrowedOrFn>;
+}[matcherType] : p extends Primitives ? p : p extends readonly any[] ? InvertArrayPattern<p, WithDefault<Extract<input, readonly any[]>, unknown[]>> : IsPlainObject<p> extends true ? OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? {
+    [k in Exclude<keyof p, optKeys>]: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+} : Compute<{
+    [k in Exclude<keyof p, optKeys>]: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+} & {
+    [k in Extract<optKeys, keyof p>]?: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+}> : never : p;
+export type ReduceIntersectionForExclude<tuple extends readonly any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersectionForExclude<tail, i, output & InvertPatternForExcludeInternal<p, i, unknown>> : output;
+export type ReduceUnionForExclude<tuple extends readonly any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnionForExclude<tail, i, output | InvertPatternForExcludeInternal<p, i, never>> : output;
+type ExcludeIfExists<a, b> = [
+    b
+] extends [never] ? never : unknown extends a ? never : All<[
+    Extends<a, NonLiteralPrimitive>,
+    Not<IsLiteral<a>>,
+    IsLiteral<b>
+]> extends true ? never : DeepExclude<a, b>;
+type InvertArrayPatternForExclude<p, i, empty, isReadonly extends boolean, startOutput extends any[] = [], endOutput extends any[] = []> = i extends readonly (infer ii)[] ? p extends readonly [] ? MaybeAddReadonly<[...startOutput, ...endOutput], isReadonly> : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? InvertArrayPatternForExclude<pRest, iRest, empty, isReadonly, [
+    ...startOutput,
+    InvertPatternForExcludeInternal<p1, i1, empty>
+], endOutput> : InvertArrayPatternForExclude<pRest, ii[], empty, isReadonly, [
+    ...startOutput,
+    InvertPatternForExcludeInternal<p1, ii, empty>
+], endOutput> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? InvertArrayPatternForExclude<pInit, iInit, empty, isReadonly, startOutput, [
+    ...endOutput,
+    InvertPatternForExcludeInternal<p1, i1, empty>
+]> : InvertArrayPatternForExclude<pInit, ii[], empty, isReadonly, startOutput, [
+    ...endOutput,
+    InvertPatternForExcludeInternal<p1, ii, empty>
+]> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? MaybeAddReadonly<[
+    ...startOutput,
+    ...Extract<InvertPatternForExcludeInternal<pRest, i, empty>, readonly any[]>,
+    ...endOutput
+], isReadonly> : MaybeAddReadonly<[
+    ...startOutput,
+    ...InvertPatternForExcludeInternal<ValueOf<p>, ii, empty>[],
+    ...endOutput
+], isReadonly> : empty;
+/**
+ * ### InvertPatternForExclude
+ */
+export type InvertPatternForExclude<p, i> = Equal<Pattern<i>, p> extends true ? never : InvertPatternForExcludeInternal<p, i>;
+type InvertPatternForExcludeInternal<p, i, empty = never> = unknown extends p ? i : [p] extends [Primitives] ? IsLiteral<p> extends true ? p : IsLiteral<i> extends true ? p : empty : p extends Matcher<infer matchableInput, infer subpattern, infer matcherType, any, infer excluded> ? {
+    select: InvertPatternForExcludeInternal<subpattern, i, empty>;
+    array: i extends readonly (infer ii)[] ? MaybeAddReadonly<InvertPatternForExcludeInternal<subpattern, ii, empty>[], IsReadonlyArray<i>> : empty;
+    record: subpattern extends [infer pk, infer pv] ? Record<Extract<InvertPatternForExcludeInternal<pk, RecordKey<i>, empty>, PropertyKey>, InvertPatternForExcludeInternal<pv, RecordValue<i>, empty>> : empty;
+    map: subpattern extends [infer pk, infer pv] ? i extends Map<infer ik, infer iv> ? Map<InvertPatternForExcludeInternal<pk, ik, empty>, InvertPatternForExcludeInternal<pv, iv, empty>> : empty : empty;
+    set: i extends Set<infer iv> ? Set<InvertPatternForExcludeInternal<subpattern, iv, empty>> : empty;
+    optional: InvertPatternForExcludeInternal<subpattern, i, empty> | undefined;
+    and: ReduceIntersectionForExclude<Extract<subpattern, readonly any[]>, i>;
+    or: ReduceUnionForExclude<Extract<subpattern, readonly any[]>, i>;
+    not: ExcludeIfExists<unknown extends matchableInput ? i : matchableInput, InvertPatternForExcludeInternal<subpattern, i>>;
+    default: excluded;
+    custom: excluded extends infer narrowedOrFn extends Fn ? Call<narrowedOrFn, i> : excluded;
+}[matcherType] : p extends readonly any[] ? Extract<i, readonly any[]> extends infer arrayInput ? InvertArrayPatternForExclude<p, arrayInput, empty, IsReadonlyArray<arrayInput>> : never : IsPlainObject<p> extends true ? Equal<{}, p> extends true ? {} : i extends object ? [keyof p & keyof i] extends [never] ? empty : OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? {
+    readonly [k in keyof p]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+} : Compute<{
+    readonly [k in Exclude<keyof p, optKeys>]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+} & {
+    readonly [k in Extract<optKeys, keyof p>]?: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+}> : empty : empty : empty;
+export {};