@cmtlyt/lingshu-toolkit 0.2.0 → 0.4.0

package/dist/707.js

@@ -1,5 +1,8 @@
+function createError(fnName, message, ErrorClass = Error) {
+    return new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+}
 function throwError(fnName, message, ErrorClass = Error) {
-    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+    throw createError(fnName, message, ErrorClass);
 }
 function throwType(fnName, message) {
     throwError(fnName, message, TypeError);
@@ -12,6 +15,8 @@ const logger = new Proxy(console, {
         };
     }
 });
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
 function getType(_v) {
     return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
 }
@@ -34,7 +39,12 @@ const $t = {
     object: typeHandler('object'),
     array: typeHandler('array'),
     function: typeHandler('function'),
-    symbol: typeHandler('symbol')
+    symbol: typeHandler('symbol'),
+    enum: (list, fullback)=>{
+        if (!Array.isArray(list)) throwType('$t.enum', 'list must be an array');
+        const set = new Set(list);
+        return typeHandler('enum', (_v)=>set.has(_v))(fullback);
+    }
 };
 function defineTransform(dataInfo) {
     const verifyInfo = {};
@@ -128,4 +138,4 @@ function dataHandler(data, handler, options) {
         errors: ctx.errors
     };
 }
-export { $dt, $t, dataHandler, defineTransform, logger, throwError, throwType };
+export { $dt, $t, createError, dataHandler, defineTransform, getType, identity, logger, noop, 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';

package/dist/react/index.js

@@ -1,5 +1,42 @@
-import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
-import { dataHandler, logger, $dt, $t } from "../707.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);
@@ -84,5 +121,85 @@ function useCounter(initialValue = 0, options = {}) {
         actions
     ];
 }
+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();
+    }, []);
+}
+const clone = structuredClone;
+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 { useControllableValue, useCounter, useValidData };
+export { useBoolean, useControllableValue, useCounter, useForceUpdate, useMount, useRefState, useStorage, useTitle, useToggle, useValidData };

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-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,33 @@
+import { useMemo, useRef } from "react";
+import { useForceUpdate } from "../use-force-update/index.js";
+const clone = structuredClone;
+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-valid-data/index.d.ts

@@ -1,8 +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>, O extends DataHandlerOptions<T> = DataHandlerOptions<T> & {
+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: Handler<T>, options?: O): O["unwrap"] extends true ? T & O["defaultValue"] : {
-    result: T & O["defaultValue"];
+}>(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/shared/allx/__test__/allsettled.test.d.ts

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

package/dist/shared/allx/__test__/basic.test.d.ts

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

package/dist/shared/allx/__test__/circular-dependency.test.d.ts

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

package/dist/shared/allx/__test__/dependency.test.d.ts

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

package/dist/shared/allx/__test__/edge-cases.test.d.ts

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

package/dist/shared/allx/__test__/error-handling.test.d.ts

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

package/dist/shared/allx/__test__/execution-order.test.d.ts

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

package/dist/shared/allx/__test__/falsy-values.test.d.ts

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

package/dist/shared/allx/__test__/performance.test.d.ts

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

package/dist/shared/allx/__test__/type-checking.test.d.ts

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

package/dist/shared/allx/__test__/use-cases.test.d.ts

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

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

@@ -0,0 +1,13 @@
+import type { AllxContext, AllxOptions, AllxResult } from './types';
+/**
+ * 支持自动依赖优化和完整类型推断的 Promise.all, 执行任务时自动解决依赖关系。
+ *
+ * @platform web, node, webworker
+ * @example
+ * const { a, b, c } = await allx({
+ *   a() { return 1 },
+ *   async b() { return 'hello' },
+ *   async c() { return (await this.$.a) + 10 }
+ * })
+ */
+export declare function allx<M extends Record<PropertyKey, any>, O extends AllxOptions>(tasks: M & ThisType<AllxContext<M>>, options?: O): Promise<AllxResult<M, O>>;

package/dist/shared/allx/index.js

@@ -0,0 +1,44 @@
+import { $dt, $t, dataHandler } from "../data-handler/index.js";
+import { isFunction, isPromiseLike } from "../utils/verify.js";
+import { withResolvers } from "../with-resolvers/index.js";
+import { createDepProxy, getValueFormatFunc } from "./utils.js";
+const validInfo = $dt({
+    allSettled: $t.boolean(false)
+});
+async function allx(tasks, options) {
+    const validOptions = dataHandler(options || {}, validInfo, {
+        unwrap: true
+    });
+    const { allSettled } = validOptions;
+    const results = {};
+    const depCtrl = createDepProxy(tasks, results, validOptions);
+    const valueFormat = getValueFormatFunc(options);
+    const promises = [];
+    depCtrl.taskNameSet.forEach(async (taskName)=>{
+        const taskFn = tasks[taskName];
+        const context = {
+            $: depCtrl.createContextFor(taskName)
+        };
+        const taskResolvers = withResolvers();
+        taskResolvers.promise.then((value)=>{
+            results[taskName] = valueFormat(value, 'fulfilled');
+            depCtrl.resolveDepFor(taskName, value);
+            return value;
+        }, (error)=>{
+            if (allSettled) results[taskName] = valueFormat(error, 'rejected');
+            depCtrl.rejectDepFor(taskName, error);
+        });
+        promises.push(taskResolvers.promise);
+        if (isPromiseLike(taskFn)) return void await taskFn.then(taskResolvers.resolve, taskResolvers.reject);
+        if (!isFunction(taskFn)) return void taskResolvers.resolve(taskFn);
+        try {
+            const result = await taskFn.call(context);
+            taskResolvers.resolve(result);
+        } catch (error) {
+            taskResolvers.reject(error);
+        }
+    });
+    if (allSettled) return Promise.allSettled(promises).then(()=>results);
+    return Promise.all(promises).then(()=>results);
+}
+export { allx };

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

@@ -0,0 +1,13 @@
+import type { AnyFunc } from '../types/base';
+export interface AllxOptions {
+    allSettled?: boolean;
+}
+export type AllxTaskValue<T> = T extends AnyFunc ? Awaited<ReturnType<T>> : Awaited<T>;
+export interface AllxContext<M extends Record<PropertyKey, AnyFunc>> {
+    $: {
+        [P in keyof M]: Promise<AllxTaskValue<M[P]>>;
+    };
+}
+export type AllxResult<M extends Record<PropertyKey, AnyFunc>, O extends AllxOptions = AllxOptions> = {
+    [P in keyof M]: O['allSettled'] extends true ? PromiseSettledResult<Awaited<ReturnType<M[P]>>> : AllxTaskValue<M[P]>;
+};

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

@@ -0,0 +1,9 @@
+import type { AnyFunc } from '../types/base';
+import type { AllxOptions } from './types';
+export declare function createDepProxy(tasks: Record<PropertyKey, AnyFunc>, results: Record<PropertyKey, any>, options: Required<AllxOptions>): {
+    taskNameSet: Set<PropertyKey>;
+    createContextFor: (currentTask: PropertyKey) => {};
+    resolveDepFor: (depName: PropertyKey, value: any) => void;
+    rejectDepFor: (depName: PropertyKey, error: any) => void;
+};
+export declare function getValueFormatFunc(options?: AllxOptions): (value: any, _type?: PromiseSettledResult<any>["status"]) => any;

package/dist/shared/allx/utils.js

@@ -0,0 +1,94 @@
+import { createError } from "../throw-error/index.js";
+import { withResolvers } from "../with-resolvers/index.js";
+function detectCycle(from, to, waitingForGraph) {
+    const visited = new Set();
+    const queue = [
+        to
+    ];
+    let head = 0;
+    while(head < queue.length){
+        const node = queue[head++];
+        if (node === from) return true;
+        if (visited.has(node)) continue;
+        visited.add(node);
+        const deps = waitingForGraph.get(node);
+        if (deps) {
+            const depsIter = deps.values();
+            for(let dep = depsIter.next(); !dep.done; dep = depsIter.next())queue.push(dep.value);
+        }
+    }
+    return false;
+}
+function getCached(results, depName, allSettled) {
+    if (Reflect.getOwnPropertyDescriptor(results, depName)) {
+        const cached = results[depName];
+        if (allSettled) return 'rejected' === cached.status ? Promise.reject(cached.reason) : Promise.resolve(cached.value);
+        return Promise.resolve(cached);
+    }
+}
+function createDepResolver(waitingFor, resolverMap, currentTask, depName) {
+    waitingFor.set(currentTask, (waitingFor.get(currentTask) || new Set()).add(depName));
+    const depResolvers = resolverMap.get(depName) || withResolvers();
+    resolverMap.set(depName, depResolvers);
+    return depResolvers.promise.then((value)=>{
+        waitingFor.get(currentTask)?.delete(depName);
+        return value;
+    }, (error)=>{
+        waitingFor.get(currentTask)?.delete(depName);
+        throw error;
+    });
+}
+function cleanWaitingForGraph(waitingForGraph, depName) {
+    waitingForGraph.forEach((deps, task)=>{
+        deps.delete(depName);
+        if (0 === deps.size) waitingForGraph.delete(task);
+    });
+}
+function createDepProxy(tasks, results, options) {
+    const resolverMap = new Map();
+    const taskNameSet = new Set(Reflect.ownKeys(tasks));
+    const waitingForGraph = new Map();
+    const resolveDepFor = (depName, value)=>{
+        const resolver = resolverMap.get(depName);
+        if (resolver) {
+            resolver.resolve(value);
+            resolverMap.delete(depName);
+        }
+        cleanWaitingForGraph(waitingForGraph, depName);
+    };
+    const rejectDepFor = (depName, error)=>{
+        const resolver = resolverMap.get(depName);
+        if (resolver) {
+            resolver.reject(error);
+            resolverMap.delete(depName);
+        }
+        cleanWaitingForGraph(waitingForGraph, depName);
+    };
+    const createContextFor = (currentTask)=>new Proxy({}, {
+            get (_, depName) {
+                if (!taskNameSet.has(depName)) return Promise.reject(createError('allx', `Unknown task "${String(depName)}"`));
+                const cached = getCached(results, depName, options.allSettled);
+                if (cached) return cached;
+                if (detectCycle(currentTask, depName, waitingForGraph)) return Promise.reject(createError('allx', `Circular dependency detected: "${String(currentTask)}" -> "${String(depName)}"`));
+                return createDepResolver(waitingForGraph, resolverMap, currentTask, depName);
+            }
+        });
+    return {
+        taskNameSet,
+        createContextFor,
+        resolveDepFor,
+        rejectDepFor
+    };
+}
+function getValueFormatFunc(options) {
+    if (!options) return (value, _type = 'fulfilled')=>value;
+    if (options.allSettled) return (value, status = 'fulfilled')=>'fulfilled' === status ? {
+            status,
+            value
+        } : {
+            status,
+            reason: value
+        };
+    return (value, _type = 'fulfilled')=>value;
+}
+export { createDepProxy, getValueFormatFunc };

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<T>): Generator<any, void, unknown>;
+export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions<T>): AnimationResult;

package/dist/shared/animation/index.js

@@ -0,0 +1,77 @@
+import { $dt, $t, dataHandler } from "../data-handler/index.js";
+import { throwError } from "../throw-error/index.js";
+import { identity, noop } from "../utils/base.js";
+import { createNextTick, createRunningControllerSignal, getNextValueHandler, matchValid } from "./utils.js";
+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),
+    formatterValue: $t["function"](()=>identity),
+    formatter: $t["function"](()=>identity),
+    parser: $t["function"](()=>identity)
+});
+function* stepAnimation(from, to, step, options = {}) {
+    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
+    const validOptions = dataHandler(options, validInfo, {
+        unwrap: true
+    });
+    const { parser: valueParser = identity, formatterValue = identity, formatter } = validOptions;
+    const [validFrom, validTo] = matchValid(from, to, valueParser);
+    const getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
+    for(let i = 0; i <= step; i++){
+        const value = formatter(getNextValue(i / step));
+        yield value;
+    }
+}
+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, formatterValue, formatter } = validOptions;
+    const _getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
+    const getNextValue = (...args)=>formatter(_getNextValue(...args));
+    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,24 @@
+export type FormatterValue = (value: number) => any;
+export type Formatter<T> = (value: T) => any;
+export interface AnimationBaseOptions<T> {
+    parser?: (value: any) => number;
+    formatterValue?: FormatterValue;
+    formatter?: Formatter<T>;
+}
+export interface AnimationOptions<T> extends AnimationBaseOptions<T> {
+    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,14 @@
+import { type Resolver } from '../with-resolvers';
+import type { AnimationOptions, FormatterValue } from './types';
+export declare function getNextValueHandler<T>(from: T, to: T, valueFormatter: FormatterValue): (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<any>>): {
+    stopSignal: boolean;
+    resolvers: Resolver<boolean>;
+    stop: () => void;
+    start: () => void;
+    clear: () => void;
+};
+export type RCSignal = Omit<ReturnType<typeof createRunningControllerSignal>, 'resolvers'>;