@duplojs/utils 0.3.0 → 1.0.0

package/dist/common/stringToMillisecond.d.ts

@@ -0,0 +1,18 @@
+declare const kind = "kind-invalid-millisecond-in-string-error";
+export declare class InvalidMillisecondInStringError extends Error {
+    input: string;
+    constructor(input: string);
+    [kind]: unknown;
+    static instanceof(value: unknown): value is InvalidMillisecondInStringError;
+}
+declare const unitMapper: {
+    ms: number;
+    s: number;
+    m: number;
+    h: number;
+    d: number;
+    w: number;
+};
+export type MillisecondInString = `${number}${keyof typeof unitMapper}` | `${number}.${number}${keyof typeof unitMapper}`;
+export declare function stringToMillisecond(millisecondInString: MillisecondInString | number, ...millisecondInStrings: (MillisecondInString | number)[]): number;
+export {};

package/dist/common/stringToMillisecond.mjs

@@ -0,0 +1,45 @@
+import { isKeyof } from '../string/isKeyof.mjs';
+
+/* eslint-disable id-length */
+const kind = "kind-invalid-millisecond-in-string-error";
+class InvalidMillisecondInStringError extends Error {
+    input;
+    constructor(input) {
+        super(`Invalid Input: ${input}`);
+        this.input = input;
+    }
+    [kind] = null;
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "InvalidMillisecondInStringError"
+            && kind in value;
+    }
+}
+const unitMapper = {
+    ms: 1,
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+    w: 604_800_000,
+};
+const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>ms|s|m|h|d|w)/;
+function stringToMillisecond(millisecondInString, ...millisecondInStrings) {
+    if (typeof millisecondInString === "number") {
+        return millisecondInString;
+    }
+    const result = parseRegExp.exec(millisecondInString);
+    const { rawValue, unit } = result?.groups ?? {};
+    const value = parseFloat(rawValue ?? "");
+    if (isNaN(value) || !unit || !isKeyof(unit, unitMapper)) {
+        throw new InvalidMillisecondInStringError(millisecondInString);
+    }
+    const millisecond = Math.floor(value * unitMapper[unit]);
+    const [otherMillisecondInString, ...restMillisecondInStrings] = millisecondInStrings;
+    if (otherMillisecondInString) {
+        return millisecond + stringToMillisecond(otherMillisecondInString, ...restMillisecondInStrings);
+    }
+    return millisecond;
+}
+
+export { InvalidMillisecondInStringError, stringToMillisecond };

package/dist/common/toJson.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+function toJSON(value) {
+    if (typeof value === "string"
+        || typeof value === "number"
+        || value === null
+        || value === undefined) {
+        return value;
+    }
+    else if (typeof value === "object"
+        && "toJSON" in value
+        && typeof value.toJSON === "function") {
+        return value.toJSON();
+    }
+    else if (typeof value === "object"
+        && (!value.constructor
+            || value.constructor.name === "Object")) {
+        return Object
+            .entries(value)
+            .reduce((pv, [key, value]) => ({
+            ...pv,
+            [key]: toJSON(value),
+        }), {});
+    }
+    else if (value instanceof Array
+        && value.constructor.name === "Array") {
+        return value.map(toJSON);
+    }
+    else {
+        return undefined;
+    }
+}
+
+exports.toJSON = toJSON;

package/dist/common/toJson.d.ts

@@ -0,0 +1,11 @@
+import { type AnyFunction } from "./types/anyFunction";
+import { type IsEqual } from "./types/isEqual";
+export type ToJSON<GenericValue extends unknown> = GenericValue extends number | string | null | undefined ? GenericValue : GenericValue extends ({
+    toJSON: AnyFunction;
+}) ? ReturnType<GenericValue["toJSON"]> : GenericValue extends [infer InferredFirst, ...infer InferredRest] ? [
+    ToJSON<InferredFirst>,
+    ...(ToJSON<InferredRest> extends infer InferredSubRest extends any[] ? IsEqual<InferredSubRest, never[]> extends false ? InferredSubRest : [] : [])
+] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends Record<number, unknown> ? {
+    [Prop in keyof GenericValue as GenericValue[Prop] extends AnyFunction ? never : Prop]: ToJSON<GenericValue[Prop]>;
+} : undefined;
+export declare function toJSON<GenericValue extends unknown>(value: GenericValue): ToJSON<GenericValue>;

package/dist/common/toJson.mjs

@@ -0,0 +1,32 @@
+function toJSON(value) {
+    if (typeof value === "string"
+        || typeof value === "number"
+        || value === null
+        || value === undefined) {
+        return value;
+    }
+    else if (typeof value === "object"
+        && "toJSON" in value
+        && typeof value.toJSON === "function") {
+        return value.toJSON();
+    }
+    else if (typeof value === "object"
+        && (!value.constructor
+            || value.constructor.name === "Object")) {
+        return Object
+            .entries(value)
+            .reduce((pv, [key, value]) => ({
+            ...pv,
+            [key]: toJSON(value),
+        }), {});
+    }
+    else if (value instanceof Array
+        && value.constructor.name === "Array") {
+        return value.map(toJSON);
+    }
+    else {
+        return undefined;
+    }
+}
+
+export { toJSON };

package/dist/common/toString.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function toString(value) {
+    return `${value}`;
+}
+
+exports.toString = toString;

package/dist/common/toString.d.ts

@@ -0,0 +1 @@
+export declare function toString<GenericValue extends number | string | bigint | boolean | null | undefined>(value: GenericValue): `${GenericValue}`;

package/dist/common/toString.mjs

@@ -0,0 +1,5 @@
+function toString(value) {
+    return `${value}`;
+}
+
+export { toString };

package/dist/common/toTransform.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+function toTransform(value) {
+    if (typeof value === "string"
+        || typeof value === "number"
+        || value === null
+        || value === undefined) {
+        return value;
+    }
+    else if (value
+        && typeof value === "object"
+        && "toTransform" in value
+        && typeof value.toTransform === "function") {
+        return (value.toTransform());
+    }
+    else if (typeof value === "object"
+        && (!value.constructor
+            || value.constructor.name === "Object")) {
+        return Object.entries(value)
+            .reduce((pv, [key, value]) => ({
+            ...pv,
+            [key]: toTransform(value),
+        }), {});
+    }
+    else if (value instanceof Array
+        && value.constructor.name === "Array") {
+        return value.map((subValue) => toTransform(subValue));
+    }
+    else {
+        return value;
+    }
+}
+
+exports.toTransform = toTransform;

package/dist/common/toTransform.d.ts

@@ -0,0 +1,11 @@
+import { type AnyFunction } from "./types/anyFunction";
+import { type IsEqual } from "./types/isEqual";
+export type ToTransform<GenericValue extends unknown> = GenericValue extends number | string | null | undefined ? GenericValue : GenericValue extends ({
+    toTransform: AnyFunction;
+}) ? ReturnType<GenericValue["toTransform"]> : GenericValue extends [infer InferredFirst, ...infer InferredRest] ? [
+    ToTransform<InferredFirst>,
+    ...(ToTransform<InferredRest> extends infer InferredSubRest extends any[] ? IsEqual<InferredSubRest, never[]> extends false ? InferredSubRest : [] : [])
+] : GenericValue extends any[] ? ToTransform<GenericValue[number]>[] : GenericValue extends Record<number, unknown> ? {
+    [Prop in keyof GenericValue]: ToTransform<GenericValue[Prop]>;
+} : GenericValue;
+export declare function toTransform<GenericValue extends unknown>(value: GenericValue): ToTransform<GenericValue>;

package/dist/common/toTransform.mjs

@@ -0,0 +1,32 @@
+function toTransform(value) {
+    if (typeof value === "string"
+        || typeof value === "number"
+        || value === null
+        || value === undefined) {
+        return value;
+    }
+    else if (value
+        && typeof value === "object"
+        && "toTransform" in value
+        && typeof value.toTransform === "function") {
+        return (value.toTransform());
+    }
+    else if (typeof value === "object"
+        && (!value.constructor
+            || value.constructor.name === "Object")) {
+        return Object.entries(value)
+            .reduce((pv, [key, value]) => ({
+            ...pv,
+            [key]: toTransform(value),
+        }), {});
+    }
+    else if (value instanceof Array
+        && value.constructor.name === "Array") {
+        return value.map((subValue) => toTransform(subValue));
+    }
+    else {
+        return value;
+    }
+}
+
+export { toTransform };

package/dist/common/toWrappedValue.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var wrapValue = require('./wrapValue.cjs');
+
+function toWrappedValue(value) {
+    return wrapValue.isWrappedValue(value)
+        ? value
+        : wrapValue.wrapValue(value);
+}
+
+exports.toWrappedValue = toWrappedValue;

package/dist/common/toWrappedValue.d.ts

@@ -0,0 +1,4 @@
+import { type WrappedValue } from "../common/wrapValue";
+import { type MaybeWrapped } from "./types/maybeWrapped";
+import { type AnyValue } from "./types";
+export declare function toWrappedValue<GenericInnerValue extends AnyValue, GenericValue extends MaybeWrapped<GenericInnerValue>>(value: GenericValue): GenericValue extends WrappedValue ? GenericValue : WrappedValue<GenericValue>;

package/dist/common/toWrappedValue.mjs

@@ -0,0 +1,9 @@
+import { wrapValue, isWrappedValue } from './wrapValue.mjs';
+
+function toWrappedValue(value) {
+    return isWrappedValue(value)
+        ? value
+        : wrapValue(value);
+}
+
+export { toWrappedValue };

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

@@ -0,0 +1 @@
+export type IsExtends<GenericValueA extends unknown, GenericValueB extends unknown> = GenericValueA extends GenericValueB ? true : false;

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

@@ -0,0 +1 @@
+export type Adaptor<GenericValue extends unknown, GenericExpectedType extends unknown, GenericElse extends unknown = never> = GenericValue extends GenericExpectedType ? GenericValue : GenericElse;

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

@@ -0,0 +1,23 @@
+export interface NumberTailer {
+    "0": "1";
+    "1": "2";
+    "2": "3";
+    "3": "4";
+    "4": "5";
+    "5": "6";
+    "6": "7";
+    "7": "8";
+    "8": "9";
+    "9": "0";
+}
+type MakeArrayFromString<GenericValue extends string> = GenericValue extends `${infer InferredFirst}${infer InferredRest}` ? [InferredFirst, ...MakeArrayFromString<InferredRest>] : [];
+type MakeStringFromArray<GenericValue extends string[]> = GenericValue extends [infer InferredFirst extends string, ...infer InferredRest extends string[]] ? `${InferredFirst}${MakeStringFromArray<InferredRest>}` : "";
+type MakeNumberFromArray<GenericValue extends string[]> = MakeStringFromArray<GenericValue> extends `${infer InferredValue extends number}` ? InferredValue : never;
+export type AddOne<GenericValue extends number> = MakeArrayFromString<`${GenericValue}`> extends [
+    ...infer InferredRest extends string[],
+    infer InferredLast extends keyof NumberTailer
+] ? NumberTailer[InferredLast] extends "0" ? MakeNumberFromArray<[
+    InferredRest extends [] ? "1" : `${AddOne<MakeNumberFromArray<InferredRest>>}`,
+    NumberTailer[InferredLast]
+]> : MakeNumberFromArray<[...InferredRest, NumberTailer[InferredLast]]> : never;
+export {};

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type And<GenericBooleans extends [boolean, ...boolean[]]> = IsEqual<GenericBooleans[number], true>;

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

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

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

@@ -0,0 +1,4 @@
+import { type ObjectKey } from "./objectKey";
+export interface AnyObject {
+    [key: ObjectKey]: any;
+}

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

@@ -0,0 +1 @@
+export type AnyTuple<GenericValue extends unknown = any> = readonly [GenericValue, ...GenericValue[]];

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

@@ -0,0 +1,2 @@
+import { type AnyFunction } from "./anyFunction";
+export type AnyValue = string | number | boolean | object | null | bigint | AnyFunction | undefined | symbol;

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

@@ -0,0 +1 @@
+export type BreakGenericLink<GenericValue extends unknown> = [GenericValue][GenericValue extends never ? 0 : never];

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

@@ -0,0 +1,6 @@
+import { type AddOne } from "./addOne";
+import { type IsEqual } from "./isEqual";
+export type CreateTupleFromLength<GenericInnerValue extends unknown, GenericLength extends number, GenericIncrement extends number = 1> = IsEqual<GenericLength, number> extends false ? GenericLength extends GenericIncrement ? [GenericInnerValue, ...GenericInnerValue[]] : [
+    GenericInnerValue,
+    ...(GenericIncrement extends 48 ? GenericInnerValue[] : CreateTupleFromLength<GenericInnerValue, GenericLength, AddOne<GenericIncrement>>)
+] : GenericInnerValue[];

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

@@ -0,0 +1,3 @@
+export type DeepPartial<GenericPattern extends object> = {
+    [Prop in keyof GenericPattern]?: GenericPattern[Prop] extends object ? DeepPartial<GenericPattern[Prop]> : GenericPattern[Prop];
+};

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

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

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

@@ -0,0 +1 @@
+export type EscapeAny = any;

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

@@ -0,0 +1 @@
+export type EscapeVoid = void;

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

@@ -0,0 +1,6 @@
+import { type IsEqual } from "./isEqual";
+export interface ExpectType<GenericOne extends unknown, GenericTwo extends GenericOne, GenericRule extends (IsEqual<GenericOne, GenericTwo> extends true ? "strict" : (GenericOne extends GenericTwo ? true : 1) extends (GenericTwo extends GenericOne ? true : 2) ? "flexible" : GenericOne extends GenericTwo ? "one-extends-two" : GenericTwo extends GenericOne ? "two-extends-one" : "none")> {
+    one: GenericOne;
+    two: GenericTwo;
+    rule: GenericRule;
+}

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type FixDeepFunctionInfer<GenericValue extends unknown, GenericValueInfer extends unknown> = IsEqual<GenericValueInfer, never> extends true ? NoInfer<GenericValue> : GenericValueInfer;

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

@@ -0,0 +1,3 @@
+export type ForcePredicate<GenericArgValue extends unknown, GenericWantValue extends unknown> = ({
+    [Prop in GenericWantValue as "prop"]: Prop;
+} & Record<string, GenericArgValue>)["prop"];

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

@@ -0,0 +1,37 @@
+export * from "./addOne";
+export * from "./anyFunction";
+export * from "./anyValue";
+export * from "./createTupleFromLength";
+export * from "./escapeAny";
+export * from "./escapeVoid";
+export * from "./expectType";
+export * from "./isEqual";
+export * from "./maybeArray";
+export * from "./maybePromise";
+export * from "./simplifyTopLevel";
+export * from "./simplifyType";
+export * from "./simplifyTypeForce";
+export * from "./unionToIntersection";
+export * from "./unionToTuple";
+export * from "./isUnion";
+export * from "./anyTuple";
+export * from "./anyObject";
+export * from "./objectEntry";
+export * from "./objectKey";
+export * from "./toLargeEnsemble";
+export * from "./deepPartial";
+export * from "./fixDeepFunctionInfer";
+export * from "./adaptor";
+export * from "./neverCoalescing";
+export * from "./unionContain";
+export * from "./forcePredicate";
+export * from "./IsExtends";
+export * from "./removeReadonly";
+export * from "./deepRemoveReadonly";
+export * from "./and";
+export * from "./or";
+export * from "./breakGenericLink";
+export * from "./not";
+export * from "./lastUnionElement";
+export * from "./removeDuplicateInUnion";
+export * from "./isStringLIteral";

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type IsStringLiteral<GenericString extends string> = IsEqual<GenericString, string> extends true ? false : true;

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type IsUnion<GenericValue extends unknown, GenericCloneValue extends unknown = GenericValue> = IsEqual<GenericValue, never> extends true ? false : GenericValue extends unknown ? IsEqual<GenericValue, GenericCloneValue> extends true ? false : true : never;

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

@@ -0,0 +1,2 @@
+import { type UnionToIntersection } from "./unionToIntersection";
+export type LastUnionElement<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;

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

@@ -0,0 +1 @@
+export type MaybeArray<GenericValue extends unknown> = GenericValue | GenericValue[];

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

@@ -0,0 +1 @@
+export type MaybePromise<GenericValue extends unknown> = GenericValue | Promise<GenericValue>;

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

@@ -0,0 +1,2 @@
+import { type WrappedValue } from "../../common/wrapValue";
+export type MaybeWrapped<GenericInnerValue extends unknown> = GenericInnerValue | WrappedValue<GenericInnerValue>;

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type NeverCoalescing<GenericValue extends unknown, GenericCoalescingValue extends unknown> = IsEqual<GenericValue, never> extends true ? GenericCoalescingValue : GenericValue;

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

@@ -0,0 +1 @@
+export type Not<GenericBoolean extends boolean> = GenericBoolean extends false ? true : false;

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

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

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

@@ -0,0 +1 @@
+export type ObjectKey = keyof any;

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

@@ -0,0 +1,2 @@
+import { type IsEqual } from "./isEqual";
+export type Or<GenericBooleans extends [boolean, ...boolean[]]> = IsEqual<GenericBooleans[number] | false, boolean>;

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

@@ -0,0 +1,4 @@
+import { type IsEqual } from "./isEqual";
+import { type IsUnion } from "./isUnion";
+import { type LastUnionElement } from "./lastUnionElement";
+export type RemoveDuplicateInUnion<GenericValue extends unknown> = IsUnion<GenericValue> extends true ? LastUnionElement<GenericValue> extends infer InferredValue ? (InferredValue | RemoveDuplicateInUnion<GenericValue extends any ? IsEqual<GenericValue, InferredValue> extends true ? never : GenericValue : never>) : never : GenericValue;

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

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

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

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

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

@@ -0,0 +1,3 @@
+export type SimplifyType<GenericValue extends unknown> = GenericValue extends Record<number, unknown> ? {
+    [Prop in keyof GenericValue]: SimplifyType<GenericValue[Prop]>;
+} : GenericValue;

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

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

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

@@ -0,0 +1,6 @@
+export type ToLargeEnsemble<GenericValue extends unknown> = GenericValue extends string ? string : GenericValue extends number ? number : GenericValue extends bigint ? bigint : GenericValue extends boolean ? boolean : GenericValue extends null ? null : GenericValue extends undefined ? undefined : GenericValue extends symbol ? symbol : GenericValue extends [infer InferredValue, ...infer InferredRest] ? [
+    ToLargeEnsemble<InferredValue>,
+    ...ToLargeEnsemble<InferredRest>
+] : GenericValue extends never[] ? [] : GenericValue extends (infer InferredValue)[] ? ToLargeEnsemble<InferredValue>[] : GenericValue extends object ? {
+    [Prop in keyof GenericValue]: ToLargeEnsemble<GenericValue[Prop]>;
+} : GenericValue extends (...args: infer InferredArgs) => infer InferredReturn ? (...args: ToLargeEnsemble<InferredArgs>) => ToLargeEnsemble<InferredReturn> : GenericValue extends Promise<infer InferredValue> ? InferredValue : never;

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

@@ -0,0 +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>;

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

@@ -0,0 +1 @@
+export type UnionToIntersection<GenericUnion extends unknown> = (GenericUnion extends any ? (_x: GenericUnion) => any : never) extends (_x: infer InferredArg) => any ? InferredArg : never;

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

@@ -0,0 +1,5 @@
+import { type LastUnionElement } from "./lastUnionElement";
+type PushElementToTuple<T extends any[], V> = [...T, V];
+export type UnionToTuple<T, L = LastUnionElement<T>, N = [T] extends [never] ? true : false> = true extends N ? [
+] : PushElementToTuple<UnionToTuple<Exclude<T, L>>, L>;
+export {};

package/dist/common/unwrap.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var wrapValue = require('./wrapValue.cjs');
+
+function unwrap(anyValue) {
+    return anyValue && typeof anyValue === "object" && wrapValue.keyWrappedValue in anyValue
+        ? anyValue[wrapValue.keyWrappedValue]
+        : anyValue;
+}
+
+exports.unwrap = unwrap;

package/dist/common/unwrap.d.ts

@@ -0,0 +1,4 @@
+import { type WrappedValue } from "./wrapValue";
+import { type AnyValue } from "./types/anyValue";
+export type Unwrap<GenericAnyValue extends unknown> = GenericAnyValue extends WrappedValue<infer inferredValue> ? inferredValue : GenericAnyValue;
+export declare function unwrap<GenericValue extends AnyValue, GenericAnyValue extends AnyValue | WrappedValue<GenericValue>>(anyValue: GenericAnyValue): Unwrap<GenericAnyValue>;

package/dist/common/unwrap.mjs

@@ -0,0 +1,9 @@
+import { keyWrappedValue } from './wrapValue.mjs';
+
+function unwrap(anyValue) {
+    return anyValue && typeof anyValue === "object" && keyWrappedValue in anyValue
+        ? anyValue[keyWrappedValue]
+        : anyValue;
+}
+
+export { unwrap };

package/dist/common/when.d.ts

@@ -0,0 +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>;
+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/whenNot.d.ts

@@ -0,0 +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;
+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;

package/dist/common/wrapValue.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const keyWrappedValue = "@duplojs/utils/value";
+function wrapValue(value) {
+    return {
+        [keyWrappedValue]: value,
+    };
+}
+function isWrappedValue(input) {
+    return !!input && typeof input === "object" && keyWrappedValue in input;
+}
+
+exports.isWrappedValue = isWrappedValue;
+exports.keyWrappedValue = keyWrappedValue;
+exports.wrapValue = wrapValue;

package/dist/common/wrapValue.d.ts

@@ -0,0 +1,9 @@
+declare const SymbolWrappedValue: unique symbol;
+export type SymbolWrappedValue = typeof SymbolWrappedValue;
+export declare const keyWrappedValue = "@duplojs/utils/value";
+export interface WrappedValue<GenericValue extends unknown = unknown> {
+    [SymbolWrappedValue]: GenericValue;
+}
+export declare function wrapValue<const GenericValue extends unknown>(value: GenericValue): WrappedValue<GenericValue>;
+export declare function isWrappedValue<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, WrappedValue<any>>;
+export {};

package/dist/common/wrapValue.mjs

@@ -0,0 +1,11 @@
+const keyWrappedValue = "@duplojs/utils/value";
+function wrapValue(value) {
+    return {
+        [keyWrappedValue]: value,
+    };
+}
+function isWrappedValue(input) {
+    return !!input && typeof input === "object" && keyWrappedValue in input;
+}
+
+export { isWrappedValue, keyWrappedValue, wrapValue };

package/dist/either/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const eitherInformationKind = kind.createKind("either-information");
+
+exports.eitherInformationKind = eitherInformationKind;

package/dist/either/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"either-information", string>>;

package/dist/either/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../common/kind.mjs';
+
+const eitherInformationKind = createKind("either-information");
+
+export { eitherInformationKind };

package/dist/either/bool/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+
+const eitherBoolKind = kind.createKind("either-bool");
+
+exports.eitherBoolKind = eitherBoolKind;