@duplojs/utils 1.0.3 → 1.0.5

package/dist/common/and.d.ts

@@ -0,0 +1,31 @@
+import { type IsEqual, type AnyFunction, type UnionToIntersection } from "./types";
+type ExtractIntersection<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[], GenericResult extends unknown = GenericInput> = GenericPredicatedInput extends [
+    (input: any) => input is infer InferredPredicate,
+    ...infer InferredRest extends AnyFunction<any[], boolean>[]
+] ? Extract<GenericResult, InferredPredicate> extends infer InferredResult extends GenericInput ? InferredRest extends readonly [] ? InferredResult : ExtractIntersection<GenericInput, InferredRest, InferredResult> : never : never;
+type ExtractPredicate<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[]> = GenericPredicatedInput extends [
+    (input: any) => input is infer InferredPredicate,
+    ...infer InferredRest extends AnyFunction<any[], boolean>[]
+] ? InferredRest extends readonly [] ? InferredPredicate : InferredPredicate | ExtractPredicate<GenericInput, InferredRest> : GenericInput;
+type ComputeResult<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[]> = ExtractIntersection<GenericInput, GenericPredicatedInput> extends infer InferredResult extends GenericInput ? IsEqual<InferredResult, never> extends true ? GenericInput & UnionToIntersection<ExtractPredicate<GenericInput, GenericPredicatedInput>> : InferredResult : never;
+export declare function and<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+    (input: GenericInput) => input is any,
+    (input: GenericInput) => input is any,
+    ...((input: GenericInput) => input is any)[]
+]>(predicatedList: GenericArrayPredicatedInput): (input: GenericInput) => input is ComputeResult<GenericInput, GenericArrayPredicatedInput>;
+export declare function and<GenericInput extends unknown>(predicatedList: [
+    (input: GenericInput) => boolean,
+    (input: GenericInput) => boolean,
+    ...((input: GenericInput) => boolean)[]
+]): (input: GenericInput) => boolean;
+export declare function and<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+    (input: GenericInput) => input is any,
+    (input: GenericInput) => input is any,
+    ...((input: GenericInput) => input is any)[]
+]>(input: GenericInput, predicatedList: GenericArrayPredicatedInput): input is ComputeResult<GenericInput, GenericArrayPredicatedInput>;
+export declare function and<GenericInput extends unknown>(input: GenericInput, predicatedList: [
+    (input: GenericInput) => boolean,
+    (input: GenericInput) => boolean,
+    ...((input: GenericInput) => boolean)[]
+]): boolean;
+export {};

package/dist/common/equal.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function equal(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => equal(input, value);
+    }
+    const [input, value] = args;
+    return value instanceof Array
+        ? value.includes(input)
+        : input === value;
+}
+
+exports.equal = equal;

package/dist/common/equal.d.ts

@@ -0,0 +1,3 @@
+export type EligibleEqual = string | null | number | undefined | bigint | boolean | symbol;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(value: GenericValue | GenericValue[]): (input: GenericInput) => input is NoInfer<GenericValue>;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(input: GenericInput, value: GenericValue | GenericValue[]): input is GenericValue;

package/dist/common/equal.mjs

@@ -0,0 +1,12 @@
+function equal(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => equal(input, value);
+    }
+    const [input, value] = args;
+    return value instanceof Array
+        ? value.includes(input)
+        : input === value;
+}
+
+export { equal };

package/dist/common/index.d.ts

@@ -27,3 +27,6 @@ export * from "./loop";
 export * from "./forward";
 export * from "./when";
 export * from "./whenNot";
+export * from "./equal";
+export * from "./not";
+export * from "./isType";

package/dist/common/isType.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const testTypeWrapper = {
+    string: (input) => typeof input === "string",
+    number: (input) => typeof input === "number",
+    bigint: (input) => typeof input === "bigint",
+    boolean: (input) => typeof input === "boolean",
+    function: (input) => typeof input === "function",
+    symbol: (input) => typeof input === "symbol",
+    undefined: (input) => typeof input === "undefined",
+    null: (input) => input === null,
+    array: (input) => input instanceof Array,
+    object: (input) => !!input && typeof input === "object" && !(input instanceof Array),
+};
+function isType(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (input) => isType(input, type);
+    }
+    const [input, type] = args;
+    return testTypeWrapper[type](input);
+}
+
+exports.isType = isType;

package/dist/common/isType.d.ts

@@ -0,0 +1,20 @@
+import { type IsEqual, type AnyFunction } from "./types";
+interface Type {
+    string: [string, never];
+    number: [number, never];
+    boolean: [boolean, never];
+    function: [AnyFunction, never];
+    bigint: [bigint, never];
+    undefined: [undefined, never];
+    null: [null, never];
+    symbol: [symbol, never];
+    object: [object, any[] | AnyFunction];
+    array: [any[], never];
+}
+type ComputeResult<GenericInput extends unknown, GenericTypeEntry extends Type[keyof Type]> = Exclude<Extract<GenericInput, GenericTypeEntry[0]>, GenericTypeEntry[1]>;
+type EligibleType<GenericInput extends unknown> = {
+    [Prop in keyof Type]: IsEqual<ComputeResult<GenericInput, Type[Prop]>, never> extends true ? never : Prop;
+}[keyof Type];
+export declare function isType<GenericInput extends unknown, GenericType extends EligibleType<GenericInput>>(type: GenericType): (input: GenericInput) => input is ComputeResult<GenericInput, Type[GenericType]>;
+export declare function isType<GenericInput extends unknown, GenericType extends EligibleType<GenericInput>>(input: GenericInput, type: GenericType): input is ComputeResult<GenericInput, Type[GenericType]>;
+export {};

package/dist/common/isType.mjs

@@ -0,0 +1,22 @@
+const testTypeWrapper = {
+    string: (input) => typeof input === "string",
+    number: (input) => typeof input === "number",
+    bigint: (input) => typeof input === "bigint",
+    boolean: (input) => typeof input === "boolean",
+    function: (input) => typeof input === "function",
+    symbol: (input) => typeof input === "symbol",
+    undefined: (input) => typeof input === "undefined",
+    null: (input) => input === null,
+    array: (input) => input instanceof Array,
+    object: (input) => !!input && typeof input === "object" && !(input instanceof Array),
+};
+function isType(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (input) => isType(input, type);
+    }
+    const [input, type] = args;
+    return testTypeWrapper[type](input);
+}
+
+export { isType };

package/dist/common/not.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function not(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (input) => not(input, predicate);
+    }
+    const [input, predicate] = args;
+    return !predicate(input);
+}
+
+exports.not = not;

package/dist/common/not.d.ts

@@ -0,0 +1,2 @@
+export declare function not<GenericInput extends unknown, GenericPredicatedInput extends GenericInput>(predicate: (input: GenericInput) => input is GenericPredicatedInput): (input: GenericInput) => input is Exclude<GenericInput, GenericPredicatedInput>;
+export declare function not<GenericInput extends unknown, GenericPredicatedInput extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput): input is Exclude<GenericInput, GenericPredicatedInput>;

package/dist/common/not.mjs

@@ -0,0 +1,10 @@
+function not(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (input) => not(input, predicate);
+    }
+    const [input, predicate] = args;
+    return !predicate(input);
+}
+
+export { not };

package/dist/common/or.d.ts

@@ -0,0 +1,26 @@
+import { type AnyFunction } from "./types";
+type ExtractPredicate<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[]> = GenericPredicatedInput extends [
+    (input: any) => input is infer InferredPredicate,
+    ...infer InferredRest extends AnyFunction<any[], boolean>[]
+] ? InferredRest extends readonly [] ? InferredPredicate : InferredPredicate | ExtractPredicate<GenericInput, InferredRest> : GenericInput;
+export declare function or<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+    (input: GenericInput) => input is any,
+    (input: GenericInput) => input is any,
+    ...((input: GenericInput) => input is any)[]
+]>(predicatedList: GenericArrayPredicatedInput): (input: GenericInput) => input is Extract<GenericInput, ExtractPredicate<GenericInput, GenericArrayPredicatedInput>>;
+export declare function or<GenericInput extends unknown>(predicatedList: [
+    (input: GenericInput) => boolean,
+    (input: GenericInput) => boolean,
+    ...((input: GenericInput) => boolean)[]
+]): (input: GenericInput) => boolean;
+export declare function or<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+    (input: GenericInput) => input is any,
+    (input: GenericInput) => input is any,
+    ...((input: GenericInput) => input is any)[]
+]>(input: GenericInput, predicatedList: GenericArrayPredicatedInput): input is Extract<GenericInput, ExtractPredicate<GenericInput, GenericArrayPredicatedInput>>;
+export declare function or<GenericInput extends unknown>(input: GenericInput, predicatedList: [
+    (input: GenericInput) => boolean,
+    (input: GenericInput) => boolean,
+    ...((input: GenericInput) => boolean)[]
+]): boolean;
+export {};

package/dist/index.cjs

@@ -28,6 +28,9 @@ var loop = require('./common/loop.cjs');
 var forward = require('./common/forward.cjs');
 var when = require('./common/when.cjs');
 var whenNot = require('./common/whenNot.cjs');
+var equal = require('./common/equal.cjs');
+var not = require('./common/not.cjs');
+var isType = require('./common/isType.cjs');
 var index = require('./array/index.cjs');
 var index$1 = require('./number/index.cjs');
 var index$2 = require('./either/index.cjs');
@@ -72,6 +75,9 @@ exports.loop = loop.loop;
 exports.forward = forward.forward;
 exports.when = when.when;
 exports.whenNot = whenNot.whenNot;
+exports.equal = equal.equal;
+exports.not = not.not;
+exports.isType = isType.isType;
 exports.A = index;
 exports.DArray = index;
 exports.DNumber = index$1;

package/dist/index.mjs

@@ -26,6 +26,9 @@ export { loop } from './common/loop.mjs';
 export { forward } from './common/forward.mjs';
 export { when } from './common/when.mjs';
 export { whenNot } from './common/whenNot.mjs';
+export { equal } from './common/equal.mjs';
+export { not } from './common/not.mjs';
+export { isType } from './common/isType.mjs';
 import * as index from './array/index.mjs';
 export { index as A };
 export { index as DArray };

package/dist/object/deepDiscriminate.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var equal = require('../common/equal.cjs');
+var getDeepProperty = require('./getDeepProperty.cjs');
+
+function deepDiscriminate(...args) {
+    if (args.length === 2) {
+        const [path, value] = args;
+        return (input) => deepDiscriminate(input, path, value);
+    }
+    const [input, path, value] = args;
+    return equal.equal(getDeepProperty.getDeepProperty(input, path), value);
+}
+
+exports.deepDiscriminate = deepDiscriminate;

package/dist/object/deepDiscriminate.d.ts

@@ -0,0 +1,11 @@
+import { type EligibleEqual, type MaybeArray } from "../common";
+import { type UnFlatObject, type FlatObject } from "./types";
+import { type GetPropsWithValueExtends } from "./types/getPropsWithValueExtends";
+type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, EligibleEqual>>, `${string}[${string}]${string}`> : never;
+export declare function deepDiscriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): (input: GenericInput) => input is Extract<GenericInput, UnFlatObject<{
+    [Prop in GenericPath]: GenericValue;
+}>>;
+export declare function deepDiscriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(input: GenericInput, path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): input is Extract<GenericInput, UnFlatObject<{
+    [Prop in GenericPath]: GenericValue;
+}>>;
+export {};

package/dist/object/deepDiscriminate.mjs

@@ -0,0 +1,13 @@
+import { equal } from '../common/equal.mjs';
+import { getDeepProperty } from './getDeepProperty.mjs';
+
+function deepDiscriminate(...args) {
+    if (args.length === 2) {
+        const [path, value] = args;
+        return (input) => deepDiscriminate(input, path, value);
+    }
+    const [input, path, value] = args;
+    return equal(getDeepProperty(input, path), value);
+}
+
+export { deepDiscriminate };

package/dist/object/discriminate.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var equal = require('../common/equal.cjs');
+
+function discriminate(...args) {
+    if (args.length === 2) {
+        const [key, value] = args;
+        return (input) => discriminate(input, key, value);
+    }
+    const [input, key, value] = args;
+    return equal.equal(input[key], value);
+}
+
+exports.discriminate = discriminate;

package/dist/object/discriminate.d.ts

@@ -0,0 +1,8 @@
+import { type EligibleEqual, type MaybeArray } from "../common";
+import { type GetPropsWithValueExtends } from "./types/getPropsWithValueExtends";
+export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): (input: GenericInput) => input is Extract<GenericInput, {
+    [Prop in GenericKey]: GenericValue;
+}>;
+export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(input: GenericInput, key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): input is Extract<GenericInput, {
+    [Prop in GenericKey]: GenericValue;
+}>;

package/dist/object/discriminate.mjs

@@ -0,0 +1,12 @@
+import { equal } from '../common/equal.mjs';
+
+function discriminate(...args) {
+    if (args.length === 2) {
+        const [key, value] = args;
+        return (input) => discriminate(input, key, value);
+    }
+    const [input, key, value] = args;
+    return equal(input[key], value);
+}
+
+export { discriminate };

package/dist/object/getDeepProperty.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const regexExtractProperty = /([^.]*)(?:\.([^]*))?/;
+function getDeepProperty(...args) {
+    if (args.length === 1) {
+        const [path] = args;
+        return (input) => getDeepProperty(input, path);
+    }
+    const [input, path] = args;
+    const [_match, first, rest] = path.match(regexExtractProperty);
+    const currentValue = input[first];
+    if (rest) {
+        return getDeepProperty(currentValue, rest);
+    }
+    return currentValue;
+}
+
+exports.getDeepProperty = getDeepProperty;

package/dist/object/getDeepProperty.d.ts

@@ -0,0 +1,6 @@
+import { type EligibleEqual } from "../common";
+import { type FlatObject, type GetPropsWithValueExtends } from "./types";
+type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, EligibleEqual>>, `${string}[${string}]${string}`> : never;
+export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(path: GenericPath): (input: GenericInput) => GenericObjectProjection[GenericPath];
+export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(input: GenericInput, path: GenericPath): GenericObjectProjection[GenericPath];
+export {};

package/dist/object/getDeepProperty.mjs

@@ -0,0 +1,16 @@
+const regexExtractProperty = /([^.]*)(?:\.([^]*))?/;
+function getDeepProperty(...args) {
+    if (args.length === 1) {
+        const [path] = args;
+        return (input) => getDeepProperty(input, path);
+    }
+    const [input, path] = args;
+    const [_match, first, rest] = path.match(regexExtractProperty);
+    const currentValue = input[first];
+    if (rest) {
+        return getDeepProperty(currentValue, rest);
+    }
+    return currentValue;
+}
+
+export { getDeepProperty };

package/dist/object/index.cjs

@@ -13,6 +13,9 @@ var assign = require('./assign.cjs');
 var override = require('./override.cjs');
 var omit = require('./omit.cjs');
 var pick = require('./pick.cjs');
+var deepDiscriminate = require('./deepDiscriminate.cjs');
+var getDeepProperty = require('./getDeepProperty.cjs');
+var discriminate = require('./discriminate.cjs');
 
 
 
@@ -29,3 +32,6 @@ exports.assign = assign.assign;
 exports.override = override.override;
 exports.omit = omit.omit;
 exports.pick = pick.pick;
+exports.deepDiscriminate = deepDiscriminate.deepDiscriminate;
+exports.getDeepProperty = getDeepProperty.getDeepProperty;
+exports.discriminate = discriminate.discriminate;

package/dist/object/index.d.ts

@@ -12,3 +12,6 @@ export * from "./assign";
 export * from "./override";
 export * from "./omit";
 export * from "./pick";
+export * from "./deepDiscriminate";
+export * from "./getDeepProperty";
+export * from "./discriminate";

package/dist/object/index.mjs

@@ -11,3 +11,6 @@ export { assign } from './assign.mjs';
 export { override } from './override.mjs';
 export { omit } from './omit.mjs';
 export { pick } from './pick.mjs';
+export { deepDiscriminate } from './deepDiscriminate.mjs';
+export { getDeepProperty } from './getDeepProperty.mjs';
+export { discriminate } from './discriminate.mjs';

package/dist/object/types/getPropsWithValueExtends.d.ts

@@ -0,0 +1,3 @@
+export type GetPropsWithValueExtends<GenericObject extends object, GenericValue extends unknown> = {
+    [Prop in keyof GenericObject]: GenericObject[Prop] extends GenericValue ? Prop : never;
+}[keyof GenericObject];

package/dist/object/types/index.d.ts

@@ -4,3 +4,5 @@ export * from "./requiredKeys";
 export * from "./UnionObjectToIntersection";
 export * from "./getPropsWithValue";
 export * from "./flatObject";
+export * from "./getPropsWithValueExtends";
+export * from "./unFlatObject";

package/dist/object/types/unFlatObject.d.ts

@@ -0,0 +1,21 @@
+import { type IsEqual, type Adaptor, type LastUnionElement, type UnionToIntersection, type SimplifyTopLevel, type IsExtends } from "../../common";
+type GroupPath<GenericPath extends string> = IsEqual<GenericPath, never> extends true ? never : LastUnionElement<GenericPath> extends infer InferredLast ? InferredLast extends `${infer InferredFirst}.${string}` ? InferredFirst extends `[${number}]` ? Extract<GenericPath, `[${number}].${string}`> extends infer InferredResult ? ["[tuple]", InferredResult] | GroupPath<Exclude<GenericPath, InferredResult>> : never : Extract<GenericPath, `${InferredFirst}.${string}`> extends infer InferredResult ? [InferredFirst, InferredResult] | GroupPath<Exclude<GenericPath, InferredResult>> : never : InferredLast extends `[${number}]` ? ["[tuple]", Extract<GenericPath, `[${number}]`>] | GroupPath<Exclude<GenericPath, `[${number}]`>> : [InferredLast, InferredLast] | GroupPath<Exclude<GenericPath, InferredLast>> : never;
+type RemoveFirstFromKey<GenericObject extends object, GenericFirst extends string> = {
+    [Prop in keyof GenericObject as Prop extends `${GenericFirst}.${infer InferredRst}` ? InferredRst : never]: GenericObject[Prop];
+};
+type UnFlatTuple<GenericObject extends object, GenericGroupPath extends [string, string], GenericLastTuple extends unknown[] = []> = Extract<GenericGroupPath[1], `[${GenericLastTuple["length"]}]${string}`> extends infer InferredElementPath ? IsEqual<InferredElementPath, never> extends true ? GenericLastTuple : (IsEqual<InferredElementPath, `[${GenericLastTuple["length"]}]`> extends true ? [
+    ...GenericLastTuple,
+    GenericObject[Adaptor<InferredElementPath, keyof GenericObject>]
+] : [
+    ...GenericLastTuple,
+    UnFlatObject<RemoveFirstFromKey<Pick<GenericObject, Adaptor<InferredElementPath, keyof GenericObject>>, `[${GenericLastTuple["length"]}]`>>
+]) extends infer InferredResult extends any[] ? UnFlatTuple<GenericObject, GenericGroupPath, InferredResult> : never : never;
+export type UnFlatObject<GenericObject extends object> = GroupPath<Adaptor<keyof GenericObject, string>> extends infer InferredGroupedPath ? (InferredGroupedPath extends [
+    infer InferredFirst extends string,
+    infer InferredPath extends string
+] ? IsExtends<InferredFirst, "[tuple]"> extends true ? UnFlatTuple<GenericObject, InferredGroupedPath> : IsEqual<InferredFirst, "[number]"> extends true ? IsEqual<InferredFirst, InferredPath> extends true ? GenericObject[Adaptor<InferredFirst, keyof GenericObject>][] : UnFlatObject<RemoveFirstFromKey<Pick<GenericObject, Adaptor<InferredPath, keyof GenericObject>>, InferredFirst>>[] : IsEqual<InferredFirst, InferredPath> extends true ? {
+    [Prop in InferredFirst]: GenericObject[Adaptor<Prop, keyof GenericObject>];
+} : {
+    [Prop in InferredFirst]: UnFlatObject<RemoveFirstFromKey<Pick<GenericObject, Adaptor<InferredPath, keyof GenericObject>>, InferredFirst>>;
+} : never) extends infer InferredResult ? SimplifyTopLevel<UnionToIntersection<InferredResult>> : never : never;
+export {};

package/dist/pattern/index.cjs

@@ -3,11 +3,11 @@
 var result = require('./result.cjs');
 var exhaustive = require('./exhaustive.cjs');
 var otherwise = require('./otherwise.cjs');
-var matchPrimitive = require('./matchPrimitive.cjs');
 var match = require('./match.cjs');
 var isMatch = require('./isMatch.cjs');
 var pattern = require('./types/pattern.cjs');
 var union = require('./union.cjs');
+var when = require('./when.cjs');
 
 
 
@@ -15,8 +15,8 @@ exports.isResult = result.isResult;
 exports.result = result.result;
 exports.exhaustive = exhaustive.exhaustive;
 exports.otherwise = otherwise.otherwise;
-exports.matchPrimitive = matchPrimitive.matchPrimitive;
 exports.match = match.match;
 exports.isMatch = isMatch.isMatch;
 exports.SymbolToolPatternFunctionLabel = pattern.SymbolToolPatternFunctionLabel;
 exports.union = union.union;
+exports.when = when.when;

package/dist/pattern/index.d.ts

@@ -1,8 +1,8 @@
 export * from "./result";
 export * from "./exhaustive";
 export * from "./otherwise";
-export * from "./matchPrimitive";
 export * from "./match";
 export * from "./isMatch";
 export * from "./types";
 export * from "./union";
+export * from "./when";

package/dist/pattern/index.mjs

@@ -1,8 +1,8 @@
 export { isResult, result } from './result.mjs';
 export { exhaustive } from './exhaustive.mjs';
 export { otherwise } from './otherwise.mjs';
-export { matchPrimitive } from './matchPrimitive.mjs';
 export { match } from './match.mjs';
 export { isMatch } from './isMatch.mjs';
 export { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
 export { union } from './union.mjs';
+export { when } from './when.mjs';

package/dist/pattern/isMatch.cjs

@@ -3,7 +3,12 @@
 var pattern = require('./types/pattern.cjs');
 
 const SymbolToolPatternFunction = Symbol.for(pattern.SymbolToolPatternFunctionLabel);
-function isMatch(input, pattern) {
+function isMatch(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => isMatch(input, pattern);
+    }
+    const [input, pattern] = args;
     if (typeof pattern === "string"
         || typeof pattern === "number"
         || typeof pattern === "boolean"

package/dist/pattern/isMatch.d.ts

@@ -1,2 +1,5 @@
-import { type Pattern } from "./types/pattern";
-export declare function isMatch(input: unknown, pattern: Pattern): boolean;
+import { type ForcePredicate, type AnyValue, type FixDeepFunctionInfer } from "../common";
+import { type Pattern, type PatternValue } from "./types/pattern";
+import { type ComplexMatchedValue } from "./types";
+export declare function isMatch<GenericInput extends AnyValue, const GenericPattern extends Pattern<GenericInput>>(pattern: FixDeepFunctionInfer<Pattern<GenericInput>, GenericPattern>): (input: GenericInput) => input is ForcePredicate<GenericInput, ComplexMatchedValue<GenericInput, PatternValue<GenericPattern>>>;
+export declare function isMatch<GenericInput extends AnyValue, const GenericPattern extends Pattern<GenericInput>>(input: GenericInput, pattern: FixDeepFunctionInfer<Pattern<GenericInput>, GenericPattern>): input is ForcePredicate<GenericInput, ComplexMatchedValue<GenericInput, PatternValue<GenericPattern>>>;

package/dist/pattern/isMatch.mjs

@@ -1,7 +1,12 @@
 import { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
 
 const SymbolToolPatternFunction = Symbol.for(SymbolToolPatternFunctionLabel);
-function isMatch(input, pattern) {
+function isMatch(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => isMatch(input, pattern);
+    }
+    const [input, pattern] = args;
     if (typeof pattern === "string"
         || typeof pattern === "number"
         || typeof pattern === "boolean"

package/dist/pattern/match.cjs

@@ -9,7 +9,7 @@ function match(...args) {
         return (input) => match(input, pattern, theFunction);
     }
     const [input, pattern, theFunction] = args;
-    if (isMatch.isMatch(input, pattern)) {
+    if (!result.isResult(input) && isMatch.isMatch(input, pattern)) {
         return result.result(theFunction(input));
     }
     return input;

package/dist/pattern/match.mjs

@@ -1,4 +1,4 @@
-import { result } from './result.mjs';
+import { isResult, result } from './result.mjs';
 import { isMatch } from './isMatch.mjs';
 
 function match(...args) {
@@ -7,7 +7,7 @@ function match(...args) {
         return (input) => match(input, pattern, theFunction);
     }
     const [input, pattern, theFunction] = args;
-    if (isMatch(input, pattern)) {
+    if (!isResult(input) && isMatch(input, pattern)) {
         return result(theFunction(input));
     }
     return input;

package/dist/pattern/result.cjs

@@ -5,7 +5,7 @@ var wrapValue = require('../common/wrapValue.cjs');
 
 const patternResultKind = kind.createKind("pattern-result");
 function result(value) {
-    return patternResultKind.addTo(wrapValue.wrapValue(value), null);
+    return patternResultKind.addTo(wrapValue.wrapValue(value));
 }
 const isResult = patternResultKind.has;
 

package/dist/pattern/result.mjs

@@ -3,7 +3,7 @@ import { wrapValue } from '../common/wrapValue.mjs';
 
 const patternResultKind = createKind("pattern-result");
 function result(value) {
-    return patternResultKind.addTo(wrapValue(value), null);
+    return patternResultKind.addTo(wrapValue(value));
 }
 const isResult = patternResultKind.has;
 

package/dist/pattern/when.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var result = require('./result.cjs');
+
+function when(...args) {
+    if (args.length === 2) {
+        const [predicate, theFunction] = args;
+        return (input) => when(input, predicate, theFunction);
+    }
+    const [input, predicate, theFunction] = args;
+    if (!result.isResult(input) && predicate(input)) {
+        return result.result(theFunction(input));
+    }
+    return input;
+}
+
+exports.when = when;

package/dist/pattern/when.d.ts

@@ -0,0 +1,6 @@
+import { type AnyValue } from "../common";
+import { type PatternResult } from "./result";
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);

package/dist/pattern/when.mjs

@@ -0,0 +1,15 @@
+import { isResult, result } from './result.mjs';
+
+function when(...args) {
+    if (args.length === 2) {
+        const [predicate, theFunction] = args;
+        return (input) => when(input, predicate, theFunction);
+    }
+    const [input, predicate, theFunction] = args;
+    if (!isResult(input) && predicate(input)) {
+        return result(theFunction(input));
+    }
+    return input;
+}
+
+export { when };

package/dist/string/endsWith.d.ts

@@ -1,2 +1,5 @@
-export declare function endsWith<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${string}${GenericSearchString}`>;
-export declare function endsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${string}${GenericSearchString}`>;
+import { type IsEqual } from "../common";
+type ComputeResult<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${string}${GenericSearchString}`> extends infer InferredResult extends GenericString ? IsEqual<InferredResult, never> extends true ? GenericString & `${string}${GenericSearchString}` : InferredResult : never;
+export declare function endsWith<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (input: GenericString) => input is ComputeResult<GenericString, GenericSearchString>;
+export declare function endsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is ComputeResult<GenericString, GenericSearchString>;
+export {};

package/dist/string/includes.d.ts

@@ -1,2 +1,5 @@
-export declare function includes<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${string}${GenericSearchString}${string}`>;
-export declare function includes<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${string}${GenericSearchString}${string}`>;
+import { type IsEqual } from "../common";
+type ComputeResult<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${string}${GenericSearchString}${string}`> extends infer InferredResult extends GenericString ? IsEqual<InferredResult, never> extends true ? GenericString & `${string}${GenericSearchString}${string}` : InferredResult : never;
+export declare function includes<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (input: GenericString) => input is ComputeResult<GenericString, GenericSearchString>;
+export declare function includes<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is ComputeResult<GenericString, GenericSearchString>;
+export {};

package/dist/string/isIn.d.ts

@@ -1,2 +1,2 @@
-export declare function isIn<GenericInput extends string, GenericValue extends string>(array: readonly GenericValue[]): (input: GenericInput) => input is Extract<GenericInput, GenericValue>;
-export declare function isIn<GenericInput extends string, GenericValue extends string>(input: GenericInput, array: readonly GenericValue[]): input is Extract<GenericInput, GenericValue>;
+export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(array: readonly GenericValue[]): (input: GenericInput) => input is Extract<GenericInput, GenericValue>;
+export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(input: GenericInput, array: readonly GenericValue[]): input is Extract<GenericInput, GenericValue>;

package/dist/string/startsWith.d.ts

@@ -1,2 +1,5 @@
-export declare function startsWith<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${GenericSearchString}${string}`>;
-export declare function startsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${GenericSearchString}${string}`>;
+import { type IsEqual } from "../common";
+type ComputeResult<GenericString extends string, GenericSearchString extends string> = Extract<GenericString, `${GenericSearchString}${string}`> extends infer InferredResult extends GenericString ? IsEqual<InferredResult, never> extends true ? GenericString & `${GenericSearchString}${string}` : InferredResult : never;
+export declare function startsWith<GenericString extends string, GenericSearchString extends string>(searchString: GenericSearchString): (input: GenericString) => input is ComputeResult<GenericString, GenericSearchString>;
+export declare function startsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is ComputeResult<GenericString, GenericSearchString>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",

package/dist/pattern/matchPrimitive.cjs

@@ -1,17 +0,0 @@
-'use strict';
-
-var result = require('./result.cjs');
-
-function matchPrimitive(primitive, theFunction) {
-    const formattedPrimitive = primitive instanceof Array
-        ? primitive
-        : [primitive];
-    return (input) => {
-        if (!result.isResult(input) && formattedPrimitive.includes(input)) {
-            return result.result(theFunction(input));
-        }
-        return input;
-    };
-}
-
-exports.matchPrimitive = matchPrimitive;

package/dist/pattern/matchPrimitive.d.ts

@@ -1,3 +0,0 @@
-import { type AnyValue } from "..";
-import { type PatternResult } from "./result";
-export declare function matchPrimitive<GenericInput extends AnyValue, GenericMatch extends Exclude<GenericInput, PatternResult>, GenericOutput extends AnyValue>(primitive: GenericMatch | GenericMatch[], theFunction: (predicatedInput: Extract<GenericInput, GenericMatch>) => GenericOutput): (input: GenericInput) => PatternResult<GenericOutput> | Exclude<GenericInput, GenericMatch>;

package/dist/pattern/matchPrimitive.mjs

@@ -1,15 +0,0 @@
-import { isResult, result } from './result.mjs';
-
-function matchPrimitive(primitive, theFunction) {
-    const formattedPrimitive = primitive instanceof Array
-        ? primitive
-        : [primitive];
-    return (input) => {
-        if (!isResult(input) && formattedPrimitive.includes(input)) {
-            return result(theFunction(input));
-        }
-        return input;
-    };
-}
-
-export { matchPrimitive };