@cmtlyt/lingshu-toolkit 0.4.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.d.ts

@@ -0,0 +1,26 @@
+import type { APIConfig, APIMap, APIMapTransformMethods, APITransformMethod, DefaultAPIConfig, DefineAPIConfig } from './types';
+/**
+ * 通过 API config map 创建请求对象
+ *
+ * @param apiMap API config map
+ * @param defaultConfig 默认配置
+ */
+export declare function createApiWithMap<M extends APIMap, D extends DefaultAPIConfig = DefaultAPIConfig>(apiMap: M, defaultConfig?: D): APIMapTransformMethods<M, D>;
+/**
+ * 通过 API config 创建一个请求方法
+ *
+ * @param api API config
+ * @param defaultConfig 默认配置
+ * @param custom 是否为自定义请求
+ */
+export declare function createApi<A extends APIConfig, D extends DefaultAPIConfig = DefaultAPIConfig, C extends boolean = false>(api: A, defaultConfig?: D, custom?: C): APITransformMethod<A, D, C>;
+/**
+ * 定义 API, ts 支持, 获取更好的类型声明
+ * @warn 不应该被复用, 如果希望复用的话请使用 apiInstance.$
+ */
+export declare function defineApi<U extends string, A extends DefineAPIConfig<U>>(_api: A): A;
+/**
+ * 定义 API map, ts 支持, 获取更好的类型声明
+ * @warn 不应该被复用, 如果希望复用的话请使用 apiInstance.$
+ */
+export declare function defineApiMap<U extends string, A extends APIMap<U>>(_apiMap: A): A;

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

@@ -0,0 +1 @@
+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.d.ts

@@ -0,0 +1,3 @@
+export { createApi, createApiWithMap, defineApi, defineApiMap } from './create-api';
+export { request } from './request';
+export type { APIConfig, APIMap, RequestMethod } from './types';

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

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

package/dist/shared/api-controller/request.d.ts

@@ -0,0 +1,7 @@
+import type { RequestAPIConfig } from './types';
+/**
+ * 请求方法
+ *
+ * @param config 请求配置
+ */
+export declare function request<R, C extends RequestAPIConfig<any, R> = RequestAPIConfig<any, R>>(config: C): Promise<R>;

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

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

package/dist/shared/api-controller/types.d.ts

@@ -0,0 +1,140 @@
+import type { AnyFunc, Cast, Equal, Func } from '../types/base';
+import type { Pack as TPack } from '../types/pack';
+export interface Empty {
+    __EMPTY__: never;
+}
+/** 请求方法 */
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | (string & {});
+export type Parser = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes' | 'stream' | (string & {});
+export type RequestMode<E extends string = string & {}> = 'mock' | 'network' | E;
+export type EmptyUnwrap<UserR = Empty, T = any> = Equal<UserR, Empty> extends true ? T : UserR;
+export interface ParserResultMap<UserR = Empty> {
+    json: EmptyUnwrap<UserR>;
+    text: string;
+    blob: Blob;
+    arrayBuffer: ArrayBuffer;
+    formData: FormData;
+    bytes: Uint8Array;
+    stream: ReadableStream | null;
+}
+export type ParserResult<P extends Parser, UserR = Empty> = P extends keyof ParserResultMap ? ParserResultMap<UserR>[P] : EmptyUnwrap<UserR>;
+export type ParserReturn<RM extends RequestMode, P extends Parser, ReqOutput, UserR = Empty> = RM extends 'network' ? ParserResult<P, UserR> : EmptyUnwrap<UserR, RM extends 'mock' ? ReqOutput : any>;
+export type URLParamParser<U extends string, Param extends string = never> = U extends `${string}/:${infer P}/${infer Rest}` ? URLParamParser<`/${Rest}`, Param | P> : U extends `${string}/:${infer P}` ? P | Param : Param;
+export type CheckNonParamUrlAPIConfig<A extends APIConfig> = Equal<URLParamParser<A['url']>, never>;
+export interface BaseAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> extends RequestInit {
+    /**
+     * 请求地址
+     *
+     * @example '/api/user'
+     * @example 'https://example.com/api/user'
+     */
+    url: Url;
+    params?: Record<URLParamParser<Url>, string | number>;
+    /** 请求模式 */
+    requestMode?: RequestMode<ReqModeMapKeys>;
+    /** 请求方法 */
+    method?: RequestMethod | Lowercase<RequestMethod>;
+    /**
+     * 响应体解析方式
+     * 如果存在 onResponse 的话, 则会使用 onResponse 的返回值, 如果想要屏蔽 onResponse 的继承, 则应该设置 onResponse 为 null
+     *
+     * @default 'json'
+     */
+    parser?: Parser;
+    /**
+     * transform data transfer object
+     *
+     * @tips GET/HEAD 方法因为是无 body 的请求, 不会触发 tdto 的转换
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    tdto?: ((data: Input) => any) | null;
+    /**
+     * transform view object
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    tvo?: ((data: Awaited<FindNonAny<[ResOutput, ReturnType<NonNullable<DefaultConfig['onResponse']>>]>>) => Output) | null;
+    /**
+     * 请求前 hook
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    onRequest?: ((req: Request, config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => ReqOutput) | null;
+    /**
+     * 响应前 hook
+     * 会覆盖 parser 的解析方式
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    onResponse?: ((res: Response, config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => ResOutput) | null;
+}
+export interface DefaultAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, ReqModeMapKeys extends string = string & {}> extends Omit<BaseAPIConfig<Input, Output, ReqOutput, ResOutput, DefaultAPIConfig, ReqModeMapKeys>, 'url'> {
+    /** 基本地址 */
+    baseUrl?: string;
+    /** 请求模式 map */
+    requestModeMap?: Record<ReqModeMapKeys, (config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => any>;
+}
+export interface RequestAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, ReqModeMapKeys extends string = string & {}> extends DefaultAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>, APIConfig<Input, Output, ReqOutput, ResOutput, DefaultAPIConfig, ReqModeMapKeys> {
+    /** 请求数据 */
+    data?: Input;
+    oriUrl: string;
+}
+/**
+ * API config
+ */
+export type APIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> = BaseAPIConfig<Input, Output, ReqOutput, ResOutput, DefaultConfig, ReqModeMapKeys, Url>;
+export type CallAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> = Omit<APIConfig<Input, Output, ReqOutput, ResOutput, DefaultConfig, ReqModeMapKeys, Url>, 'url'>;
+export type DefineAPIConfig<U extends string> = APIConfig<any, any, any, any, any, any, U>;
+/** API map */
+export interface APIMap<U extends string = string & {}> {
+    [key: string]: DefineAPIConfig<U> | APIMap<U>;
+}
+export type IsUnknownAny<T> = Equal<T, any> extends true ? true : Equal<T, unknown> extends true ? true : false;
+export type FindNonAny<T extends any[], Other = Empty> = T extends [infer F, ...infer Last] ? IsUnknownAny<F> extends true ? FindNonAny<Last, Other> : F extends Other ? FindNonAny<Last, Other> : F : any;
+export type APIHandlerArgs<I, C extends CallAPIConfig, Custom, NonParamUrl extends boolean> = FindNonAny<[
+    NonParamUrl extends true ? any : [I, C & Required<Pick<C, 'params'>>],
+    Custom extends true ? [I?, C?] : [I?],
+    [I?]
+]>;
+export type DefineRequestModes<D extends DefaultAPIConfig> = keyof NonNullable<D['requestModeMap']> & string;
+export type RealProp<P extends keyof DefaultAPIConfig & keyof APIConfig, C extends Pick<APIConfig, P>, A extends Pick<APIConfig, P>, D extends DefaultAPIConfig, Other = Empty> = FindNonAny<[C[P], A[P], D[P]], Other>;
+export type OnResponseReturn<OnResponse> = OnResponse extends AnyFunc ? ReturnType<OnResponse> : any;
+export type CustomCallConfigUnwrap<C extends CallAPIConfig, Custom extends boolean> = Custom extends true ? {
+    [K in keyof C as undefined extends C[K] ? never : K]: C[K];
+} : Record<never, Empty>;
+export interface Pack<T> extends TPack<T> {
+    __value: T;
+}
+export type PackUnwrap<P> = P extends Pack<any> ? P['__value'] : P;
+export interface OriginalPack<T> extends TPack<T> {
+    __originValue: T;
+}
+export type OriginalPackUnwrap<P> = P extends OriginalPack<any> ? P['__originValue'] : Promise<P>;
+export type CustomRequestModeReturn<RealRM extends RequestMode, InputD extends DefaultAPIConfig, CustomReq = NonNullable<InputD['requestModeMap']>[RealRM]> = IsUnknownAny<RealRM> extends true ? any : Equal<RealRM, string> extends true ? any : CustomReq extends AnyFunc ? OriginalPack<ReturnType<CustomReq>> : any;
+export type UserInputResult<UserR, CustomRequestResult> = IsUnknownAny<CustomRequestResult> extends true ? UserR : IsUnknownAny<UserR> extends true ? any : UserR extends CustomRequestResult ? OriginalPack<UserR> : UserR;
+export type APIHandlerResult<AConfig extends APIConfig, CallConfig extends CallAPIConfig = APIConfig, UserR = Empty, InputDefault extends DefaultAPIConfig = DefaultAPIConfig, ReqOutput = any, Custom extends boolean = false, CC extends CallAPIConfig = CustomCallConfigUnwrap<CallConfig, Custom>, CustomRequestResult = CustomRequestModeReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, InputDefault>> = OriginalPackUnwrap<Awaited<PackUnwrap<FindNonAny<[
+    UserInputResult<EmptyUnwrap<UserR>, OriginalPackUnwrap<CustomRequestResult>>,
+    CustomRequestResult,
+    ReturnType<Cast<RealProp<'tvo', CC, AConfig, InputDefault>, AnyFunc>>,
+    OnResponseReturn<RealProp<'onResponse', CC, AConfig, InputDefault>>,
+    ParserReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, NonNullable<RealProp<'parser', CC, AConfig, InputDefault>>, ReqOutput, UserR>
+], undefined | null>>>>;
+export type APIInputType<A extends Pick<APIConfig, 'tdto'> = APIConfig, D extends Pick<DefaultAPIConfig, 'tdto'> = DefaultAPIConfig> = Parameters<Cast<FindNonAny<[A['tdto'], D['tdto']], undefined | null>, (...args: any[]) => any>>[0];
+export type PropResult<A extends APIConfig, P extends keyof A> = A[P] extends AnyFunc ? ReturnType<A[P]> : unknown;
+export type APITransformMethod<A extends APIConfig, InputD extends DefaultAPIConfig = DefaultAPIConfig, Custom extends boolean = false, NonParamUrl extends boolean = CheckNonParamUrlAPIConfig<A>, I extends APIInputType<A, InputD> = APIInputType<A, InputD>> = (<R = Empty, C extends CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']> = CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']>>(...args: APIHandlerArgs<Equal<I, APIInputType<A, InputD>> extends true ? APIInputType<C, {
+    tdto: Func<[I]>;
+}> : I, C, Custom, NonParamUrl>) => APIHandlerResult<A, Cast<C, Partial<APIConfig>>, R, InputD, ReturnType<Cast<RealProp<'onRequest', C, A, InputD>, AnyFunc>>, Custom>) & APIInstance<A, InputD>;
+export type APIInstance<A, D> = {
+    $: A;
+    $$: DefaultAPIConfig extends D ? undefined : D;
+    $$r: DefaultAPIConfig;
+} & APIInstanceHandler;
+export interface APIInstanceHandler {
+    $updateBaseUrl: (baseUrl?: string) => void;
+}
+export type APIMapTransformMethods<M extends APIMap | Record<string, APIConfig>, D extends DefaultAPIConfig = DefaultAPIConfig> = {
+    [K in keyof M as M[K] extends APIConfig ? CheckNonParamUrlAPIConfig<M[K]> extends true ? K : never : K]: M[K] extends APIConfig ? APITransformMethod<M[K], D, false> : APIMapTransformMethods<Cast<M[K], APIMap>, D>;
+} & {
+    [K in keyof M as M[K] extends APIConfig ? `${K & string}Custom` : never]: APITransformMethod<Cast<M[K], APIConfig>, D, true>;
+} & APIInstance<M, D>;