@duplojs/utils 1.0.6 → 1.1.7

package/dist/array/coalescing.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function coalescing(value) {
+    return value instanceof Array
+        ? value
+        : [value];
+}
+
+exports.coalescing = coalescing;

package/dist/array/coalescing.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "../common";
+import { type ArrayCoalescing } from "./types";
+export declare function coalescing<GenericValue extends AnyValue>(value: GenericValue): ArrayCoalescing<GenericValue>;

package/dist/array/coalescing.mjs

@@ -0,0 +1,7 @@
+function coalescing(value) {
+    return value instanceof Array
+        ? value
+        : [value];
+}
+
+export { coalescing };

package/dist/array/index.cjs

@@ -49,6 +49,7 @@ var insert$1 = require('./findAndSplice/insert.cjs');
 var replace$1 = require('./findAndSplice/replace.cjs');
 var sum = require('./sum.cjs');
 var length = require('./length.cjs');
+var coalescing = require('./coalescing.cjs');
 
 
 
@@ -103,3 +104,4 @@ exports.findAndSpliceInsert = insert$1.findAndSpliceInsert;
 exports.findAndSpliceReplace = replace$1.findAndSpliceReplace;
 exports.sum = sum.sum;
 exports.length = length.length;
+exports.coalescing = coalescing.coalescing;

package/dist/array/index.d.ts

@@ -39,3 +39,4 @@ export * from "./findAndReplace";
 export * from "./findAndSplice";
 export * from "./sum";
 export * from "./length";
+export * from "./coalescing";

package/dist/array/index.mjs

@@ -47,3 +47,4 @@ export { findAndSpliceInsert } from './findAndSplice/insert.mjs';
 export { findAndSpliceReplace } from './findAndSplice/replace.mjs';
 export { sum } from './sum.mjs';
 export { length } from './length.mjs';
+export { coalescing } from './coalescing.mjs';

package/dist/array/map.cjs

@@ -6,7 +6,7 @@ function map(...args) {
         return (array) => map(array, theFunction);
     }
     const [array, theFunction] = args;
-    return array.map((item, index) => theFunction(item, { index }));
+    return array.map((element, index) => theFunction(element, { index }));
 }
 
 exports.map = map;

package/dist/array/map.d.ts

@@ -1,6 +1,6 @@
 interface ArrayMapParams {
     index: number;
 }
-export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (item: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
-export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (item: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
+export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
+export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
 export {};

package/dist/array/map.mjs

@@ -4,7 +4,7 @@ function map(...args) {
         return (array) => map(array, theFunction);
     }
     const [array, theFunction] = args;
-    return array.map((item, index) => theFunction(item, { index }));
+    return array.map((element, index) => theFunction(element, { index }));
 }
 
 export { map };

package/dist/array/reduce.cjs

@@ -7,7 +7,7 @@ var override = require('../object/override.cjs');
 
 const arrayReduceFromKind = kind.createKind("array-reduce-from");
 function reduceFrom(value) {
-    return arrayReduceFromKind.addTo(wrapValue.wrapValue(value));
+    return arrayReduceFromKind.setTo(wrapValue.wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/array/reduce.mjs

@@ -5,7 +5,7 @@ import { override } from '../object/override.mjs';
 
 const arrayReduceFromKind = createKind("array-reduce-from");
 function reduceFrom(value) {
-    return arrayReduceFromKind.addTo(wrapValue(value));
+    return arrayReduceFromKind.setTo(wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/array/types/ArrayCoalescing.d.ts

@@ -0,0 +1 @@
+export type ArrayCoalescing<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue : [GenericValue];

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

@@ -7,3 +7,4 @@ export * from "./mergeUnionTuple";
 export * from "./extractTuple";
 export * from "./excludeTuple";
 export * from "./createTuple";
+export * from "./ArrayCoalescing";

package/dist/common/escapeRegExp.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+function escapeRegExp(input) {
+    return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
 
 exports.escapeRegExp = escapeRegExp;

package/dist/common/escapeRegExp.d.ts

@@ -1 +1 @@
-export declare function escapeRegExp(text: string): string;
+export declare function escapeRegExp<GenericInput extends string>(input: GenericInput): string;

package/dist/common/escapeRegExp.mjs

@@ -1,5 +1,5 @@
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+function escapeRegExp(input) {
+    return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
 
 export { escapeRegExp };

package/dist/common/index.d.ts

@@ -32,3 +32,7 @@ export * from "./not";
 export * from "./isType";
 export * from "./and";
 export * from "./or";
+export * from "./whenElse";
+export * from "./justReturn";
+export * from "./memo";
+export * from "./instanceOf";

package/dist/common/instanceOf.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var coalescing = require('../array/coalescing.cjs');
+
+function instanceOf(...args) {
+    if (args.length === 1) {
+        const [constructor] = args;
+        return (input) => instanceOf(input, constructor);
+    }
+    const [input, constructor] = args;
+    const formattedConstructor = coalescing.coalescing(constructor);
+    for (const constructor of formattedConstructor) {
+        if (input instanceof constructor) {
+            return true;
+        }
+    }
+    return false;
+}
+
+exports.instanceOf = instanceOf;

package/dist/common/instanceOf.d.ts

@@ -0,0 +1,3 @@
+import { type AnyConstructor } from "./types";
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(constructor: GenericConstructor | GenericConstructor[]): (input: GenericInput) => input is Extract<GenericInput, InstanceType<GenericConstructor>>;
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(input: GenericInput, constructor: GenericConstructor | GenericConstructor[]): input is Extract<GenericInput, InstanceType<GenericConstructor>>;

package/dist/common/instanceOf.mjs

@@ -0,0 +1,18 @@
+import { coalescing } from '../array/coalescing.mjs';
+
+function instanceOf(...args) {
+    if (args.length === 1) {
+        const [constructor] = args;
+        return (input) => instanceOf(input, constructor);
+    }
+    const [input, constructor] = args;
+    const formattedConstructor = coalescing(constructor);
+    for (const constructor of formattedConstructor) {
+        if (input instanceof constructor) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { instanceOf };

package/dist/common/justReturn.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+exports.justReturn = justReturn;

package/dist/common/justReturn.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "./types";
+export declare function justReturn<GenericValue extends AnyValue>(value: GenericValue): (input: unknown) => GenericValue;
+export declare function justReturn<GenericValue extends AnyValue>(input: unknown, value: GenericValue): GenericValue;

package/dist/common/justReturn.mjs

@@ -0,0 +1,10 @@
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+export { justReturn };

package/dist/common/kind.cjs

@@ -6,7 +6,10 @@ const keyKindPrefix = `${wrapValue.keyWrappedValue}/kind/`;
 function createKind(name) {
     const runTimeKey = `${keyKindPrefix}${name}`;
     return {
-        definition: undefined,
+        definition: {
+            name,
+            value: null,
+        },
         runTimeKey,
         addTo(input, value = null) {
             return {
@@ -14,6 +17,10 @@ function createKind(name) {
                 [runTimeKey]: value,
             };
         },
+        setTo(input, value = null) {
+            input[runTimeKey] = value;
+            return input;
+        },
         has(input) {
             return input
                 && typeof input === "object"
@@ -24,6 +31,36 @@ function createKind(name) {
         },
     };
 }
+function kindHeritage(uniqueName, kind) {
+    const uniqueKind = createKind(uniqueName);
+    const kinds = kind instanceof Array
+        ? kind
+        : [kind];
+    const ParentKindClass = (function ParentKindClass(params = {}) {
+        for (const kind of kinds) {
+            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+        }
+    });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
+    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
+        value: (value) => {
+            if (!uniqueKind.has(value)) {
+                return false;
+            }
+            for (const kind of kinds) {
+                if (!kind.has(value)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    });
+    return ParentKindClass;
+}
 
 exports.createKind = createKind;
 exports.keyKindPrefix = keyKindPrefix;
+exports.kindHeritage = kindHeritage;

package/dist/common/kind.d.ts

@@ -1,5 +1,6 @@
-import { type Or, type IsEqual } from "./types";
-export interface KindHandler<GenericKindDefinition extends KindDefinition> {
+import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection } from "./types";
+import { type GetPropsWithValue, type PartialKeys } from "../object";
+export interface KindHandler<GenericKindDefinition extends KindDefinition = KindDefinition> {
     definition: GenericKindDefinition;
     runTimeKey: string;
     has<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Kind<GenericKindDefinition, GenericKindDefinition["value"]>>;
@@ -7,7 +8,15 @@ export interface KindHandler<GenericKindDefinition extends KindDefinition> {
         IsEqual<GenericValue, never>,
         IsEqual<GenericValue, unknown>,
         IsEqual<GenericValue, any>
-    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & GenericInput;
+    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
+    /**
+     * @deprecated This method make mutation.
+     */
+    setTo<GenericInput extends {}, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]>(...args: Or<[
+        IsEqual<GenericValue, never>,
+        IsEqual<GenericValue, unknown>,
+        IsEqual<GenericValue, any>
+    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
     getValue<GenericKind extends Kind<GenericKindDefinition, GenericKindDefinition["value"]>>(input: GenericKind): GenericKind[SymbolKind][GenericKindDefinition["name"]];
 }
 export interface KindDefinition<GenericName extends string = string, GenericValue extends unknown = unknown> {
@@ -16,11 +25,20 @@ export interface KindDefinition<GenericName extends string = string, GenericValu
 }
 declare const SymbolKind: unique symbol;
 type SymbolKind = typeof SymbolKind;
-export interface Kind<GenericKindDefinition extends KindDefinition, GenericValue extends KindDefinition["value"] = KindDefinition["value"]> {
+export interface Kind<GenericKindDefinition extends KindDefinition, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]> {
     [SymbolKind]: {
         [Prop in GenericKindDefinition["name"]]: GenericValue;
     };
 }
+export type RemoveKind<GenericObject extends Kind<any>> = Omit<GenericObject, SymbolKind>;
+export type GetKindValue<GenericKindHandler extends KindHandler, GenericObject extends Kind<any>> = GenericObject[SymbolKind][GenericKindHandler["definition"]["name"]];
+export type GetKindHandler<GenericObject extends Kind<any>> = {
+    [Prop in keyof GenericObject[SymbolKind]]: KindHandler<KindDefinition<Adaptor<Prop, string>, GenericObject[SymbolKind][Prop]>>;
+}[keyof GenericObject[SymbolKind]];
 export declare const keyKindPrefix = "@duplojs/utils/value/kind/";
 export declare function createKind<GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName): KindHandler<KindDefinition<GenericName, GenericKindValue>>;
+export type KindHeritageConstructorParams<GenericKindHandler extends KindHandler> = {
+    [KindHandler in GenericKindHandler as KindHandler["definition"]["name"]]: KindHandler["definition"]["value"];
+} extends infer InferredResult extends object ? PartialKeys<InferredResult, GetPropsWithValue<InferredResult, unknown>> : never;
+export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler>(uniqueName: GenericUniqueName, kind: GenericKindHandler | GenericKindHandler[]): new (...args: IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>>>;
 export {};

package/dist/common/kind.mjs

@@ -4,7 +4,10 @@ const keyKindPrefix = `${keyWrappedValue}/kind/`;
 function createKind(name) {
     const runTimeKey = `${keyKindPrefix}${name}`;
     return {
-        definition: undefined,
+        definition: {
+            name,
+            value: null,
+        },
         runTimeKey,
         addTo(input, value = null) {
             return {
@@ -12,6 +15,10 @@ function createKind(name) {
                 [runTimeKey]: value,
             };
         },
+        setTo(input, value = null) {
+            input[runTimeKey] = value;
+            return input;
+        },
         has(input) {
             return input
                 && typeof input === "object"
@@ -22,5 +29,34 @@ function createKind(name) {
         },
     };
 }
+function kindHeritage(uniqueName, kind) {
+    const uniqueKind = createKind(uniqueName);
+    const kinds = kind instanceof Array
+        ? kind
+        : [kind];
+    const ParentKindClass = (function ParentKindClass(params = {}) {
+        for (const kind of kinds) {
+            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+        }
+    });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
+    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
+        value: (value) => {
+            if (!uniqueKind.has(value)) {
+                return false;
+            }
+            for (const kind of kinds) {
+                if (!kind.has(value)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    });
+    return ParentKindClass;
+}
 
-export { createKind, keyKindPrefix };
+export { createKind, keyKindPrefix, kindHeritage };

package/dist/common/memo.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function memo(theFunction) {
+    const payload = {
+        get value() {
+            const value = theFunction();
+            Object.defineProperty(payload, "value", {
+                value,
+            });
+            return value;
+        },
+    };
+    return payload;
+}
+
+exports.memo = memo;

package/dist/common/memo.d.ts

@@ -0,0 +1,5 @@
+import { type AnyValue } from "./types";
+export interface Memoized<GenericValue extends unknown> {
+    readonly value: GenericValue;
+}
+export declare function memo<GenericOutput extends AnyValue>(theFunction: () => GenericOutput): Memoized<GenericOutput>;

package/dist/common/memo.mjs

@@ -0,0 +1,14 @@
+function memo(theFunction) {
+    const payload = {
+        get value() {
+            const value = theFunction();
+            Object.defineProperty(payload, "value", {
+                value,
+            });
+            return value;
+        },
+    };
+    return payload;
+}
+
+export { memo };

package/dist/common/simpleClone.cjs

@@ -7,8 +7,8 @@ function simpleClone(unknownValue) {
     else if (typeof unknownValue !== "object") {
         return unknownValue;
     }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
+    else if (unknownValue.constructor === undefined
+        || unknownValue.constructor.name === "Object") {
         return Object.entries(unknownValue).reduce((pv, [key, value]) => {
             pv[key] = simpleClone(value);
             return pv;

package/dist/common/simpleClone.mjs

@@ -5,8 +5,8 @@ function simpleClone(unknownValue) {
     else if (typeof unknownValue !== "object") {
         return unknownValue;
     }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
+    else if (unknownValue.constructor === undefined
+        || unknownValue.constructor.name === "Object") {
         return Object.entries(unknownValue).reduce((pv, [key, value]) => {
             pv[key] = simpleClone(value);
             return pv;

package/dist/common/types/anyConstructor.d.ts

@@ -0,0 +1 @@
+export type AnyConstructor<GenericArgs extends any[] = any[], GenericInstance extends any = any> = new (...args: GenericArgs) => GenericInstance;

package/dist/common/types/anyPredicate.d.ts

@@ -0,0 +1 @@
+export type AnyPredicate<GenericInput extends any = any, GenericArgs extends any[] = any[], GenericPredicate extends GenericInput = any> = (input: GenericInput, ...args: GenericArgs) => input is GenericPredicate;

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

@@ -35,3 +35,5 @@ export * from "./lastUnionElement";
 export * from "./removeDuplicateInUnion";
 export * from "./isStringLIteral";
 export * from "./maybeWrapped";
+export * from "./anyConstructor";
+export * from "./anyPredicate";

package/dist/common/types/objectEntry.d.ts

@@ -1,2 +1,2 @@
 import { type ObjectKey } from "./objectKey";
-export type ObjectEntry = [ObjectKey, any];
+export type ObjectEntry = readonly [ObjectKey, any];

package/dist/common/types/predicate.d.ts

@@ -0,0 +1 @@
+export type Predicate<GenericFunction extends (input: any, ...args: any[]) => input is any> = GenericFunction extends (input: any, ...args: any[]) => input is infer InferredPredicate ? InferredPredicate : never;

package/dist/common/types/unionContain.d.ts

@@ -1,2 +1,2 @@
 import { type IsEqual } from "./isEqual";
-export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never, boolean>;
+export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<(GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never) | false, boolean>;

package/dist/common/when.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/common/whenElse.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+exports.whenElse = whenElse;

package/dist/common/whenElse.d.ts

@@ -0,0 +1,5 @@
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): (input: GenericInput) => BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): (input: GenericInput) => GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;

package/dist/common/whenElse.mjs

@@ -0,0 +1,15 @@
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+export { whenElse };

package/dist/common/whenNot.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | GenericPredicatedInput;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | BreakGenericLink<GenericPredicatedInput>;
 export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): GenericOutput | GenericPredicatedInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;