@cmtlyt/lingshu-toolkit 0.1.1 → 0.3.0

package/dist/react/index.js

@@ -1,9 +1,49 @@
-import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
-import { dataHandler, logger, $dt, $t } from "../607.js";
+import { useEffect, useEffectEvent, useMemo, useReducer, useRef, useState } from "react";
+import { dataHandler, logger, $dt, $t, throwType } from "../707.js";
+import { createStorageHandler } from "../607.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
+    ];
+}
+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
+    ];
+}
 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 +53,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 +95,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 +121,87 @@ function useCounter(initialValue = 0, options = {}) {
         actions
     ];
 }
-export { $dt, $t, defineTransform } from "../607.js";
-export { useControllableValue, useCounter, useValidData };
+function useForceUpdate() {
+    const [, forceUpdate] = useReducer((prev)=>(prev + 1) % 10, 0);
+    return forceUpdate;
+}
+function useMount(callback) {
+    const callbackRef = useRef(callback);
+    useEffect(()=>{
+        dataHandler({
+            fn: callbackRef.current
+        }, {
+            fn: $t["function"]()
+        }, {
+            strict: true
+        });
+        callbackRef.current();
+    }, []);
+}
+function clone(_v) {
+    return structuredClone(_v);
+}
+function useRefState(initialState) {
+    const stateRef = useRef(initialState);
+    const forceUpdate = useForceUpdate();
+    const ctrl = useMemo(()=>{
+        const origin = clone(stateRef.current);
+        const updateHandler = (update = true)=>void (update && forceUpdate());
+        const patchState = (updater, update = true)=>{
+            updater(stateRef.current);
+            updateHandler(update);
+        };
+        const setState = (state, update = true)=>{
+            stateRef.current = state;
+            updateHandler(update);
+        };
+        return {
+            patchState,
+            forceUpdate,
+            getState: ()=>stateRef.current,
+            setState,
+            reset: (update = true)=>setState(clone(origin), update)
+        };
+    }, [
+        forceUpdate
+    ]);
+    return [
+        stateRef.current,
+        ctrl
+    ];
+}
+function useStorage(storageKey, options, initialData) {
+    const optionsRef = useRef({
+        initialData,
+        options
+    });
+    return useMemo(()=>{
+        const { initialData: _initialData, options: _options } = optionsRef.current;
+        return createStorageHandler(storageKey, _initialData || {}, _options);
+    }, [
+        storageKey
+    ]);
+}
+function setTitle(title) {
+    if (!title) return;
+    document.title = title;
+}
+const use_title_validInfo = $dt({
+    restoreOnUnmount: $t.boolean(true)
+});
+function useTitle(title, options = {}) {
+    const { restoreOnUnmount } = useValidData(options, use_title_validInfo);
+    useEffect(()=>{
+        const originalTitle = document.title;
+        setTitle(title);
+        return ()=>{
+            if (restoreOnUnmount) setTitle(originalTitle);
+        };
+    }, [
+        title,
+        restoreOnUnmount
+    ]);
+    return setTitle;
+}
+export { $dt, $t, defineTransform } from "../707.js";
+export { useBoolean, useControllableValue, useCounter, useForceUpdate, useMount, useRefState, useStorage, useTitle, useToggle, 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.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-force-update/index.d.ts

@@ -0,0 +1 @@
+export declare function useForceUpdate(): import("react").ActionDispatch<[]>;

package/dist/react/use-force-update/index.js

@@ -0,0 +1,6 @@
+import { useReducer } from "react";
+function useForceUpdate() {
+    const [, forceUpdate] = useReducer((prev)=>(prev + 1) % 10, 0);
+    return forceUpdate;
+}
+export { useForceUpdate };

package/dist/react/use-force-update/index.test.d.ts

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

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

@@ -0,0 +1,8 @@
+export interface UseRefStateCtrl<T> {
+    patchState: (updater: (draft: T) => void, update?: boolean) => void;
+    forceUpdate: () => void;
+    getState: () => T;
+    setState: (state: T, update?: boolean) => void;
+    reset: (update?: boolean) => void;
+}
+export declare function useRefState<T>(initialState: T): readonly [T, UseRefStateCtrl<T>];

package/dist/react/use-ref-state/index.js

@@ -0,0 +1,35 @@
+import { useMemo, useRef } from "react";
+import { useForceUpdate } from "../use-force-update/index.js";
+function clone(_v) {
+    return structuredClone(_v);
+}
+function useRefState(initialState) {
+    const stateRef = useRef(initialState);
+    const forceUpdate = useForceUpdate();
+    const ctrl = useMemo(()=>{
+        const origin = clone(stateRef.current);
+        const updateHandler = (update = true)=>void (update && forceUpdate());
+        const patchState = (updater, update = true)=>{
+            updater(stateRef.current);
+            updateHandler(update);
+        };
+        const setState = (state, update = true)=>{
+            stateRef.current = state;
+            updateHandler(update);
+        };
+        return {
+            patchState,
+            forceUpdate,
+            getState: ()=>stateRef.current,
+            setState,
+            reset: (update = true)=>setState(clone(origin), update)
+        };
+    }, [
+        forceUpdate
+    ]);
+    return [
+        stateRef.current,
+        ctrl
+    ];
+}
+export { useRefState };

package/dist/react/use-ref-state/index.test.d.ts

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

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

@@ -0,0 +1,2 @@
+import { type CreateStorageOptions } from '../../shared/create-storage-handler';
+export declare function useStorage<T extends Record<string, any>>(storageKey: string, options?: Partial<CreateStorageOptions>, initialData?: T): import("../../shared/create-storage-handler").StorageHandler<T>;

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

@@ -0,0 +1,15 @@
+import { useMemo, useRef } from "react";
+import { createStorageHandler } from "../../shared/create-storage-handler/index.js";
+function useStorage(storageKey, options, initialData) {
+    const optionsRef = useRef({
+        initialData,
+        options
+    });
+    return useMemo(()=>{
+        const { initialData: _initialData, options: _options } = optionsRef.current;
+        return createStorageHandler(storageKey, _initialData || {}, _options);
+    }, [
+        storageKey
+    ]);
+}
+export { useStorage };

package/dist/react/use-storage/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>, H extends Handler<T> = Handler<T>, O extends DataHandlerOptions<T> = DataHandlerOptions<T> & {
+    unwrap: true;
+}>(data: T, verifyInfo: H, options?: O): O["unwrap"] extends true ? import("../../shared").Printify<import("../../shared/data-handler").Transform2Type<H> extends infer T_1 ? T_1 extends import("../../shared/data-handler").Transform2Type<H> ? T_1 extends (...args: any[]) => any ? T & O["defaultValue"] : T & O["defaultValue"] & { [K in keyof T_1]: import("../../shared").Equal<T_1[K], any> extends true ? Required<T & O["defaultValue"]>[K] : T_1[K]; } : never : never> : {
+    result: import("../../shared").Printify<import("../../shared/data-handler").Transform2Type<H> extends infer T_2 ? T_2 extends import("../../shared/data-handler").Transform2Type<H> ? T_2 extends (...args: any[]) => any ? T & O["defaultValue"] : T & O["defaultValue"] & { [K_1 in keyof T_2]: import("../../shared").Equal<T_2[K_1], any> extends true ? Required<T & O["defaultValue"]>[K_1] : T_2[K_1]; } : never : never>;
     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/animation/__test__/animation-pause-resume.test.d.ts

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

package/dist/shared/animation/__test__/animation.test.d.ts

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

package/dist/shared/animation/__test__/step-animation.test.d.ts

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

package/dist/shared/animation/__test__/utils.test.d.ts

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

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

@@ -0,0 +1,3 @@
+import type { AnimationBaseOptions, AnimationOptions, AnimationResult } from './types';
+export declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions): Generator<T, void, unknown>;
+export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions): AnimationResult;

package/dist/shared/animation/index.js

@@ -0,0 +1,71 @@
+import { $dt, $t, dataHandler } from "../data-handler/index.js";
+import { throwError } from "../throw-error/index.js";
+import { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop } from "./utils.js";
+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;
+    }
+}
+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
+    };
+}
+export { animation, stepAnimation };

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

@@ -0,0 +1,22 @@
+export type Formatter = (value: number) => any;
+export interface AnimationBaseOptions {
+    parser?: (value: any) => number;
+    formatter?: Formatter;
+}
+export interface AnimationOptions extends AnimationBaseOptions {
+    autoStart?: boolean;
+    easing?: (time: number) => number;
+    onStart?: () => void;
+    onStop?: () => void;
+    onClear?: () => void;
+    onUpdate?: (value: any) => void;
+    onComplete?: () => void;
+}
+export interface AnimationCtrl {
+    stop: () => void;
+    start: () => void;
+    clear: () => void;
+}
+export type AnimationResult = AnimationCtrl & {
+    promise: Promise<boolean>;
+};

package/dist/shared/animation/utils.d.ts

@@ -0,0 +1,16 @@
+import { type Resolver } from '../with-resolvers';
+import type { AnimationOptions, Formatter } from './types';
+export declare const noop: () => undefined;
+export declare const identity: <T>(_v: T) => T;
+export declare function getNextValueHandler(from: any, to: any, valueFormatter: Formatter): (progress: number) => any;
+export declare function matchValid(from: any, to: any, valueParser: (value: any) => number): number[] | unknown[][] | [Record<PropertyKey, any>, Record<PropertyKey, any>];
+export declare function createNextTick(resolvers: Resolver<any>, rcSignal: RCSignal): (callback: (...args: any[]) => void) => boolean;
+export declare function tryRun(callback: () => any, resolvers: Resolver<any>, customErrorHandler?: (err: any) => void): Promise<void>;
+export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions>): {
+    stopSignal: boolean;
+    resolvers: Resolver<boolean>;
+    stop: () => void;
+    start: () => void;
+    clear: () => void;
+};
+export type RCSignal = Omit<ReturnType<typeof createRunningControllerSignal>, 'resolvers'>;