@cmtlyt/lingshu-toolkit 0.4.0 → 0.6.0

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

@@ -0,0 +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 | 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): 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 apiNamesCheck(_apiMap: APIMap, isDeep?: boolean): string[];

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

@@ -0,0 +1 @@
+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};

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

@@ -1,226 +1 @@
-import { $dt, $t, dataHandler } from "../data-handler/index.js";
-import { throwError } from "../throw-error/index.js";
-import { SLOT_TYPE } from "./constants.js";
-const validInfo = $dt({
-    name: $t.string('default'),
-    fixedSlots: $t.array([]),
-    dataList: $t.array([]),
-    listener: $t.object({})
-});
-class DataMixedManager extends EventTarget {
-    addEventListener(...args) {
-        return super.addEventListener.apply(this, args);
-    }
-    removeEventListener(...args) {
-        return super.removeEventListener.apply(this, args);
-    }
-    options;
-    fixedSlots = new Map();
-    dataList = [];
-    mixedData = [];
-    lastMixedSlotIdx = -1;
-    prevDataLength = 0;
-    isBatching = false;
-    constructor(options){
-        super();
-        const validOptions = dataHandler(options || {}, validInfo, {
-            unwrap: true
-        });
-        const { fixedSlots, dataList, listener } = validOptions;
-        this.options = validOptions;
-        this.addFixedSlots(fixedSlots, {
-            lazy: true
-        });
-        this.appendList(dataList);
-        try {
-            this.initListener(listener);
-        } catch (error) {
-            throwError('dataMixedManager', error.message, error.constructor);
-        }
-    }
-    initListener(listener) {
-        const listenerNames = Object.keys(listener);
-        for(let i = 0, name = listenerNames[i], handler = listener[name]; i < listenerNames.length; name = listenerNames[++i], handler = listener[name])this.addEventListener(name, handler);
-    }
-    getTypeText(_type) {
-        switch(_type){
-            case SLOT_TYPE.fixed:
-                return 'fixed';
-            case SLOT_TYPE.insert:
-                return 'insert';
-        }
-    }
-    buildSlotConfig(config, type) {
-        const typeText = this.getTypeText(config.type || type);
-        return {
-            ...config,
-            type: typeText,
-            inputPosition: config.position,
-            insertMode: config.insertMode || 'cover'
-        };
-    }
-    addFixedSlot(config, buildOptions) {
-        const realConfig = this.reorderFixedSlots(this.buildSlotConfig(config, SLOT_TYPE.fixed));
-        this.fixedSlots.set(realConfig.position, realConfig);
-        this.buildMixedData(buildOptions);
-        return realConfig.position;
-    }
-    reorderFixedSlots(config) {
-        const { position: oldPosition, insertMode } = config;
-        if (null == insertMode || 'cover' === insertMode || !this.fixedSlots.has(oldPosition)) return {
-            ...config,
-            inputPosition: oldPosition
-        };
-        const position = 'after' === insertMode ? oldPosition + 1 : oldPosition;
-        for(let i = position + 1, preItem = this.fixedSlots.get(i - 1), currItem = this.fixedSlots.get(i); preItem; ++i, preItem = currItem, currItem = this.fixedSlots.get(i)){
-            preItem.position = i;
-            this.fixedSlots.set(i, preItem);
-        }
-        return {
-            ...config,
-            position,
-            inputPosition: oldPosition
-        };
-    }
-    addFixedSlots(configs, buildOptions) {
-        if (!configs.length) return [];
-        const positions = this.batchUpdate(()=>configs.map((config)=>this.addFixedSlot(config)));
-        this.buildMixedData(buildOptions);
-        return positions;
-    }
-    deleteFixedSlot(position, buildOptions) {
-        this.fixedSlots.delete(position);
-        this.buildMixedData(buildOptions);
-    }
-    deleteFixedSlots(positions, buildOptions) {
-        if (!positions.length) return;
-        this.batchUpdate(()=>positions.forEach((position)=>void this.deleteFixedSlot(position)));
-        this.buildMixedData(buildOptions);
-    }
-    batchUpdate(callback) {
-        try {
-            this.isBatching = true;
-            const result = callback();
-            return result;
-        } finally{
-            this.isBatching = false;
-        }
-    }
-    clearFixedSlots(buildOptions) {
-        this.fixedSlots.clear();
-        this.buildMixedData(buildOptions);
-    }
-    appendList(list, buildOptions) {
-        if (!list.length) return;
-        this.dataList.push(...list);
-        this.buildMixedData({
-            ...buildOptions,
-            lazy: true === (buildOptions || {}).lazy
-        });
-    }
-    clearList() {
-        this.dataList.length = 0;
-        this.mixedData.length = 0;
-        this.dispatch('change', {
-            mode: 'clear',
-            mixedData: this.getMixedData({
-                mode: 'rebuild'
-            })
-        });
-        this.dispatch('clear');
-    }
-    getMixedData(buildOptions) {
-        this.buildMixedData({
-            ...buildOptions,
-            lazy: false
-        });
-        return this.mixedData.slice();
-    }
-    dispatch(name, data) {
-        const detail = {
-            name: this.options.name,
-            ...data
-        };
-        this.dispatchEvent(new CustomEvent(name, {
-            detail
-        }));
-        if ("u" > typeof window) window.dispatchEvent(new CustomEvent(`[DMM]:${name}`, {
-            detail
-        }));
-    }
-    buildMixedData(buildOptions) {
-        if (this.isBatching) return;
-        const { lazy, mode } = buildOptions || {};
-        if ('rebuild' === mode) {
-            this.prevDataLength = 0;
-            this.lastMixedSlotIdx = -1;
-        }
-        if (false !== lazy || this.dataList.length <= this.prevDataLength) return;
-        let dataStartIdx = this.prevDataLength;
-        const dataEndIdx = this.dataList.length;
-        const newItemCount = dataEndIdx - dataStartIdx;
-        this.prevDataLength = dataEndIdx;
-        const isPatchMode = dataStartIdx > 0;
-        const filteredSlots = this.sliceSlots(isPatchMode ? this.mixedData.length : this.lastMixedSlotIdx, this.mixedData.length + newItemCount);
-        this.lastMixedSlotIdx = filteredSlots.at(-1) ?? this.lastMixedSlotIdx;
-        let mixedStartIdx = isPatchMode ? this.mixedData.length : 0;
-        this.mixedData.length = (isPatchMode ? newItemCount + mixedStartIdx : dataEndIdx) + filteredSlots.length;
-        for(let fpIdx = 0, fpItem = filteredSlots[fpIdx]; dataStartIdx < dataEndIdx; ++mixedStartIdx)if (mixedStartIdx === fpItem) {
-            const fixedSlot = this.fixedSlots.get(fpItem);
-            this.mixedData[mixedStartIdx] = {
-                isFixed: true,
-                type: fixedSlot.type,
-                data: fixedSlot.data
-            };
-            fpItem = filteredSlots[++fpIdx];
-        } else {
-            this.mixedData[mixedStartIdx] = {
-                isFixed: false,
-                type: 'plain',
-                data: this.dataList[dataStartIdx]
-            };
-            ++dataStartIdx;
-        }
-        this.dispatch('change', {
-            mode: isPatchMode ? 'patch' : 'rebuild',
-            mixedData: this.mixedData.slice()
-        });
-    }
-    sliceSlots(startIdx, endIdx = 1 / 0) {
-        let prevItem = -2;
-        let count = 0;
-        return Array.from(this.fixedSlots.keys()).sort((ai, bi)=>ai - bi).filter((item)=>{
-            if (item >= startIdx && item < endIdx + count || item - 1 === prevItem) {
-                ++count;
-                prevItem = item;
-                return true;
-            }
-            return false;
-        });
-    }
-    insertSlot(config) {
-        const realPosition = this.addFixedSlot({
-            ...config,
-            type: SLOT_TYPE.insert
-        });
-        if (realPosition > this.mixedData.length) return realPosition;
-        this.buildMixedData({
-            lazy: false,
-            mode: 'rebuild'
-        });
-        return realPosition;
-    }
-    insertSlots(configs) {
-        if (!configs.length) return [];
-        const positions = this.batchUpdate(()=>configs.map((config)=>this.insertSlot(config)));
-        this.buildMixedData({
-            lazy: false,
-            mode: 'rebuild'
-        });
-        return positions;
-    }
-}
-function dataMixedManager(options) {
-    return new DataMixedManager(options);
-}
-export { dataMixedManager };
+import{$dt as t,$t as e,dataHandler as i}from"../data-handler/index.js";import{throwError as s}from"../throw-error/index.js";import{isEmptyArray as a,isNullOrUndef as d}from"../utils/verify.js";import{SLOT_TYPE as l}from"./constants.js";let r=t({name:e.string("default"),fixedSlots:e.array([]),dataList:e.array([]),listener:e.object({})});class h extends EventTarget{addEventListener(...t){super.addEventListener.apply(this,t)}removeEventListener(...t){super.removeEventListener.apply(this,t)}options;fixedSlots=new Map;dataList=[];mixedData=[];lastMixedSlotIdx=-1;prevDataLength=0;isBatching=!1;constructor(t){super();let e=i(t||{},r,{unwrap:!0}),{fixedSlots:a,dataList:d,listener:l}=e;this.options=e,this.addFixedSlots(a,{lazy:!0}),this.appendList(d);try{this.initListener(l)}catch(t){s("dataMixedManager",t.message,t.constructor)}}initListener(t){let e=Object.keys(t);for(let i=0,s=e[i],a=t[s];i<e.length;a=t[s=e[++i]])this.addEventListener(s,a)}getTypeText(t){switch(t){case l.fixed:return"fixed";case l.insert:return"insert"}}buildSlotConfig(t,e){let i=this.getTypeText(t.type||e);return{...t,type:i,inputPosition:t.position,insertMode:t.insertMode??"cover"}}addFixedSlot(t,e){let i=this.reorderFixedSlots(this.buildSlotConfig(t,l.fixed));return this.fixedSlots.set(i.position,i),this.buildMixedData(e),i.position}reorderFixedSlots(t){let{position:e,insertMode:i}=t;if(d(i)||"cover"===i||!this.fixedSlots.has(e))return{...t,inputPosition:e};let s="after"===i?e+1:e;for(let t=s+1,e=this.fixedSlots.get(t-1),i=this.fixedSlots.get(t);e;++t,e=i,i=this.fixedSlots.get(t))e.position=t,this.fixedSlots.set(t,e);return{...t,position:s,inputPosition:e}}addFixedSlots(t,e){if(a(t))return[];let i=this.batchUpdate(()=>t.map(t=>this.addFixedSlot(t)));return this.buildMixedData(e),i}deleteFixedSlot(t,e){this.fixedSlots.delete(t),this.buildMixedData(e)}deleteFixedSlots(t,e){a(t)||(this.batchUpdate(()=>t.forEach(t=>void this.deleteFixedSlot(t))),this.buildMixedData(e))}batchUpdate(t){try{return this.isBatching=!0,t()}finally{this.isBatching=!1}}clearFixedSlots(t){this.fixedSlots.clear(),this.buildMixedData(t)}appendList(t,e){a(t)||(this.dataList.push(...t),this.buildMixedData({...e,lazy:!0===(e||{}).lazy}))}clearList(){this.dataList.length=0,this.mixedData.length=0,this.dispatch("change",{mode:"clear",mixedData:this.getMixedData({mode:"rebuild"})}),this.dispatch("clear")}getMixedData(t){return this.buildMixedData({...t,lazy:!1}),this.mixedData.slice()}dispatch(t,e){let i={name:this.options.name,...e};this.dispatchEvent(new CustomEvent(t,{detail:i})),void 0!==globalThis.window&&globalThis.window.dispatchEvent(new CustomEvent(`[DMM]:${t}`,{detail:i}))}buildMixedData(t){if(this.isBatching)return;let{lazy:e,mode:i}=t||{};if("rebuild"===i&&(this.prevDataLength=0,this.lastMixedSlotIdx=-1),!1!==e||this.dataList.length<=this.prevDataLength)return;let s=this.prevDataLength,a=this.dataList.length,d=a-s;this.prevDataLength=a;let l=s>0,r=this.sliceSlots(l?this.mixedData.length:this.lastMixedSlotIdx,this.mixedData.length+d);this.lastMixedSlotIdx=r.at(-1)??this.lastMixedSlotIdx;let h=l?this.mixedData.length:0;this.mixedData.length=(l?d+h:a)+r.length;for(let t=0,e=r[t];s<a;++h)if(h===e){let i=this.fixedSlots.get(e);this.mixedData[h]={isFixed:!0,type:i.type,data:i.data},e=r[++t]}else this.mixedData[h]={isFixed:!1,type:"plain",data:this.dataList[s]},++s;this.dispatch("change",{mode:l?"patch":"rebuild",mixedData:this.mixedData.slice()})}sliceSlots(t,e=1/0){let i=-2,s=0;return Array.from(this.fixedSlots.keys()).sort((t,e)=>t-e).filter(a=>(a>=t&&a<e+s||a-1===i)&&(++s,i=a,!0))}insertSlot(t){let e=this.addFixedSlot({...t,type:l.insert});return e>this.mixedData.length||this.buildMixedData({lazy:!1,mode:"rebuild"}),e}insertSlots(t){if(a(t))return[];let e=this.batchUpdate(()=>t.map(t=>this.insertSlot(t)));return this.buildMixedData({lazy:!1,mode:"rebuild"}),e}}function n(t){return new h(t)}export{n as dataMixedManager};

package/dist/shared/data-mixed-manager/types.d.ts

@@ -59,7 +59,7 @@ export interface BuildOptions {
     /** 构建模式：rebuild-全量重建，patch-增量更新 */
     mode?: 'rebuild' | 'patch';
 }
-interface DiffEventDetailMap<T> {
+export interface DiffEventDetailMap<T> {
     change: {
         mode: NonNullable<BuildOptions['mode']> | 'clear';
         mixedData: MixedDataItem<T>[];
@@ -87,4 +87,3 @@ export interface DataMixedManagerOptions<T> {
         [K in keyof EventDetailMap<T>]?: DMMEventHandler<T, K>;
     };
 }
-export {};