@cmtlyt/lingshu-toolkit 0.1.1 → 0.3.0

package/README.md

@@ -2,6 +2,8 @@
 
 一个支持 shadcn 的工具库
 
+[![codecov](https://codecov.io/gh/cmtlyt/lingshu-toolkit/graph/badge.svg?token=WCAIRJNBFN)](https://codecov.io/gh/cmtlyt/lingshu-toolkit)
+
 ## 为什么要支持 shadcn?
 
 如果是纯 shadcn 的话, 就会失去长期维护能力, 作者对包的后续修改也很难进行更新, 所以对于这个痛点, 我希望这个包能同时支持 shadcn 和 npm package

package/dist/607.js

@@ -1,131 +1,311 @@
-function throwError(message, ErrorClass = Error) {
-    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit]: ${message}`);
-}
-function throwType(message) {
-    throwError(message, TypeError);
-}
-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);
+import { dataHandler, logger, $dt, throwError, $t, throwType } from "./707.js";
+function withResolvers() {
+    return 'function' == typeof Promise.withResolvers ? Promise.withResolvers() : (()=>{
+        const resolver = {
+            promise: null,
+            resolve: null,
+            reject: null
         };
-    }
-});
+        resolver.promise = new Promise((resolve, reject)=>{
+            resolver.resolve = resolve;
+            resolver.reject = reject;
+        });
+        return resolver;
+    })();
+}
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
 function getType(_v) {
     return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
 }
-function typeHandler(type, verifyFn) {
-    return (fullback)=>(_v, actions)=>{
-            if (verifyFn ? verifyFn(_v) : getType(_v) === type) return true;
-            if (null == fullback) return false;
-            let fullbackValue = fullback;
-            if ('function' == typeof fullback) fullbackValue = fullback(_v);
-            actions.transform(fullbackValue);
-        };
+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);
+    };
 }
-const $t = {
-    notNullable: typeHandler('notNullable', (_v)=>null != _v),
-    string: typeHandler('string'),
-    validString: typeHandler('validString', (_v)=>'string' == typeof _v && _v.length > 0),
-    number: typeHandler('number'),
-    validNumber: typeHandler('validNumber', (_v)=>'number' == typeof _v && !Number.isNaN(_v)),
-    boolean: typeHandler('boolean'),
-    object: typeHandler('object'),
-    array: typeHandler('array'),
-    function: typeHandler('function'),
-    symbol: typeHandler('symbol')
-};
-function defineTransform(dataInfo) {
-    const verifyInfo = {};
-    const keys = Reflect.ownKeys(dataInfo);
-    for(let i = 0, key = keys[i], item = dataInfo[key]; i < keys.length; key = keys[++i], item = dataInfo[key]){
-        if ('function' == typeof item) {
-            verifyInfo[key] = item;
-            continue;
+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;
         }
-        const handler = $t[item];
-        if (!handler) {
-            logger.warn(`${item} is not a valid type`);
-            continue;
+        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;
         }
-        verifyInfo[key] = handler();
+        return result;
     }
-    return verifyInfo;
+    if ('number' !== fromType) return [
+        valueParser(from),
+        valueParser(to)
+    ];
+    return [
+        from,
+        to
+    ];
 }
-const $dt = defineTransform;
-function createActions() {
-    const ctx = {
-        errors: [],
-        transforms: [],
-        handledErrorKeys: new Set()
+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;
     };
-    const handler = {
-        addError (key, msg = `${String(key)} is not valid`) {
-            if (ctx.handledErrorKeys.has(key)) return;
-            ctx.handledErrorKeys.add(key);
-            ctx.errors.push(msg);
+}
+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();
         },
-        addTransform (key, value) {
-            ctx.transforms.push([
-                key,
-                value
-            ]);
+        start: ()=>{
+            ctrl.stopSignal = false;
+            onStart();
+            startFn();
+        },
+        clear: ()=>{
+            ctrl.stopSignal = true;
+            onClear();
+            resolvers.resolve(true);
         }
     };
-    return [
-        ctx,
-        handler,
-        (key)=>({
-                assert: (flag, msg = `${String(key)} is not valid`)=>{
-                    if (!flag) handler.addError(key, msg);
-                    return flag;
-                },
-                transform: (value)=>{
-                    if (!ctx.handledErrorKeys.has(key)) handler.addTransform(key, value);
-                    return value;
-                }
-            })
-    ];
-}
-function transformApply(data, transforms) {
-    if (!transforms.length) return;
-    for(let i = 0, [key, value] = transforms[i]; i < transforms.length; [key, value] = transforms[++i] || [])data[key] = value;
+    return ctrl;
 }
-function handleProcess(data, keys, handleFn, getActions, actionHandlers) {
-    for(let i = 0, key = keys[i]; i < keys.length; key = keys[++i]){
-        const flag = handleFn(data[key], key, getActions(key), data);
-        if (false === flag) actionHandlers.addError(key);
+function* stepAnimation(from, to, step, options = {}) {
+    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
+    const { parser: valueParser = identity, formatter: valueFormatter = identity } = options;
+    const [validFrom, validTo] = matchValid(from, to, valueParser);
+    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
+    for(let i = 0; i <= step; i++){
+        const value = getNextValue(i / step);
+        yield value;
     }
 }
-function errorProcess(errors, errorHandler, strict) {
-    if (!errors.length) return;
-    if (errorHandler) errorHandler(errors);
-    else if (strict) throwType(errors.join('\n'));
+const validInfo = $dt({
+    autoStart: $t.boolean(true),
+    easing: $t["function"](()=>identity),
+    onStart: $t["function"](()=>noop),
+    onStop: $t["function"](()=>noop),
+    onClear: $t["function"](()=>noop),
+    onUpdate: $t["function"](()=>noop),
+    onComplete: $t["function"](()=>noop),
+    formatter: $t["function"](()=>identity),
+    parser: $t["function"](()=>identity)
+});
+function animation(from, to, duration, options = {}) {
+    if (duration <= 0 || !Number.isInteger(duration)) throwError('animation', 'duration must be a positive integer', RangeError);
+    const validOptions = dataHandler(options, validInfo, {
+        unwrap: true
+    });
+    const [validFrom, validTo] = matchValid(from, to, validOptions.parser);
+    const { autoStart, easing, onComplete, onUpdate, formatter: valueFormatter } = validOptions;
+    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
+    let startTime = 0;
+    let hasStarted = false;
+    const rcSignal = createRunningControllerSignal(()=>{
+        const now = performance.now();
+        startTime += now;
+        const stopFlag = nextTick(tick);
+        if (stopFlag) {
+            startTime -= performance.now();
+            return;
+        }
+        if (!hasStarted) {
+            onUpdate(getNextValue(0));
+            hasStarted = true;
+        }
+    }, validOptions);
+    const { resolvers } = rcSignal;
+    const nextTick = createNextTick(resolvers, rcSignal);
+    const tick = ()=>{
+        const elapsed = performance.now() - startTime;
+        const progress = easing(Math.min(elapsed / duration, 1));
+        const value = getNextValue(progress);
+        onUpdate(value);
+        if (elapsed < duration) {
+            const stopFlag = nextTick(tick);
+            if (stopFlag) startTime = -elapsed;
+        } else {
+            onComplete();
+            resolvers.resolve(false);
+        }
+    };
+    if (false !== autoStart) rcSignal.start();
+    return {
+        promise: resolvers.promise,
+        stop: rcSignal.stop,
+        start: rcSignal.start,
+        clear: rcSignal.clear
+    };
+}
+function getEmpty(_v) {
+    return Array.isArray(_v) ? [] : {};
+}
+function valueCheck(_v) {
+    return Array.isArray(_v) || 'object' == typeof _v;
 }
-function filterData(data, ctx, defaultValue = {}) {
-    ctx.handledErrorKeys.forEach((key)=>{
-        data[key] = defaultValue[key];
+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;
 }
-function dataHandler(data, handler, options) {
-    if (!handler) throwType('handler is required');
-    const { strict = false, errorHandler, defaultValue } = options || {};
-    const handlerIsFunction = 'function' == typeof handler;
-    const handleFn = handlerIsFunction ? handler : (value, key, ...args)=>handler[key](value, ...args);
-    const tempData = {
-        ...defaultValue,
-        ...data
+const create_storage_handler_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
+    }, create_storage_handler_validInfo, {
+        unwrap: true
+    });
+    const storage = getStorage(storageType);
+    const storageData = storage.getItem(validStorageKey);
+    const context = {
+        data: storageData ? JSON.parse(storageData) : initialData || {}
     };
-    const keys = handlerIsFunction ? Reflect.ownKeys(data) : Reflect.ownKeys(handler);
-    const [ctx, actionHandler, getActions] = createActions();
-    handleProcess(tempData, keys, handleFn, getActions, actionHandler);
-    errorProcess(ctx.errors, errorHandler, strict);
-    transformApply(tempData, ctx.transforms);
-    filterData(tempData, ctx, defaultValue);
     return {
-        result: tempData,
-        errors: ctx.errors
+        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 { $dt, $t, dataHandler, defineTransform, logger, throwError, throwType };
+Symbol('__PACK__');
+export { animation, conditionMerge, createStorageHandler, stepAnimation, withResolvers };

package/dist/707.js

@@ -0,0 +1,136 @@
+function throwError(fnName, message, ErrorClass = Error) {
+    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+}
+function throwType(fnName, message) {
+    throwError(fnName, message, TypeError);
+}
+const logger = new Proxy(console, {
+    get (target, prop, receiver) {
+        const oldLog = Reflect.get(target, prop, receiver).bind(console);
+        return (fnName, ...args)=>{
+            oldLog(`[@cmtlyt/lingshu-toolkit#${fnName}]:`, ...args);
+        };
+    }
+});
+function getType(_v) {
+    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+}
+function typeHandler(type, verifyFn) {
+    return (fullback)=>(_v, actions)=>{
+            if (verifyFn ? verifyFn(_v) : getType(_v) === type) return true;
+            if (null == fullback) return false;
+            let fullbackValue = fullback;
+            if ('function' == typeof fullback) fullbackValue = fullback(_v);
+            actions.transform(fullbackValue);
+        };
+}
+const $t = {
+    notNullable: typeHandler('notNullable', (_v)=>null != _v),
+    string: typeHandler('string'),
+    validString: typeHandler('validString', (_v)=>'string' == typeof _v && _v.length > 0),
+    number: typeHandler('number'),
+    validNumber: typeHandler('validNumber', (_v)=>'number' == typeof _v && !Number.isNaN(_v)),
+    boolean: typeHandler('boolean'),
+    object: typeHandler('object'),
+    array: typeHandler('array'),
+    function: typeHandler('function'),
+    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 = {};
+    const keys = Reflect.ownKeys(dataInfo);
+    for(let i = 0, key = keys[i], item = dataInfo[key]; i < keys.length; key = keys[++i], item = dataInfo[key]){
+        if ('function' == typeof item) {
+            verifyInfo[key] = item;
+            continue;
+        }
+        const handler = $t[item];
+        if (!handler) {
+            logger.warn('defineTransform', `${item} is not a valid type`);
+            continue;
+        }
+        verifyInfo[key] = handler();
+    }
+    return verifyInfo;
+}
+const $dt = defineTransform;
+function createActions() {
+    const ctx = {
+        errors: [],
+        transforms: [],
+        handledErrorKeys: new Set()
+    };
+    const handler = {
+        addError (key, msg = `${String(key)} is not valid`) {
+            if (ctx.handledErrorKeys.has(key)) return;
+            ctx.handledErrorKeys.add(key);
+            ctx.errors.push(msg);
+        },
+        addTransform (key, value) {
+            ctx.transforms.push([
+                key,
+                value
+            ]);
+        }
+    };
+    return [
+        ctx,
+        handler,
+        (key)=>({
+                assert: (flag, msg = `${String(key)} is not valid`)=>{
+                    if (!flag) handler.addError(key, msg);
+                    return flag;
+                },
+                transform: (value)=>{
+                    if (!ctx.handledErrorKeys.has(key)) handler.addTransform(key, value);
+                    return value;
+                }
+            })
+    ];
+}
+function transformApply(data, transforms) {
+    if (!transforms.length) return;
+    for(let i = 0, [key, value] = transforms[i]; i < transforms.length; [key, value] = transforms[++i] || [])data[key] = value;
+}
+function handleProcess(data, keys, handleFn, getActions, actionHandlers) {
+    for(let i = 0, key = keys[i]; i < keys.length; key = keys[++i]){
+        const flag = handleFn(data[key], key, getActions(key), data);
+        if (false === flag) actionHandlers.addError(key);
+    }
+}
+function errorProcess(errors, errorHandler, strict) {
+    if (!errors.length) return;
+    if (errorHandler) errorHandler(errors);
+    else if (strict) throwType('dataHandler', errors.join('\n'));
+}
+function filterData(data, ctx, defaultValue = {}) {
+    ctx.handledErrorKeys.forEach((key)=>{
+        data[key] = defaultValue[key];
+    });
+}
+function dataHandler(data, handler, 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 = {
+        ...defaultValue,
+        ...data
+    };
+    const keys = handlerIsFunction ? Reflect.ownKeys(data) : Reflect.ownKeys(handler);
+    const [ctx, actionHandler, getActions] = createActions();
+    handleProcess(tempData, keys, handleFn, getActions, actionHandler);
+    errorProcess(ctx.errors, errorHandler, strict);
+    transformApply(tempData, ctx.transforms);
+    filterData(tempData, ctx, defaultValue);
+    return unwrap ? tempData : {
+        result: tempData,
+        errors: ctx.errors
+    };
+}
+export { $dt, $t, dataHandler, defineTransform, logger, throwError, throwType };

package/dist/react/index.d.ts

@@ -1,3 +1,10 @@
+export * from './use-boolean';
 export * from './use-controllable-value';
 export * from './use-counter';
+export * from './use-force-update';
+export * from './use-mount';
+export * from './use-ref-state';
+export * from './use-storage';
+export * from './use-title';
+export * from './use-toggle';
 export * from './use-valid-data';