@duplojs/utils 0.3.0 → 1.0.0

package/dist/common/escapeRegExp.cjs

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

package/dist/common/escapeRegExp.mjs

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

package/dist/common/externalPromise.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function createExternalPromise() {
+    let resolve = undefined;
+    let reject = undefined;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        resolve,
+        reject,
+        promise,
+    };
+}
+
+exports.createExternalPromise = createExternalPromise;

package/dist/common/externalPromise.d.ts

@@ -0,0 +1,5 @@
+export declare function createExternalPromise<GenericPromiseValue extends unknown>(): {
+    resolve: (_value: GenericPromiseValue | Awaited<GenericPromiseValue> | Promise<GenericPromiseValue>) => void;
+    reject: (_value: unknown) => void;
+    promise: Promise<Awaited<GenericPromiseValue>>;
+};

package/dist/common/externalPromise.mjs

@@ -0,0 +1,15 @@
+function createExternalPromise() {
+    let resolve = undefined;
+    let reject = undefined;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        resolve,
+        reject,
+        promise,
+    };
+}
+
+export { createExternalPromise };

package/dist/common/forward.cjs

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

package/dist/common/forward.d.ts

@@ -0,0 +1 @@
+export declare function forward<GenericValue extends unknown>(value: GenericValue): GenericValue;

package/dist/common/forward.mjs

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

package/dist/common/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./types";
+export * from "./addWrappedProperties";
+export * from "./asyncPipe";
+export * from "./clone";
+export * from "./enum";
+export * from "./escapeRegExp";
+export * from "./externalPromise";
+export * from "./interpolation";
+export * from "./kind";
+export * from "./pipe";
+export * from "./promiseObject";
+export * from "./simpleClone";
+export * from "./sleep";
+export * from "./stringToBytes";
+export * from "./stringToMillisecond";
+export * from "./toJson";
+export * from "./toTransform";
+export * from "./toWrappedValue";
+export * from "./unwrap";
+export * from "./asyncLoop";
+export * from "./asyncRetry";
+export * from "./wrapValue";
+export * from "./toString";
+export * from "./innerPipe";
+export * from "./asyncInnerPipe";
+export * from "./loop";
+export * from "./forward";

package/dist/common/innerPipe.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function innerPipe(...pipes) {
+    return (input) => {
+        let acc = input;
+        for (const pipe of pipes) {
+            acc = pipe(acc);
+        }
+        return acc;
+    };
+}
+
+exports.innerPipe = innerPipe;

package/dist/common/innerPipe.d.ts

@@ -0,0 +1,12 @@
+import { type BreakGenericLink, type EscapeVoid } from "./types";
+import { type AnyValue } from "./types/anyValue";
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1): (input: GenericInput) => GenericOutputPipe1;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2): (input: GenericInput) => GenericOutputPipe2;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3): (input: GenericInput) => GenericOutputPipe3;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4): (input: GenericInput) => GenericOutputPipe4;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5): (input: GenericInput) => GenericOutputPipe5;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6): (input: GenericInput) => GenericOutputPipe6;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7): (input: GenericInput) => GenericOutputPipe7;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8): (input: GenericInput) => GenericOutputPipe8;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => GenericOutputPipe9): (input: GenericInput) => GenericOutputPipe9;
+export declare function innerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid, GenericOutputPipe10 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => GenericOutputPipe9, pipe10: (input: BreakGenericLink<GenericOutputPipe9>) => GenericOutputPipe10): (input: GenericInput) => GenericOutputPipe10;

package/dist/common/innerPipe.mjs

@@ -0,0 +1,11 @@
+function innerPipe(...pipes) {
+    return (input) => {
+        let acc = input;
+        for (const pipe of pipes) {
+            acc = pipe(acc);
+        }
+        return acc;
+    };
+}
+
+export { innerPipe };

package/dist/common/interpolation.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function createInterpolation(value, _strict) {
+    return (interpolationValues) => (interpolationValues
+        ? value.replace(/\{([^}]*)\}/g, (match, interpolationId) => interpolationValues[interpolationId])
+        : value);
+}
+
+exports.createInterpolation = createInterpolation;

package/dist/{interpolation.d.ts → common/interpolation.d.ts}

@@ -1,5 +1,5 @@
-import { type IsEqual } from "./isEqual";
-export type ExtractInterpolationId<GenericValue extends string> = GenericValue extends `${string}{${infer InferedInterpolationId}}${infer InferedEndValue}` ? InferedInterpolationId | ExtractInterpolationId<InferedEndValue> : never;
-export type ReplaceInterpolationIdByValues<GenericValue extends string, GenericInterpolationValues extends Record<string, string>> = GenericValue extends `${infer InferedStartValue}{${infer InferedInterpolationId}}${infer InferedEndValue}` ? InferedInterpolationId extends keyof GenericInterpolationValues ? `${InferedStartValue}${GenericInterpolationValues[InferedInterpolationId]}${ReplaceInterpolationIdByValues<InferedEndValue, GenericInterpolationValues>}` : `${InferedStartValue}${string}${ReplaceInterpolationIdByValues<InferedEndValue, GenericInterpolationValues>}` : GenericValue;
+import { type IsEqual } from "../common/types/isEqual";
+export type ExtractInterpolationId<GenericValue extends string> = GenericValue extends `${string}{${infer InferredInterpolationId}}${infer InferredEndValue}` ? InferredInterpolationId | ExtractInterpolationId<InferredEndValue> : never;
+export type ReplaceInterpolationIdByValues<GenericValue extends string, GenericInterpolationValues extends Record<string, string>> = GenericValue extends `${infer InferredStartValue}{${infer InferredInterpolationId}}${infer InferredEndValue}` ? InferredInterpolationId extends keyof GenericInterpolationValues ? `${InferredStartValue}${GenericInterpolationValues[InferredInterpolationId]}${ReplaceInterpolationIdByValues<InferredEndValue, GenericInterpolationValues>}` : `${InferredStartValue}${string}${ReplaceInterpolationIdByValues<InferredEndValue, GenericInterpolationValues>}` : GenericValue;
 export type CreateInterpolationContract<GenericInterpolationFunction extends ((value: Record<string, string>) => string)> = ReplaceInterpolationIdByValues<ReturnType<GenericInterpolationFunction>, {}>;
 export declare function createInterpolation<GenericValue extends string, GenericInterpolationId extends ExtractInterpolationId<GenericValue>, GenericStrict extends boolean>(value: GenericValue, strict?: GenericStrict): <GenericInterpolationMapperValue extends string, GenericInterpolationValues extends Record<GenericInterpolationId, GenericInterpolationMapperValue>>(...[interpolationValues]: IsEqual<GenericInterpolationId, never> extends true ? [] : [interpolationValues: GenericInterpolationValues]) => IsEqual<GenericStrict, true> extends true ? ReplaceInterpolationIdByValues<GenericValue, GenericInterpolationValues> : string;

package/dist/common/interpolation.mjs

@@ -0,0 +1,7 @@
+function createInterpolation(value, _strict) {
+    return (interpolationValues) => (interpolationValues
+        ? value.replace(/\{([^}]*)\}/g, (match, interpolationId) => interpolationValues[interpolationId])
+        : value);
+}
+
+export { createInterpolation };

package/dist/common/kind.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var wrapValue = require('./wrapValue.cjs');
+
+const keyKindPrefix = `${wrapValue.keyWrappedValue}/kind/`;
+function createKind(name) {
+    const runTimeKey = `${keyKindPrefix}${name}`;
+    return {
+        definition: undefined,
+        runTimeKey,
+        addTo(input, value = null) {
+            return {
+                ...input,
+                [runTimeKey]: value,
+            };
+        },
+        has(input) {
+            return input
+                && typeof input === "object"
+                && runTimeKey in input;
+        },
+        getValue(input) {
+            return input[runTimeKey];
+        },
+    };
+}
+
+exports.createKind = createKind;
+exports.keyKindPrefix = keyKindPrefix;

package/dist/common/kind.d.ts

@@ -0,0 +1,26 @@
+import { type Or, type IsEqual } from "./types";
+export interface KindHandler<GenericKindDefinition extends KindDefinition> {
+    definition: GenericKindDefinition;
+    runTimeKey: string;
+    has<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Kind<GenericKindDefinition, GenericKindDefinition["value"]>>;
+    addTo<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> & 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> {
+    name: GenericName;
+    value: GenericValue;
+}
+declare const SymbolKind: unique symbol;
+type SymbolKind = typeof SymbolKind;
+export interface Kind<GenericKindDefinition extends KindDefinition, GenericValue extends KindDefinition["value"] = KindDefinition["value"]> {
+    [SymbolKind]: {
+        [Prop in GenericKindDefinition["name"]]: GenericValue;
+    };
+}
+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 {};

package/dist/common/kind.mjs

@@ -0,0 +1,26 @@
+import { keyWrappedValue } from './wrapValue.mjs';
+
+const keyKindPrefix = `${keyWrappedValue}/kind/`;
+function createKind(name) {
+    const runTimeKey = `${keyKindPrefix}${name}`;
+    return {
+        definition: undefined,
+        runTimeKey,
+        addTo(input, value = null) {
+            return {
+                ...input,
+                [runTimeKey]: value,
+            };
+        },
+        has(input) {
+            return input
+                && typeof input === "object"
+                && runTimeKey in input;
+        },
+        getValue(input) {
+            return input[runTimeKey];
+        },
+    };
+}
+
+export { createKind, keyKindPrefix };

package/dist/common/loop.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function loop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            return result["-exitData"];
+        }
+        previousOutput = result["-nextData"];
+    }
+}
+
+exports.loop = loop;

package/dist/common/loop.d.ts

@@ -0,0 +1,15 @@
+import { type AnyValue } from "./types/anyValue";
+interface LoopOutputExistResult<GenericOutput extends any> {
+    "-exitData": GenericOutput;
+}
+interface LoopOutputNextResult<GenericOutput extends any> {
+    "-nextData": GenericOutput;
+}
+export interface LoopParams<GenericRawNextOutput extends any> {
+    count: number;
+    previousOutput: GenericRawNextOutput | undefined;
+    next<GenericValue extends GenericRawNextOutput | undefined = undefined>(output?: GenericValue): LoopOutputNextResult<GenericValue>;
+    exit<GenericOutput extends AnyValue = undefined>(output?: GenericOutput): LoopOutputExistResult<GenericOutput>;
+}
+export declare function loop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: LoopParams<GenericRawNextOutput>) => LoopOutputNextResult<GenericRawNextOutput> | LoopOutputExistResult<GenericRawExitOutput>): GenericRawExitOutput;
+export {};

package/dist/common/loop.mjs

@@ -0,0 +1,17 @@
+function loop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            return result["-exitData"];
+        }
+        previousOutput = result["-nextData"];
+    }
+}
+
+export { loop };

package/dist/common/pipe.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+function pipe(input, ...pipes) {
+    let acc = input;
+    for (const pipe of pipes) {
+        acc = pipe(acc);
+    }
+    return acc;
+}
+
+exports.pipe = pipe;

package/dist/common/pipe.d.ts

@@ -0,0 +1,12 @@
+import { type BreakGenericLink, type EscapeVoid } from "./types";
+import { type AnyValue } from "./types/anyValue";
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1): GenericOutputPipe1;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2): GenericOutputPipe2;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3): GenericOutputPipe3;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4): GenericOutputPipe4;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5): GenericOutputPipe5;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6): GenericOutputPipe6;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7): GenericOutputPipe7;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8): GenericOutputPipe8;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => GenericOutputPipe9): GenericOutputPipe9;
+export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid, GenericOutputPipe10 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: BreakGenericLink<GenericInput>) => GenericOutputPipe1, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => GenericOutputPipe2, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => GenericOutputPipe3, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => GenericOutputPipe4, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => GenericOutputPipe5, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => GenericOutputPipe6, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => GenericOutputPipe7, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => GenericOutputPipe8, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => GenericOutputPipe9, pipe10: (input: BreakGenericLink<GenericOutputPipe9>) => GenericOutputPipe10): GenericOutputPipe10;

package/dist/common/pipe.mjs

@@ -0,0 +1,9 @@
+function pipe(input, ...pipes) {
+    let acc = input;
+    for (const pipe of pipes) {
+        acc = pipe(acc);
+    }
+    return acc;
+}
+
+export { pipe };

package/dist/common/promiseObject.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function promiseObject(object) {
+    return Promise
+        .all(Object.entries(object)
+        .map(([key, promisedValue]) => promisedValue instanceof Promise
+        ? promisedValue.then((value) => [key, value])
+        : [key, promisedValue]))
+        .then((entries) => Object.fromEntries(entries));
+}
+
+exports.promiseObject = promiseObject;

package/dist/common/promiseObject.d.ts

@@ -0,0 +1,7 @@
+import { type AnyValue } from "../common/types/anyValue";
+import { type MaybePromise } from "../common/types/maybePromise";
+import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
+export type AwaitedPromiseObject<GenericObject extends Record<string, MaybePromise<unknown>>> = {
+    [Prop in keyof GenericObject]: Awaited<GenericObject[Prop]>;
+};
+export declare function promiseObject<GenericValue extends AnyValue, GenericObject extends Record<string, MaybePromise<GenericValue>>>(object: GenericObject): Promise<SimplifyTopLevel<AwaitedPromiseObject<GenericObject>>>;

package/dist/common/promiseObject.mjs

@@ -0,0 +1,10 @@
+function promiseObject(object) {
+    return Promise
+        .all(Object.entries(object)
+        .map(([key, promisedValue]) => promisedValue instanceof Promise
+        ? promisedValue.then((value) => [key, value])
+        : [key, promisedValue]))
+        .then((entries) => Object.fromEntries(entries));
+}
+
+export { promiseObject };

package/dist/common/simpleClone.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+function simpleClone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue.constructor?.name === "Object"
+        || unknownValue.constructor === undefined) {
+        return Object.entries(unknownValue).reduce((pv, [key, value]) => {
+            pv[key] = simpleClone(value);
+            return pv;
+        }, {});
+    }
+    else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
+        return unknownValue.map(simpleClone);
+    }
+    else {
+        return unknownValue;
+    }
+}
+
+exports.simpleClone = simpleClone;

package/dist/common/simpleClone.d.ts

@@ -0,0 +1 @@
+export declare function simpleClone<GenericObject extends unknown = unknown>(unknownValue: GenericObject): GenericObject;

package/dist/common/simpleClone.mjs

@@ -0,0 +1,23 @@
+function simpleClone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue.constructor?.name === "Object"
+        || unknownValue.constructor === undefined) {
+        return Object.entries(unknownValue).reduce((pv, [key, value]) => {
+            pv[key] = simpleClone(value);
+            return pv;
+        }, {});
+    }
+    else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
+        return unknownValue.map(simpleClone);
+    }
+    else {
+        return unknownValue;
+    }
+}
+
+export { simpleClone };

package/dist/common/sleep.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function sleep(millieSeconde) {
+    return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
+}
+
+exports.sleep = sleep;

package/dist/common/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(millieSeconde?: number): Promise<void>;

package/dist/common/sleep.mjs

@@ -0,0 +1,5 @@
+function sleep(millieSeconde) {
+    return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
+}
+
+export { sleep };

package/dist/common/stringToBytes.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var isKeyof = require('../string/isKeyof.cjs');
+
+/* eslint-disable id-length */
+const kind = "kind-invalid-bytes-in-string-error";
+class InvalidBytesInStringError extends Error {
+    input;
+    constructor(input) {
+        super(`Invalid Input: ${input}`);
+        this.input = input;
+    }
+    [kind] = null;
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "InvalidBytesInStringError"
+            && kind in value;
+    }
+}
+const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>b|kb|mb|gb|tb|pd)/;
+const unitMapper = {
+    b: 1,
+    kb: 1 << 10,
+    mb: 1 << 20,
+    gb: 1 << 30,
+    tb: Math.pow(1024, 4),
+    pb: Math.pow(1024, 5),
+};
+function stringToBytes(bytesInString) {
+    if (typeof bytesInString === "number") {
+        return bytesInString;
+    }
+    const regExpResults = parseRegExp.exec(bytesInString);
+    const { rawValue, unit } = regExpResults?.groups ?? {};
+    const value = parseFloat(rawValue ?? "");
+    if (isNaN(value) || !unit || !isKeyof.isKeyof(unit, unitMapper)) {
+        throw new InvalidBytesInStringError(bytesInString);
+    }
+    return Math.floor(unitMapper[unit] * value);
+}
+
+exports.InvalidBytesInStringError = InvalidBytesInStringError;
+exports.stringToBytes = stringToBytes;

package/dist/{stringToBytes.d.ts → common/stringToBytes.d.ts}

@@ -1,6 +1,9 @@
+declare const kind = "kind-invalid-bytes-in-string-error";
 export declare class InvalidBytesInStringError extends Error {
     input: string;
     constructor(input: string);
+    [kind]: unknown;
+    static instanceof(value: unknown): value is InvalidBytesInStringError;
 }
 declare const unitMapper: {
     b: number;

package/dist/common/stringToBytes.mjs

@@ -0,0 +1,40 @@
+import { isKeyof } from '../string/isKeyof.mjs';
+
+/* eslint-disable id-length */
+const kind = "kind-invalid-bytes-in-string-error";
+class InvalidBytesInStringError extends Error {
+    input;
+    constructor(input) {
+        super(`Invalid Input: ${input}`);
+        this.input = input;
+    }
+    [kind] = null;
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "InvalidBytesInStringError"
+            && kind in value;
+    }
+}
+const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>b|kb|mb|gb|tb|pd)/;
+const unitMapper = {
+    b: 1,
+    kb: 1 << 10,
+    mb: 1 << 20,
+    gb: 1 << 30,
+    tb: Math.pow(1024, 4),
+    pb: Math.pow(1024, 5),
+};
+function stringToBytes(bytesInString) {
+    if (typeof bytesInString === "number") {
+        return bytesInString;
+    }
+    const regExpResults = parseRegExp.exec(bytesInString);
+    const { rawValue, unit } = regExpResults?.groups ?? {};
+    const value = parseFloat(rawValue ?? "");
+    if (isNaN(value) || !unit || !isKeyof(unit, unitMapper)) {
+        throw new InvalidBytesInStringError(bytesInString);
+    }
+    return Math.floor(unitMapper[unit] * value);
+}
+
+export { InvalidBytesInStringError, stringToBytes };

package/dist/common/stringToMillisecond.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var isKeyof = require('../string/isKeyof.cjs');
+
+/* 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.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;
+}
+
+exports.InvalidMillisecondInStringError = InvalidMillisecondInStringError;
+exports.stringToMillisecond = stringToMillisecond;