@cmtlyt/lingshu-toolkit 0.5.0 → 0.6.0

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

@@ -1,14 +1,14 @@
 import type { AnyFunc, Cast, Equal, Func } from '../types/base';
 import type { Pack as TPack } from '../types/pack';
-type Empty = {
+export interface 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> {
+export type Parser = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes' | 'stream' | (string & {});
+export type RequestMode<E extends string = string & {}> = 'mock' | 'network' | E;
+export type EmptyUnwrap<UserR = Empty, T = any> = Equal<UserR, Empty> extends true ? T : UserR;
+export interface ParserResultMap<UserR = Empty> {
     json: EmptyUnwrap<UserR>;
     text: string;
     blob: Blob;
@@ -17,10 +17,10 @@ interface ParserResultMap<UserR = Empty> {
     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 type ParserResult<P extends Parser, UserR = Empty> = P extends keyof ParserResultMap ? ParserResultMap<UserR>[P] : EmptyUnwrap<UserR>;
+export type ParserReturn<RM extends RequestMode, P extends Parser, ReqOutput, UserR = Empty> = RM extends 'network' ? ParserResult<P, UserR> : EmptyUnwrap<UserR, RM extends 'mock' ? ReqOutput : any>;
+export type URLParamParser<U extends string, Param extends string = never> = U extends `${string}/:${infer P}/${infer Rest}` ? URLParamParser<`/${Rest}`, Param | P> : U extends `${string}/:${infer P}` ? P | Param : Param;
+export type CheckNonParamUrlAPIConfig<A extends APIConfig> = Equal<URLParamParser<A['url']>, never>;
 export interface BaseAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> extends RequestInit {
     /**
      * 请求地址
@@ -92,36 +92,36 @@ export interface APIMap<U extends string = string & {}> {
 }
 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<[
+export type APIHandlerArgs<I, C extends CallAPIConfig, Custom, NonParamUrl extends boolean> = FindNonAny<[
     NonParamUrl extends true ? any : [I, C & Required<Pick<C, 'params'>>],
     Custom extends true ? [I?, C?] : [I?],
     [I?]
 ]>;
-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 ? {
+export type DefineRequestModes<D extends DefaultAPIConfig> = keyof NonNullable<D['requestModeMap']> & string;
+export type RealProp<P extends keyof DefaultAPIConfig & keyof APIConfig, C extends Pick<APIConfig, P>, A extends Pick<APIConfig, P>, D extends DefaultAPIConfig, Other = Empty> = FindNonAny<[C[P], A[P], D[P]], Other>;
+export type OnResponseReturn<OnResponse> = OnResponse extends AnyFunc ? ReturnType<OnResponse> : any;
+export type CustomCallConfigUnwrap<C extends CallAPIConfig, Custom extends boolean> = Custom extends true ? {
     [K in keyof C as undefined extends C[K] ? never : K]: C[K];
 } : Record<never, Empty>;
-interface Pack<T> extends TPack<T> {
+export interface Pack<T> extends TPack<T> {
     __value: T;
 }
-type PackUnwrap<P> = P extends Pack<any> ? P['__value'] : P;
-interface OriginalPack<T> extends TPack<T> {
+export type PackUnwrap<P> = P extends Pack<any> ? P['__value'] : P;
+export 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<[
+export type OriginalPackUnwrap<P> = P extends OriginalPack<any> ? P['__originValue'] : Promise<P>;
+export type CustomRequestModeReturn<RealRM extends RequestMode, InputD extends DefaultAPIConfig, CustomReq = NonNullable<InputD['requestModeMap']>[RealRM]> = IsUnknownAny<RealRM> extends true ? any : Equal<RealRM, string> extends true ? any : CustomReq extends AnyFunc ? OriginalPack<ReturnType<CustomReq>> : any;
+export type UserInputResult<UserR, CustomRequestResult> = IsUnknownAny<CustomRequestResult> extends true ? UserR : IsUnknownAny<UserR> extends true ? any : UserR extends CustomRequestResult ? OriginalPack<UserR> : UserR;
+export type APIHandlerResult<AConfig extends APIConfig, CallConfig extends CallAPIConfig = APIConfig, UserR = Empty, InputDefault extends DefaultAPIConfig = DefaultAPIConfig, ReqOutput = any, Custom extends boolean = false, CC extends CallAPIConfig = CustomCallConfigUnwrap<CallConfig, Custom>, CustomRequestResult = CustomRequestModeReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, InputDefault>> = OriginalPackUnwrap<Awaited<PackUnwrap<FindNonAny<[
     UserInputResult<EmptyUnwrap<UserR>, OriginalPackUnwrap<CustomRequestResult>>,
     CustomRequestResult,
     ReturnType<Cast<RealProp<'tvo', CC, AConfig, InputDefault>, AnyFunc>>,
     OnResponseReturn<RealProp<'onResponse', CC, AConfig, InputDefault>>,
     ParserReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, NonNullable<RealProp<'parser', CC, AConfig, InputDefault>>, ReqOutput, UserR>
 ], undefined | null>>>>;
-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 APIInputType<A extends Pick<APIConfig, 'tdto'> = APIConfig, D extends Pick<DefaultAPIConfig, 'tdto'> = DefaultAPIConfig> = Parameters<Cast<FindNonAny<[A['tdto'], D['tdto']], undefined | null>, (...args: any[]) => any>>[0];
+export type PropResult<A extends APIConfig, P extends keyof A> = A[P] extends AnyFunc ? ReturnType<A[P]> : unknown;
 export type APITransformMethod<A extends APIConfig, InputD extends DefaultAPIConfig = DefaultAPIConfig, Custom extends boolean = false, NonParamUrl extends boolean = CheckNonParamUrlAPIConfig<A>, I extends APIInputType<A, InputD> = APIInputType<A, InputD>> = (<R = Empty, C extends CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']> = CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']>>(...args: APIHandlerArgs<Equal<I, APIInputType<A, InputD>> extends true ? APIInputType<C, {
     tdto: Func<[I]>;
 }> : I, C, Custom, NonParamUrl>) => APIHandlerResult<A, Cast<C, Partial<APIConfig>>, R, InputD, ReturnType<Cast<RealProp<'onRequest', C, A, InputD>, AnyFunc>>, Custom>) & APIInstance<A, InputD>;
@@ -130,12 +130,11 @@ export type APIInstance<A, D> = {
     $$: DefaultAPIConfig extends D ? undefined : D;
     $$r: DefaultAPIConfig;
 } & APIInstanceHandler;
-interface APIInstanceHandler {
-    $updateBaseUrl(baseUrl?: string): void;
+export interface APIInstanceHandler {
+    $updateBaseUrl: (baseUrl?: string) => void;
 }
 export type APIMapTransformMethods<M extends APIMap | Record<string, APIConfig>, D extends DefaultAPIConfig = DefaultAPIConfig> = {
     [K in keyof M as M[K] extends APIConfig ? CheckNonParamUrlAPIConfig<M[K]> extends true ? K : never : K]: M[K] extends APIConfig ? APITransformMethod<M[K], D, false> : APIMapTransformMethods<Cast<M[K], APIMap>, D>;
 } & {
     [K in keyof M as M[K] extends APIConfig ? `${K & string}Custom` : never]: APITransformMethod<Cast<M[K], APIConfig>, D, true>;
 } & APIInstance<M, D>;
-export {};

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

@@ -1,22 +1,13 @@
 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 urlParamsParser(url: string, params: Record<string, string | number> | 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 createInstance(apiMap: APIConfig | APIMap, realDefaultConfig: DefaultAPIConfig, defaultConfig?: DefaultAPIConfig): APIInstance<any, any>;
+export declare function getInstanceMemberOrApi(target: APIMap, prop: string, receiver: any, instanceObj: APIInstance<any, any>): undefined | {
+    api?: APIConfig | APIMap;
+    isCustom?: boolean;
+    instanceMember?: any;
 };
-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

@@ -1,96 +1 @@
-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 };
+import{logger as e}from"../logger/index.js";import{throwError as t,throwType as r}from"../throw-error/index.js";import{getType as n}from"../utils/base.js";import{isPlainNumber as a,isString as i}from"../utils/verify.js";let s=/^[a-z][a-z\d+\-.]*:/imu;function l(e){return!!e&&s.test(e)}function o(e,t){if(l(e))return new URL(e);l(t)||r("apiController.request","baseUrl 配置不合法, 必须是绝对路径");let n=new URL(t),a="/"===n.pathname?"":n.pathname.replace(/\/$/u,""),i=e.startsWith("/")?e:`/${e}`;return new URL(`${a}${i}`,n)}function u(e,t){if(!e.includes("/:"))return e;t||r("apiController.parseParams","url 中存在 params 参数, params 配置不能为空, 请使用 custom 方法调用并传递 params 配置");let n=e.split("/"),i=[];for(let e=1;e<n.length;++e){if(":"!==n[e][0])continue;let r=n[e].slice(1),s=t[r];if(!(a(s)||s)){i.push(r);continue}let l=encodeURIComponent(String(s));n[e]=l}return i.length>0&&r("apiController.parseParams",`params 配置中缺少 [${i.join(", ")}] 参数`),n.join("/")}function c(e,t){let r=t?t(e):e;switch(n(r)){case"object":case"array":case"number":case"boolean":case"function":return JSON.stringify(r);default:return r}}function p(e,t){return t[e]}function f(e,r,n){return{$:e,$$:n,$$r:r,$updateBaseUrl(e){if(l(e))r.baseUrl=e;else{let{origin:n}=globalThis.location||{};n||t("apiController.$updateBaseUrl","location.origin is undefined");let a=(e||"/").startsWith("/")?e||"":`/${e}`;r.baseUrl=`${n}${a}`}}}}function m(e,t,r,n){if(Reflect.getOwnPropertyDescriptor(n,t))return{instanceMember:p(t,n)};let a=i(t)&&Reflect.has(e,t),s=i(t)&&t.endsWith("Custom")&&!a,l=s?t.slice(0,-6):t;if(!Reflect.getOwnPropertyDescriptor(e,l))return;let o=Reflect.get(e,l,r);if(!s||i(o.url))return{api:o,isCustom:s}}function h(t,r=!1){let n=Reflect.ownKeys(t),a=[];for(let e=0;e<n.length;e++){let r=n[e];r.endsWith("Custom")&&a.push(r),i(t[r].url)||a.push(...h(t[r],!0))}return!r&&a.length>0&&e.warn("apiController.createApiWithMap","api 命名不应该使用 Custom 结尾, 因为这是一个内部实现的方法",a),a}export{h as apiNamesCheck,f as createInstance,c as getBody,m as getInstanceMemberOrApi,p as instanceMemberGetter,l as isAbsUrl,o as targetUrlParser,u as urlParamsParser};

package/dist/shared/condition-merge/index.d.ts

@@ -1,11 +1,11 @@
-import type { IsPrimitive, Printify, UnionToIntersection } from '../types';
+import type { IsPrimitive, Printify, UnionToIntersection } from '../types/base';
 type AssertValue = Record<PropertyKey, any> | any[];
 type ConditionArrayItem = [boolean, AssertValue, AssertValue?];
-type ConditionObjItem = {
+interface ConditionObjItem {
     condition: boolean;
     value: AssertValue;
     fullback?: AssertValue;
-};
+}
 type ConditionItem = ConditionObjItem | ConditionArrayItem;
 type GetDefaultValue<V> = IsPrimitive<V> extends true ? never : Record<never, any>;
 type ParseDefaultValue<V, D> = FormatValue<unknown extends D ? (V extends any[] ? [] : GetDefaultValue<V>) : D extends undefined | null ? GetDefaultValue<V> : D>;
@@ -26,6 +26,6 @@ type MergedResult<T extends ConditionItem[]> = T extends [
 ] ? ParseConditionValue<First> & MergedResult<Last> : ParseConditionValue<T[0]>;
 type CMInput = ConditionItem[];
 type FormatResult<T extends any[]> = T[0] & Record<PropertyKey, any>;
-export declare function conditionMerge<T extends CMInput>(...input: T): FormatResult<MergedResult<T>>;
-export declare function conditionMerge<T extends CMInput>(input: T): FormatResult<MergedResult<T>>;
-export {};
+declare function conditionMerge<T extends CMInput>(...input: T): FormatResult<MergedResult<T>>;
+declare function conditionMerge<T extends CMInput>(input: T): FormatResult<MergedResult<T>>;
+export { conditionMerge };

package/dist/shared/condition-merge/index.js

@@ -1,30 +1 @@
-import { throwType } from "../throw-error/index.js";
-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;
-}
-export { conditionMerge };
+import{throwType as r}from"../throw-error/index.js";function e(r){return Array.isArray(r)?[]:{}}function t(r){return Array.isArray(r)||"object"==typeof r}function n(...o){let i=(1===o.length&&Array.isArray(o[0])?o[0]:o).map(e=>{let n=null;if(Array.isArray(e)){let[r,t,o]=e;n={condition:r,value:t,fullback:o}}else Object.getOwnPropertyDescriptor(e,"condition")?n=e:r("conditionMerge","input must be an ConditionItem");let o=t(n.value),i=void 0===n.fullback||t(n.fullback);return o&&i||r("conditionMerge","value and fullback must be an array or object"),n}),l=e((i[0]||{}).value),a=Array.isArray(l)?(r,e)=>Reflect.apply(Array.prototype.splice.bind(r,r.length,0),null,e):Object.assign;for(let r=0,t=i[r];r<i.length;t=i[++r])a(l,t.condition?t.value:t.fullback||e(t.value));return l}export{n as conditionMerge};

package/dist/shared/create-storage-handler/index.d.ts

@@ -1,10 +1,11 @@
-export interface CreateStorageOptions {
+interface CreateStorageOptions {
     storageType: 'local' | 'session' | 'memory';
     autoSaveInterval: number;
 }
-export interface StorageHandler<T extends Record<string, any>> {
+interface StorageHandler<T extends Record<string, any>> {
     get: <K extends keyof T | (string & {})>(key?: K) => string extends K ? T : T[K & keyof T];
     set: <K extends keyof T | (string & {})>(value: string extends K ? T : T[K & keyof T], key?: K) => void;
     clear: () => void;
 }
-export declare function createStorageHandler<T extends Record<string, any>>(storageKey: string, initialData?: T, options?: Partial<CreateStorageOptions>): StorageHandler<T>;
+declare function createStorageHandler<T extends Record<string, any>>(storageKey: string, initialData?: T, options?: Partial<CreateStorageOptions>): StorageHandler<T>;
+export { type CreateStorageOptions, createStorageHandler, type StorageHandler };

package/dist/shared/create-storage-handler/index.js

@@ -1,68 +1 @@
-import { $dt, $t, dataHandler } from "../data-handler/index.js";
-import { logger } from "../logger/index.js";
-import { throwError } from "../throw-error/index.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 };
+import{$dt as e,$t as t,dataHandler as a}from"../data-handler/index.js";import{logger as r}from"../logger/index.js";import{throwError as o}from"../throw-error/index.js";import{isNullOrUndef as i}from"../utils/verify.js";let l=e({storageKey:"validString",storageType:t.enum(["local","session","memory"],"local"),autoSaveInterval:t.number(0)}),n={data:{},getItem(e){return this.data[e]},setItem(e,t){this.data[e]=t},removeItem(e){delete this.data[e]}},s=Symbol("cleared");function m(e,t,d={}){let{storageKey:g,storageType:c,autoSaveInterval:u}=a({storageKey:e,...d},l,{unwrap:!0}),S=function(e){try{if("memory"===e)return n;return"local"===e?localStorage:sessionStorage}catch{return r.warn("createStorage","Failed to access localStorage or sessionStorage, using memoryStorage instead."),n}}(c),y=S.getItem(g),f={data:y?JSON.parse(y):t||{},timer:null},h=()=>{null!==f.timer&&(clearTimeout(f.timer),f.timer=null)};return{get:e=>(f.data===s&&o("createStorageHandler","Storage has been cleared."),i(e))?f.data:f.data[e],set(e,t){f.data===s&&o("createStorageHandler","Storage has been cleared."),i(t)?f.data=e:f.data[t]=e,u>0?(h(),f.timer=setTimeout(()=>{S.setItem(g,JSON.stringify(f.data))},u)):S.setItem(g,JSON.stringify(f.data))},clear(){h(),f.data=s,S.removeItem(g)}}}export{m as createStorageHandler};

package/dist/shared/data-handler/index.d.ts

@@ -1,11 +1,12 @@
-import type { Equal, Printify } from '../types';
+import type { Equal, Printify } from '../types/base';
 import type { Transform2Type } from './tools';
 import type { DataHandlerOptions, Handler } from './types';
 type MergeResult<BaseResult extends Record<PropertyKey, any>, HandlerResult extends Handler<any>> = Printify<HandlerResult extends (...args: any[]) => any ? BaseResult : BaseResult & {
     [K in keyof HandlerResult]: Equal<HandlerResult[K], any> extends true ? Required<BaseResult>[K] : HandlerResult[K];
 }>;
-export declare function dataHandler<M extends Record<PropertyKey, any>, H extends Handler<M> = Handler<M>, O extends DataHandlerOptions<M> = DataHandlerOptions<M>>(data: M & Partial<O['defaultValue']>, handler: H, options?: O): O['unwrap'] extends true ? MergeResult<M & O['defaultValue'], Transform2Type<H>> : {
+declare function dataHandler<M extends Record<PropertyKey, any>, H extends Handler<M> = Handler<M>, O extends DataHandlerOptions<M> = DataHandlerOptions<M>>(data: M & Partial<O['defaultValue']>, handler: H, options?: O): O['unwrap'] extends true ? MergeResult<M & O['defaultValue'], Transform2Type<H>> : {
     result: MergeResult<M & O['defaultValue'], Transform2Type<H>>;
     errors: string[];
 };
-export * from './tools';
+export { $dt, $t, defineTransform } from './tools';
+export { dataHandler };

package/dist/shared/data-handler/index.js

@@ -1,77 +1 @@
-import { throwType } from "../throw-error/index.js";
-export * from "./tools.js";
-function createActions() {
-    const ctx = {
-        errors: [],
-        transforms: [],
-        handledErrorKeys: new Set()
-    };
-    const handler = {
-        addError (key, msg = `${String(key)} is not valid`) {
-            if (ctx.handledErrorKeys.has(key)) return;
-            ctx.handledErrorKeys.add(key);
-            ctx.errors.push(msg);
-        },
-        addTransform (key, value) {
-            ctx.transforms.push([
-                key,
-                value
-            ]);
-        }
-    };
-    return [
-        ctx,
-        handler,
-        (key)=>({
-                assert: (flag, msg = `${String(key)} is not valid`)=>{
-                    if (!flag) handler.addError(key, msg);
-                    return flag;
-                },
-                transform: (value)=>{
-                    if (!ctx.handledErrorKeys.has(key)) handler.addTransform(key, value);
-                    return value;
-                }
-            })
-    ];
-}
-function transformApply(data, transforms) {
-    if (!transforms.length) return;
-    for(let i = 0, [key, value] = transforms[i]; i < transforms.length; [key, value] = transforms[++i] || [])data[key] = value;
-}
-function handleProcess(data, keys, handleFn, getActions, actionHandlers) {
-    for(let i = 0, key = keys[i]; i < keys.length; key = keys[++i]){
-        const flag = handleFn(data[key], key, getActions(key), data);
-        if (false === flag) actionHandlers.addError(key);
-    }
-}
-function errorProcess(errors, errorHandler, strict) {
-    if (!errors.length) return;
-    if (errorHandler) errorHandler(errors);
-    else if (strict) throwType('dataHandler', errors.join('\n'));
-}
-function filterData(data, ctx, defaultValue = {}) {
-    ctx.handledErrorKeys.forEach((key)=>{
-        data[key] = defaultValue[key];
-    });
-}
-function dataHandler(data, handler, options) {
-    if (!handler) throwType('dataHandler', 'handler is required');
-    const { strict = false, errorHandler, defaultValue, unwrap = false } = options || {};
-    const handlerIsFunction = 'function' == typeof handler;
-    const handleFn = handlerIsFunction ? handler : (value, key, ...args)=>handler[key](value, ...args);
-    const tempData = {
-        ...defaultValue,
-        ...data
-    };
-    const keys = handlerIsFunction ? Reflect.ownKeys(data) : Reflect.ownKeys(handler);
-    const [ctx, actionHandler, getActions] = createActions();
-    handleProcess(tempData, keys, handleFn, getActions, actionHandler);
-    errorProcess(ctx.errors, errorHandler, strict);
-    transformApply(tempData, ctx.transforms);
-    filterData(tempData, ctx, defaultValue);
-    return unwrap ? tempData : {
-        result: tempData,
-        errors: ctx.errors
-    };
-}
-export { dataHandler };
+import{throwType as r}from"../throw-error/index.js";import{isEmptyArray as e}from"../utils/verify.js";function o(o,s,n){let t,a;s||r("dataHandler","handler is required");let{strict:d=!1,errorHandler:f,defaultValue:l,unwrap:i=!1}=n||{},h="function"==typeof s,m=h?s:(r,e,...o)=>s[e](r,...o),u={...l,...o},y=h?Reflect.ownKeys(o):Reflect.ownKeys(s),[E,p,K]=(t={errors:[],transforms:[],handledErrorKeys:new Set},a={addError(r,e=`${String(r)} is not valid`){t.handledErrorKeys.has(r)||(t.handledErrorKeys.add(r),t.errors.push(e))},addTransform(r,e){t.transforms.push([r,e])}},[t,a,r=>({assert:(e,o=`${String(r)} is not valid`)=>(e||a.addError(r,o),e),transform:e=>(t.handledErrorKeys.has(r)||a.addTransform(r,e),e)})]);for(let r=0,e=y[r];r<y.length;e=y[++r])!1===m(u[e],e,K(e),u)&&p.addError(e);c=E.errors,!e(c)&&(f?f(c):d&&r("dataHandler",c.join("\n")));var c,g=E.transforms;if(!e(g))for(let r=0,[e,o]=g[r];r<g.length;[e,o]=g[++r]||[])u[e]=o;return!function(r,e,o={}){e.handledErrorKeys.forEach(e=>{r[e]=o[e]})}(u,E,l),i?u:{result:u,errors:E.errors}}export{$dt,$t,defineTransform}from"./tools.js";export{o as dataHandler};

package/dist/shared/data-handler/tools.d.ts

@@ -1,21 +1,5 @@
-import type { Handler } from './types';
-type TypeHandler = NonNullable<Exclude<Handler<any>, (...args: any[]) => any>[string]>;
-type TypeHandlerParams = Parameters<TypeHandler> extends [any, ...infer Rest] ? Rest : never;
-type ParseType<T extends string> = T extends keyof TypeMap ? TypeMap[T] : any;
-type TypeHandlerInfo<T extends string> = (value: ParseType<T>, ...args: TypeHandlerParams) => ReturnType<TypeHandler>;
-interface TypeMap {
-    notNullable: any & {};
-    string: string;
-    validString: string;
-    number: number;
-    validNumber: number;
-    boolean: boolean;
-    object: Record<PropertyKey, any>;
-    array: any[];
-    function: (...args: any[]) => any;
-    symbol: symbol;
-    enum: any & {};
-}
+import type { Fullback, ParseType, TypeHandler, TypeHandlerInfo } from './types';
+export declare function typeHandler<T extends string>(type: T, verifyFn?: (_v: any) => boolean): (fullback?: Fullback<T>) => TypeHandlerInfo<T>;
 export declare const $t: {
     notNullable: (fullback?: any) => TypeHandlerInfo<"notNullable">;
     string: (fullback?: string | ((_v: any) => string) | undefined) => TypeHandlerInfo<"string">;
@@ -29,14 +13,13 @@ export declare const $t: {
     symbol: (fullback?: symbol | ((_v: any) => symbol) | undefined) => TypeHandlerInfo<"symbol">;
     enum: <T>(list: T[], fullback?: T) => TypeHandlerInfo<"enum">;
 };
-type TransformMap = typeof $t;
-type TransformKey = Exclude<keyof TransformMap, 'enum'>;
-type DataTransformResult<D extends Record<PropertyKey, TransformKey | TypeHandler | undefined>> = {
+export type TransformMap = typeof $t;
+export type TransformKey = Exclude<keyof TransformMap, 'enum'>;
+export type DataTransformResult<D extends Record<PropertyKey, TransformKey | TypeHandler | undefined>> = {
     [K in keyof D]: D[K] extends TransformKey ? TransformMap[D[K]] : D[K];
 };
 export type Transform2Type<R extends DataTransformResult<any>> = {
     [K in keyof R]: R[K] extends TypeHandlerInfo<infer T> ? ParseType<T> & {} : any & {};
 };
 export declare function defineTransform<T extends Record<PropertyKey, any>, D extends Partial<Record<keyof T, TransformKey | TypeHandler>> = Partial<Record<keyof T, TransformKey | TypeHandler>>>(dataInfo: D): DataTransformResult<D>;
-export declare const $dt: typeof defineTransform;
-export {};
+export { defineTransform as $dt };

package/dist/shared/data-handler/tools.js

@@ -1,48 +1 @@
-import { logger } from "../logger/index.js";
-import { throwType } from "../throw-error/index.js";
-import { getType } from "../utils/base.js";
-function typeHandler(type, verifyFn) {
-    return (fullback)=>(_v, actions)=>{
-            if (verifyFn ? verifyFn(_v) : getType(_v) === type) return true;
-            if (null == fullback) return false;
-            let fullbackValue = fullback;
-            if ('function' == typeof fullback) fullbackValue = fullback(_v);
-            actions.transform(fullbackValue);
-        };
-}
-const $t = {
-    notNullable: typeHandler('notNullable', (_v)=>null != _v),
-    string: typeHandler('string'),
-    validString: typeHandler('validString', (_v)=>'string' == typeof _v && _v.length > 0),
-    number: typeHandler('number'),
-    validNumber: typeHandler('validNumber', (_v)=>'number' == typeof _v && !Number.isNaN(_v)),
-    boolean: typeHandler('boolean'),
-    object: typeHandler('object'),
-    array: typeHandler('array'),
-    function: typeHandler('function'),
-    symbol: typeHandler('symbol'),
-    enum: (list, fullback)=>{
-        if (!Array.isArray(list)) throwType('$t.enum', 'list must be an array');
-        const set = new Set(list);
-        return typeHandler('enum', (_v)=>set.has(_v))(fullback);
-    }
-};
-function defineTransform(dataInfo) {
-    const verifyInfo = {};
-    const keys = Reflect.ownKeys(dataInfo);
-    for(let i = 0, key = keys[i], item = dataInfo[key]; i < keys.length; key = keys[++i], item = dataInfo[key]){
-        if ('function' == typeof item) {
-            verifyInfo[key] = item;
-            continue;
-        }
-        const handler = $t[item];
-        if (!handler) {
-            logger.warn('defineTransform', `${item} is not a valid type`);
-            continue;
-        }
-        verifyInfo[key] = handler();
-    }
-    return verifyInfo;
-}
-const $dt = defineTransform;
-export { $dt, $t, defineTransform };
+import{logger as r}from"../logger/index.js";import{throwType as e}from"../throw-error/index.js";import{getType as n}from"../utils/base.js";import{isNullOrUndef as t}from"../utils/verify.js";function o(r,e){return o=>(i,a)=>{if(e?e(i):n(i)===r)return!0;if(t(o))return!1;let l=o;"function"==typeof o&&(l=o(i)),a.transform(l)}}let i={notNullable:o("notNullable",r=>!t(r)),string:o("string"),validString:o("validString",r=>"string"==typeof r&&r.length>0),number:o("number"),validNumber:o("validNumber",r=>"number"==typeof r&&!Number.isNaN(r)),boolean:o("boolean"),object:o("object"),array:o("array"),function:o("function"),symbol:o("symbol"),enum:(r,n)=>{Array.isArray(r)||e("$t.enum","list must be an array");let t=new Set(r);return o("enum",r=>t.has(r))(n)}};function a(e){let n={},t=Reflect.ownKeys(e);for(let o=0,a=t[o],l=e[a];o<t.length;l=e[a=t[++o]]){if("function"==typeof l){n[a]=l;continue}let e=i[l];if(!e){r.warn("defineTransform",`${l} is not a valid type`);continue}n[a]=e()}return n}export{i as $t,a as $dt,a as defineTransform,o as typeHandler};

package/dist/shared/data-handler/types.d.ts

@@ -16,8 +16,8 @@ export interface ActionContext {
     handledErrorKeys: Set<PropertyKey>;
 }
 export interface ActionHandlers {
-    addError(key: PropertyKey, msg?: string): void;
-    addTransform(key: PropertyKey, value: any): void;
+    addError: (key: PropertyKey, msg?: string) => void;
+    addTransform: (key: PropertyKey, value: any) => void;
 }
 export interface DataHandlerOptions<M extends Record<PropertyKey, any>> {
     strict?: boolean;
@@ -25,3 +25,21 @@ export interface DataHandlerOptions<M extends Record<PropertyKey, any>> {
     defaultValue?: M;
     unwrap?: boolean;
 }
+export interface TypeMap {
+    notNullable: any & {};
+    string: string;
+    validString: string;
+    number: number;
+    validNumber: number;
+    boolean: boolean;
+    object: Record<PropertyKey, any>;
+    array: any[];
+    function: (...args: any[]) => any;
+    symbol: symbol;
+    enum: any & {};
+}
+export type TypeHandler = NonNullable<Exclude<Handler<any>, (...args: any[]) => any>[string]>;
+export type TypeHandlerParams = Parameters<TypeHandler> extends [any, ...infer Rest] ? Rest : never;
+export type ParseType<T extends string> = T extends keyof TypeMap ? TypeMap[T] : any;
+export type TypeHandlerInfo<T extends string> = (value: ParseType<T>, ...args: TypeHandlerParams) => ReturnType<TypeHandler>;
+export type Fullback<T extends string> = T extends 'function' ? (_v: any) => ParseType<T> : ((_v: any) => ParseType<T>) | (ParseType<T> & {});

package/dist/shared/data-mixed-manager/constants.js

@@ -1,9 +1 @@
-const SLOT_TYPE = {
-    fixed: {
-        fixedFlag: Symbol('fixed')
-    },
-    insert: {
-        insertFlag: Symbol('insert')
-    }
-};
-export { SLOT_TYPE };
+let e={fixed:{fixedFlag:Symbol("fixed")},insert:{insertFlag:Symbol("insert")}};export{e as SLOT_TYPE};