@cmtlyt/lingshu-toolkit 0.2.0 → 0.4.0

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

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

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

@@ -0,0 +1,90 @@
+import type { SLOT_TYPE } from './constants';
+export type SlotType = (typeof SLOT_TYPE)[keyof typeof SLOT_TYPE];
+export interface InputSlotConfig<T> {
+    /** 坑位位置（从1开始） */
+    position: number;
+    /** 定坑数据 */
+    data: T;
+    /** 插入模式：cover-覆盖，before-在指定位置前插入，after-在指定位置后插入 */
+    insertMode?: 'cover' | 'before' | 'after';
+}
+/**
+ * 定坑配置接口
+ */
+export interface SlotConfig<T> {
+    /** 坑位位置（从1开始） */
+    position: number;
+    /** 定坑数据 */
+    data: T;
+    /** 定坑类型 */
+    type: 'fixed' | 'insert';
+    /** 插入模式：cover-覆盖，before-在指定位置前插入，after-在指定位置后插入 */
+    insertMode: 'cover' | 'before' | 'after';
+    /** 输入位置（用于记录原始输入的位置） */
+    inputPosition: number;
+}
+export interface BaseDataItem<T> {
+    /** 数据内容 */
+    data: T;
+}
+/**
+ * 普通数据项接口
+ */
+export interface PlainDataItem<T> extends BaseDataItem<T> {
+    /** 是否为定坑数据 */
+    isFixed: false;
+    /** 数据类型 */
+    type: 'plain';
+}
+/**
+ * 定坑数据项接口
+ */
+export interface FixedDataItem<T> extends BaseDataItem<T> {
+    /** 是否为定坑数据 */
+    isFixed: true;
+    /** 定坑类型 */
+    type: SlotConfig<T>['type'];
+}
+/**
+ * 混合数据项类型
+ * 可以是定坑数据项或普通数据项
+ */
+export type MixedDataItem<T> = FixedDataItem<T> | PlainDataItem<T>;
+/**
+ * 构建选项接口
+ */
+export interface BuildOptions {
+    /** 是否延迟构建，为 true 时不立即构建混合数据 */
+    lazy?: boolean;
+    /** 构建模式：rebuild-全量重建，patch-增量更新 */
+    mode?: 'rebuild' | 'patch';
+}
+interface DiffEventDetailMap<T> {
+    change: {
+        mode: NonNullable<BuildOptions['mode']> | 'clear';
+        mixedData: MixedDataItem<T>[];
+    };
+    clear: Record<PropertyKey, never>;
+}
+export interface BaseEventDetail {
+    name: string;
+}
+export type EventDetailMap<T> = {
+    [K in keyof DiffEventDetailMap<T>]: BaseEventDetail & DiffEventDetailMap<T>[K];
+};
+export type DMMEventHandler<T, K extends keyof EventDetailMap<T>> = ((event: CustomEvent<EventDetailMap<T>[K]>) => void) | {
+    handleEvent: (event: CustomEvent<EventDetailMap<T>[K]>) => void;
+};
+export interface DataMixedManagerOptions<T> {
+    /** 实例名称 */
+    name?: string;
+    /** 定坑配置数组 */
+    fixedSlots?: InputSlotConfig<T>[];
+    /** 普通数据列表 */
+    dataList?: T[];
+    /** 事件监听 */
+    listener?: {
+        [K in keyof EventDetailMap<T>]?: DMMEventHandler<T, K>;
+    };
+}
+export {};

package/dist/shared/index.d.ts

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

package/dist/shared/index.js

@@ -1 +1,2 @@
-export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../707.js";
+export { $dt, $t, createError, dataHandler, defineTransform, getType, identity, noop, throwError, throwType } from "../707.js";
+export { allx, animation, conditionMerge, createStorageHandler, dataMixedManager, isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, isNaN, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef, stepAnimation, withResolvers } from "../607.js";

package/dist/shared/throw-error/index.d.ts

@@ -1,2 +1,3 @@
+export declare function createError(fnName: string, message: string, ErrorClass?: ErrorConstructor): Error;
 export declare function throwError(fnName: string, message: string, ErrorClass?: ErrorConstructor): never;
 export declare function throwType(fnName: string, message: string): never;

package/dist/shared/throw-error/index.js

@@ -1,7 +1,10 @@
+function createError(fnName, message, ErrorClass = Error) {
+    return new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+}
 function throwError(fnName, message, ErrorClass = Error) {
-    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+    throw createError(fnName, message, ErrorClass);
 }
 function throwType(fnName, message) {
     throwError(fnName, message, TypeError);
 }
-export { throwError, throwType };
+export { createError, throwError, throwType };

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

@@ -3,3 +3,9 @@ export type NonUnion<T> = Equal<[T] extends [never] ? never : T[], T extends any
 export type UnionToIntersection<U> = [U] extends [never] ? never : (U extends any ? (_v: U) => void : never) extends (_v: infer I) => void ? I : never;
 export type IsPrimitive<T> = T extends number | string | boolean | symbol | bigint | null | undefined ? true : false;
 export type IsBasicType<T> = T extends number | string | boolean | symbol | bigint ? true : false;
+export type Printify<T> = T extends any[] ? T : [T] extends [never] ? T : {
+    [K in keyof T]: T[K];
+};
+export type PickRequired<T, K extends keyof T> = Printify<Omit<T, K> & Required<Pick<T, K>>>;
+export type AnyFunc = (...args: any[]) => any;
+export type UnULCase<T extends string> = T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${UnULCase<R>}` : Uppercase<T> | Lowercase<T>;

package/dist/shared/utils/__test__/base.test.d.ts

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

package/dist/shared/utils/__test__/verify.test.d.ts

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

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

@@ -0,0 +1,3 @@
+export declare const noop: () => undefined;
+export declare const identity: <T>(_v: T) => T;
+export declare function getType(_v: any): string;

package/dist/shared/utils/base.js

@@ -0,0 +1,6 @@
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
+function getType(_v) {
+    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+}
+export { getType, identity, noop };

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

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './verify';

package/dist/shared/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./verify.js";

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

@@ -0,0 +1,53 @@
+import type { AnyFunc, UnULCase } from '../types/base';
+/** 判断是一个 symbol */
+export declare function isSymbol(_v: unknown): _v is symbol;
+/** 判断是一个 undefined */
+export declare function isUndef(_v: unknown): _v is undefined;
+/** 判断是一个 null */
+export declare function isNull(_v: unknown): _v is null;
+/** 判断是一个 null 或者 undefined */
+export declare function isNullOrUndef(_v: unknown): _v is null | undefined;
+/** 判断是一个 NaN */
+export declare function isNaN(_v: unknown): _v is number;
+/** 判断是一个 plain symbol */
+export declare function isPlainSymbol(_v: unknown): _v is symbol;
+/** 判断是一个对象 (数组也返回 true) */
+export declare function isObject(_v: unknown): _v is object;
+/** 判断是一个非数组对象 */
+export declare function isPlainObject(_v: unknown): _v is object;
+/** 判断是一个数组 */
+export declare function isArray(_v: unknown): _v is any[];
+/** 判断是否为空数组 */
+export declare function isEmptyArray(_v: unknown): _v is [];
+/** 判断是一个字符串 */
+export declare function isString(_v: unknown): _v is string;
+/** 判断是一个空字符串 */
+export declare function isEmptyString(_v: unknown): _v is '';
+/** 判断是一个数字 */
+export declare function isNumber(_v: unknown): _v is number;
+/** 判断是一个纯数字 (排除 NaN) */
+export declare function isPlainNumber(_v: unknown): _v is number;
+/** 判断是一个合法的对象 key */
+export declare function isPropertyKey(_v: unknown): _v is PropertyKey;
+/** 判断是一个布尔值 */
+export declare function isBoolean(_v: unknown): _v is boolean;
+/** 判断是一个 true 值 */
+export declare function isTrue(_v: unknown): _v is true | UnULCase<'true'>;
+/** 判断是一个 false 值 */
+export declare function isFalse(_v: unknown): _v is false | UnULCase<'false'>;
+/**
+ * 判断是一个真值
+ *
+ * @warn 字符串 'false' 等满足 isFalse 判断的字符串也会被视为真值
+ */
+export declare function isTruthy<T>(_v: T): _v is Exclude<T, false | 0 | '' | null | undefined>;
+/**
+ * 判断是一个非值
+ *
+ * @warn 字符串 'false' 等满足 isFalse 判断的字符串不会被视为非值
+ */
+export declare function isFalsy(_v: unknown): _v is false | 0 | '' | null | undefined;
+/** 判断是一个函数 */
+export declare function isFunction(_v: unknown): _v is AnyFunc;
+/** 判断是一个 Promise */
+export declare function isPromiseLike(_v: unknown): _v is PromiseLike<any>;

package/dist/shared/utils/verify.js

@@ -0,0 +1,67 @@
+function isSymbol(_v) {
+    return 'symbol' == typeof _v;
+}
+function isUndef(_v) {
+    return void 0 === _v;
+}
+function isNull(_v) {
+    return null === _v;
+}
+function isNullOrUndef(_v) {
+    return isNull(_v) || isUndef(_v);
+}
+function verify_isNaN(_v) {
+    return Number.isNaN(_v);
+}
+function isPlainSymbol(_v) {
+    return isSymbol(_v) && isUndef(Symbol.keyFor(_v));
+}
+function isObject(_v) {
+    return 'object' == typeof _v && !isNull(_v);
+}
+function isPlainObject(_v) {
+    return isObject(_v) && !isArray(_v);
+}
+function isArray(_v) {
+    return Array.isArray(_v);
+}
+function isEmptyArray(_v) {
+    return isArray(_v) && 0 === _v.length;
+}
+function isString(_v) {
+    return 'string' == typeof _v;
+}
+function isEmptyString(_v) {
+    return isString(_v) && 0 === _v.length;
+}
+function isNumber(_v) {
+    return 'number' == typeof _v;
+}
+function isPlainNumber(_v) {
+    return isNumber(_v) && !verify_isNaN(_v);
+}
+function isPropertyKey(_v) {
+    return isString(_v) || isNumber(_v) || isSymbol(_v);
+}
+function isBoolean(_v) {
+    return 'boolean' == typeof _v;
+}
+function isTrue(_v) {
+    return true === _v || isString(_v) && 'true' === _v.toLowerCase();
+}
+function isFalse(_v) {
+    return false === _v || isString(_v) && 'false' === _v.toLowerCase();
+}
+function isTruthy(_v) {
+    return !!_v;
+}
+function isFalsy(_v) {
+    return !(verify_isNaN(_v) || _v);
+}
+function isFunction(_v) {
+    return 'function' == typeof _v;
+}
+function isPromiseLike(_v) {
+    return isObject(_v) && isFunction(_v.then);
+}
+export { isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, verify_isNaN as isNaN, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef };

package/dist/shared/with-resolvers/index.d.ts

@@ -0,0 +1,6 @@
+export type Resolver<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare function withResolvers<T>(): Resolver<T>;

package/dist/shared/with-resolvers/index.js

@@ -0,0 +1,15 @@
+function withResolvers() {
+    return 'function' == typeof Promise.withResolvers ? Promise.withResolvers() : (()=>{
+        const resolver = {
+            promise: null,
+            resolve: null,
+            reject: null
+        };
+        resolver.promise = new Promise((resolve, reject)=>{
+            resolver.resolve = resolve;
+            resolver.reject = reject;
+        });
+        return resolver;
+    })();
+}
+export { withResolvers };

package/dist/shared/with-resolvers/index.test.d.ts

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

package/dist/test/utils.d.ts

@@ -0,0 +1,13 @@
+import { Component, type PropsWithChildren } from 'react';
+export declare class ErrorBoundary extends Component<PropsWithChildren<{
+    onError: () => void;
+}>> {
+    state: {
+        hasError: boolean;
+    };
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidCatch(): void;
+    render(): import("react").ReactNode;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmtlyt/lingshu-toolkit",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "main": "./dist/shared.js",
   "module": "./dist/shared.js",
@@ -41,10 +41,11 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.8",
-    "@cmtlyt/unplugin-shadcn-registry-generate": "^0.1.3",
+    "@cmtlyt/unplugin-shadcn-registry-generate": "^0.1.5",
     "@commitlint/cli": "^20.3.1",
     "@commitlint/config-conventional": "^20.3.1",
     "@rslib/core": "^0.19.3",
+    "@rspress/core": "^2.0.8",
     "@types/node": "^24.10.9",
     "@types/react": "^19.2.9",
     "@vitejs/plugin-react": "^5.1.2",
@@ -52,13 +53,14 @@
     "@vitest/browser-playwright": "4.0.18",
     "@vitest/coverage-v8": "4.0.18",
     "@vitest/ui": "4.0.18",
+    "cross-env": "^10.1.0",
     "esno": "^4.8.0",
     "husky": "^9.1.7",
     "jsdom": "^27.4.0",
     "lint-staged": "^16.2.7",
+    "playwright": "^1.58.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "rspress": "^1.47.1",
     "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^6.0.4",
     "vitest": "4.0.18",
@@ -73,7 +75,7 @@
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": ">=18.0.0"
+      "version": ">=22.12.0"
     },
     "packageManager": {
       "name": "pnpm"
@@ -115,9 +117,9 @@
     "dev:registry": "pnpm dlx serve src/public -p 3000",
     "preview:docs": "rspress preview",
     "format": "biome format --write",
-    "test": "vitest --config=vitest.browser.config.ts --coverage.enabled --ui",
-    "test:ci": "vitest run --config=vitest.browser.config.ts",
-    "test:lib:ci": "vitest run",
+    "test": "vitest --config=vitest.project.config.ts --coverage.enabled --ui",
+    "test:ci": "cross-env skip_type_check=true gen_file_disabled=true vitest run --config=vitest.project.config.ts",
+    "test:lib:ci": "cross-env skip_type_check=true gen_file_disabled=true vitest run",
     "test:lib": "vitest --coverage.enabled --ui",
     "script:gen-file": "esno scripts/gen-file.ts"
   }