@cmtlyt/lingshu-toolkit 0.3.0 → 0.4.0

package/dist/607.js

@@ -1,4 +1,70 @@
-import { dataHandler, logger, $dt, throwError, $t, throwType } from "./707.js";
+import { throwType, createError, logger, $dt, throwError, getType, identity, dataHandler, $t, noop } from "./707.js";
+function isSymbol(_v) {
+    return 'symbol' == typeof _v;
+}
+function isUndef(_v) {
+    return void 0 === _v;
+}
+function isNull(_v) {
+    return null === _v;
+}
+function isNullOrUndef(_v) {
+    return isNull(_v) || isUndef(_v);
+}
+function verify_isNaN(_v) {
+    return Number.isNaN(_v);
+}
+function isPlainSymbol(_v) {
+    return isSymbol(_v) && isUndef(Symbol.keyFor(_v));
+}
+function isObject(_v) {
+    return 'object' == typeof _v && !isNull(_v);
+}
+function isPlainObject(_v) {
+    return isObject(_v) && !isArray(_v);
+}
+function isArray(_v) {
+    return Array.isArray(_v);
+}
+function isEmptyArray(_v) {
+    return isArray(_v) && 0 === _v.length;
+}
+function isString(_v) {
+    return 'string' == typeof _v;
+}
+function isEmptyString(_v) {
+    return isString(_v) && 0 === _v.length;
+}
+function isNumber(_v) {
+    return 'number' == typeof _v;
+}
+function isPlainNumber(_v) {
+    return isNumber(_v) && !verify_isNaN(_v);
+}
+function isPropertyKey(_v) {
+    return isString(_v) || isNumber(_v) || isSymbol(_v);
+}
+function isBoolean(_v) {
+    return 'boolean' == typeof _v;
+}
+function isTrue(_v) {
+    return true === _v || isString(_v) && 'true' === _v.toLowerCase();
+}
+function isFalse(_v) {
+    return false === _v || isString(_v) && 'false' === _v.toLowerCase();
+}
+function isTruthy(_v) {
+    return !!_v;
+}
+function isFalsy(_v) {
+    return !(verify_isNaN(_v) || _v);
+}
+function isFunction(_v) {
+    return 'function' == typeof _v;
+}
+function isPromiseLike(_v) {
+    return isObject(_v) && isFunction(_v.then);
+}
 function withResolvers() {
     return 'function' == typeof Promise.withResolvers ? Promise.withResolvers() : (()=>{
         const resolver = {
@@ -13,10 +79,135 @@ function withResolvers() {
         return resolver;
     })();
 }
-const noop = ()=>void 0;
-const identity = (_v)=>_v;
-function getType(_v) {
-    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+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;
+}
+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);
 }
 function getNextValueHandler(from, to, valueFormatter) {
     const type = getType(from);
@@ -148,17 +339,7 @@ function createRunningControllerSignal(startFn, options) {
     };
     return ctrl;
 }
-function* stepAnimation(from, to, step, options = {}) {
-    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
-    const { parser: valueParser = identity, formatter: valueFormatter = identity } = options;
-    const [validFrom, validTo] = matchValid(from, to, valueParser);
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
-    for(let i = 0; i <= step; i++){
-        const value = getNextValue(i / step);
-        yield value;
-    }
-}
-const validInfo = $dt({
+const animation_validInfo = $dt({
     autoStart: $t.boolean(true),
     easing: $t["function"](()=>identity),
     onStart: $t["function"](()=>noop),
@@ -166,17 +347,32 @@ const validInfo = $dt({
     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, animation_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, {
+    const validOptions = dataHandler(options, animation_validInfo, {
         unwrap: true
     });
     const [validFrom, validTo] = matchValid(from, to, validOptions.parser);
-    const { autoStart, easing, onComplete, onUpdate, formatter: valueFormatter } = validOptions;
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
+    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(()=>{
@@ -307,5 +503,235 @@ function createStorageHandler(storageKey, initialData, options = {}) {
         }
     };
 }
+const SLOT_TYPE = {
+    fixed: {
+        fixedFlag: Symbol('fixed')
+    },
+    insert: {
+        insertFlag: Symbol('insert')
+    }
+};
+const data_mixed_manager_validInfo = $dt({
+    name: $t.string('default'),
+    fixedSlots: $t.array([]),
+    dataList: $t.array([]),
+    listener: $t.object({})
+});
+class DataMixedManager extends EventTarget {
+    addEventListener(...args) {
+        return super.addEventListener.apply(this, args);
+    }
+    removeEventListener(...args) {
+        return super.removeEventListener.apply(this, args);
+    }
+    options;
+    fixedSlots = new Map();
+    dataList = [];
+    mixedData = [];
+    lastMixedSlotIdx = -1;
+    prevDataLength = 0;
+    isBatching = false;
+    constructor(options){
+        super();
+        const validOptions = dataHandler(options || {}, data_mixed_manager_validInfo, {
+            unwrap: true
+        });
+        const { fixedSlots, dataList, listener } = validOptions;
+        this.options = validOptions;
+        this.addFixedSlots(fixedSlots, {
+            lazy: true
+        });
+        this.appendList(dataList);
+        try {
+            this.initListener(listener);
+        } catch (error) {
+            throwError('dataMixedManager', error.message, error.constructor);
+        }
+    }
+    initListener(listener) {
+        const listenerNames = Object.keys(listener);
+        for(let i = 0, name = listenerNames[i], handler = listener[name]; i < listenerNames.length; name = listenerNames[++i], handler = listener[name])this.addEventListener(name, handler);
+    }
+    getTypeText(_type) {
+        switch(_type){
+            case SLOT_TYPE.fixed:
+                return 'fixed';
+            case SLOT_TYPE.insert:
+                return 'insert';
+        }
+    }
+    buildSlotConfig(config, type) {
+        const typeText = this.getTypeText(config.type || type);
+        return {
+            ...config,
+            type: typeText,
+            inputPosition: config.position,
+            insertMode: config.insertMode || 'cover'
+        };
+    }
+    addFixedSlot(config, buildOptions) {
+        const realConfig = this.reorderFixedSlots(this.buildSlotConfig(config, SLOT_TYPE.fixed));
+        this.fixedSlots.set(realConfig.position, realConfig);
+        this.buildMixedData(buildOptions);
+        return realConfig.position;
+    }
+    reorderFixedSlots(config) {
+        const { position: oldPosition, insertMode } = config;
+        if (null == insertMode || 'cover' === insertMode || !this.fixedSlots.has(oldPosition)) return {
+            ...config,
+            inputPosition: oldPosition
+        };
+        const position = 'after' === insertMode ? oldPosition + 1 : oldPosition;
+        for(let i = position + 1, preItem = this.fixedSlots.get(i - 1), currItem = this.fixedSlots.get(i); preItem; ++i, preItem = currItem, currItem = this.fixedSlots.get(i)){
+            preItem.position = i;
+            this.fixedSlots.set(i, preItem);
+        }
+        return {
+            ...config,
+            position,
+            inputPosition: oldPosition
+        };
+    }
+    addFixedSlots(configs, buildOptions) {
+        if (!configs.length) return [];
+        const positions = this.batchUpdate(()=>configs.map((config)=>this.addFixedSlot(config)));
+        this.buildMixedData(buildOptions);
+        return positions;
+    }
+    deleteFixedSlot(position, buildOptions) {
+        this.fixedSlots.delete(position);
+        this.buildMixedData(buildOptions);
+    }
+    deleteFixedSlots(positions, buildOptions) {
+        if (!positions.length) return;
+        this.batchUpdate(()=>positions.forEach((position)=>void this.deleteFixedSlot(position)));
+        this.buildMixedData(buildOptions);
+    }
+    batchUpdate(callback) {
+        try {
+            this.isBatching = true;
+            const result = callback();
+            return result;
+        } finally{
+            this.isBatching = false;
+        }
+    }
+    clearFixedSlots(buildOptions) {
+        this.fixedSlots.clear();
+        this.buildMixedData(buildOptions);
+    }
+    appendList(list, buildOptions) {
+        if (!list.length) return;
+        this.dataList.push(...list);
+        this.buildMixedData({
+            ...buildOptions,
+            lazy: true === (buildOptions || {}).lazy
+        });
+    }
+    clearList() {
+        this.dataList.length = 0;
+        this.mixedData.length = 0;
+        this.dispatch('change', {
+            mode: 'clear',
+            mixedData: this.getMixedData({
+                mode: 'rebuild'
+            })
+        });
+        this.dispatch('clear');
+    }
+    getMixedData(buildOptions) {
+        this.buildMixedData({
+            ...buildOptions,
+            lazy: false
+        });
+        return this.mixedData.slice();
+    }
+    dispatch(name, data) {
+        const detail = {
+            name: this.options.name,
+            ...data
+        };
+        this.dispatchEvent(new CustomEvent(name, {
+            detail
+        }));
+        if ("u" > typeof window) window.dispatchEvent(new CustomEvent(`[DMM]:${name}`, {
+            detail
+        }));
+    }
+    buildMixedData(buildOptions) {
+        if (this.isBatching) return;
+        const { lazy, mode } = buildOptions || {};
+        if ('rebuild' === mode) {
+            this.prevDataLength = 0;
+            this.lastMixedSlotIdx = -1;
+        }
+        if (false !== lazy || this.dataList.length <= this.prevDataLength) return;
+        let dataStartIdx = this.prevDataLength;
+        const dataEndIdx = this.dataList.length;
+        const newItemCount = dataEndIdx - dataStartIdx;
+        this.prevDataLength = dataEndIdx;
+        const isPatchMode = dataStartIdx > 0;
+        const filteredSlots = this.sliceSlots(isPatchMode ? this.mixedData.length : this.lastMixedSlotIdx, this.mixedData.length + newItemCount);
+        this.lastMixedSlotIdx = filteredSlots.at(-1) ?? this.lastMixedSlotIdx;
+        let mixedStartIdx = isPatchMode ? this.mixedData.length : 0;
+        this.mixedData.length = (isPatchMode ? newItemCount + mixedStartIdx : dataEndIdx) + filteredSlots.length;
+        for(let fpIdx = 0, fpItem = filteredSlots[fpIdx]; dataStartIdx < dataEndIdx; ++mixedStartIdx)if (mixedStartIdx === fpItem) {
+            const fixedSlot = this.fixedSlots.get(fpItem);
+            this.mixedData[mixedStartIdx] = {
+                isFixed: true,
+                type: fixedSlot.type,
+                data: fixedSlot.data
+            };
+            fpItem = filteredSlots[++fpIdx];
+        } else {
+            this.mixedData[mixedStartIdx] = {
+                isFixed: false,
+                type: 'plain',
+                data: this.dataList[dataStartIdx]
+            };
+            ++dataStartIdx;
+        }
+        this.dispatch('change', {
+            mode: isPatchMode ? 'patch' : 'rebuild',
+            mixedData: this.mixedData.slice()
+        });
+    }
+    sliceSlots(startIdx, endIdx = 1 / 0) {
+        let prevItem = -2;
+        let count = 0;
+        return Array.from(this.fixedSlots.keys()).sort((ai, bi)=>ai - bi).filter((item)=>{
+            if (item >= startIdx && item < endIdx + count || item - 1 === prevItem) {
+                ++count;
+                prevItem = item;
+                return true;
+            }
+            return false;
+        });
+    }
+    insertSlot(config) {
+        const realPosition = this.addFixedSlot({
+            ...config,
+            type: SLOT_TYPE.insert
+        });
+        if (realPosition > this.mixedData.length) return realPosition;
+        this.buildMixedData({
+            lazy: false,
+            mode: 'rebuild'
+        });
+        return realPosition;
+    }
+    insertSlots(configs) {
+        if (!configs.length) return [];
+        const positions = this.batchUpdate(()=>configs.map((config)=>this.insertSlot(config)));
+        this.buildMixedData({
+            lazy: false,
+            mode: 'rebuild'
+        });
+        return positions;
+    }
+}
+function dataMixedManager(options) {
+    return new DataMixedManager(options);
+}
 Symbol('__PACK__');
-export { animation, conditionMerge, createStorageHandler, stepAnimation, withResolvers };
+export { allx, animation, conditionMerge, createStorageHandler, dataMixedManager, isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef, stepAnimation, verify_isNaN as isNaN, withResolvers };

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();
 }
@@ -133,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.js

@@ -138,9 +138,7 @@ function useMount(callback) {
         callbackRef.current();
     }, []);
 }
-function clone(_v) {
-    return structuredClone(_v);
-}
+const clone = structuredClone;
 function useRefState(initialState) {
     const stateRef = useRef(initialState);
     const forceUpdate = useForceUpdate();

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

@@ -1,8 +1,6 @@
 import { useMemo, useRef } from "react";
 import { useForceUpdate } from "../use-force-update/index.js";
-function clone(_v) {
-    return structuredClone(_v);
-}
+const clone = structuredClone;
 function useRefState(initialState) {
     const stateRef = useRef(initialState);
     const forceUpdate = useForceUpdate();

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;