@duplojs/utils 0.1.0

package/README.md

@@ -0,0 +1,2 @@
+# @duplojs/utils
+[![NPM version](https://img.shields.io/npm/v/@duplojs/utils)](https://www.npmjs.com/package/@duplojs/utils)

package/dist/addThis.d.ts

@@ -0,0 +1,2 @@
+import type { AnyFunction } from "./types";
+export type AddThis<T extends AnyFunction, A extends unknown> = (this: A, ...args: Parameters<T>) => ReturnType<T>;

package/dist/clone.d.ts

@@ -0,0 +1,2 @@
+import { type SimplifyTypeForce } from "./simplifyType";
+export declare function clone<T extends unknown = unknown>(unknownValue: T): SimplifyTypeForce<T>;

package/dist/entryUseMapper.d.ts

@@ -0,0 +1,6 @@
+import type { AnyFunction, ObjectEntry, ObjectKey } from "./types";
+import type { UnionToIntersection } from "./unionToIntersection";
+export type EntriesToMapper<E extends ObjectEntry> = UnionToIntersection<E extends [infer K, infer V] ? {
+    [_P in K extends ObjectKey ? K : never]: (_value: V, _key: K) => any;
+} : never>;
+export declare function entryUseMapper<E extends ObjectEntry, M extends EntriesToMapper<E>, R = ReturnType<M[keyof M] extends AnyFunction ? M[keyof M] : never>>([key, value]: E, mapper: M): R;

package/dist/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(text: string): string;

package/dist/expectType.d.ts

@@ -0,0 +1,5 @@
+export interface ExpectType<GenericOne extends unknown, GenericTwo extends unknown, GenericRule extends ((<V>() => V extends GenericOne ? 1 : 2) extends (<V>() => V extends GenericTwo ? 1 : 2) ? "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" : never)> {
+    one: GenericOne;
+    two: GenericTwo;
+    rule: GenericRule;
+}

package/dist/getLastOfUnion.d.ts

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

package/dist/getPropsWithTrueValue.d.ts

@@ -0,0 +1,3 @@
+export type GetPropsWithTrueValue<O extends object> = {
+    [P in keyof O]: O[P] extends true ? P : never;
+}[keyof O];

package/dist/getTypedEntries.d.ts

@@ -0,0 +1,6 @@
+export type GetEntries<O extends object, T = {
+    [P in keyof O]-?: O[P];
+}> = {
+    [P in keyof T]: [P, T[P]];
+}[keyof T][];
+export declare function getTypedEntries<O extends object>(object: O): GetEntries<O>;

package/dist/getTypedKeys.d.ts

@@ -0,0 +1 @@
+export declare function getTypedKeys<O extends object>(object: O): (keyof O)[];

package/dist/hasKey.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectKey } from "./types";
+export declare function hasKey<O extends object>(obj: O, key: ObjectKey): key is keyof O;

package/dist/incremente.d.ts

@@ -0,0 +1,33 @@
+export interface NumberTail {
+    0: 1;
+    1: 2;
+    2: 3;
+    3: 4;
+    4: 5;
+    5: 6;
+    6: 7;
+    7: 8;
+    8: 9;
+    9: 10;
+    10: 11;
+    11: 12;
+    12: 13;
+    13: 14;
+    14: 15;
+    15: 16;
+    16: 17;
+    17: 18;
+    18: 19;
+    19: 20;
+    20: 21;
+    21: 22;
+    22: 23;
+    23: 24;
+    24: 25;
+    25: 26;
+    26: 27;
+    27: 28;
+    28: 29;
+    29: 30;
+}
+export type AddOne<T extends number> = T extends keyof NumberTail ? NumberTail[T] : never;

package/dist/index.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+function getTypedEntries(object) {
+    return Object.entries(object);
+}
+
+function clone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue instanceof Array) {
+        return unknownValue.map(clone);
+    }
+    else {
+        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
+            pv[key] = clone(value);
+            return pv;
+        }, {});
+    }
+}
+
+function entryUseMapper([key, value], mapper) {
+    const ReTypedMapper = mapper;
+    return ReTypedMapper[key](value);
+}
+
+function escapeRegExp(text) {
+    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+
+function getTypedKeys(object) {
+    return Object.keys(object);
+}
+
+function hasKey(obj, key) {
+    return key in obj;
+}
+
+function simpleClone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue.constructor?.name === "Object"
+        || unknownValue.constructor === undefined) {
+        return getTypedEntries(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;
+    }
+}
+
+function sleep(milliseconde) {
+    return new Promise((resolve) => void setTimeout(resolve, milliseconde));
+}
+
+/* eslint-disable id-length */
+class InvalidBytesInStringError extends Error {
+    input;
+    constructor(input) {
+        super("Invalid Input");
+        this.input = input;
+    }
+}
+const parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+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 floatValue = regExpResults
+        ? parseFloat(regExpResults[1])
+        : parseInt(bytesInString, 10);
+    const unit = regExpResults
+        ? regExpResults[4].toLowerCase()
+        : "b";
+    if (!hasKey(unitMapper, unit) || isNaN(floatValue)) {
+        throw new InvalidBytesInStringError(bytesInString);
+    }
+    return Math.floor(unitMapper[unit] * floatValue);
+}
+
+class UnPartialError extends Error {
+    key;
+    partialObject;
+    constructor(key, partialObject) {
+        super(`The key "${key.toString()}" is missing in partial object.`);
+        this.key = key;
+        this.partialObject = partialObject;
+    }
+}
+function unPartial(partialObject, keys) {
+    keys.forEach((key) => {
+        if (partialObject[key] === undefined) {
+            throw new UnPartialError(key, partialObject);
+        }
+    });
+    return partialObject;
+}
+
+exports.InvalidBytesInStringError = InvalidBytesInStringError;
+exports.UnPartialError = UnPartialError;
+exports.clone = clone;
+exports.entryUseMapper = entryUseMapper;
+exports.escapeRegExp = escapeRegExp;
+exports.getTypedEntries = getTypedEntries;
+exports.getTypedKeys = getTypedKeys;
+exports.hasKey = hasKey;
+exports.simpleClone = simpleClone;
+exports.sleep = sleep;
+exports.stringToBytes = stringToBytes;
+exports.unPartial = unPartial;

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./addThis";
+export * from "./clone";
+export * from "./entryUseMapper";
+export * from "./escapeRegExp";
+export * from "./expectType";
+export * from "./getLastOfUnion";
+export * from "./getPropsWithTrueValue";
+export * from "./getTypedEntries";
+export * from "./getTypedKeys";
+export * from "./hasKey";
+export * from "./incremente";
+export * from "./isAny";
+export * from "./overrideInterface";
+export * from "./partialKeys";
+export * from "./requiredKeys";
+export * from "./simpleClone";
+export * from "./simplifyType";
+export * from "./sleep";
+export * from "./stringToBytes";
+export * from "./types";
+export * from "./unionToIntersection";
+export * from "./unionToTuple";
+export * from "./uniqueGeneric";
+export * from "./unPartial";

package/dist/index.mjs

@@ -0,0 +1,118 @@
+function getTypedEntries(object) {
+    return Object.entries(object);
+}
+
+function clone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue instanceof Array) {
+        return unknownValue.map(clone);
+    }
+    else {
+        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
+            pv[key] = clone(value);
+            return pv;
+        }, {});
+    }
+}
+
+function entryUseMapper([key, value], mapper) {
+    const ReTypedMapper = mapper;
+    return ReTypedMapper[key](value);
+}
+
+function escapeRegExp(text) {
+    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+
+function getTypedKeys(object) {
+    return Object.keys(object);
+}
+
+function hasKey(obj, key) {
+    return key in obj;
+}
+
+function simpleClone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue.constructor?.name === "Object"
+        || unknownValue.constructor === undefined) {
+        return getTypedEntries(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;
+    }
+}
+
+function sleep(milliseconde) {
+    return new Promise((resolve) => void setTimeout(resolve, milliseconde));
+}
+
+/* eslint-disable id-length */
+class InvalidBytesInStringError extends Error {
+    input;
+    constructor(input) {
+        super("Invalid Input");
+        this.input = input;
+    }
+}
+const parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+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 floatValue = regExpResults
+        ? parseFloat(regExpResults[1])
+        : parseInt(bytesInString, 10);
+    const unit = regExpResults
+        ? regExpResults[4].toLowerCase()
+        : "b";
+    if (!hasKey(unitMapper, unit) || isNaN(floatValue)) {
+        throw new InvalidBytesInStringError(bytesInString);
+    }
+    return Math.floor(unitMapper[unit] * floatValue);
+}
+
+class UnPartialError extends Error {
+    key;
+    partialObject;
+    constructor(key, partialObject) {
+        super(`The key "${key.toString()}" is missing in partial object.`);
+        this.key = key;
+        this.partialObject = partialObject;
+    }
+}
+function unPartial(partialObject, keys) {
+    keys.forEach((key) => {
+        if (partialObject[key] === undefined) {
+            throw new UnPartialError(key, partialObject);
+        }
+    });
+    return partialObject;
+}
+
+export { InvalidBytesInStringError, UnPartialError, clone, entryUseMapper, escapeRegExp, getTypedEntries, getTypedKeys, hasKey, simpleClone, sleep, stringToBytes, unPartial };

package/dist/isAny.d.ts

@@ -0,0 +1 @@
+export type IsAny<T extends any> = (any extends T ? true : false) extends true ? true : false;

package/dist/overrideInterface.d.ts

@@ -0,0 +1 @@
+export type OverrideInterface<O extends object, T extends object> = Omit<O, keyof T> & T;

package/dist/partialKeys.d.ts

@@ -0,0 +1,2 @@
+import type { SimplifyType } from "./simplifyType";
+export type PartialKeys<T extends object, K extends keyof T = keyof T> = SimplifyType<Omit<T, K> & Partial<Pick<T, K>>>;

package/dist/requiredKeys.d.ts

@@ -0,0 +1,2 @@
+import type { SimplifyType } from "./simplifyType";
+export type RequiredKeys<T extends object, K extends keyof T = keyof T> = SimplifyType<Required<Pick<T, K>> & Omit<T, K>>;

package/dist/simpleClone.d.ts

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

package/dist/simplifyType.d.ts

@@ -0,0 +1,6 @@
+export type SimplifyType<T> = T extends Record<number, unknown> ? {
+    [K in keyof T]: SimplifyType<T[K]>;
+} : T;
+export type SimplifyTypeForce<T> = T extends object ? {
+    [K in keyof T]: SimplifyTypeForce<T[K]>;
+} : T;

package/dist/sleep.d.ts

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

package/dist/stringToBytes.d.ts

@@ -0,0 +1,15 @@
+export declare class InvalidBytesInStringError extends Error {
+    input: string;
+    constructor(input: string);
+}
+declare const unitMapper: {
+    b: number;
+    kb: number;
+    mb: number;
+    gb: number;
+    tb: number;
+    pb: number;
+};
+export type BytesInString = `${number}${keyof typeof unitMapper}`;
+export declare function stringToBytes(bytesInString: BytesInString | number): number;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type ObjectKey = keyof any;
+export type ObjectEntry = [ObjectKey, any];
+export type AnyFunction = (...args: any) => any;
+export type MybePromise<T> = T | Promise<T>;

package/dist/unPartial.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectKey } from "./types";
+export declare class UnPartialError extends Error {
+    key: ObjectKey;
+    partialObject: object;
+    constructor(key: ObjectKey, partialObject: object);
+}
+export type UnPartial<T extends object, K extends keyof T> = T & {
+    [P in K]-?: Exclude<T[P], undefined>;
+};
+export declare function unPartial<T extends object, K extends keyof T>(partialObject: T, keys: K[]): UnPartial<T, K>;

package/dist/unionToIntersection.d.ts

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

package/dist/unionToTuple.d.ts

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

package/dist/uniqueGeneric.d.ts

@@ -0,0 +1,5 @@
+declare const unique: unique symbol;
+export type UniqueGeneric<T extends unknown> = T & {
+    [unique]?: typeof unique;
+};
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@duplojs/utils",
+  "version": "0.1.0",
+  "author": "mathcovax",
+  "license": "MIT",
+  "type": "module",
+  "repository": "https://github.com/duplojs/utils",
+  "scripts": {
+    "build": "rollup --config && tsc-alias -p tsconfig.build.json",
+    "test:tu": "vitest --coverage",
+    "test:tu:watch": "vitest --coverage --watch",
+    "test:tu:update": "vitest --coverage --update",
+    "test:types": "npm run test:types:scripts && npm run integration:test:types",
+    "test:types:scripts": "tsc",
+    "integration:test:types": "npm -w test/integration run test:types",
+    "test:lint": "eslint",
+    "test:lint:fix": "eslint --fix",
+    "prepare": "husky"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "workspaces": [
+    "test/integration"
+  ],
+  "peerDependencies": {
+
+  },
+  "dependencies": {
+    
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.7.1",
+    "@commitlint/config-conventional": "19.2.2",
+    "@duplojs/eslint": "0.4.0",
+    "@rollup/plugin-typescript": "12.1.2",
+    "@types/node": "22.1.0",
+    "@vitest/coverage-istanbul": "3.0.5",
+    "eslint": "9.20.0",
+    "husky": "9.1.7",
+    "rollup": "4.34.6",
+    "rollup-plugin-esbuild": "6.2.0",
+    "tsc-alias": "1.8.10",
+    "tslib": "2.8.1",
+    "tsx": "4.19.2",
+    "typescript": "5.7.3",
+    "vite-tsconfig-paths": "5.1.4",
+    "vitest": "3.0.5"
+  },
+  "keywords": []
+}