@cmtlyt/lingshu-toolkit 0.5.0 → 0.6.0

package/dist/shared/allx/index.js

@@ -1,44 +1 @@
-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 };
+import{$dt as e,$t as r,dataHandler as t}from"../data-handler/index.js";import{isFunction as o,isPromiseLike as l}from"../utils/verify.js";import{withResolvers as i}from"../with-resolvers/index.js";import{createDepProxy as a,getValueFormatFunc as s}from"./utils.js";let n=e({allSettled:r.boolean(!1)});async function m(e,r){let m=t(r||{},n,{unwrap:!0}),{allSettled:c}=m,f={},p=a(e,f,m),d=s(r),h=[];return(p.taskNameSet.forEach(async r=>{let t=e[r],a={$:p.createContextFor(r)},s=i();if(s.promise.then(e=>(f[r]=d(e,"fulfilled"),p.resolveDepFor(r,e),e),e=>{c&&(f[r]=d(e,"rejected")),p.rejectDepFor(r,e)}),h.push(s.promise),l(t))return void await t.then(s.resolve,s.reject);if(!o(t))return void s.resolve(t);try{let e=await t.call(a);s.resolve(e)}catch(e){s.reject(e)}}),c)?Promise.allSettled(h).then(()=>f):Promise.all(h).then(()=>f)}export{m as allx};

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

@@ -11,3 +11,9 @@ export interface AllxContext<M extends Record<PropertyKey, AnyFunc>> {
 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]>;
 };
+export interface DepProxyResult {
+    taskNameSet: Set<PropertyKey>;
+    createContextFor: (currentTask: PropertyKey) => any;
+    resolveDepFor: (depName: PropertyKey, value: any) => void;
+    rejectDepFor: (depName: PropertyKey, error: any) => void;
+}

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

@@ -1,9 +1,11 @@
 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;
-};
+import type { AllxOptions, DepProxyResult } from './types';
+/**
+ * BFS 算法处理 waitingForGraph 的依赖关系
+ */
+export declare function detectCycle(from: PropertyKey, to: PropertyKey, waitingForGraph: Map<PropertyKey, Set<PropertyKey>>): boolean;
+export declare function getCached(results: Record<PropertyKey, any>, depName: PropertyKey, allSettled: boolean): Promise<any> | undefined;
+export declare function createDepResolver(waitingFor: Map<PropertyKey, Set<PropertyKey>>, resolverMap: Map<PropertyKey, PromiseWithResolvers<any>>, currentTask: PropertyKey, depName: PropertyKey): Promise<any>;
+export declare function cleanWaitingForGraph(waitingForGraph: Map<PropertyKey, Set<PropertyKey>>, depName: PropertyKey): void;
+export declare function createDepProxy(tasks: Record<PropertyKey, AnyFunc>, results: Record<PropertyKey, any>, options: Required<AllxOptions>): DepProxyResult;
 export declare function getValueFormatFunc(options?: AllxOptions): (value: any, _type?: PromiseSettledResult<any>["status"]) => any;

package/dist/shared/allx/utils.js

@@ -1,94 +1 @@
-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 };
+import{createError as e}from"../throw-error/index.js";import{isNullOrUndef as t}from"../utils/verify.js";import{withResolvers as r}from"../with-resolvers/index.js";function l(e,t,r){let l=new Set,n=[t],o=0;for(;o<n.length;){let t=n[o++];if(t===e)return!0;if(l.has(t))continue;l.add(t);let i=r.get(t);if(i){let e=i.values();for(let t=e.next();!t.done;t=e.next())n.push(t.value)}}return!1}function n(e,t,r){if(Reflect.getOwnPropertyDescriptor(e,t)){let l=e[t];return r?"rejected"===l.status?Promise.reject(l.reason):Promise.resolve(l.value):Promise.resolve(l)}}function o(e,t,l,n){e.set(l,(e.get(l)||new Set).add(n));let o=t.get(n)||r();return t.set(n,o),o.promise.then(t=>(e.get(l)?.delete(n),t),t=>{throw e.get(l)?.delete(n),t})}function i(e,t){e.forEach((r,l)=>{r.delete(t),0===r.size&&e.delete(l)})}function s(r,s,a){let c=new Map,f=new Set(Reflect.ownKeys(r)),u=new Map;return{taskNameSet:f,createContextFor:r=>new Proxy({},{get(i,d){if(!f.has(d))return Promise.reject(e("allx",`Unknown task "${String(d)}"`));let g=n(s,d,a.allSettled);return t(g)?l(r,d,u)?Promise.reject(e("allx",`Circular dependency detected: "${String(r)}" -> "${String(d)}"`)):o(u,c,r,d):g}}),resolveDepFor:(e,t)=>{let r=c.get(e);r&&(r.resolve(t),c.delete(e)),i(u,e)},rejectDepFor:(e,t)=>{let r=c.get(e);r&&(r.reject(t),c.delete(e)),i(u,e)}}}function a(e){return e?e.allSettled?(e,t="fulfilled")=>"fulfilled"===t?{status:t,value:e}:{status:t,reason:e}:(e,t="fulfilled")=>e:(e,t="fulfilled")=>e}export{i as cleanWaitingForGraph,s as createDepProxy,o as createDepResolver,l as detectCycle,n as getCached,a as getValueFormatFunc};

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

@@ -1,3 +1,4 @@
 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;
+declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions<T>): Generator<T>;
+declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions<T>): AnimationResult;
+export { animation, stepAnimation };

package/dist/shared/animation/index.js

@@ -1,77 +1 @@
-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 };
+import{$dt as t,$t as r,dataHandler as e}from"../data-handler/index.js";import{throwError as n}from"../throw-error/index.js";import{identity as o,noop as i}from"../utils/base.js";import{createNextTick as a,createRunningControllerSignal as s,getNextValueHandler as m,matchValid as p}from"./utils.js";let u=t({autoStart:r.boolean(!0),easing:r.function(()=>o),onStart:r.function(()=>i),onStop:r.function(()=>i),onClear:r.function(()=>i),onUpdate:r.function(()=>i),onComplete:r.function(()=>i),formatterValue:r.function(()=>o),formatter:r.function(()=>o),parser:r.function(()=>o)});function*f(t,r,i,a={}){(!Number.isInteger(i)||i<=0)&&n("stepAnimation","step must be a positive integer",RangeError);let{parser:s=o,formatterValue:l=o,formatter:c}=e(a,u,{unwrap:!0}),[d,g]=p(t,r,s),b=m(d,g,l);for(let t=0;t<=i;t++){let r=c(b(t/i));yield r}}function l(t,r,o,i={}){(o<=0||!Number.isInteger(o))&&n("animation","duration must be a positive integer",RangeError);let f=e(i,u,{unwrap:!0}),[c,d]=p(t,r,f.parser),{autoStart:g,easing:b,onComplete:w,onUpdate:j,formatterValue:h,formatter:v}=f,x=m(c,d,h),S=(...t)=>v(x(...t)),A=0,C=!1,E=s(()=>{let t=performance.now();if(A+=t,N(R)){A-=performance.now();return}C||(j(S(0)),C=!0)},f),{resolvers:I}=E,N=a(I,E),R=()=>{let t=performance.now()-A;j(S(b(Math.min(t/o,1)))),t<o?N(R)&&(A=-t):(w(),I.resolve(!1))};return!1!==g&&E.start(),{promise:I.promise,stop:E.stop,start:E.start,clear:E.clear}}export{l as animation,f as stepAnimation};

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

@@ -1,3 +1,4 @@
+import type { Resolver } from '../with-resolvers';
 export type FormatterValue = (value: number) => any;
 export type Formatter<T> = (value: T) => any;
 export interface AnimationBaseOptions<T> {
@@ -22,3 +23,10 @@ export interface AnimationCtrl {
 export type AnimationResult = AnimationCtrl & {
     promise: Promise<boolean>;
 };
+export interface RCSignal {
+    stopSignal: boolean;
+    resolvers: Resolver<boolean>;
+    stop: () => void;
+    start: () => void;
+    clear: () => void;
+}

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

@@ -1,14 +1,7 @@
 import { type Resolver } from '../with-resolvers';
-import type { AnimationOptions, FormatterValue } from './types';
+import type { AnimationOptions, FormatterValue, RCSignal } 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 matchValid(from: any, to: any, valueParser: (value: any) => number): [any, 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'>;
+export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions<any>>): RCSignal;

package/dist/shared/animation/utils.js

@@ -1,134 +1 @@
-import { throwType } from "../throw-error/index.js";
-import { getType } from "../utils/base.js";
-import { withResolvers } from "../with-resolvers/index.js";
-function getNextValueHandler(from, to, valueFormatter) {
-    const type = getType(from);
-    const context = {
-        progress: 0,
-        valueFormatter
-    };
-    const baseNextValue = (_from, _to)=>{
-        const { valueFormatter: formatter, progress } = context;
-        if ('number' !== getType(_from)) return _from;
-        return formatter(_from + (_to - _from) * progress);
-    };
-    const arrayHandler = (_from, _to)=>{
-        const result = Array.from(_from, (item, idx)=>{
-            if (Array.isArray(item)) return arrayHandler(item, _to[idx]);
-            if ('object' === getType(item)) return objectHandler(item, _to[idx]);
-            return baseNextValue(item, _to[idx]);
-        });
-        return result;
-    };
-    const objectHandler = (_from, _to)=>{
-        const result = {};
-        const keys = Reflect.ownKeys(_from);
-        for(let i = 0; i < keys.length; i++){
-            const key = keys[i];
-            const fromValue = _from[key];
-            const toValue = _to[key];
-            if (Array.isArray(_from[key])) result[key] = arrayHandler(fromValue, toValue);
-            else if ('object' === getType(fromValue)) result[key] = objectHandler(fromValue, toValue);
-            else result[key] = baseNextValue(fromValue, toValue);
-        }
-        return result;
-    };
-    let nextValueHandler = baseNextValue;
-    if ('array' === type) nextValueHandler = arrayHandler;
-    else if ('object' === type) nextValueHandler = objectHandler;
-    return (progress)=>{
-        context.progress = progress;
-        return nextValueHandler(from, to);
-    };
-}
-function matchValid(from, to, valueParser) {
-    const fromType = getType(from);
-    const toType = getType(to);
-    if (fromType !== toType) throwType('animation/stepAnimation', 'from and to must be the same type');
-    if ('array' === fromType) {
-        if (from.length !== to.length) throwType('animation/stepAnimation', 'from and to must be the same length');
-        const result = [
-            Array.from({
-                length: from.length
-            }),
-            Array.from({
-                length: to.length
-            })
-        ];
-        for(let i = 0; i < from.length; i++){
-            const [fromItem, toItem] = matchValid(from[i], to[i], valueParser);
-            result[0][i] = fromItem;
-            result[1][i] = toItem;
-        }
-        return result;
-    }
-    if ('object' === fromType) {
-        const toKeys = Reflect.ownKeys(to);
-        const fromKeys = new Set(Reflect.ownKeys(from));
-        const result = [
-            {},
-            {}
-        ];
-        for(let i = 0; i < toKeys.length; i++){
-            const key = toKeys[i];
-            if (!fromKeys.has(key)) throwType('animation/stepAnimation', `from does not have this key: ${String(key)}`);
-            const [fromItem, toItem] = matchValid(from[key], to[key], valueParser);
-            result[0][key] = fromItem;
-            result[1][key] = toItem;
-        }
-        return result;
-    }
-    if ('number' !== fromType) return [
-        valueParser(from),
-        valueParser(to)
-    ];
-    return [
-        from,
-        to
-    ];
-}
-function createNextTick(resolvers, rcSignal) {
-    const nextTick = (()=>{
-        if ('function' == typeof globalThis.requestAnimationFrame) return globalThis.requestAnimationFrame;
-        return (callback)=>setTimeout(callback, 16);
-    })();
-    return (callback)=>{
-        if (rcSignal.stopSignal) return true;
-        nextTick(()=>tryRun(callback, resolvers, (error)=>{
-                rcSignal.stop();
-                resolvers.reject(error);
-            }));
-        return false;
-    };
-}
-async function tryRun(callback, resolvers, customErrorHandler) {
-    return new Promise((resolve, reject)=>{
-        const result = callback();
-        if (result && 'function' == typeof result.then) return result.then(resolve, reject);
-        resolve();
-    }).catch(customErrorHandler || resolvers.reject);
-}
-function createRunningControllerSignal(startFn, options) {
-    const { onStart, onStop, onClear } = options;
-    const resolvers = withResolvers();
-    const ctrl = {
-        stopSignal: true,
-        resolvers,
-        stop: ()=>{
-            ctrl.stopSignal = true;
-            onStop();
-        },
-        start: ()=>{
-            ctrl.stopSignal = false;
-            onStart();
-            startFn();
-        },
-        clear: ()=>{
-            ctrl.stopSignal = true;
-            onClear();
-            resolvers.resolve(true);
-        }
-    };
-    return ctrl;
-}
-export { createNextTick, createRunningControllerSignal, getNextValueHandler, matchValid, tryRun };
+import{throwType as t}from"../throw-error/index.js";import{getType as e}from"../utils/base.js";import{isPromiseLike as r}from"../utils/verify.js";import{withResolvers as n}from"../with-resolvers/index.js";function o(t,r,n){let o=e(t),i={progress:0,valueFormatter:n},a=(t,r)=>{let{valueFormatter:n,progress:o}=i;return"number"!==e(t)?t:n(t+(r-t)*o)},l=(t,r)=>Array.from(t,(t,n)=>Array.isArray(t)?l(t,r[n]):"object"===e(t)?s(t,r[n]):a(t,r[n])),s=(t,r)=>{let n={},o=Reflect.ownKeys(t);for(let i=0;i<o.length;i++){let m=o[i],u=t[m],f=r[m];Array.isArray(t[m])?n[m]=l(u,f):"object"===e(u)?n[m]=s(u,f):n[m]=a(u,f)}return n},m=a;return"array"===o?m=l:"object"===o&&(m=s),e=>(i.progress=e,m(t,r))}function i(r,n,o){let a=e(r);if(a!==e(n)&&t("animation/stepAnimation","from and to must be the same type"),"array"===a){r.length!==n.length&&t("animation/stepAnimation","from and to must be the same length");let e=[Array.from({length:r.length}),Array.from({length:n.length})];for(let t=0;t<r.length;t++){let[a,l]=i(r[t],n[t],o);e[0][t]=a,e[1][t]=l}return e}if("object"===a){let e=Reflect.ownKeys(n),a=new Set(Reflect.ownKeys(r)),l=[{},{}];for(let s=0;s<e.length;s++){let m=e[s];a.has(m)||t("animation/stepAnimation",`from does not have this key: ${String(m)}`);let[u,f]=i(r[m],n[m],o);l[0][m]=u,l[1][m]=f}return l}return"number"!==a?[o(r),o(n)]:[r,n]}function a(t,e){let r="function"==typeof globalThis.requestAnimationFrame?globalThis.requestAnimationFrame:t=>setTimeout(t,16);return n=>!!e.stopSignal||(r(()=>l(n,t,r=>{e.stop(),t.reject(r)})),!1)}async function l(t,e,n){return new Promise((e,n)=>{let o=t();if(r(o))return o.then(e,n);e()}).catch(n??e.reject)}function s(t,e){let{onStart:r,onStop:o,onClear:i}=e,a=n(),l={stopSignal:!0,resolvers:a,stop:()=>{l.stopSignal=!0,o()},start:()=>{l.stopSignal=!1,r(),t()},clear:()=>{l.stopSignal=!0,i(),a.resolve(!0)}};return l}export{a as createNextTick,s as createRunningControllerSignal,o as getNextValueHandler,i as matchValid,l as tryRun};

package/dist/shared/api-controller/create-api.js

@@ -1,79 +1 @@
-import { logger } from "../logger/index.js";
-import { throwType } from "../throw-error/index.js";
-import { isString, isTrue } from "../utils/verify.js";
-import { request } from "./request.js";
-import { apiNamesCheck, createInstance, getInstanceMemberOrApi, instanceMemberGetter, isAbsUrl } from "./utils.js";
-const FROM_DEFINE = Symbol('fromDefine');
-function createApiWithMap(apiMap, defaultConfig) {
-    const fromDefine = apiMap[FROM_DEFINE];
-    delete apiMap[FROM_DEFINE];
-    const proxyCache = Object.create(null);
-    const realDefaultConfig = defaultConfig || {};
-    if (!isTrue(fromDefine)) apiNamesCheck(apiMap);
-    const instanceObj = createInstance(apiMap, realDefaultConfig, defaultConfig);
-    const proxy = new Proxy(apiMap, {
-        get (target, prop, receiver) {
-            if (Reflect.getOwnPropertyDescriptor(proxyCache, prop)) return proxyCache[prop];
-            const { instanceMember, api, isCustom = false } = getInstanceMemberOrApi(target, prop, receiver, instanceObj) || {};
-            if (instanceMember) return instanceMember;
-            if (!api) return;
-            let result = null;
-            result = isString(api.url) ? createApi({
-                ...api,
-                [FROM_DEFINE]: fromDefine
-            }, realDefaultConfig, isCustom) : createApiWithMap({
-                ...api,
-                [FROM_DEFINE]: fromDefine
-            }, realDefaultConfig);
-            proxyCache[prop] = result;
-            return result;
-        }
-    });
-    return proxy;
-}
-function createApi(api, defaultConfig, custom) {
-    const fromDefine = api[FROM_DEFINE];
-    delete api[FROM_DEFINE];
-    const realDefaultConfig = defaultConfig || {};
-    if (!isString(api.url)) throwType('apiController.createApi', '入参应为 APIConfig 对象');
-    if (api.url.includes('/:')) {
-        if (!isTrue(fromDefine)) logger.warn('apiController.createApi', 'url 中存在 params 参数, 使用 defineApi 或 defineApiMap 定义 API 或 API map 来获取更好的类型提示');
-        if (!isTrue(custom)) throwType('apiController.createApi', 'url 中存在 params 参数, 不支持普通请求, 转为自定义请求');
-    }
-    let handler = null;
-    handler = isTrue(custom) ? (data, config)=>request({
-            ...realDefaultConfig,
-            ...api,
-            ...config,
-            url: api.url,
-            data,
-            oriUrl: api.url
-        }) : (data)=>request({
-            ...realDefaultConfig,
-            ...api,
-            data,
-            oriUrl: api.url
-        });
-    const instanceObj = createInstance(api, realDefaultConfig, defaultConfig);
-    if (!isAbsUrl(api.url)) instanceObj.$updateBaseUrl(realDefaultConfig.baseUrl);
-    return new Proxy(handler, {
-        get (target, prop, receiver) {
-            if (Reflect.getOwnPropertyDescriptor(instanceObj, prop)) return instanceMemberGetter(prop, instanceObj);
-            return Reflect.get(target, prop, receiver);
-        }
-    });
-}
-function defineApi(_api) {
-    return {
-        ..._api,
-        [FROM_DEFINE]: true
-    };
-}
-function defineApiMap(_apiMap) {
-    apiNamesCheck(_apiMap);
-    return {
-        ..._apiMap,
-        [FROM_DEFINE]: true
-    };
-}
-export { createApi, createApiWithMap, defineApi, defineApiMap };
+import{logger as e}from"../logger/index.js";import{throwType as r}from"../throw-error/index.js";import{isString as t,isTrue as l}from"../utils/verify.js";import{request as i}from"./request.js";import{apiNamesCheck as n,createInstance as o,getInstanceMemberOrApi as u,instanceMemberGetter as p,isAbsUrl as f}from"./utils.js";let a=Symbol("fromDefine");function c(e,r){let i=e[a];delete e[a];let p=Object.create(null),f=r||{};l(i)||n(e);let s=o(e,f,r);return new Proxy(e,{get(e,r,l){if(Reflect.getOwnPropertyDescriptor(p,r))return p[r];let{instanceMember:n,api:o,isCustom:A=!1}=u(e,r,l,s)||{};if(n)return n;if(!o)return;let d=null;return d=t(o.url)?m({...o,[a]:i},f,A):c({...o,[a]:i},f),p[r]=d,d}})}function m(n,u,c){let m=n[a];delete n[a];let s=u||{};t(n.url)||r("apiController.createApi","入参应为 APIConfig 对象"),n.url.includes("/:")&&(l(m)||e.warn("apiController.createApi","url 中存在 params 参数, 使用 defineApi 或 defineApiMap 定义 API 或 API map 来获取更好的类型提示"),l(c)||r("apiController.createApi","url 中存在 params 参数, 不支持普通请求, 转为自定义请求"));let A=null;A=l(c)?(e,r)=>i({...s,...n,...r,url:n.url,data:e,oriUrl:n.url}):e=>i({...s,...n,data:e,oriUrl:n.url});let d=o(n,s,u);return f(n.url)||d.$updateBaseUrl(s.baseUrl),new Proxy(A,{get:(e,r,t)=>Reflect.getOwnPropertyDescriptor(d,r)?p(r,d):Reflect.get(e,r,t)})}function s(e){return{...e,[a]:!0}}function A(e){return n(e),{...e,[a]:!0}}export{m as createApi,c as createApiWithMap,s as defineApi,A as defineApiMap};

package/dist/shared/api-controller/index.js

@@ -1,3 +1 @@
-import { createApi, createApiWithMap, defineApi, defineApiMap } from "./create-api.js";
-import { request } from "./request.js";
-export { createApi, createApiWithMap, defineApi, defineApiMap, request };
+export{createApi,createApiWithMap,defineApi,defineApiMap}from"./create-api.js";export{request}from"./request.js";

package/dist/shared/api-controller/request.js

@@ -1,66 +1 @@
-import { throwType } from "../throw-error/index.js";
-import { tryCall } from "../try-call/index.js";
-import { isFunction, isNullOrUndef } from "../utils/verify.js";
-import { getBody, targetUrlParser, urlParamsParser } from "./utils.js";
-async function baseRequest(config, getResponse) {
-    const { baseUrl, url, method: _method, parser, data, tdto, tvo, onResponse, ...rest } = config;
-    const targetUrl = targetUrlParser(url, baseUrl);
-    const method = _method?.toUpperCase();
-    const requestInfo = tryCall(()=>{
-        if (isNullOrUndef(method) || 'GET' === method || 'HEAD' === method) {
-            const queryKeys = Object.keys(data || {});
-            for(let i = 0; i < queryKeys.length; ++i)targetUrl.searchParams.append(queryKeys[i], data[queryKeys[i]]);
-            return new Request(targetUrl, {
-                ...rest,
-                method
-            });
-        }
-        const body = getBody(data, tdto);
-        return new Request(targetUrl, {
-            ...rest,
-            method,
-            body
-        });
-    });
-    const responseInfo = await getResponse(requestInfo);
-    const resResult = await tryCall(()=>{
-        if (onResponse) return onResponse(responseInfo, config);
-        if (!parser) return responseInfo.json();
-        if ('stream' === parser) return responseInfo.body;
-        const responseHandler = responseInfo[parser];
-        if (isFunction(responseHandler)) return Reflect.apply(responseHandler, responseInfo, []);
-        throwType('apiController.responseParser', 'Invalid parser');
-    });
-    return tvo ? tvo(resResult) : resResult;
-}
-async function mockRequest(config) {
-    const { onRequest, ...rest } = config;
-    return baseRequest(config, async (requestInfo)=>{
-        const reqResult = await (onRequest && onRequest(requestInfo, config));
-        const responseBody = getBody(reqResult);
-        return new Response(responseBody, {
-            ...rest
-        });
-    });
-}
-async function networkRequest(config) {
-    return baseRequest(config, fetch);
-}
-function request(config) {
-    const url = urlParamsParser(config.url, config.params);
-    const { requestMode, requestModeMap } = config;
-    const customRequest = (requestModeMap || {})[requestMode || ''];
-    if (customRequest) return customRequest({
-        ...config,
-        url
-    });
-    if ('mock' === requestMode) return mockRequest({
-        ...config,
-        url
-    });
-    return networkRequest({
-        ...config,
-        url
-    });
-}
-export { request };
+import{throwType as e}from"../throw-error/index.js";import{tryCall as r}from"../try-call/index.js";import{isFunction as t,isNullOrUndef as n}from"../utils/verify.js";import{getBody as s,targetUrlParser as o,urlParamsParser as a}from"./utils.js";async function i(a,i){let{baseUrl:u,url:l,method:f,parser:p,data:c,tdto:m,tvo:y,onResponse:w,...d}=a,j=o(l,u),h=f?.toUpperCase(),R=r(()=>{if(n(h)||"GET"===h||"HEAD"===h){let e=Object.keys(c||{});for(let r=0;r<e.length;++r)j.searchParams.append(e[r],c[e[r]]);return new Request(j,{...d,method:h})}let e=s(c,m);return new Request(j,{...d,method:h,body:e})}),q=await i(R),x=await r(()=>{if(w)return w(q,a);if(!p)return q.json();if("stream"===p)return q.body;let r=q[p];if(t(r))return Reflect.apply(r,q,[]);e("apiController.responseParser","Invalid parser")});return y?y(x):x}async function u(e){let{onRequest:r,...t}=e;return i(e,async n=>new Response(s(await (r&&r(n,e))),{...t}))}async function l(e){return i(e,fetch)}function f(e){let r=a(e.url,e.params),{requestMode:t,requestModeMap:n}=e,s=(n||{})[t||""];return s?s({...e,url:r}):"mock"===t?u({...e,url:r}):l({...e,url:r})}export{f as request};