@cmtlyt/lingshu-toolkit 0.1.0 → 0.2.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 → 707.js}

@@ -1,14 +1,14 @@
-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);
 }
 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);
         };
     }
 });
@@ -46,7 +46,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();
@@ -101,7 +101,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)=>{
@@ -109,8 +109,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 = {
@@ -123,7 +123,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/{react.js → react/index.js}

@@ -1,9 +1,12 @@
 import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
-import { dataHandler, logger, $dt, $t } from "./607.js";
+import { dataHandler, logger, $dt, $t } from "../707.js";
 function useValidData(data, verifyInfo, options) {
     const verifyInfoRef = useRef(verifyInfo);
     const optionsRef = useRef(options);
-    return useMemo(()=>dataHandler(data, verifyInfoRef.current, optionsRef.current), [
+    return useMemo(()=>dataHandler(data, verifyInfoRef.current, {
+            unwrap: true,
+            ...optionsRef.current
+        }), [
         data
     ]);
 }
@@ -13,8 +16,7 @@ const validInfo = $dt({
     trigger: $t.validString('onChange')
 });
 function useControllableValue(props = {}, options = {}) {
-    const { result: validOptions } = useValidData(options, validInfo);
-    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = validOptions;
+    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = useValidData(options, validInfo);
     const { [valuePropName]: propValue, [defaultValuePropName]: defaultValue = _defaultValue, [trigger]: emitChange } = props;
     const hasValueRef = useRef(Boolean(Reflect.getOwnPropertyDescriptor(props, valuePropName)));
     const isFirstRenderRef = useRef(true);
@@ -56,7 +58,7 @@ const use_counter_validInfo = $dt({
     step: $t.validNumber(nanTransform(1))
 });
 function useCounter(initialValue = 0, options = {}) {
-    const { result: validOptions } = useValidData(options, use_counter_validInfo);
+    const validOptions = useValidData(options, use_counter_validInfo);
     const { step } = validOptions;
     const initialValueRef = useRef(getRealValue(Number(initialValue), validOptions));
     const [current, setCurrent] = useState(getRealValue(Number(initialValue), validOptions));
@@ -82,5 +84,5 @@ function useCounter(initialValue = 0, options = {}) {
         actions
     ];
 }
-export { $dt, $t, defineTransform } from "./607.js";
+export { $dt, $t, defineTransform } from "../707.js";
 export { useControllableValue, useCounter, useValidData };

package/dist/react/use-boolean/index.d.ts

@@ -0,0 +1,6 @@
+export declare function useBoolean(defaultValue?: boolean): readonly [boolean, {
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+    set: (value: boolean) => void;
+}];

package/dist/react/use-boolean/index.js

@@ -0,0 +1,16 @@
+import { useMemo } from "react";
+import { useToggle } from "../use-toggle/index.js";
+function useBoolean(defaultValue = false) {
+    const [state, { toggle, set }] = useToggle(!!defaultValue);
+    const actions = useMemo(()=>({
+            toggle,
+            setTrue: ()=>set(true),
+            setFalse: ()=>set(false),
+            set: (value)=>set(!!value)
+        }), []);
+    return [
+        state,
+        actions
+    ];
+}
+export { useBoolean };

package/dist/react/use-boolean/index.test.d.ts

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

package/dist/react/use-controllable-value/index.d.ts

@@ -1,4 +1,3 @@
-import type { NotUnion } from '../../shared/types';
 interface UseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P extends Ks | (string & {}) = 'value'> {
     defaultValue: any;
     defaultValuePropName: Ks;
@@ -6,9 +5,11 @@ interface UseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P ex
     trigger: Ks;
 }
 export type PublicUseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P extends Ks | (string & {}) = 'value'> = Partial<UseControllableValueOptions<Ks, P>>;
-type ValueType<T extends Record<PropertyKey, any>, P> = NotUnion<P> extends true ? P extends keyof T ? T[P] : T['value'] : T['value'];
+type ParseDefaultValue<OT extends Record<PropertyKey, any>, O extends PublicUseControllableValueOptions> = O['defaultValuePropName'] extends keyof OT ? OT[O['defaultValuePropName']] : O['defaultValue'];
+type Defaultize<OT extends Record<PropertyKey, any>, P extends keyof OT | (string & {}), O extends PublicUseControllableValueOptions> = P extends keyof OT ? undefined extends OT[P] ? OT[P] & ParseDefaultValue<OT, O> : OT[P] : ParseDefaultValue<OT, O>;
+type ValueType<T extends Record<PropertyKey, any>, O extends PublicUseControllableValueOptions<PropertyKey, any>> = O['valuePropName'] extends keyof T ? Defaultize<T, O['valuePropName'], O> : Defaultize<T, 'value', O>;
 /**
  * 受控组件 value 逻辑切换, 如果传递了 value 则走受控逻辑, 否则走非受控逻辑
  */
-export declare function useControllableValue<T extends Record<PropertyKey, any>, P extends keyof T | (string & {}) = PropertyKey>(props?: T, options?: PublicUseControllableValueOptions<keyof T, P>): [ValueType<T, P>, (value: ValueType<T, P>, ...args: any[]) => void];
+export declare function useControllableValue<T extends Record<PropertyKey, any>, P extends keyof T | (string & {}) = PropertyKey, O extends PublicUseControllableValueOptions<keyof T, P> = PublicUseControllableValueOptions<keyof T, P>>(props?: T, options?: O): [ValueType<T, O>, (value: ValueType<T, O>, ...args: any[]) => void];
 export {};

package/dist/react/use-controllable-value/index.js

@@ -6,8 +6,7 @@ const validInfo = $dt({
     trigger: $t.validString('onChange')
 });
 function useControllableValue(props = {}, options = {}) {
-    const { result: validOptions } = useValidData(options, validInfo);
-    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = validOptions;
+    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = useValidData(options, validInfo);
     const { [valuePropName]: propValue, [defaultValuePropName]: defaultValue = _defaultValue, [trigger]: emitChange } = props;
     const hasValueRef = useRef(Boolean(Reflect.getOwnPropertyDescriptor(props, valuePropName)));
     const isFirstRenderRef = useRef(true);

package/dist/react/use-counter/index.js

@@ -1,6 +1,6 @@
-import { logger } from "../../shared/logger/index.js";
 import { useEffectEvent, useMemo, useRef, useState } from "react";
 import { $dt, $t, useValidData } from "../use-valid-data/index.js";
+import { logger } from "../../shared/logger/index.js";
 function getRealValue(value, options) {
     const { min, max } = options;
     return Math.min(Math.max(value, min), max);
@@ -20,7 +20,7 @@ const validInfo = $dt({
     step: $t.validNumber(nanTransform(1))
 });
 function useCounter(initialValue = 0, options = {}) {
-    const { result: validOptions } = useValidData(options, validInfo);
+    const validOptions = useValidData(options, validInfo);
     const { step } = validOptions;
     const initialValueRef = useRef(getRealValue(Number(initialValue), validOptions));
     const [current, setCurrent] = useState(getRealValue(Number(initialValue), validOptions));

package/dist/react/use-mount/index.d.ts

@@ -0,0 +1 @@
+export declare function useMount(callback: () => any): void;

package/dist/react/use-mount/index.js

@@ -0,0 +1,16 @@
+import { useEffect, useRef } from "react";
+import { $t, dataHandler } from "../../shared/index.js";
+function useMount(callback) {
+    const callbackRef = useRef(callback);
+    useEffect(()=>{
+        dataHandler({
+            fn: callbackRef.current
+        }, {
+            fn: $t["function"]()
+        }, {
+            strict: true
+        });
+        callbackRef.current();
+    }, []);
+}
+export { useMount };

package/dist/react/use-mount/index.test.d.ts

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

package/dist/react/use-title/index.d.ts

@@ -0,0 +1,6 @@
+interface UseTitleOptions {
+    restoreOnUnmount: boolean;
+}
+declare function setTitle(title?: string): void;
+export declare function useTitle(title?: string, options?: Partial<UseTitleOptions>): typeof setTitle;
+export {};

package/dist/react/use-title/index.js

@@ -0,0 +1,24 @@
+import { useEffect } from "react";
+import { $dt, $t, useValidData } from "../use-valid-data/index.js";
+function setTitle(title) {
+    if (!title) return;
+    document.title = title;
+}
+const validInfo = $dt({
+    restoreOnUnmount: $t.boolean(true)
+});
+function useTitle(title, options = {}) {
+    const { restoreOnUnmount } = useValidData(options, validInfo);
+    useEffect(()=>{
+        const originalTitle = document.title;
+        setTitle(title);
+        return ()=>{
+            if (restoreOnUnmount) setTitle(originalTitle);
+        };
+    }, [
+        title,
+        restoreOnUnmount
+    ]);
+    return setTitle;
+}
+export { useTitle };

package/dist/react/use-title/index.test.d.ts

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

package/dist/react/use-toggle/index.d.ts

@@ -0,0 +1,10 @@
+interface Actions<T> {
+    set: (value: T) => void;
+    setLeft: () => void;
+    setRight: () => void;
+    toggle: () => void;
+}
+export declare function useToggle(): [boolean, Actions<boolean>];
+export declare function useToggle<L>(defaultValue: L): [L, Actions<L>];
+export declare function useToggle<L, R>(defaultValue: L, reverseValue: R): [L | R, Actions<L | R>];
+export {};

package/dist/react/use-toggle/index.js

@@ -0,0 +1,26 @@
+import { useMemo, useRef, useState } from "react";
+import { throwType } from "../../shared/throw-error/index.js";
+function useToggle(defualtValue = false, reverseValue) {
+    const [state, setState] = useState(defualtValue);
+    const toggleRef = useRef([
+        defualtValue,
+        void 0 === reverseValue ? !defualtValue : reverseValue
+    ]);
+    const actions = useMemo(()=>{
+        const [left, right] = toggleRef.current;
+        return {
+            set: (value)=>{
+                if (value !== left && value !== right) throwType('useToggle', 'value is not left or right');
+                setState(value);
+            },
+            setLeft: ()=>setState(left),
+            setRight: ()=>setState(right),
+            toggle: ()=>setState((prev)=>prev === left ? right : left)
+        };
+    }, []);
+    return [
+        state,
+        actions
+    ];
+}
+export { useToggle };

package/dist/react/use-toggle/index.test.d.ts

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

package/dist/react/use-valid-data/index.d.ts

@@ -1,6 +1,8 @@
 import type { DataHandlerOptions, Handler } from '../../shared/data-handler/types';
 export * from '../../shared/data-handler/tools';
-export declare function useValidData<T extends Record<PropertyKey, any>>(data: T, verifyInfo: Handler<T>, options?: DataHandlerOptions<T>): {
-    result: T | (T & undefined);
+export declare function useValidData<T extends Record<PropertyKey, any>, O extends DataHandlerOptions<T> = DataHandlerOptions<T> & {
+    unwrap: true;
+}>(data: T, verifyInfo: Handler<T>, options?: O): O["unwrap"] extends true ? T & O["defaultValue"] : {
+    result: T & O["defaultValue"];
     errors: string[];
 };

package/dist/react/use-valid-data/index.js

@@ -1,10 +1,13 @@
-import { dataHandler } from "../../shared/index.js";
 import { useMemo, useRef } from "react";
+import { dataHandler } from "../../shared/data-handler/index.js";
 export * from "../../shared/data-handler/tools.js";
 function useValidData(data, verifyInfo, options) {
     const verifyInfoRef = useRef(verifyInfo);
     const optionsRef = useRef(options);
-    return useMemo(()=>dataHandler(data, verifyInfoRef.current, optionsRef.current), [
+    return useMemo(()=>dataHandler(data, verifyInfoRef.current, {
+            unwrap: true,
+            ...optionsRef.current
+        }), [
         data
     ]);
 }

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

@@ -0,0 +1,35 @@
+import type { IsPrimitive, 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 Printify<T> = T extends any[] ? T : [T] extends [never] ? T : {
+    [K in keyof T]: T[K];
+};
+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 {};
+t {};

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/data-handler/index.d.ts

@@ -1,5 +1,5 @@
 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): {
+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): O['unwrap'] extends true ? M & O['defaultValue'] : {
     result: M & O['defaultValue'];
     errors: string[];
 };

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.js

@@ -0,0 +1,44 @@
+import { logger } from "../logger/index.js";
+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')
+};
+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;
+export { $dt, $t, defineTransform };

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

@@ -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.js → shared/index.js}

@@ -1 +1 @@
-export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "./607.js";
+export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../707.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,5 @@
+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;

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/vue/index.d.ts

@@ -0,0 +1 @@
+export * from './use-title';

package/dist/vue/index.js

@@ -0,0 +1,29 @@
+import { onScopeDispose, ref, toValue, watch } from "vue";
+import { dataHandler, $t, $dt } from "../707.js";
+function setTitle(title) {
+    if (!title || "u" < typeof document) return;
+    const oldTitle = document.title;
+    document.title = title;
+    return oldTitle;
+}
+const validInfo = $dt({
+    restoreOnUnmount: $t.boolean(true)
+});
+function useTitle(newTitle = '', options = {}) {
+    const { restoreOnUnmount } = dataHandler(options, validInfo, {
+        unwrap: true
+    });
+    const title = ref(toValue(newTitle));
+    const originalTitle = setTitle(title.value);
+    watch(title, setTitle, {
+        flush: 'sync'
+    });
+    watch(()=>toValue(newTitle), (value)=>{
+        title.value = value;
+    });
+    if (restoreOnUnmount) onScopeDispose(()=>{
+        setTitle(originalTitle);
+    });
+    return title;
+}
+export { useTitle };

package/dist/vue/use-title/index.d.ts

@@ -0,0 +1,6 @@
+import { type MaybeRefOrGetter } from 'vue';
+interface UseTitleOptions {
+    restoreOnUnmount: boolean;
+}
+export declare function useTitle(newTitle?: MaybeRefOrGetter<string>, options?: Partial<UseTitleOptions>): import("vue").Ref<string, string>;
+export {};

package/dist/vue/use-title/index.js

@@ -0,0 +1,29 @@
+import { onScopeDispose, ref, toValue, watch } from "vue";
+import { $dt, $t, dataHandler } from "../../shared/data-handler/index.js";
+function setTitle(title) {
+    if (!title || "u" < typeof document) return;
+    const oldTitle = document.title;
+    document.title = title;
+    return oldTitle;
+}
+const validInfo = $dt({
+    restoreOnUnmount: $t.boolean(true)
+});
+function useTitle(newTitle = '', options = {}) {
+    const { restoreOnUnmount } = dataHandler(options, validInfo, {
+        unwrap: true
+    });
+    const title = ref(toValue(newTitle));
+    const originalTitle = setTitle(title.value);
+    watch(title, setTitle, {
+        flush: 'sync'
+    });
+    watch(()=>toValue(newTitle), (value)=>{
+        title.value = value;
+    });
+    if (restoreOnUnmount) onScopeDispose(()=>{
+        setTitle(originalTitle);
+    });
+    return title;
+}
+export { useTitle };

package/dist/vue/use-title/index.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmtlyt/lingshu-toolkit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/shared.js",
   "module": "./dist/shared.js",
@@ -8,21 +8,31 @@
   "exports": {
     ".": {
       "types": "./dist/shared/index.d.ts",
-      "import": "./dist/shared.js"
+      "import": "./dist/shared/index.js"
     },
     "./react": {
       "types": "./dist/react/index.d.ts",
-      "import": "./dist/react.js"
+      "import": "./dist/react/index.js"
     },
     "./react/*": {
+      "types": "./dist/react/*/index.d.ts",
       "import": "./dist/react/*"
     },
     "./shared": {
       "types": "./dist/shared/index.d.ts",
-      "import": "./dist/shared.js"
+      "import": "./dist/shared/index.js"
     },
     "./shared/*": {
+      "types": "./dist/shared/*/index.d.ts",
       "import": "./dist/shared/*"
+    },
+    "./vue": {
+      "types": "./dist/vue/index.d.ts",
+      "import": "./dist/vue/index.js"
+    },
+    "./vue/*": {
+      "types": "./dist/vue/*/index.d.ts",
+      "import": "./dist/vue/*"
     }
   },
   "author": {
@@ -102,6 +112,8 @@
     "build:docs": "rspress build",
     "check": "biome check --write",
     "dev:docs": "rspress dev",
+    "dev:registry": "pnpm dlx serve src/public -p 3000",
+    "preview:docs": "rspress preview",
     "format": "biome format --write",
     "test": "vitest --config=vitest.browser.config.ts --coverage.enabled --ui",
     "test:ci": "vitest run --config=vitest.browser.config.ts",