@cmtlyt/lingshu-toolkit 0.3.0 → 0.5.0

package/dist/shared/index.js

@@ -1,2 +1,957 @@
-export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../707.js";
-export { animation, conditionMerge, createStorageHandler, stepAnimation, withResolvers } from "../607.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 = {
+            promise: null,
+            resolve: null,
+            reject: null
+        };
+        resolver.promise = new Promise((resolve, reject)=>{
+            resolver.resolve = resolve;
+            resolver.reject = reject;
+        });
+        return resolver;
+    })();
+}
+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);
+    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;
+}
+const animation_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, 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, animation_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
+    };
+}
+const EMPTY = Symbol('EMPTY');
+function tryCallFunc(cb, onError, onFinal) {
+    if (!isFunction(cb)) throwType('tryCallFunc', 'callback is not a function');
+    const catchFn = (self, ctx, error)=>{
+        if (isFunction(onError)) try {
+            ctx.errorResult = Reflect.apply(onError, self, [
+                error
+            ]);
+        } catch (err) {
+            ctx.error = err;
+        }
+        else ctx.error = error;
+        return ctx.errorResult;
+    };
+    const finallyFn = (self, ctx, result)=>{
+        try {
+            if (ctx.error !== EMPTY) throw ctx.error;
+        } finally{
+            if (isFunction(onFinal)) if (ctx.errorResult !== EMPTY) Reflect.apply(onFinal, self, [
+                ctx.errorResult
+            ]);
+            else if (ctx.error !== EMPTY) Reflect.apply(onFinal, self, [
+                ctx.error
+            ]);
+            else Reflect.apply(onFinal, self, [
+                result
+            ]);
+        }
+    };
+    return function(...args) {
+        const ctx = {
+            oriResult: EMPTY,
+            errorResult: EMPTY,
+            error: EMPTY
+        };
+        const asyncFn = async ()=>{
+            try {
+                ctx.oriResult = Reflect.apply(cb, this, args);
+                return ctx.oriResult;
+            } catch (error) {
+                return catchFn(this, ctx, error);
+            }
+        };
+        const fnPromise = asyncFn().catch((error)=>catchFn(this, ctx, error));
+        if (isPromiseLike(ctx.oriResult)) return fnPromise.then((result)=>{
+            finallyFn(this, ctx, result);
+            return result;
+        });
+        finallyFn(this, ctx, ctx.oriResult);
+        return ctx.oriResult !== EMPTY ? ctx.oriResult : ctx.errorResult;
+    };
+}
+function tryCall(cb, onError, onFinal) {
+    if (!isFunction(cb)) throwType('tryCall', 'callback is not a function');
+    return tryCallFunc(cb, onError, onFinal).call(this);
+}
+const ABSOLUTE_URL_REG = /^[a-z][a-z\d+\-.]*:/im;
+function isAbsUrl(url) {
+    if (!url) return false;
+    return ABSOLUTE_URL_REG.test(url);
+}
+function targetUrlParser(_url, _baseUrl) {
+    if (isAbsUrl(_url)) return new URL(_url);
+    if (!isAbsUrl(_baseUrl)) throwType('apiController.request', 'baseUrl 配置不合法, 必须是绝对路径');
+    const baseUrl = new URL(_baseUrl);
+    const basePath = '/' === baseUrl.pathname ? '' : baseUrl.pathname.replace(/\/$/, '');
+    const relativePath = _url.startsWith('/') ? _url : `/${_url}`;
+    const url = `${basePath}${relativePath}`;
+    return new URL(url, baseUrl);
+}
+function urlParamsParser(url, params) {
+    if (!url.includes('/:')) return url;
+    if (!params) throwType('apiController.parseParams', 'url 中存在 params 参数, params 配置不能为空, 请使用 custom 方法调用并传递 params 配置');
+    const urlSplit = url.split('/');
+    const emptyKeys = [];
+    for(let i = 1; i < urlSplit.length; ++i){
+        if (':' !== urlSplit[i][0]) continue;
+        const param = urlSplit[i].slice(1);
+        const originValue = params[param];
+        if (!(isPlainNumber(originValue) || originValue)) {
+            emptyKeys.push(param);
+            continue;
+        }
+        const paramValue = encodeURIComponent(String(originValue));
+        urlSplit[i] = paramValue;
+    }
+    if (emptyKeys.length) throwType('apiController.parseParams', `params 配置中缺少 [${emptyKeys.join(', ')}] 参数`);
+    return urlSplit.join('/');
+}
+function getBody(data, tdto) {
+    const _body = tdto ? tdto(data) : data;
+    const bodyType = getType(_body);
+    switch(bodyType){
+        case 'object':
+        case 'array':
+        case 'number':
+        case 'boolean':
+        case 'function':
+            return JSON.stringify(_body);
+        default:
+            return _body;
+    }
+}
+function instanceMemberGetter(prop, instanceObj) {
+    return instanceObj[prop];
+}
+function createInstance(apiMap, realDefaultConfig, defaultConfig) {
+    return {
+        $: apiMap,
+        $$: defaultConfig,
+        $$r: realDefaultConfig,
+        $updateBaseUrl (baseUrl) {
+            if (isAbsUrl(baseUrl)) realDefaultConfig.baseUrl = baseUrl;
+            else {
+                const { origin } = globalThis.location || {};
+                if (!origin) throwError('apiController.$updateBaseUrl', 'location.origin is undefined');
+                const normalizedPath = (baseUrl || '/').startsWith('/') ? baseUrl || '' : `/${baseUrl}`;
+                realDefaultConfig.baseUrl = `${origin}${normalizedPath}`;
+            }
+        }
+    };
+}
+function getInstanceMemberOrApi(target, prop, receiver, instanceObj) {
+    if (Reflect.getOwnPropertyDescriptor(instanceObj, prop)) return {
+        instanceMember: instanceMemberGetter(prop, instanceObj)
+    };
+    const hasExactProp = isString(prop) && Reflect.has(target, prop);
+    const isCustom = isString(prop) && prop.endsWith('Custom') && !hasExactProp;
+    const name = isCustom ? prop.slice(0, -6) : prop;
+    if (!Reflect.getOwnPropertyDescriptor(target, name)) return;
+    const api = Reflect.get(target, name, receiver);
+    if (isCustom && !isString(api.url)) return;
+    return {
+        api,
+        isCustom
+    };
+}
+function apiNamesCheck(_apiMap, isDeep = false) {
+    const apiNames = Reflect.ownKeys(_apiMap);
+    const warnNames = [];
+    for(let i = 0; i < apiNames.length; i++){
+        const name = apiNames[i];
+        if (name.endsWith('Custom')) warnNames.push(name);
+        if (!isString(_apiMap[name].url)) warnNames.push(...apiNamesCheck(_apiMap[name], true));
+    }
+    if (!isDeep && warnNames.length > 0) logger.warn('apiController.createApiWithMap', 'api 命名不应该使用 Custom 结尾, 因为这是一个内部实现的方法', warnNames);
+    return warnNames;
+}
+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
+    });
+}
+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
+    };
+}
+function getEmpty(_v) {
+    return Array.isArray(_v) ? [] : {};
+}
+function valueCheck(_v) {
+    return Array.isArray(_v) || 'object' == typeof _v;
+}
+function conditionMerge(...input) {
+    const conditionItems = (input.length > 1 ? input : input[0]).map((item)=>{
+        let result = null;
+        if (Array.isArray(item)) {
+            const [condition, value, fullback] = item;
+            result = {
+                condition,
+                value,
+                fullback
+            };
+        } else if (Object.getOwnPropertyDescriptor(item, 'condition')) result = item;
+        else throwType('conditionMerge', 'input must be an ConditionItem');
+        const validValue = valueCheck(result.value);
+        const validFullback = void 0 === result.fullback || valueCheck(result.fullback);
+        if (!(validValue && validFullback)) throwType('conditionMerge', 'value and fullback must be an array or object');
+        return result;
+    });
+    const result = getEmpty(conditionItems[0].value);
+    const mergeFn = Array.isArray(result) ? (a1, a2)=>Reflect.apply(Array.prototype.splice.bind(a1, a1.length, 0), null, a2) : Object.assign;
+    for(let i = 0, item = conditionItems[i]; i < conditionItems.length; item = conditionItems[++i])mergeFn(result, item.condition ? item.value : item.fullback || getEmpty(item.value));
+    return result;
+}
+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 { $dt, $t, createError, dataHandler, defineTransform, getType, identity, noop, throwError, throwType } from "../707.js";
+export { createStorageHandler } from "../247.js";
+export { allx, animation, conditionMerge, createApi, createApiWithMap, dataMixedManager, defineApi, defineApiMap, isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef, request, stepAnimation, tryCall, tryCallFunc, verify_isNaN as isNaN, withResolvers };