@cmtlyt/lingshu-toolkit 0.1.1 → 0.3.0

package/dist/shared/animation/utils.js

@@ -0,0 +1,138 @@
+import { throwType } from "../throw-error/index.js";
+import { withResolvers } from "../with-resolvers/index.js";
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
+function getType(_v) {
+    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+}
+function getNextValueHandler(from, to, valueFormatter) {
+    const type = getType(from);
+    const context = {
+        progress: 0,
+        valueFormatter
+    };
+    const baseNextValue = (_from, _to)=>{
+        const { valueFormatter: formatter, progress } = context;
+        if ('number' !== getType(_from)) return _from;
+        return formatter(_from + (_to - _from) * progress);
+    };
+    const arrayHandler = (_from, _to)=>{
+        const result = Array.from(_from, (item, idx)=>{
+            if (Array.isArray(item)) return arrayHandler(item, _to[idx]);
+            if ('object' === getType(item)) return objectHandler(item, _to[idx]);
+            return baseNextValue(item, _to[idx]);
+        });
+        return result;
+    };
+    const objectHandler = (_from, _to)=>{
+        const result = {};
+        const keys = Reflect.ownKeys(_from);
+        for(let i = 0; i < keys.length; i++){
+            const key = keys[i];
+            const fromValue = _from[key];
+            const toValue = _to[key];
+            if (Array.isArray(_from[key])) result[key] = arrayHandler(fromValue, toValue);
+            else if ('object' === getType(fromValue)) result[key] = objectHandler(fromValue, toValue);
+            else result[key] = baseNextValue(fromValue, toValue);
+        }
+        return result;
+    };
+    let nextValueHandler = baseNextValue;
+    if ('array' === type) nextValueHandler = arrayHandler;
+    else if ('object' === type) nextValueHandler = objectHandler;
+    return (progress)=>{
+        context.progress = progress;
+        return nextValueHandler(from, to);
+    };
+}
+function matchValid(from, to, valueParser) {
+    const fromType = getType(from);
+    const toType = getType(to);
+    if (fromType !== toType) throwType('animation/stepAnimation', 'from and to must be the same type');
+    if ('array' === fromType) {
+        if (from.length !== to.length) throwType('animation/stepAnimation', 'from and to must be the same length');
+        const result = [
+            Array.from({
+                length: from.length
+            }),
+            Array.from({
+                length: to.length
+            })
+        ];
+        for(let i = 0; i < from.length; i++){
+            const [fromItem, toItem] = matchValid(from[i], to[i], valueParser);
+            result[0][i] = fromItem;
+            result[1][i] = toItem;
+        }
+        return result;
+    }
+    if ('object' === fromType) {
+        const toKeys = Reflect.ownKeys(to);
+        const fromKeys = new Set(Reflect.ownKeys(from));
+        const result = [
+            {},
+            {}
+        ];
+        for(let i = 0; i < toKeys.length; i++){
+            const key = toKeys[i];
+            if (!fromKeys.has(key)) throwType('animation/stepAnimation', `from does not have this key: ${String(key)}`);
+            const [fromItem, toItem] = matchValid(from[key], to[key], valueParser);
+            result[0][key] = fromItem;
+            result[1][key] = toItem;
+        }
+        return result;
+    }
+    if ('number' !== fromType) return [
+        valueParser(from),
+        valueParser(to)
+    ];
+    return [
+        from,
+        to
+    ];
+}
+function createNextTick(resolvers, rcSignal) {
+    const nextTick = (()=>{
+        if ('function' == typeof globalThis.requestAnimationFrame) return globalThis.requestAnimationFrame;
+        return (callback)=>setTimeout(callback, 16);
+    })();
+    return (callback)=>{
+        if (rcSignal.stopSignal) return true;
+        nextTick(()=>tryRun(callback, resolvers, (error)=>{
+                rcSignal.stop();
+                resolvers.reject(error);
+            }));
+        return false;
+    };
+}
+async function tryRun(callback, resolvers, customErrorHandler) {
+    return new Promise((resolve, reject)=>{
+        const result = callback();
+        if (result && 'function' == typeof result.then) return result.then(resolve, reject);
+        resolve();
+    }).catch(customErrorHandler || resolvers.reject);
+}
+function createRunningControllerSignal(startFn, options) {
+    const { onStart, onStop, onClear } = options;
+    const resolvers = withResolvers();
+    const ctrl = {
+        stopSignal: true,
+        resolvers,
+        stop: ()=>{
+            ctrl.stopSignal = true;
+            onStop();
+        },
+        start: ()=>{
+            ctrl.stopSignal = false;
+            onStart();
+            startFn();
+        },
+        clear: ()=>{
+            ctrl.stopSignal = true;
+            onClear();
+            resolvers.resolve(true);
+        }
+    };
+    return ctrl;
+}
+export { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop, tryRun };

package/dist/shared/condition-merge/index.d.ts

@@ -0,0 +1,31 @@
+import type { IsPrimitive, Printify, UnionToIntersection } from '../types';
+type AssertValue = Record<PropertyKey, any> | any[];
+type ConditionArrayItem = [boolean, AssertValue, AssertValue?];
+type ConditionObjItem = {
+    condition: boolean;
+    value: AssertValue;
+    fullback?: AssertValue;
+};
+type ConditionItem = ConditionObjItem | ConditionArrayItem;
+type GetDefaultValue<V> = IsPrimitive<V> extends true ? never : Record<never, any>;
+type ParseDefaultValue<V, D> = FormatValue<unknown extends D ? (V extends any[] ? [] : GetDefaultValue<V>) : D extends undefined | null ? GetDefaultValue<V> : D>;
+type ParseArrayCondition<T extends [any, any, any?]> = T extends [infer Flag, infer Value, (infer DefaultValue)?] ? boolean extends Flag ? FormatValue<Value> | ParseDefaultValue<Value, DefaultValue> : Flag extends true ? FormatValue<Value> & Record<PropertyKey, any> : ParseDefaultValue<Value, DefaultValue> & Record<PropertyKey, any> : never;
+type ParseObjCondition<T extends ConditionObjItem> = T extends {
+    condition: infer Flag extends boolean;
+    value: infer Value;
+    fullback?: infer DefaultValue;
+} ? ParseArrayCondition<[Flag, Value, DefaultValue]> : never;
+type FormatValue<V> = [V] extends [never] ? never : V extends any[] ? V : {
+    [K in keyof V as V[K] extends undefined ? never : K]: V[K];
+};
+type BuildConditionValue<T> = [T];
+type ParseConditionValue<T extends ConditionItem> = UnionToIntersection<T extends infer IT ? BuildConditionValue<Printify<IT extends ConditionArrayItem ? ParseArrayCondition<IT> : IT extends ConditionObjItem ? ParseObjCondition<IT> : never>> : never>;
+type MergedResult<T extends ConditionItem[]> = T extends [
+    infer First extends ConditionItem,
+    ...infer Last extends [ConditionItem, ...ConditionItem[]]
+] ? ParseConditionValue<First> & MergedResult<Last> : ParseConditionValue<T[0]>;
+type CMInput = ConditionItem[];
+type FormatResult<T extends any[]> = T[0] & Record<PropertyKey, any>;
+export declare function conditionMerge<T extends CMInput>(...input: T): FormatResult<MergedResult<T>>;
+export declare function conditionMerge<T extends CMInput>(input: T): FormatResult<MergedResult<T>>;
+export {};

package/dist/shared/condition-merge/index.js

@@ -0,0 +1,30 @@
+import { throwType } from "../throw-error/index.js";
+function getEmpty(_v) {
+    return Array.isArray(_v) ? [] : {};
+}
+function valueCheck(_v) {
+    return Array.isArray(_v) || 'object' == typeof _v;
+}
+function conditionMerge(...input) {
+    const conditionItems = (input.length > 1 ? input : input[0]).map((item)=>{
+        let result = null;
+        if (Array.isArray(item)) {
+            const [condition, value, fullback] = item;
+            result = {
+                condition,
+                value,
+                fullback
+            };
+        } else if (Object.getOwnPropertyDescriptor(item, 'condition')) result = item;
+        else throwType('conditionMerge', 'input must be an ConditionItem');
+        const validValue = valueCheck(result.value);
+        const validFullback = void 0 === result.fullback || valueCheck(result.fullback);
+        if (!(validValue && validFullback)) throwType('conditionMerge', 'value and fullback must be an array or object');
+        return result;
+    });
+    const result = getEmpty(conditionItems[0].value);
+    const mergeFn = Array.isArray(result) ? (a1, a2)=>Reflect.apply(Array.prototype.splice.bind(a1, a1.length, 0), null, a2) : Object.assign;
+    for(let i = 0, item = conditionItems[i]; i < conditionItems.length; item = conditionItems[++i])mergeFn(result, item.condition ? item.value : item.fullback || getEmpty(item.value));
+    return result;
+}
+export { conditionMerge };

package/dist/shared/condition-merge/index.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/condition-merge/index.test-d.js

@@ -0,0 +1,108 @@
+import { describe, expectTypeOf, test } from "vitest";
+import { conditionMerge } from "./index.js";
+describe('conditionMerge 类型测试', ()=>{
+    test(': 混合布尔类型', ()=>{
+        const t1 = conditionMerge([
+            {
+                condition: true,
+                value: {
+                    num: 1
+                }
+            },
+            {
+                condition: Math.random() > 0.5,
+                value: {
+                    num: 3,
+                    str: '3'
+                },
+                fullback: {
+                    str: '4'
+                }
+            }
+        ]);
+        expectTypeOf(t1).pick().toEqualTypeOf();
+        expectTypeOf(t1).pick().toEqualTypeOf();
+        expectTypeOf(conditionMerge({
+            condition: true,
+            value: {
+                num: 1
+            }
+        }, {
+            condition: Math.random() > 0.5,
+            value: {
+                num: 3,
+                str: '3'
+            },
+            fullback: {
+                str: '4'
+            }
+        })).toEqualTypeOf(t1);
+        const t3 = conditionMerge([
+            {
+                condition: true,
+                value: {
+                    num: 1
+                }
+            },
+            {
+                condition: false,
+                value: {
+                    num: 1
+                },
+                fullback: {
+                    bool: true
+                }
+            },
+            {
+                condition: Math.random() > 0.5,
+                value: {
+                    num: 3,
+                    str: '3'
+                },
+                fullback: {
+                    str: '4'
+                }
+            }
+        ]);
+        expectTypeOf(t3).pick().toEqualTypeOf();
+        expectTypeOf(t3).pick().toEqualTypeOf();
+        expectTypeOf(t3).pick().toEqualTypeOf();
+    });
+    test('类型测试: 纯 boolean 类型测试', ()=>{
+        const t1 = conditionMerge([
+            {
+                condition: Math.random() > 0.1,
+                value: {
+                    num: 1
+                }
+            },
+            {
+                condition: Math.random() > 0.5,
+                value: {
+                    num: 3,
+                    str: '3'
+                },
+                fullback: {
+                    str: '4'
+                }
+            }
+        ]);
+        expectTypeOf(t1).pick().toEqualTypeOf();
+        expectTypeOf(t1).pick().toEqualTypeOf();
+        expectTypeOf(conditionMerge({
+            condition: Math.random() > 0.1,
+            value: {
+                num: 1
+            }
+        }, {
+            condition: Math.random() > 0.5,
+            value: {
+                num: 3,
+                str: '3'
+            },
+            fullback: {
+                str: '4'
+            }
+        })).toEqualTypeOf(t1);
+    });
+});

package/dist/shared/condition-merge/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/create-storage-handler/index.browser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/create-storage-handler/index.d.ts

@@ -0,0 +1,10 @@
+export interface CreateStorageOptions {
+    storageType: 'local' | 'session' | 'memory';
+    autoSaveInterval: number;
+}
+export interface StorageHandler<T extends Record<string, any>> {
+    get: <K extends keyof T | (string & {})>(key?: K) => string extends K ? T : T[K & keyof T];
+    set: <K extends keyof T | (string & {})>(value: string extends K ? T : T[K & keyof T], key?: K) => void;
+    clear: () => void;
+}
+export declare function createStorageHandler<T extends Record<string, any>>(storageKey: string, initialData?: T, options?: Partial<CreateStorageOptions>): StorageHandler<T>;

package/dist/shared/create-storage-handler/index.js

@@ -0,0 +1,68 @@
+import { $dt, $t, dataHandler } from "../data-handler/index.js";
+import { logger } from "../logger/index.js";
+import { throwError } from "../throw-error/index.js";
+const validInfo = $dt({
+    storageKey: 'validString',
+    storageType: $t["enum"]([
+        'local',
+        'session',
+        'memory'
+    ], 'local'),
+    autoSaveInterval: $t.number(0)
+});
+const memoryStorage = {
+    data: {},
+    getItem (key) {
+        return this.data[key];
+    },
+    setItem (key, value) {
+        this.data[key] = value;
+    },
+    removeItem (key) {
+        delete this.data[key];
+    }
+};
+function getStorage(storageType) {
+    try {
+        if ('memory' === storageType) return memoryStorage;
+        return 'local' === storageType ? localStorage : sessionStorage;
+    } catch  {
+        logger.warn('createStorage', 'Failed to access localStorage or sessionStorage, using memoryStorage instead.');
+        return memoryStorage;
+    }
+}
+const CLEAR_FLAG = Symbol('cleared');
+function createStorageHandler(storageKey, initialData, options = {}) {
+    const { storageKey: validStorageKey, storageType, autoSaveInterval } = dataHandler({
+        storageKey,
+        ...options
+    }, validInfo, {
+        unwrap: true
+    });
+    const storage = getStorage(storageType);
+    const storageData = storage.getItem(validStorageKey);
+    const context = {
+        data: storageData ? JSON.parse(storageData) : initialData || {}
+    };
+    return {
+        get (key) {
+            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
+            if (null == key) return context.data;
+            return context.data[key];
+        },
+        set (value, key) {
+            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
+            if (null == key) context.data = value;
+            else context.data[key] = value;
+            if (autoSaveInterval > 0) setTimeout(()=>{
+                storage.setItem(validStorageKey, JSON.stringify(context.data));
+            }, autoSaveInterval);
+            else storage.setItem(validStorageKey, JSON.stringify(context.data));
+        },
+        clear () {
+            context.data = CLEAR_FLAG;
+            storage.removeItem(validStorageKey);
+        }
+    };
+}
+export { createStorageHandler };

package/dist/shared/create-storage-handler/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/data-handler/index.d.ts

@@ -1,6 +1,11 @@
+import type { Equal, Printify } from '../types';
+import type { Transform2Type } from './tools';
 import type { DataHandlerOptions, Handler } from './types';
-export declare function dataHandler<M extends Record<PropertyKey, any>, O extends DataHandlerOptions<M> = DataHandlerOptions<M>>(data: M & Partial<O['defaultValue']>, handler: Handler<M>, options?: O): {
-    result: M & O['defaultValue'];
+type MergeResult<BaseResult extends Record<PropertyKey, any>, HandlerResult extends Handler<any>> = Printify<HandlerResult extends (...args: any[]) => any ? BaseResult : BaseResult & {
+    [K in keyof HandlerResult]: Equal<HandlerResult[K], any> extends true ? Required<BaseResult>[K] : HandlerResult[K];
+}>;
+export declare function dataHandler<M extends Record<PropertyKey, any>, H extends Handler<M> = Handler<M>, O extends DataHandlerOptions<M> = DataHandlerOptions<M>>(data: M & Partial<O['defaultValue']>, handler: H, options?: O): O['unwrap'] extends true ? MergeResult<M & O['defaultValue'], Transform2Type<H>> : {
+    result: MergeResult<M & O['defaultValue'], Transform2Type<H>>;
     errors: string[];
 };
 export * from './tools';

package/dist/shared/data-handler/index.js

@@ -47,7 +47,7 @@ function handleProcess(data, keys, handleFn, getActions, actionHandlers) {
 function errorProcess(errors, errorHandler, strict) {
     if (!errors.length) return;
     if (errorHandler) errorHandler(errors);
-    else if (strict) throwType(errors.join('\n'));
+    else if (strict) throwType('dataHandler', errors.join('\n'));
 }
 function filterData(data, ctx, defaultValue = {}) {
     ctx.handledErrorKeys.forEach((key)=>{
@@ -55,8 +55,8 @@ function filterData(data, ctx, defaultValue = {}) {
     });
 }
 function dataHandler(data, handler, options) {
-    if (!handler) throwType('handler is required');
-    const { strict = false, errorHandler, defaultValue } = options || {};
+    if (!handler) throwType('dataHandler', 'handler is required');
+    const { strict = false, errorHandler, defaultValue, unwrap = false } = options || {};
     const handlerIsFunction = 'function' == typeof handler;
     const handleFn = handlerIsFunction ? handler : (value, key, ...args)=>handler[key](value, ...args);
     const tempData = {
@@ -69,7 +69,7 @@ function dataHandler(data, handler, options) {
     errorProcess(ctx.errors, errorHandler, strict);
     transformApply(tempData, ctx.transforms);
     filterData(tempData, ctx, defaultValue);
-    return {
+    return unwrap ? tempData : {
         result: tempData,
         errors: ctx.errors
     };

package/dist/shared/data-handler/tools.d.ts

@@ -1,18 +1,42 @@
 import type { Handler } from './types';
 type TypeHandler = NonNullable<Exclude<Handler<any>, (...args: any[]) => any>[string]>;
-type Fullback = ((_v: any) => any) | (any & {});
+type TypeHandlerParams = Parameters<TypeHandler> extends [any, ...infer Rest] ? Rest : never;
+type ParseType<T extends string> = T extends keyof TypeMap ? TypeMap[T] : any;
+type TypeHandlerInfo<T extends string> = (value: ParseType<T>, ...args: TypeHandlerParams) => ReturnType<TypeHandler>;
+interface TypeMap {
+    notNullable: any & {};
+    string: string;
+    validString: string;
+    number: number;
+    validNumber: number;
+    boolean: boolean;
+    object: Record<PropertyKey, any>;
+    array: any[];
+    function: (...args: any[]) => any;
+    symbol: symbol;
+    enum: any & {};
+}
 export declare const $t: {
-    notNullable: (fullback?: Fullback) => TypeHandler;
-    string: (fullback?: Fullback) => TypeHandler;
-    validString: (fullback?: Fullback) => TypeHandler;
-    number: (fullback?: Fullback) => TypeHandler;
-    validNumber: (fullback?: Fullback) => TypeHandler;
-    boolean: (fullback?: Fullback) => TypeHandler;
-    object: (fullback?: Fullback) => TypeHandler;
-    array: (fullback?: Fullback) => TypeHandler;
-    function: (fullback?: Fullback) => TypeHandler;
-    symbol: (fullback?: Fullback) => TypeHandler;
+    notNullable: (fullback?: any) => TypeHandlerInfo<"notNullable">;
+    string: (fullback?: string | ((_v: any) => string) | undefined) => TypeHandlerInfo<"string">;
+    validString: (fullback?: string | ((_v: any) => string) | undefined) => TypeHandlerInfo<"validString">;
+    number: (fullback?: number | ((_v: any) => number) | undefined) => TypeHandlerInfo<"number">;
+    validNumber: (fullback?: number | ((_v: any) => number) | undefined) => TypeHandlerInfo<"validNumber">;
+    boolean: (fullback?: boolean | ((_v: any) => boolean) | undefined) => TypeHandlerInfo<"boolean">;
+    object: (fullback?: Record<PropertyKey, any> | ((_v: any) => Record<PropertyKey, any>) | undefined) => TypeHandlerInfo<"object">;
+    array: (fullback?: any[] | ((_v: any) => any[]) | undefined) => TypeHandlerInfo<"array">;
+    function: (fullback?: ((_v: any) => (...args: any[]) => any) | undefined) => TypeHandlerInfo<"function">;
+    symbol: (fullback?: symbol | ((_v: any) => symbol) | undefined) => TypeHandlerInfo<"symbol">;
+    enum: <T>(list: T[], fullback?: T) => TypeHandlerInfo<"enum">;
 };
-export declare function defineTransform<T extends Record<PropertyKey, any>>(dataInfo: Partial<Record<keyof T, keyof typeof $t | TypeHandler>>): Record<PropertyKey, (value: any, action: import("./types").Actions, option: any) => false | (any & {})>;
+type TransformMap = typeof $t;
+type TransformKey = Exclude<keyof TransformMap, 'enum'>;
+type DataTransformResult<D extends Record<PropertyKey, TransformKey | TypeHandler | undefined>> = {
+    [K in keyof D]: D[K] extends TransformKey ? TransformMap[D[K]] : D[K];
+};
+export type Transform2Type<R extends DataTransformResult<any>> = {
+    [K in keyof R]: R[K] extends TypeHandlerInfo<infer T> ? ParseType<T> & {} : any & {};
+};
+export declare function defineTransform<T extends Record<PropertyKey, any>, D extends Partial<Record<keyof T, TransformKey | TypeHandler>> = Partial<Record<keyof T, TransformKey | TypeHandler>>>(dataInfo: D): DataTransformResult<D>;
 export declare const $dt: typeof defineTransform;
 export {};

package/dist/shared/data-handler/tools.js

@@ -1,4 +1,5 @@
 import { logger } from "../logger/index.js";
+import { throwType } from "../throw-error/index.js";
 function getType(_v) {
     return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
 }
@@ -21,7 +22,12 @@ const $t = {
     object: typeHandler('object'),
     array: typeHandler('array'),
     function: typeHandler('function'),
-    symbol: typeHandler('symbol')
+    symbol: typeHandler('symbol'),
+    enum: (list, fullback)=>{
+        if (!Array.isArray(list)) throwType('$t.enum', 'list must be an array');
+        const set = new Set(list);
+        return typeHandler('enum', (_v)=>set.has(_v))(fullback);
+    }
 };
 function defineTransform(dataInfo) {
     const verifyInfo = {};
@@ -33,7 +39,7 @@ function defineTransform(dataInfo) {
         }
         const handler = $t[item];
         if (!handler) {
-            logger.warn(`${item} is not a valid type`);
+            logger.warn('defineTransform', `${item} is not a valid type`);
             continue;
         }
         verifyInfo[key] = handler();

package/dist/shared/data-handler/types.d.ts

@@ -8,8 +8,8 @@ export interface Actions {
     transform: <T>(value: T) => T;
 }
 export type Handler<M extends Record<PropertyKey, any>> = Partial<{
-    [K in keyof M]: (value: M[K], action: Actions, option: M) => false | (any & {});
-}> | (<K extends keyof M>(value: M[K], key: K, action: Actions, option: M) => false | (any & {}));
+    [K in keyof M]: (value: any, action: Actions, option: M) => false | (any & {});
+}> | (<K extends keyof M>(value: any, key: K, action: Actions, option: M) => false | (any & {}));
 export interface ActionContext {
     errors: string[];
     transforms: [PropertyKey, any][];
@@ -23,4 +23,5 @@ export interface DataHandlerOptions<M extends Record<PropertyKey, any>> {
     strict?: boolean;
     errorHandler?: (error: ActionContext['errors']) => void;
     defaultValue?: M;
+    unwrap?: boolean;
 }

package/dist/shared/index.d.ts

@@ -1,2 +1,7 @@
+export * from './animation';
+export * from './condition-merge';
+export * from './create-storage-handler';
 export * from './data-handler';
 export * from './throw-error';
+export * from './types';
+export * from './with-resolvers';

package/dist/shared/index.js

@@ -1 +1,2 @@
-export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../607.js";
+export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../707.js";
+export { animation, conditionMerge, createStorageHandler, stepAnimation, withResolvers } from "../607.js";

package/dist/shared/logger/index.d.ts

@@ -1 +1,5 @@
-export declare const logger: Console;
+type Logger = {
+    [K in keyof Omit<Console, 'table'> as Console[K] extends (...args: any[]) => any ? K : never]: Console[K] extends (...args: [any, ...infer AS]) => infer R ? (fnName: string, ...args: AS) => R : never;
+};
+export declare const logger: Logger;
+export {};

package/dist/shared/logger/index.js

@@ -1,8 +1,8 @@
 const logger = new Proxy(console, {
     get (target, prop, receiver) {
         const oldLog = Reflect.get(target, prop, receiver).bind(console);
-        return (...args)=>{
-            oldLog('[@cmtlyt/lingshu-toolkit]:', ...args);
+        return (fnName, ...args)=>{
+            oldLog(`[@cmtlyt/lingshu-toolkit#${fnName}]:`, ...args);
         };
     }
 });

package/dist/shared/throw-error/index.d.ts

@@ -1,2 +1,2 @@
-export declare function throwError(message: string, ErrorClass?: ErrorConstructor): never;
-export declare function throwType(message: string): never;
+export declare function throwError(fnName: string, message: string, ErrorClass?: ErrorConstructor): never;
+export declare function throwType(fnName: string, message: string): never;

package/dist/shared/throw-error/index.js

@@ -1,7 +1,7 @@
-function throwError(message, ErrorClass = Error) {
-    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit]: ${message}`);
+function throwError(fnName, message, ErrorClass = Error) {
+    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
 }
-function throwType(message) {
-    throwError(message, TypeError);
+function throwType(fnName, message) {
+    throwError(fnName, message, TypeError);
 }
 export { throwError, throwType };

package/dist/shared/types/base.d.ts

@@ -0,0 +1,8 @@
+export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+export type NonUnion<T> = Equal<[T] extends [never] ? never : T[], T extends any ? T[] : never>;
+export type UnionToIntersection<U> = [U] extends [never] ? never : (U extends any ? (_v: U) => void : never) extends (_v: infer I) => void ? I : never;
+export type IsPrimitive<T> = T extends number | string | boolean | symbol | bigint | null | undefined ? true : false;
+export type IsBasicType<T> = T extends number | string | boolean | symbol | bigint ? true : false;
+export type Printify<T> = T extends any[] ? T : [T] extends [never] ? T : {
+    [K in keyof T]: T[K];
+};

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

@@ -1,2 +1,2 @@
-export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-export type NotUnion<T> = Equal<[T] extends [never] ? never : T[], T extends any ? T[] : never>;
+export * from './base';
+export * from './pack';

package/dist/shared/types/index.js

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./pack.js";

package/dist/shared/types/pack.d.ts

@@ -0,0 +1,9 @@
+declare const __PACK__: unique symbol;
+export type Pack<T> = {
+    [__PACK__]: T;
+};
+export type Unpack<T extends Pack<any>> = T extends Pack<infer U> ? U : never;
+export type SafeUnpack<T extends Pack<any>> = T extends Pack<infer U> ? U : T;
+export type IsPack<T> = Pack<any> extends T ? true : false;
+export type HasPack<T> = (T extends any[] ? HasPack<T[number]> : IsPack<T>) extends false ? false : true;
+export {};

package/dist/shared/types/pack.js

@@ -0,0 +1 @@
+Symbol('__PACK__');

package/dist/shared/with-resolvers/index.d.ts

@@ -0,0 +1,6 @@
+export type Resolver<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare function withResolvers<T>(): Resolver<T>;