@cmtlyt/lingshu-toolkit 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# @cmtlyt/lingshu-toolkit
+
+一个支持 shadcn 的工具库
+
+## 为什么要支持 shadcn?
+
+如果是纯 shadcn 的话, 就会失去长期维护能力, 作者对包的后续修改也很难进行更新, 所以对于这个痛点, 我希望这个包能同时支持 shadcn 和 npm package
+
+然后 shadcn 可以提供很好的定制化, 而且 npm 包有 bug 的话也可以通过 shadcn 拉取并修改, 修改完成后还能通过 pr 的方式重新提交回 npm 包, 这样就可以获取 npm 包的长期维护能力了
+
+shadcn 的安装方式可以通过[官方文档](https://cmtlyt.github.io/lingshu-toolkit/)查看, 文档后续会慢慢完善的

package/dist/607.js

@@ -0,0 +1,131 @@
+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);
+        };
+    }
+});
+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(`${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(errors.join('\n'));
+}
+function filterData(data, ctx, defaultValue = {}) {
+    ctx.handledErrorKeys.forEach((key)=>{
+        data[key] = defaultValue[key];
+    });
+}
+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 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
+    };
+}
+export { $dt, $t, dataHandler, defineTransform, logger, throwError, throwType };

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-controllable-value';
+export * from './use-counter';
+export * from './use-valid-data';

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

@@ -0,0 +1,14 @@
+import type { NotUnion } from '../../shared/types';
+interface UseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P extends Ks | (string & {}) = 'value'> {
+    defaultValue: any;
+    defaultValuePropName: Ks;
+    valuePropName: P;
+    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'];
+/**
+ * 受控组件 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 {};

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

@@ -0,0 +1,33 @@
+import { useEffect, useEffectEvent, useRef, useState } from "react";
+import { $dt, $t, useValidData } from "../use-valid-data/index.js";
+const validInfo = $dt({
+    defaultValuePropName: $t.validString('defaultValue'),
+    valuePropName: $t.validString('value'),
+    trigger: $t.validString('onChange')
+});
+function useControllableValue(props = {}, options = {}) {
+    const { result: validOptions } = useValidData(options, validInfo);
+    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = validOptions;
+    const { [valuePropName]: propValue, [defaultValuePropName]: defaultValue = _defaultValue, [trigger]: emitChange } = props;
+    const hasValueRef = useRef(Boolean(Reflect.getOwnPropertyDescriptor(props, valuePropName)));
+    const isFirstRenderRef = useRef(true);
+    const [ctrlValue, setCtrlValue] = useState(hasValueRef.current ? propValue : defaultValue);
+    const setValue = useEffectEvent((value, ...args)=>{
+        if ('function' == typeof emitChange) emitChange(value, ...args);
+        if (!hasValueRef.current) setCtrlValue(value);
+    });
+    useEffect(()=>{
+        if (isFirstRenderRef.current || !hasValueRef.current) {
+            isFirstRenderRef.current = false;
+            return;
+        }
+        setCtrlValue(propValue);
+    }, [
+        propValue
+    ]);
+    return [
+        ctrlValue,
+        setValue
+    ];
+}
+export { useControllableValue };

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

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

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

@@ -0,0 +1,12 @@
+interface UseCounterOptions {
+    min: number;
+    max: number;
+    step: number;
+}
+export declare function useCounter(initialValue?: number, options?: Partial<UseCounterOptions>): readonly [number, {
+    increment: (delta?: number) => void;
+    decrement: (delta?: number) => void;
+    reset: () => void;
+    set: (value: number | ((prev: number) => number)) => void;
+}];
+export {};

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

@@ -0,0 +1,49 @@
+import { logger } from "../../shared/logger/index.js";
+import { useEffectEvent, useMemo, useRef, useState } from "react";
+import { $dt, $t, useValidData } from "../use-valid-data/index.js";
+function getRealValue(value, options) {
+    const { min, max } = options;
+    return Math.min(Math.max(value, min), max);
+}
+function nanTransform(_dv) {
+    return (_v)=>{
+        if (void 0 === _v) return _dv;
+        logger.warn('useCounter', 'value is not a number', _v, 'useCounter will use default value');
+        const numV = Number(_v);
+        if (Number.isNaN(numV)) return _dv;
+        return numV;
+    };
+}
+const validInfo = $dt({
+    min: $t.validNumber(nanTransform(-1 / 0)),
+    max: $t.validNumber(nanTransform(1 / 0)),
+    step: $t.validNumber(nanTransform(1))
+});
+function useCounter(initialValue = 0, options = {}) {
+    const { result: validOptions } = useValidData(options, validInfo);
+    const { step } = validOptions;
+    const initialValueRef = useRef(getRealValue(Number(initialValue), validOptions));
+    const [current, setCurrent] = useState(getRealValue(Number(initialValue), validOptions));
+    const setValue = useEffectEvent((value)=>{
+        setCurrent(()=>getRealValue('function' == typeof value ? value(current) : value, validOptions));
+    });
+    const actions = useMemo(()=>{
+        const _step = Math.abs(step);
+        const increment = (delta = _step)=>setValue((prev)=>prev + delta);
+        const decrement = (delta = _step)=>setValue((prev)=>prev - delta);
+        const reset = ()=>setCurrent(initialValueRef.current);
+        return {
+            increment,
+            decrement,
+            reset,
+            set: setValue
+        };
+    }, [
+        step
+    ]);
+    return [
+        current,
+        actions
+    ];
+}
+export { useCounter };

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

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

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

@@ -0,0 +1,6 @@
+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);
+    errors: string[];
+};

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

@@ -0,0 +1,11 @@
+import { dataHandler } from "../../shared/index.js";
+import { useMemo, useRef } from "react";
+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), [
+        data
+    ]);
+}
+export { useValidData };

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

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

package/dist/react.js

@@ -0,0 +1,86 @@
+import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
+import { dataHandler, logger, $dt, $t } from "./607.js";
+function useValidData(data, verifyInfo, options) {
+    const verifyInfoRef = useRef(verifyInfo);
+    const optionsRef = useRef(options);
+    return useMemo(()=>dataHandler(data, verifyInfoRef.current, optionsRef.current), [
+        data
+    ]);
+}
+const validInfo = $dt({
+    defaultValuePropName: $t.validString('defaultValue'),
+    valuePropName: $t.validString('value'),
+    trigger: $t.validString('onChange')
+});
+function useControllableValue(props = {}, options = {}) {
+    const { result: validOptions } = useValidData(options, validInfo);
+    const { defaultValue: _defaultValue, trigger, valuePropName, defaultValuePropName } = validOptions;
+    const { [valuePropName]: propValue, [defaultValuePropName]: defaultValue = _defaultValue, [trigger]: emitChange } = props;
+    const hasValueRef = useRef(Boolean(Reflect.getOwnPropertyDescriptor(props, valuePropName)));
+    const isFirstRenderRef = useRef(true);
+    const [ctrlValue, setCtrlValue] = useState(hasValueRef.current ? propValue : defaultValue);
+    const setValue = useEffectEvent((value, ...args)=>{
+        if ('function' == typeof emitChange) emitChange(value, ...args);
+        if (!hasValueRef.current) setCtrlValue(value);
+    });
+    useEffect(()=>{
+        if (isFirstRenderRef.current || !hasValueRef.current) {
+            isFirstRenderRef.current = false;
+            return;
+        }
+        setCtrlValue(propValue);
+    }, [
+        propValue
+    ]);
+    return [
+        ctrlValue,
+        setValue
+    ];
+}
+function getRealValue(value, options) {
+    const { min, max } = options;
+    return Math.min(Math.max(value, min), max);
+}
+function nanTransform(_dv) {
+    return (_v)=>{
+        if (void 0 === _v) return _dv;
+        logger.warn('useCounter', 'value is not a number', _v, 'useCounter will use default value');
+        const numV = Number(_v);
+        if (Number.isNaN(numV)) return _dv;
+        return numV;
+    };
+}
+const use_counter_validInfo = $dt({
+    min: $t.validNumber(nanTransform(-1 / 0)),
+    max: $t.validNumber(nanTransform(1 / 0)),
+    step: $t.validNumber(nanTransform(1))
+});
+function useCounter(initialValue = 0, options = {}) {
+    const { result: validOptions } = useValidData(options, use_counter_validInfo);
+    const { step } = validOptions;
+    const initialValueRef = useRef(getRealValue(Number(initialValue), validOptions));
+    const [current, setCurrent] = useState(getRealValue(Number(initialValue), validOptions));
+    const setValue = useEffectEvent((value)=>{
+        setCurrent(()=>getRealValue('function' == typeof value ? value(current) : value, validOptions));
+    });
+    const actions = useMemo(()=>{
+        const _step = Math.abs(step);
+        const increment = (delta = _step)=>setValue((prev)=>prev + delta);
+        const decrement = (delta = _step)=>setValue((prev)=>prev - delta);
+        const reset = ()=>setCurrent(initialValueRef.current);
+        return {
+            increment,
+            decrement,
+            reset,
+            set: setValue
+        };
+    }, [
+        step
+    ]);
+    return [
+        current,
+        actions
+    ];
+}
+export { $dt, $t, defineTransform } from "./607.js";
+export { useControllableValue, useCounter, useValidData };

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

@@ -0,0 +1,6 @@
+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'];
+    errors: string[];
+};
+export * from './tools';

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

@@ -0,0 +1,77 @@
+import { throwType } from "../throw-error/index.js";
+export * from "./tools.js";
+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(errors.join('\n'));
+}
+function filterData(data, ctx, defaultValue = {}) {
+    ctx.handledErrorKeys.forEach((key)=>{
+        data[key] = defaultValue[key];
+    });
+}
+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 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
+    };
+}
+export { dataHandler };

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

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

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

@@ -0,0 +1,18 @@
+import type { Handler } from './types';
+type TypeHandler = NonNullable<Exclude<Handler<any>, (...args: any[]) => any>[string]>;
+type Fullback = ((_v: any) => any) | (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;
+};
+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 & {})>;
+export declare const $dt: typeof defineTransform;
+export {};

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

@@ -0,0 +1,26 @@
+export interface Actions {
+    assert: <T extends boolean>(flag: T, msg?: string) => T;
+    /**
+     * 转换结果中的数值类型
+     *
+     * @warning 如果被 assert 处理为 false, 则不会应用转换
+     */
+    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 & {}));
+export interface ActionContext {
+    errors: string[];
+    transforms: [PropertyKey, any][];
+    handledErrorKeys: Set<PropertyKey>;
+}
+export interface ActionHandlers {
+    addError(key: PropertyKey, msg?: string): void;
+    addTransform(key: PropertyKey, value: any): void;
+}
+export interface DataHandlerOptions<M extends Record<PropertyKey, any>> {
+    strict?: boolean;
+    errorHandler?: (error: ActionContext['errors']) => void;
+    defaultValue?: M;
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-handler';
+export * from './throw-error';

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

@@ -0,0 +1 @@
+export declare const logger: Console;

package/dist/shared/logger/index.js

@@ -0,0 +1,9 @@
+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);
+        };
+    }
+});
+export { logger };

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

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

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

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

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

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

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

@@ -0,0 +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>;

package/dist/shared.js

@@ -0,0 +1 @@
+export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "./607.js";

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@cmtlyt/lingshu-toolkit",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/shared.js",
+  "module": "./dist/shared.js",
+  "types": "./dist/shared/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./react/*": {
+      "import": "./dist/react/*"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared.js"
+    },
+    "./shared/*": {
+      "import": "./dist/shared/*"
+    }
+  },
+  "author": {
+    "name": "cmtlyt",
+    "email": "cmtlyt@163.com"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@cmtlyt/unplugin-shadcn-registry-generate": "^0.1.3",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@rslib/core": "^0.19.3",
+    "@types/node": "^24.10.9",
+    "@types/react": "^19.2.9",
+    "@vitejs/plugin-react": "^5.1.2",
+    "@vitejs/plugin-vue": "^6.0.3",
+    "@vitest/browser-playwright": "4.0.18",
+    "@vitest/coverage-v8": "4.0.18",
+    "@vitest/ui": "4.0.18",
+    "esno": "^4.8.0",
+    "husky": "^9.1.7",
+    "jsdom": "^27.4.0",
+    "lint-staged": "^16.2.7",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rspress": "^1.47.1",
+    "typescript": "^5.9.3",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "4.0.18",
+    "vitest-browser-react": "2.0.2",
+    "vitest-browser-vue": "2.0.2",
+    "vue": "^3.5.27"
+  },
+  "peerDependencies": {
+    "react": "^19.2.3",
+    "vue": "^3.5.27"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=18.0.0"
+    },
+    "packageManager": {
+      "name": "pnpm"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "homepage": "https://cmtlyt.github.io/lingshu-toolkit/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cmtlyt/lingshu-toolkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cmtlyt/lingshu-toolkit/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "cmtlyt",
+    "lingshu-toolkit",
+    "hook",
+    "hooks",
+    "shadcn",
+    "shadcn-hook",
+    "vue",
+    "react",
+    "vue-hook",
+    "react-hook"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "build:docs": "rspress build",
+    "check": "biome check --write",
+    "dev:docs": "rspress dev",
+    "format": "biome format --write",
+    "test": "vitest --config=vitest.browser.config.ts --coverage.enabled --ui",
+    "test:ci": "vitest run --config=vitest.browser.config.ts",
+    "test:lib:ci": "vitest run",
+    "test:lib": "vitest --coverage.enabled --ui",
+    "script:gen-file": "esno scripts/gen-file.ts"
+  }
+}