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

@@ -9,6 +9,7 @@ function throwType(fnName, message) {
 }
 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);

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([

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

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

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

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

@@ -0,0 +1,141 @@
+import type { AnyFunc, Cast, Equal, Func } from '../types/base';
+import type { Pack as TPack } from '../types/pack';
+type Empty = {
+    __EMPTY__: never;
+};
+/** 请求方法 */
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | (string & {});
+type Parser = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes' | 'stream' | (string & {});
+type RequestMode<E extends string = string & {}> = 'mock' | 'network' | E;
+type EmptyUnwrap<UserR = Empty, T = any> = Equal<UserR, Empty> extends true ? T : UserR;
+interface ParserResultMap<UserR = Empty> {
+    json: EmptyUnwrap<UserR>;
+    text: string;
+    blob: Blob;
+    arrayBuffer: ArrayBuffer;
+    formData: FormData;
+    bytes: Uint8Array;
+    stream: ReadableStream | null;
+}
+type ParserResult<P extends Parser, UserR = Empty> = P extends keyof ParserResultMap ? ParserResultMap<UserR>[P] : EmptyUnwrap<UserR>;
+type ParserReturn<RM extends RequestMode, P extends Parser, ReqOutput, UserR = Empty> = RM extends 'network' ? ParserResult<P, UserR> : EmptyUnwrap<UserR, RM extends 'mock' ? ReqOutput : any>;
+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;
+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;
+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?]
+]>;
+type DefineRequestModes<D extends DefaultAPIConfig> = keyof NonNullable<D['requestModeMap']> & string;
+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>;
+type OnResponseReturn<OnResponse> = OnResponse extends AnyFunc ? ReturnType<OnResponse> : any;
+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>;
+interface Pack<T> extends TPack<T> {
+    __value: T;
+}
+type PackUnwrap<P> = P extends Pack<any> ? P['__value'] : P;
+interface OriginalPack<T> extends TPack<T> {
+    __originValue: T;
+}
+type OriginalPackUnwrap<P> = P extends OriginalPack<any> ? P['__originValue'] : Promise<P>;
+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;
+type UserInputResult<UserR, CustomRequestResult> = IsUnknownAny<CustomRequestResult> extends true ? UserR : IsUnknownAny<UserR> extends true ? any : UserR extends CustomRequestResult ? OriginalPack<UserR> : UserR;
+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>>>>;
+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];
+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;
+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>;
+export {};

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

@@ -0,0 +1,22 @@
+import type { APIConfig, APIInstance, APIMap, DefaultAPIConfig } from './types';
+export declare function isAbsUrl(url?: string): boolean;
+export declare function targetUrlParser(_url: string, _baseUrl: string): URL;
+export declare function urlParamsParser(url: string, params: Record<string, string> | undefined): string;
+export declare function getBody(data: any, tdto?: APIConfig['tdto']): any;
+export declare function instanceMemberGetter(prop: string, instanceObj: Record<string, any>): any;
+export declare function createInstance(apiMap: APIConfig | APIMap, realDefaultConfig: DefaultAPIConfig, defaultConfig?: DefaultAPIConfig): {
+    $: APIMap<string & {}> | APIConfig;
+    $$: any;
+    $$r: DefaultAPIConfig<any, any, any, any, string & {}>;
+    $updateBaseUrl(baseUrl: string | undefined): void;
+};
+export declare function getInstanceMemberOrApi(target: APIMap, prop: string, receiver: any, instanceObj: APIInstance<any, any>): {
+    instanceMember: any;
+    api?: undefined;
+    isCustom?: undefined;
+} | {
+    api: APIMap<string & {}> | import("./types").DefineAPIConfig<string & {}>;
+    isCustom: boolean;
+    instanceMember?: undefined;
+} | undefined;
+export declare function apiNamesCheck(_apiMap: APIMap, isDeep?: boolean): string[];

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

@@ -0,0 +1,96 @@
+import { logger } from "../logger/index.js";
+import { throwError, throwType } from "../throw-error/index.js";
+import { getType, isPlainNumber, isString } from "../utils/index.js";
+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;
+}
+export { apiNamesCheck, createInstance, getBody, getInstanceMemberOrApi, instanceMemberGetter, isAbsUrl, targetUrlParser, urlParamsParser };

package/dist/shared/index.d.ts

@@ -1,10 +1,12 @@
 export * from './allx';
 export * from './animation';
+export * from './api-controller';
 export * from './condition-merge';
 export * from './create-storage-handler';
 export * from './data-handler';
 export * from './data-mixed-manager';
 export * from './throw-error';
+export * from './try-call';
 export * from './types';
 export * from './utils';
 export * from './with-resolvers';