Socket
Socket
Sign inDemoInstall

ts-pattern

Package Overview
Dependencies
Maintainers
1
Versions
151
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

ts-pattern - npm Package Compare versions

Comparing version 2.2.2 to 3.0.1-next.0

9

lib/index.d.ts

@@ -1,7 +0,8 @@

import type { Pattern, SelectPattern, GuardPattern, NotPattern, GuardFunction } from './types/Pattern';
import type { EmptyMatch } from './types/Match';
import type { Pattern, AnonymousSelectPattern, NamedSelectPattern, GuardPattern, NotPattern, GuardFunction } from './types/Pattern';
import type { Match } from './types/Match';
import { __ } from './PatternType';
export declare const when: <a, b extends a = a>(predicate: GuardFunction<a, b>) => GuardPattern<a, b>;
export declare const not: <a>(pattern: Pattern<a>) => NotPattern<a>;
export declare const select: <k extends string>(key: k) => SelectPattern<k>;
export declare function select(): AnonymousSelectPattern;
export declare function select<k extends string>(key: k): NamedSelectPattern<k>;
/**

@@ -16,2 +17,2 @@ * # Pattern matching

*/
export declare const match: <a, b = "@ts-pattern/unset">(value: a) => EmptyMatch<a, b>;
export declare const match: <a, b = "@ts-pattern/unset">(value: a) => Match<a, b, a>;

212

lib/index.js

@@ -37,6 +37,12 @@ "use strict";

exports.not = not;
var select = function (key) { return ({
'@ts-pattern/__patternKind': PatternType_1.PatternType.Select,
'@ts-pattern/__key': key
}); };
function select(key) {
return key === undefined
? {
'@ts-pattern/__patternKind': PatternType_1.PatternType.AnonymousSelect
}
: {
'@ts-pattern/__patternKind': PatternType_1.PatternType.NamedSelect,
'@ts-pattern/__key': key
};
}
exports.select = select;

@@ -59,50 +65,4 @@ /**

*/
var builder = function (value, cases) { return ({
"with": function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var _a = __read(args
.slice(0, -1)
.reduce(function (_a, arg) {
var _b = __read(_a, 2), patterns = _b[0], predicates = _b[1];
return typeof arg === 'function'
? [patterns, __spreadArray(__spreadArray([], __read(predicates)), [arg])]
: [__spreadArray(__spreadArray([], __read(patterns)), [arg]), predicates];
}, [[], []]), 2), patterns = _a[0], predicates = _a[1];
var handler = args[args.length - 1];
var doesMatch = function (value) {
return Boolean(patterns.some(function (pattern) { return matchPattern(pattern)(value); }) &&
predicates.every(function (predicate) { return predicate(value); }));
};
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: doesMatch,
handler: handler,
select: function (value) {
return patterns.length === 1 ? selectWithPattern(patterns[0])(value) : {};
}
},
]));
},
when: function (predicate, handler) {
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: predicate,
handler: handler,
select: function () { return ({}); }
},
]));
},
otherwise: function (handler) {
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: matchPattern(PatternType_1.__),
handler: handler,
select: function () { return ({}); }
},
])).run();
},
run: function () {
var builder = function (value, cases) {
var run = function () {
var entry = cases.find(function (_a) {

@@ -122,12 +82,58 @@ var test = _a.test;

}
return entry.handler(value, entry.select(value));
},
/**
* ### exhaustive
* creates an exhaustive match expression checking
* that **all cases are handled**. `when` predicates
* aren't supported on exhaustive matches.
**/
exhaustive: function () { return builder(value, cases); }
}); };
return entry.handler.apply(entry, __spreadArray(__spreadArray([], __read(entry.select(value))), [value]));
};
return {
"with": function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var _a = args.slice(0, -1).reduce(function (acc, arg) {
if (typeof arg === 'function') {
acc.predicates.push(arg);
}
else {
acc.patterns.push(arg);
}
return acc;
}, { patterns: [], predicates: [] }), patterns = _a.patterns, predicates = _a.predicates;
var handler = args[args.length - 1];
var doesMatch = function (value) {
return Boolean(patterns.some(function (pattern) { return matchPattern(pattern, value); }) &&
predicates.every(function (predicate) { return predicate(value); }));
};
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: doesMatch,
handler: handler,
select: function (value) {
return patterns.length === 1 ? selectWithPattern(patterns[0], value) : [];
}
},
]));
},
when: function (predicate, handler) {
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: predicate,
handler: handler,
select: function () { return []; }
},
]));
},
otherwise: function (handler) {
return builder(value, __spreadArray(__spreadArray([], __read(cases)), [
{
test: function (value) {
return matchPattern(PatternType_1.__, value);
},
handler: handler,
select: function () { return []; }
},
])).exhaustive();
},
exhaustive: function () { return run(); },
run: run
};
};
var isObject = function (value) {

@@ -147,6 +153,11 @@ return Boolean(value && typeof value === 'object');

};
var isSelectPattern = function (x) {
var isNamedSelectPattern = function (x) {
var pattern = x;
return pattern && pattern['@ts-pattern/__patternKind'] === PatternType_1.PatternType.Select;
return (pattern && pattern['@ts-pattern/__patternKind'] === PatternType_1.PatternType.NamedSelect);
};
var isAnonymousSelectPattern = function (x) {
var pattern = x;
return (pattern &&
pattern['@ts-pattern/__patternKind'] === PatternType_1.PatternType.AnonymousSelect);
};
var isListPattern = function (x) {

@@ -156,4 +167,6 @@ return Array.isArray(x) && x.length === 1;

// tells us if the value matches a given pattern.
var matchPattern = function (pattern) { return function (value) {
if (pattern === PatternType_1.__ || isSelectPattern(pattern))
var matchPattern = function (pattern, value) {
if (pattern === PatternType_1.__ ||
isNamedSelectPattern(pattern) ||
isAnonymousSelectPattern(pattern))
return true;

@@ -170,6 +183,6 @@ if (pattern === PatternType_1.__.string)

if (isNotPattern(pattern))
return !matchPattern(pattern['@ts-pattern/__pattern'])(value);
return !matchPattern(pattern['@ts-pattern/__pattern'], value);
if (isListPattern(pattern))
return isArray(value)
? value.every(function (v) { return matchPattern(pattern[0])(v); })
? value.every(function (v) { return matchPattern(pattern[0], v); })
: false;

@@ -180,3 +193,3 @@ if (typeof pattern !== typeof value)

return isArray(value) && pattern.length === value.length
? pattern.every(function (subPattern, i) { return matchPattern(subPattern)(value[i]); })
? pattern.every(function (subPattern, i) { return matchPattern(subPattern, value[i]); })
: false;

@@ -188,3 +201,3 @@ }

return __spreadArray([], __read(pattern.keys())).every(function (key) {
return matchPattern(pattern.get(key))(value.get(key));
return matchPattern(pattern.get(key), value.get(key));
});

@@ -202,3 +215,3 @@ }

return Object.values(PatternType_1.__).includes(subPattern)
? matchPattern([subPattern])(allValues_1)
? matchPattern([subPattern], allValues_1)
: value.has(subPattern);

@@ -213,14 +226,55 @@ })

// @ts-ignore
return matchPattern(pattern[k])(value[k]);
return matchPattern(pattern[k], value[k]);
});
}
return value === pattern;
}; };
var selectWithPattern = function (pattern) { return function (value) {
};
var selectWithPattern = function (pattern, value) {
var positional = selectPositionalWithPattern(pattern, value);
var kwargs = selectKwargsWithPattern(pattern, value);
var selections = [];
if (positional.kind === 'some')
selections.push(positional.value);
if (Object.keys(kwargs).length)
selections.push(kwargs);
return selections;
};
var selectPositionalWithPattern = function (pattern, value) {
if (isAnonymousSelectPattern(pattern))
return { kind: 'some', value: value };
if (isListPattern(pattern) && isArray(value))
return value
.map(function (v) { return selectPositionalWithPattern(pattern[0], v); })
.filter(function (selection) {
return selection.kind === 'some';
})
.reduce(function (acc, selection) {
return acc.kind === 'none'
? { kind: 'some', value: [selection.value] }
: { kind: 'some', value: acc.value.concat([selection.value]) };
}, { kind: 'none' });
if (isArray(pattern) && isArray(value))
return pattern.length <= value.length
? pattern.reduce(function (acc, subPattern, i) {
if (acc.kind === 'some')
return acc;
return selectPositionalWithPattern(subPattern, value[i]);
}, { kind: 'none' })
: { kind: 'none' };
if (isObject(pattern) && isObject(value))
return Object.keys(pattern).reduce(function (acc, k) {
if (acc.kind === 'some')
return acc;
// @ts-ignore
return selectPositionalWithPattern(pattern[k], value[k]);
}, { kind: 'none' });
return { kind: 'none' };
};
var selectKwargsWithPattern = function (pattern, value) {
var _a;
if (isSelectPattern(pattern))
if (isNamedSelectPattern(pattern))
return _a = {}, _a[pattern['@ts-pattern/__key']] = value, _a;
if (isListPattern(pattern) && isArray(value))
return value
.map(function (v) { return selectWithPattern(pattern[0])(v); })
.map(function (v) { return selectKwargsWithPattern(pattern[0], v); })
.reduce(function (acc, selections) {

@@ -235,3 +289,3 @@ return Object.keys(selections).reduce(function (acc, key) {

? pattern.reduce(function (acc, subPattern, i) {
return Object.assign(acc, selectWithPattern(subPattern)(value[i]));
return Object.assign(acc, selectKwargsWithPattern(subPattern, value[i]));
}, {})

@@ -242,5 +296,5 @@ : {};

// @ts-ignore
return Object.assign(acc, selectWithPattern(pattern[k])(value[k]));
return Object.assign(acc, selectKwargsWithPattern(pattern[k], value[k]));
}, {});
return {};
}; };
};

3

lib/PatternType.d.ts

@@ -7,3 +7,4 @@ export declare enum PatternType {

Not = "@ts-pattern/not",
Select = "@ts-pattern/select"
NamedSelect = "@ts-pattern/named-select",
AnonymousSelect = "@ts-pattern/anonymous-select"
}

@@ -10,0 +11,0 @@ /**

3

lib/PatternType.js

@@ -11,3 +11,4 @@ "use strict";

PatternType["Not"] = "@ts-pattern/not";
PatternType["Select"] = "@ts-pattern/select";
PatternType["NamedSelect"] = "@ts-pattern/named-select";
PatternType["AnonymousSelect"] = "@ts-pattern/anonymous-select";
})(PatternType = exports.PatternType || (exports.PatternType = {}));

@@ -14,0 +15,0 @@ /**

6

lib/types/DistributeUnions.d.ts

@@ -119,3 +119,3 @@ import type { IsAny, Cast, Values, Flatten, IsUnion, Slice, Drop, Iterator, Next, IsPlainObject, Length, Compute } from './helpers';

},
...(infer tail)
...infer tail
] ? cases extends {

@@ -138,3 +138,3 @@ value: infer value;

],
...(infer tail)
...infer tail
] ? BuildOne<Update<data, value, Cast<path, PropertyKey[]>>, tail> : data;

@@ -144,3 +144,3 @@ declare type SafeGet<data, k extends PropertyKey, def> = k extends keyof data ? data[k] : def;

infer head,
...(infer tail)
...infer tail
] ? data extends [any, ...any] ? head extends number ? [

@@ -147,0 +147,0 @@ ...Slice<data, Iterator<head>>,

43

lib/types/FindSelected.d.ts

@@ -1,6 +0,5 @@

import type { Compute, IsPlainObject, UnionToIntersection, ValueOf } from './helpers';
import type { SelectPattern } from './Pattern';
declare type FindSelectionUnion<i, p> = p extends SelectPattern<infer Key> ? {
[k in Key]: i;
} : [i, p] extends [(infer ii)[], (infer pp)[]] ? [i, p] extends [
import { PatternType } from '../PatternType';
import type { Cast, Compute, IsPlainObject, UnionToTuple, ValueOf } from './helpers';
import type { NamedSelectPattern, AnonymousSelectPattern } from './Pattern';
export declare type FindSelectionUnion<i, p> = p extends NamedSelectPattern<infer k> ? [k, i] : p extends AnonymousSelectPattern ? [PatternType.AnonymousSelect, i] : p extends (infer pp)[] ? i extends (infer ii)[] ? [i, p] extends [
[

@@ -44,8 +43,32 @@ infer i1,

]
] ? FindSelectionUnion<i1, p1> | FindSelectionUnion<i2, p2> | FindSelectionUnion<i3, p3> : [i, p] extends [[infer i1, infer i2], [infer p1, infer p2]] ? FindSelectionUnion<i1, p1> | FindSelectionUnion<i2, p2> : FindSelectionUnion<ii, pp> extends infer selected ? {
[k in keyof selected]: selected[k][];
} : never : [IsPlainObject<i>, IsPlainObject<p>] extends [true, true] ? ValueOf<{
] ? FindSelectionUnion<i1, p1> | FindSelectionUnion<i2, p2> | FindSelectionUnion<i3, p3> : [i, p] extends [[infer i1, infer i2], [infer p1, infer p2]] ? FindSelectionUnion<i1, p1> | FindSelectionUnion<i2, p2> : FindSelectionUnion<ii, pp> extends infer selectionUnion ? selectionUnion extends [infer k, infer v] ? [k, v[]] : never : never : never : IsPlainObject<p> extends true ? i extends object ? ValueOf<{
[k in keyof i & keyof p]: FindSelectionUnion<i[k], p[k]>;
}> : never;
export declare type FindSelected<i, p> = Compute<UnionToIntersection<FindSelectionUnion<i, p>>>;
}> : never : never;
export declare type SeveralAnonymousSelectError = {
__error: never;
description: 'You can only used `select` once in your pattern. If you need to select multiple values, use `select.as(<name>)` instead';
};
declare type OrderSelections<selections, output extends {
positional: any;
kwargs: {};
} = {
positional: '@ts-pattern/empty';
kwargs: {};
}> = selections extends [infer head, ...infer tail] ? head extends [infer key, infer value] ? key extends PatternType.AnonymousSelect ? OrderSelections<tail, {
positional: output['positional'] extends '@ts-pattern/empty' ? value : '@ts-pattern/error';
kwargs: output['kwargs'];
}> : OrderSelections<tail, {
positional: output['positional'];
kwargs: output['kwargs'] & {
[k in Cast<key, string>]: value;
};
}> : never : output;
declare type SelectionTuplesToArgs<selections> = OrderSelections<selections> extends {
positional: infer positional;
kwargs: infer kwargs;
} ? [
...(positional extends '@ts-pattern/error' ? [SeveralAnonymousSelectError] : positional extends '@ts-pattern/empty' ? [] : [positional]),
...([keyof kwargs] extends [never] ? [] : [Compute<kwargs>])
] : [];
export declare type FindSelected<i, p> = SelectionTuplesToArgs<UnionToTuple<FindSelectionUnion<i, p>>>;
export {};

22

lib/types/helpers.d.ts

@@ -16,4 +16,4 @@ export declare type ValueOf<a> = a extends any[] ? a[number] : a[keyof a];

**/
export declare type ExcludeIfContainsNever<a> = a extends Map<any, any> | Set<any> ? a : a extends any[] ? ExcludeNeverArray<a> : IsPlainObject<a> extends true ? ExcludeNeverObject<Cast<a, object>> : a;
declare type ExcludeNeverArray<a extends any[]> = (a[0] extends never ? false : true) | (a[1] extends never ? false : true) | (a[2] extends never ? false : true) | (a[3] extends never ? false : true) | (a[4] extends never ? false : true) extends true ? a : never;
export declare type ExcludeIfContainsNever<a> = a extends Map<any, any> | Set<any> ? a : a extends any[] ? ExcludeNeverTuple<a> : IsPlainObject<a> extends true ? ExcludeNeverObject<Cast<a, object>> : a;
declare type ExcludeNeverTuple<a extends any[]> = (a[0] extends never ? false : true) | (a[1] extends never ? false : true) | (a[2] extends never ? false : true) | (a[3] extends never ? false : true) | (a[4] extends never ? false : true) extends true ? a : never;
declare type ExcludeNeverObject<a extends object> = {

@@ -26,3 +26,3 @@ [k in keyof a]-?: a[k] extends never ? 'exclude' : 'include';

export declare type Cast<a, b> = a extends b ? a : never;
export declare type Flatten<xs extends any[]> = xs extends [infer head, ...(infer tail)] ? [...Cast<head, any[]>, ...Flatten<tail>] : [];
export declare type Flatten<xs extends any[]> = xs extends [infer head, ...infer tail] ? [...Cast<head, any[]>, ...Flatten<tail>] : [];
export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

@@ -34,5 +34,5 @@ export declare type Expect<T extends true> = T;

export declare type Next<it extends any[]> = [any, ...it];
export declare type Prev<it extends any[]> = it extends [any, ...(infer tail)] ? tail : [];
export declare type Slice<xs extends any[], it extends any[], output extends any[] = []> = Length<it> extends 0 ? output : xs extends [infer head, ...(infer tail)] ? Slice<tail, Prev<it>, [...output, head]> : output;
export declare type Drop<xs extends any[], n extends any[]> = Length<n> extends 0 ? xs : xs extends [any, ...(infer tail)] ? Drop<tail, Prev<n>> : [];
export declare type Prev<it extends any[]> = it extends [any, ...infer tail] ? tail : [];
export declare type Slice<xs extends any[], it extends any[], output extends any[] = []> = Length<it> extends 0 ? output : xs extends [infer head, ...infer tail] ? Slice<tail, Prev<it>, [...output, head]> : output;
export declare type Drop<xs extends any[], n extends any[]> = Length<n> extends 0 ? xs : xs extends [any, ...infer tail] ? Drop<tail, Prev<n>> : [];
declare type BuiltInObjects = Function | Error | Date | RegExp | Generator | {

@@ -45,4 +45,12 @@ readonly [Symbol.toStringTag]: string;

} & unknown;
export declare type All<xs> = xs extends [infer head, ...(infer tail)] ? boolean extends head ? false : head extends true ? All<tail> : false : true;
export declare type All<xs> = xs extends [infer head, ...infer tail] ? boolean extends head ? false : head extends true ? All<tail> : false : true;
export declare type Or<a extends boolean, b extends boolean> = true extends a | b ? true : false;
export declare type WithDefault<a, def> = [a] extends [never] ? def : a;
declare type IsLiteralString<T extends string> = string extends T ? false : true;
declare type IsLiteralNumber<T extends number> = number extends T ? false : true;
declare type IsLiteralBoolean<T extends boolean> = boolean extends T ? false : true;
declare type IsLiteralBigInt<T extends bigint> = bigint extends T ? false : true;
declare type IsLiteralSymbol<T extends symbol> = symbol extends T ? false : true;
export declare type IsLiteral<T> = T extends null | undefined ? true : T extends string ? IsLiteralString<T> : T extends number ? IsLiteralNumber<T> : T extends boolean ? IsLiteralBoolean<T> : T extends symbol ? IsLiteralSymbol<T> : T extends bigint ? IsLiteralBigInt<T> : false;
export declare type Primitives = number | boolean | string | undefined | null | symbol | bigint;
export {};

50

lib/types/InvertPattern.d.ts
import type { __ } from '../PatternType';
import { IsPlainObject } from './helpers';
import type { SelectPattern, GuardPattern, NotPattern, Primitives } from './Pattern';
import { IsPlainObject, Primitives, IsLiteral } from './helpers';
import type { NamedSelectPattern, AnonymousSelectPattern, GuardPattern, NotPattern } from './Pattern';
/**

@@ -9,3 +9,3 @@ * ### InvertPattern

*/
export declare type InvertPattern<p> = p extends typeof __.number ? number : p extends typeof __.string ? string : p extends typeof __.boolean ? boolean : p extends SelectPattern<string> ? unknown : p extends typeof __ ? unknown : p extends GuardPattern<any, infer p1> ? p1 : p extends NotPattern<infer a1> ? NotPattern<InvertPattern<a1>> : p extends Primitives ? p : p extends readonly (infer pp)[] ? p extends readonly [infer p1, infer p2, infer p3, infer p4, infer p5] ? [
export declare type InvertPattern<p> = p extends typeof __.number ? number : p extends typeof __.string ? string : p extends typeof __.boolean ? boolean : p extends NamedSelectPattern<any> | AnonymousSelectPattern | typeof __ ? unknown : p extends GuardPattern<infer p1, infer p2> ? [p2] extends [never] ? p1 : p2 : p extends NotPattern<infer a1> ? NotPattern<InvertPattern<a1>> : p extends Primitives ? p : p extends readonly (infer pp)[] ? p extends readonly [infer p1, infer p2, infer p3, infer p4, infer p5] ? [
InvertPattern<p1>,

@@ -25,27 +25,21 @@ InvertPattern<p2>,

/**
* ### InvertNotPattern
* This generic takes the inverted pattern `p` and the input `i`
* and eliminates `NotPattern`s from `p`.
*
* It's separated from InvertPattern<p> because it's
* expensive to compute, and is only required by `DeepExclude`
* on exhaustive pattern matching.
* ### InvertPatternForExclude
*/
export declare type InvertNotPattern<p, i> = p extends NotPattern<infer p1> ? Exclude<i, p1> : p extends readonly (infer pp)[] ? i extends readonly (infer ii)[] ? p extends readonly [infer p1, infer p2, infer p3, infer p4, infer p5] ? i extends readonly [infer i1, infer i2, infer i3, infer i4, infer i5] ? [
InvertNotPattern<p1, i1>,
InvertNotPattern<p2, i2>,
InvertNotPattern<p3, i3>,
InvertNotPattern<p4, i4>,
InvertNotPattern<p5, i5>
] : p : p extends readonly [infer p1, infer p2, infer p3, infer p4] ? i extends readonly [infer i1, infer i2, infer i3, infer i4] ? [
InvertNotPattern<p1, i1>,
InvertNotPattern<p2, i2>,
InvertNotPattern<p3, i3>,
InvertNotPattern<p4, i4>
] : p : p extends readonly [infer p1, infer p2, infer p3] ? i extends readonly [infer i1, infer i2, infer i3] ? [
InvertNotPattern<p1, i1>,
InvertNotPattern<p2, i2>,
InvertNotPattern<p3, i3>
] : p : p extends readonly [infer p1, infer p2] ? i extends readonly [infer i1, infer i2] ? [InvertNotPattern<p1, i1>, InvertNotPattern<p2, i2>] : p : InvertNotPattern<pp, ii>[] : p : p extends Map<infer pk, infer pv> ? i extends Map<any, infer iv> ? Map<pk, InvertNotPattern<pv, iv>> : p : p extends Set<infer pv> ? i extends Set<infer iv> ? Set<InvertNotPattern<pv, iv>> : p : IsPlainObject<p> extends true ? IsPlainObject<i> extends true ? {
[k in keyof p]: k extends keyof i ? InvertNotPattern<p[k], i[k]> : p[k];
} : p : p;
export declare type InvertPatternForExclude<p, i> = p extends NotPattern<infer p1> ? Exclude<i, p1> : p extends typeof __.number ? number : p extends typeof __.string ? string : p extends typeof __.boolean ? boolean : p extends NamedSelectPattern<any> | AnonymousSelectPattern | typeof __ ? unknown : p extends GuardPattern<any, infer p1> ? p1 : p extends Primitives ? IsLiteral<p> extends true ? p : IsLiteral<i> extends true ? p : never : p extends readonly (infer pp)[] ? i extends readonly (infer ii)[] ? p extends readonly [infer p1, infer p2, infer p3, infer p4, infer p5] ? i extends readonly [infer i1, infer i2, infer i3, infer i4, infer i5] ? [
InvertPatternForExclude<p1, i1>,
InvertPatternForExclude<p2, i2>,
InvertPatternForExclude<p3, i3>,
InvertPatternForExclude<p4, i4>,
InvertPatternForExclude<p5, i5>
] : never : p extends readonly [infer p1, infer p2, infer p3, infer p4] ? i extends readonly [infer i1, infer i2, infer i3, infer i4] ? [
InvertPatternForExclude<p1, i1>,
InvertPatternForExclude<p2, i2>,
InvertPatternForExclude<p3, i3>,
InvertPatternForExclude<p4, i4>
] : never : p extends readonly [infer p1, infer p2, infer p3] ? i extends readonly [infer i1, infer i2, infer i3] ? [
InvertPatternForExclude<p1, i1>,
InvertPatternForExclude<p2, i2>,
InvertPatternForExclude<p3, i3>
] : never : p extends readonly [infer p1, infer p2] ? i extends readonly [infer i1, infer i2] ? [InvertPatternForExclude<p1, i1>, InvertPatternForExclude<p2, i2>] : never : InvertPatternForExclude<pp, ii>[] : never : p extends Map<infer pk, infer pv> ? i extends Map<any, infer iv> ? Map<pk, InvertPatternForExclude<pv, iv>> : never : p extends Set<infer pv> ? i extends Set<infer iv> ? Set<InvertPatternForExclude<pv, iv>> : never : IsPlainObject<p> extends true ? i extends object ? [keyof p & keyof i] extends [never] ? never : {
[k in keyof p & keyof i]: InvertPatternForExclude<p[k], i[k]>;
} : never : never;

11

lib/types/IsMatching.d.ts

@@ -1,5 +0,3 @@

import { IsPlainObject, ValueOf, All } from './helpers';
import { Primitives } from './Pattern';
declare type Extends<a, b> = a extends b ? true : false;
export declare type IsMatching<a, p> = unknown extends p ? true : p extends Primitives ? Extends<p, a> : [a, p] extends [any[], any[]] ? [a, p] extends [
import { Primitives, IsPlainObject, All } from './helpers';
export declare type IsMatching<a, p> = unknown extends p ? true : p extends Primitives ? p extends a ? true : false : [a, p] extends [any[], any[]] ? [a, p] extends [
[

@@ -54,5 +52,4 @@ infer a1,

]
] ? All<[IsMatching<a1, p1>, IsMatching<a2, p2>, IsMatching<a3, p3>]> : [a, p] extends [[infer a1, infer a2], [infer p1, infer p2]] ? All<[IsMatching<a1, p1>, IsMatching<a2, p2>]> : [a, p] extends [[infer a1], [infer p1]] ? All<[IsMatching<a1, p1>]> : Extends<p, a> : IsPlainObject<p> extends true ? true extends (a extends any ? [keyof p & keyof a] extends [never] ? false : ValueOf<{
] ? All<[IsMatching<a1, p1>, IsMatching<a2, p2>, IsMatching<a3, p3>]> : [a, p] extends [[infer a1, infer a2], [infer p1, infer p2]] ? All<[IsMatching<a1, p1>, IsMatching<a2, p2>]> : [a, p] extends [[infer a1], [infer p1]] ? All<[IsMatching<a1, p1>]> : p extends a ? true : false : IsPlainObject<p> extends true ? true extends (a extends any ? [keyof p & keyof a] extends [never] ? false : {
[k in keyof p & keyof a]: IsMatching<a[k], p[k]>;
}> extends true ? true : false : never) ? true : false : Extends<p, a>;
export {};
}[keyof p & keyof a] extends true ? true : false : never) ? true : false : p extends a ? true : false;

78

lib/types/Match.d.ts

@@ -1,5 +0,5 @@

import type { Pattern, GuardValue, ExhaustivePattern } from './Pattern';
import type { Pattern, GuardValue } from './Pattern';
import type { ExtractPreciseValue } from './ExtractPreciseValue';
import type { InvertNotPattern, InvertPattern } from './InvertPattern';
import type { DeepExclude, DeepExcludeMany } from './DeepExclude';
import type { InvertPatternForExclude, InvertPattern } from './InvertPattern';
import type { DeepExclude, ReduceDeepExclude } from './DeepExclude';
import type { WithDefault } from './helpers';

@@ -10,2 +10,9 @@ import type { FindSelected } from './FindSelected';

export declare type PickReturnValue<a, b> = a extends Unset ? b : a;
declare type NonExhaustiveError<i> = {
__nonExhaustive: never;
} & i;
declare type MapInvertPattern<ps extends any[], value> = ps extends [
infer p,
...infer rest
] ? [InvertPatternForExclude<p, value>, ...MapInvertPattern<rest, value>] : [];
/**

@@ -15,3 +22,3 @@ * ### Match

*/
export declare type Match<i, o> = {
export declare type Match<i, o, remainingCases = i> = {
/**

@@ -22,10 +29,5 @@ * ### Match.with

**/
with<p extends Pattern<i>, c, invpattern = InvertPattern<p>, value = MatchedValue<i, invpattern>>(pattern: p, handler: (value: value, selections: FindSelected<value, p>) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<p1 extends Pattern<i>, p2 extends Pattern<i>, c, p = p1 | p2, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, handler: (value: value) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<p1 extends Pattern<i>, p2 extends Pattern<i>, p3 extends Pattern<i>, c, p = p1 | p2 | p3, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, handler: (value: value) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<p1 extends Pattern<i>, p2 extends Pattern<i>, p3 extends Pattern<i>, p4 extends Pattern<i>, c, p = p1 | p2 | p3 | p4, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, pattern4: p4, handler: (value: value) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<p1 extends Pattern<i>, p2 extends Pattern<i>, p3 extends Pattern<i>, p4 extends Pattern<i>, p5 extends Pattern<i>, c, p = p1 | p2 | p3 | p4 | p5, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, pattern4: p4, pattern5: p5, handler: (value: value) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, c>(pattern: pat, predicate: pred, handler: (value: GuardValue<pred>, selections: FindSelected<i, pat>) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, pred2 extends (value: GuardValue<pred>) => unknown, c>(pattern: pat, predicate: pred, predicate2: pred2, handler: (value: GuardValue<pred2>, selections: FindSelected<i, pat>) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, pred2 extends (value: GuardValue<pred>) => unknown, pred3 extends (value: GuardValue<pred2>) => unknown, c>(pattern: pat, predicate: pred, predicate2: pred2, predicate3: pred3, handler: (value: GuardValue<pred3>, selections: FindSelected<i, pat>) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>>;
with<p extends Pattern<i>, c, value = MatchedValue<i, InvertPattern<p>>>(pattern: p, handler: (...args: [...selections: FindSelected<value, p>, value: value]) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>, DeepExclude<remainingCases, InvertPatternForExclude<p, value>>>;
with<ps extends [Pattern<i>, Pattern<i>, ...Pattern<i>[]], c, p = ps[number], value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(...args: [...patterns: ps, handler: (value: value) => PickReturnValue<o, c>]): Match<i, PickReturnValue<o, c>, ReduceDeepExclude<remainingCases, MapInvertPattern<ps, value>>>;
with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, c>(pattern: pat, predicate: pred, handler: (value: GuardValue<pred>, selections: FindSelected<i, pat>) => PickReturnValue<o, c>): Match<i, PickReturnValue<o, c>, pred extends (value: any) => value is infer narrowed ? DeepExclude<remainingCases, narrowed> : remainingCases>;
/**

@@ -36,3 +38,3 @@ * ### Match.when

**/
when: <p extends (value: i) => unknown, c>(predicate: p, handler: (value: GuardValue<p>) => PickReturnValue<o, c>) => Match<i, PickReturnValue<o, c>>;
when: <pred extends (value: i) => unknown, c>(predicate: pred, handler: (value: GuardValue<pred>) => PickReturnValue<o, c>) => Match<i, PickReturnValue<o, c>, pred extends (value: any) => value is infer narrowed ? DeepExclude<remainingCases, narrowed> : remainingCases>;
/**

@@ -47,52 +49,16 @@ * ### Match.otherwise

/**
* ### Match.run
* ### Match.exhaustive
* Runs the pattern matching and return a value.
*
* If this is of type `NonExhaustiveError`, it means you aren't matching
* every cases, and you should probably add a another `.with(...)` clause
* to prevent potential runtime errors.
* */
run: () => o;
};
export declare type EmptyMatch<i, o> = Match<i, o> & {
exhaustive: [remainingCases] extends [never] ? () => o : NonExhaustiveError<remainingCases>;
/**
* ### exhaustive
* creates an exhaustive match expression checking
* that **all cases are handled**. `when` predicates
* aren't supported on exhaustive matches.
**/
exhaustive: () => ExhaustiveMatch<i, i, o>;
};
declare type NonExhaustivePattern<i> = {
__nonExhaustive: never;
} & i;
/**
* ### ExhaustiveMatch
* An interface to create an exhaustive pattern matching clause.
*/
export declare type ExhaustiveMatch<distributedInput, i, o> = {
/**
* ### Match.with
* If the data matches the pattern provided as first argument,
* use this branch and execute the handler function.
**/
with<p extends ExhaustivePattern<i>, c, invpattern = InvertPattern<p>, value = MatchedValue<i, invpattern>>(pattern: p, handler: (value: value, selections: FindSelected<value, p>) => PickReturnValue<o, c>): ExhaustiveMatch<DeepExclude<distributedInput, InvertNotPattern<invpattern, value>>, i, PickReturnValue<o, c>>;
with<p1 extends ExhaustivePattern<i>, p2 extends ExhaustivePattern<i>, c, p = p1 | p2, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, handler: (value: value) => PickReturnValue<o, c>): ExhaustiveMatch<DeepExcludeMany<distributedInput, p extends any ? InvertNotPattern<InvertPattern<p>, value> : never>, i, PickReturnValue<o, c>>;
with<p1 extends ExhaustivePattern<i>, p2 extends ExhaustivePattern<i>, p3 extends ExhaustivePattern<i>, c, p = p1 | p2 | p3, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, handler: (value: value) => PickReturnValue<o, c>): ExhaustiveMatch<DeepExcludeMany<distributedInput, p extends any ? InvertNotPattern<InvertPattern<p>, value> : never>, i, PickReturnValue<o, c>>;
with<p1 extends ExhaustivePattern<i>, p2 extends ExhaustivePattern<i>, p3 extends ExhaustivePattern<i>, p4 extends ExhaustivePattern<i>, c, p = p1 | p2 | p3 | p4, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, pattern4: p4, handler: (value: value) => PickReturnValue<o, c>): ExhaustiveMatch<DeepExcludeMany<distributedInput, p extends any ? InvertNotPattern<InvertPattern<p>, value> : never>, i, PickReturnValue<o, c>>;
with<p1 extends ExhaustivePattern<i>, p2 extends ExhaustivePattern<i>, p3 extends ExhaustivePattern<i>, p4 extends ExhaustivePattern<i>, p5 extends ExhaustivePattern<i>, c, p = p1 | p2 | p3 | p4 | p5, value = p extends any ? MatchedValue<i, InvertPattern<p>> : never>(pattern1: p1, pattern2: p2, pattern3: p3, pattern4: p4, pattern5: p5, handler: (value: value) => PickReturnValue<o, c>): ExhaustiveMatch<DeepExcludeMany<distributedInput, p extends any ? InvertNotPattern<InvertPattern<p>, value> : never>, i, PickReturnValue<o, c>>;
/**
* ### Match.otherwise
* takes a function returning the default value
* and return the matched result.
*
* Equivalent to `.with(__, () => x).run()`
**/
otherwise: <c>(handler: () => PickReturnValue<o, c>) => PickReturnValue<o, c>;
/**
* ### Match.run
* Runs the pattern matching and return a value.
*
* If this is of type `NonExhaustivePattern`, it means you aren't matching
* every cases, and you should probably add a another `.with(...)` clause
* to prevent potential runtime errors.
* */
run: [distributedInput] extends [never] ? () => o : NonExhaustivePattern<distributedInput>;
run: () => o;
};
export {};

52

lib/types/Pattern.d.ts
import type { __, PatternType } from '../PatternType';
import { IsPlainObject } from './helpers';
export declare type Primitives = number | boolean | string | undefined | null | symbol | bigint;
import { Primitives, IsPlainObject } from './helpers';
/**

@@ -13,3 +12,3 @@ * GuardValue returns the value guarded by a type guard function.

*/
export declare type GuardPattern<a, b extends a = a> = {
export declare type GuardPattern<a, b extends a = never> = {
/** @deprecated This property should only be used by ts-pattern's internals. */

@@ -26,6 +25,10 @@ '@ts-pattern/__patternKind': PatternType.Guard;

};
export declare type SelectPattern<k extends string> = {
export declare type AnonymousSelectPattern = {
/** @deprecated This property should only be used by ts-pattern's internals. */
'@ts-pattern/__patternKind': PatternType.Select;
'@ts-pattern/__patternKind': PatternType.AnonymousSelect;
};
export declare type NamedSelectPattern<k extends string> = {
/** @deprecated This property should only be used by ts-pattern's internals. */
'@ts-pattern/__patternKind': PatternType.NamedSelect;
/** @deprecated This property should only be used by ts-pattern's internals. */
'@ts-pattern/__key': k;

@@ -39,42 +42,5 @@ };

*/
export declare type Pattern<a> = typeof __ | SelectPattern<string> | GuardPattern<a> | NotPattern<a | any> | WildCardPattern<a> | (a extends Primitives ? a : a extends (infer b)[] ? a extends [infer b, infer c, infer d, infer e, infer f] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>, Pattern<f>] : a extends [infer b, infer c, infer d, infer e] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>] : a extends [infer b, infer c, infer d] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>] : a extends [infer b, infer c] ? readonly [Pattern<b>, Pattern<c>] : [] | [Pattern<b>] | [Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>] : a extends Map<infer k, infer v> ? Map<k, Pattern<v>> : a extends Set<infer v> ? Set<Pattern<v>> : IsPlainObject<a> extends true ? {
export declare type Pattern<a> = typeof __ | AnonymousSelectPattern | NamedSelectPattern<string> | GuardPattern<a> | NotPattern<a | any> | WildCardPattern<a> | (a extends Primitives ? a : a extends (infer b)[] ? a extends [infer b, infer c, infer d, infer e, infer f] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>, Pattern<f>] : a extends [infer b, infer c, infer d, infer e] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>] : a extends [infer b, infer c, infer d] ? readonly [Pattern<b>, Pattern<c>, Pattern<d>] : a extends [infer b, infer c] ? readonly [Pattern<b>, Pattern<c>] : [] | [Pattern<b>] | [Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>] | [Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>, Pattern<b>] : a extends Map<infer k, infer v> ? Map<k, Pattern<v>> : a extends Set<infer v> ? Set<Pattern<v>> : IsPlainObject<a> extends true ? {
readonly [k in keyof a]?: Pattern<a[k]>;
} : a);
/**
* ### ExhaustivePattern
* Just like the Pattern type, excluding when clauses.
*/
export declare type ExhaustivePattern<a> = typeof __ | SelectPattern<string> | NotPattern<a | any> | WildCardPattern<a> | (a extends Primitives ? a : a extends readonly (infer b)[] ? a extends readonly [infer b, infer c, infer d, infer e, infer f] ? readonly [
ExhaustivePattern<b>,
ExhaustivePattern<c>,
ExhaustivePattern<d>,
ExhaustivePattern<e>,
ExhaustivePattern<f>
] : a extends readonly [infer b, infer c, infer d, infer e] ? readonly [
ExhaustivePattern<b>,
ExhaustivePattern<c>,
ExhaustivePattern<d>,
ExhaustivePattern<e>
] : a extends readonly [infer b, infer c, infer d] ? readonly [
ExhaustivePattern<b>,
ExhaustivePattern<c>,
ExhaustivePattern<d>
] : a extends readonly [infer b, infer c] ? readonly [ExhaustivePattern<b>, ExhaustivePattern<c>] : readonly [] | readonly [ExhaustivePattern<b>] | readonly [ExhaustivePattern<b>, ExhaustivePattern<b>] | readonly [
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>
] | readonly [
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>
] | readonly [
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>,
ExhaustivePattern<b>
] : a extends Map<infer k, infer v> ? Map<k, ExhaustivePattern<v>> : a extends Set<infer v> ? Set<ExhaustivePattern<v>> : IsPlainObject<a> extends true ? {
readonly [k in keyof a]?: ExhaustivePattern<a[k]>;
} : a);
export {};

2

package.json
{
"name": "ts-pattern",
"version": "2.2.2",
"version": "3.0.1-next.0",
"description": "Typescript pattern matching library",

@@ -5,0 +5,0 @@ "main": "lib/index.js",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc