@duplojs/utils 1.1.11 → 1.1.13

package/dist/array/index.cjs

@@ -50,6 +50,7 @@ var replace$1 = require('./findAndSplice/replace.cjs');
 var sum = require('./sum.cjs');
 var length = require('./length.cjs');
 var coalescing = require('./coalescing.cjs');
+var toTuple = require('./toTuple.cjs');
 
 
 
@@ -105,3 +106,4 @@ exports.findAndSpliceReplace = replace$1.findAndSpliceReplace;
 exports.sum = sum.sum;
 exports.length = length.length;
 exports.coalescing = coalescing.coalescing;
+exports.toTuple = toTuple.toTuple;

package/dist/array/index.d.ts

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

package/dist/array/index.mjs

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

package/dist/array/toTuple.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function toTuple(...args) {
+    if (args.length === 1) {
+        const [shape] = args;
+        return (input) => toTuple(input, shape);
+    }
+    const [input, shapeObject] = args;
+    return shapeObject.map((theFunction) => theFunction(input));
+}
+
+exports.toTuple = toTuple;

package/dist/array/toTuple.d.ts

@@ -0,0 +1,12 @@
+import { type FixDeepFunctionInfer, type AnyFunction } from "../common";
+type ShapeTuple<GenericInput extends unknown = unknown> = readonly [
+    (input: GenericInput) => unknown,
+    ...((input: GenericInput) => unknown)[]
+];
+type ComputesResult<GenericShapeTuple extends ShapeTuple<any>> = GenericShapeTuple extends readonly [
+    infer InferredFirst extends AnyFunction,
+    ...infer InferredRest extends ShapeTuple<any> | readonly []
+] ? InferredRest extends ShapeTuple<any> ? ComputesResult<InferredRest> extends infer inferredResult extends readonly any[] ? [ReturnType<InferredFirst>, ...inferredResult] : never : [ReturnType<InferredFirst>] : never;
+export declare function toTuple<GenericInput extends unknown, GenericShapeTuple extends ShapeTuple<NoInfer<GenericInput>>>(shapeObject: ShapeTuple<NoInfer<GenericInput>> & GenericShapeTuple): (input: GenericInput) => ComputesResult<NoInfer<GenericShapeTuple>>;
+export declare function toTuple<GenericInput extends unknown, GenericShapeTuple extends ShapeTuple<GenericInput>>(input: GenericInput, shapeObject: FixDeepFunctionInfer<ShapeTuple<GenericInput>, GenericShapeTuple>): ComputesResult<GenericShapeTuple>;
+export {};

package/dist/array/toTuple.mjs

@@ -0,0 +1,10 @@
+function toTuple(...args) {
+    if (args.length === 1) {
+        const [shape] = args;
+        return (input) => toTuple(input, shape);
+    }
+    const [input, shapeObject] = args;
+    return shapeObject.map((theFunction) => theFunction(input));
+}
+
+export { toTuple };

package/dist/common/equal.d.ts

@@ -1,3 +1,14 @@
+import { type Or, type UnionContain } from "./types";
 export type EligibleEqual = string | null | number | undefined | bigint | boolean | symbol;
-export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(value: GenericValue | GenericValue[]): (input: GenericInput) => input is NoInfer<GenericValue>;
-export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(input: GenericInput, value: GenericValue | GenericValue[]): input is GenericValue;
+type ExpectLiteral<GenericValue extends EligibleEqual> = Or<[
+    UnionContain<GenericValue, string>,
+    UnionContain<GenericValue, number>,
+    UnionContain<GenericValue, boolean>,
+    UnionContain<GenericValue, bigint>,
+    UnionContain<GenericValue, symbol>
+]> extends true ? never : GenericValue;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(value: ExpectLiteral<GenericValue> | ExpectLiteral<GenericValue>[]): (input: GenericInput) => input is NoInfer<GenericValue>;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(value: GenericValue | GenericValue[]): (input: GenericInput) => boolean;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(input: GenericInput, value: ExpectLiteral<GenericValue> | ExpectLiteral<GenericValue>[]): input is GenericValue;
+export declare function equal<GenericInput extends EligibleEqual, GenericValue extends GenericInput>(input: GenericInput, value: GenericValue | GenericValue[]): boolean;
+export {};

package/dist/common/kind.cjs

@@ -35,22 +35,21 @@ function createKindNamespace(namespace) {
         return kindHandler;
     };
 }
-function kindHeritage(uniqueName, kind) {
+function kindHeritage(uniqueName, kind, parent) {
     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;
+    const Extendable = (parent ?? class {
     });
-    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
-    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
-        value: (value) => {
+    const ParentKindClass = (class extends Extendable {
+        constructor(params = {}, parentParams = []) {
+            super(...parentParams);
+            for (const kind of kinds) {
+                this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+            }
+        }
+        static [Symbol.hasInstance](value) {
             if (!uniqueKind.has(value)) {
                 return false;
             }
@@ -60,8 +59,12 @@ function kindHeritage(uniqueName, kind) {
                 }
             }
             return true;
-        },
+        }
     });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
     return ParentKindClass;
 }
 function isRuntimeKind(value) {

package/dist/common/kind.d.ts

@@ -1,5 +1,5 @@
 import { type ForbiddenString } from "../string";
-import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection } from "./types";
+import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection, type AnyConstructor, type NeverCoalescing, type And } from "./types";
 import { type GetPropsWithValue, type PartialKeys } from "../object";
 export interface KindHandler<GenericKindDefinition extends KindDefinition = KindDefinition> {
     definition: GenericKindDefinition;
@@ -49,6 +49,6 @@ export declare function createKindNamespace<GenericNamespace extends string>(nam
 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 & ForbiddenKindCharacters<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 declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler, GenericParent extends AnyConstructor = never>(uniqueName: GenericUniqueName & ForbiddenKindCharacters<GenericUniqueName>, kind: GenericKindHandler | GenericKindHandler[], parent?: GenericParent): new (...args: And<[IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true>, IsEqual<GenericParent, never>]> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>, ...parentArgs: IsEqual<ConstructorParameters<GenericParent>, never> extends true ? [parentParams?: ConstructorParameters<GenericParent>] : [parentParams: ConstructorParameters<GenericParent>]]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>> | NeverCoalescing<GenericParent, {}>>;
 export declare function isRuntimeKind(value: string): boolean;
 export {};

package/dist/common/kind.mjs

@@ -33,22 +33,21 @@ function createKindNamespace(namespace) {
         return kindHandler;
     };
 }
-function kindHeritage(uniqueName, kind) {
+function kindHeritage(uniqueName, kind, parent) {
     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;
+    const Extendable = (parent ?? class {
     });
-    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
-    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
-        value: (value) => {
+    const ParentKindClass = (class extends Extendable {
+        constructor(params = {}, parentParams = []) {
+            super(...parentParams);
+            for (const kind of kinds) {
+                this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+            }
+        }
+        static [Symbol.hasInstance](value) {
             if (!uniqueKind.has(value)) {
                 return false;
             }
@@ -58,8 +57,12 @@ function kindHeritage(uniqueName, kind) {
                 }
             }
             return true;
-        },
+        }
     });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
     return ParentKindClass;
 }
 function isRuntimeKind(value) {

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

@@ -38,3 +38,4 @@ export * from "./maybeWrapped";
 export * from "./anyConstructor";
 export * from "./anyPredicate";
 export * from "./removeFromUnion";
+export * from "./unwrapArray";

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

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

package/dist/string/types/digit.d.ts

@@ -0,0 +1 @@
+export type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";

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

@@ -7,3 +7,5 @@ export * from "./normalizeForm";
 export * from "./split";
 export * from "./stringLength";
 export * from "./forbiddenString";
+export * from "./number";
+export * from "./digit";

package/dist/string/types/number.d.ts

@@ -0,0 +1 @@
+export type Number = `${number}`;

package/package.json

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