@cmtlyt/lingshu-toolkit 0.3.0 → 0.5.0

package/dist/247.js

@@ -0,0 +1,66 @@
+import { dataHandler, logger, $dt, throwError, $t } from "./707.js";
+const validInfo = $dt({
+    storageKey: 'validString',
+    storageType: $t["enum"]([
+        'local',
+        'session',
+        'memory'
+    ], 'local'),
+    autoSaveInterval: $t.number(0)
+});
+const memoryStorage = {
+    data: {},
+    getItem (key) {
+        return this.data[key];
+    },
+    setItem (key, value) {
+        this.data[key] = value;
+    },
+    removeItem (key) {
+        delete this.data[key];
+    }
+};
+function getStorage(storageType) {
+    try {
+        if ('memory' === storageType) return memoryStorage;
+        return 'local' === storageType ? localStorage : sessionStorage;
+    } catch  {
+        logger.warn('createStorage', 'Failed to access localStorage or sessionStorage, using memoryStorage instead.');
+        return memoryStorage;
+    }
+}
+const CLEAR_FLAG = Symbol('cleared');
+function createStorageHandler(storageKey, initialData, options = {}) {
+    const { storageKey: validStorageKey, storageType, autoSaveInterval } = dataHandler({
+        storageKey,
+        ...options
+    }, validInfo, {
+        unwrap: true
+    });
+    const storage = getStorage(storageType);
+    const storageData = storage.getItem(validStorageKey);
+    const context = {
+        data: storageData ? JSON.parse(storageData) : initialData || {}
+    };
+    return {
+        get (key) {
+            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
+            if (null == key) return context.data;
+            return context.data[key];
+        },
+        set (value, key) {
+            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
+            if (null == key) context.data = value;
+            else context.data[key] = value;
+            if (autoSaveInterval > 0) setTimeout(()=>{
+                storage.setItem(validStorageKey, JSON.stringify(context.data));
+            }, autoSaveInterval);
+            else storage.setItem(validStorageKey, JSON.stringify(context.data));
+        },
+        clear () {
+            context.data = CLEAR_FLAG;
+            storage.removeItem(validStorageKey);
+        }
+    };
+}
+export { createStorageHandler };

package/dist/707.js

@@ -1,17 +1,23 @@
+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);
 }
 const logger = new Proxy(console, {
     get (target, prop, receiver) {
+        if ((globalThis.$$lingshu$$ || {}).disableLogger) return ()=>void 0;
         const oldLog = Reflect.get(target, prop, receiver).bind(console);
         return (fnName, ...args)=>{
             oldLog(`[@cmtlyt/lingshu-toolkit#${fnName}]:`, ...args);
         };
     }
 });
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
 function getType(_v) {
     return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
 }
@@ -133,4 +139,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

@@ -1,6 +1,6 @@
 import { useEffect, useEffectEvent, useMemo, useReducer, useRef, useState } from "react";
 import { dataHandler, logger, $dt, $t, throwType } from "../707.js";
-import { createStorageHandler } from "../607.js";
+import { createStorageHandler } from "../247.js";
 function useToggle(defualtValue = false, reverseValue) {
     const [state, setState] = useState(defualtValue);
     const toggleRef = useRef([
@@ -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-mount/index.js

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from "react";
-import { $t, dataHandler } from "../../shared/index.js";
+import { $t, dataHandler } from "../../shared/data-handler/index.js";
 function useMount(callback) {
     const callbackRef = useRef(callback);
     useEffect(()=>{

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;

package/dist/shared/allx/utils.js

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

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

@@ -1,3 +1,3 @@
 import type { AnimationBaseOptions, AnimationOptions, AnimationResult } from './types';
-export declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions): Generator<T, void, unknown>;
-export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions): AnimationResult;
+export declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions<T>): Generator<any, void, unknown>;
+export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions<T>): AnimationResult;

package/dist/shared/animation/index.js

@@ -1,16 +1,7 @@
 import { $dt, $t, dataHandler } from "../data-handler/index.js";
 import { throwError } from "../throw-error/index.js";
-import { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop } from "./utils.js";
-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;
-    }
-}
+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),
@@ -19,17 +10,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, 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, 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(()=>{

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

@@ -1,9 +1,11 @@
-export type Formatter = (value: number) => any;
-export interface AnimationBaseOptions {
+export type FormatterValue = (value: number) => any;
+export type Formatter<T> = (value: T) => any;
+export interface AnimationBaseOptions<T> {
     parser?: (value: any) => number;
-    formatter?: Formatter;
+    formatterValue?: FormatterValue;
+    formatter?: Formatter<T>;
 }
-export interface AnimationOptions extends AnimationBaseOptions {
+export interface AnimationOptions<T> extends AnimationBaseOptions<T> {
     autoStart?: boolean;
     easing?: (time: number) => number;
     onStart?: () => void;

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

@@ -1,12 +1,10 @@
 import { type Resolver } from '../with-resolvers';
-import type { AnimationOptions, Formatter } from './types';
-export declare const noop: () => undefined;
-export declare const identity: <T>(_v: T) => T;
-export declare function getNextValueHandler(from: any, to: any, valueFormatter: Formatter): (progress: number) => any;
+import type { AnimationOptions, FormatterValue } from './types';
+export declare function getNextValueHandler<T>(from: T, to: T, valueFormatter: FormatterValue): (progress: number) => any;
 export declare function matchValid(from: any, to: any, valueParser: (value: any) => number): number[] | unknown[][] | [Record<PropertyKey, any>, Record<PropertyKey, any>];
 export declare function createNextTick(resolvers: Resolver<any>, rcSignal: RCSignal): (callback: (...args: any[]) => void) => boolean;
 export declare function tryRun(callback: () => any, resolvers: Resolver<any>, customErrorHandler?: (err: any) => void): Promise<void>;
-export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions>): {
+export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions<any>>): {
     stopSignal: boolean;
     resolvers: Resolver<boolean>;
     stop: () => void;

package/dist/shared/animation/utils.js

@@ -1,10 +1,6 @@
 import { throwType } from "../throw-error/index.js";
+import { getType } from "../utils/base.js";
 import { withResolvers } from "../with-resolvers/index.js";
-const noop = ()=>void 0;
-const identity = (_v)=>_v;
-function getType(_v) {
-    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
-}
 function getNextValueHandler(from, to, valueFormatter) {
     const type = getType(from);
     const context = {
@@ -135,4 +131,4 @@ function createRunningControllerSignal(startFn, options) {
     };
     return ctrl;
 }
-export { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop, tryRun };
+export { createNextTick, createRunningControllerSignal, getNextValueHandler, matchValid, tryRun };

package/dist/shared/api-controller/__test__/index.browser.test.d.ts

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

package/dist/shared/api-controller/__test__/index.node.test.d.ts

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

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

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,3 @@
+import { createApi, createApiWithMap, defineApi, defineApiMap } from "./create-api.js";
+import { request } from "./request.js";
+export { createApi, createApiWithMap, defineApi, defineApiMap, request };

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>;