@cmtlyt/lingshu-toolkit 0.3.0 → 0.5.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,7 +1,12 @@
+export * from './allx';
 export * from './animation';
+export * from './api-controller';
 export * from './condition-merge';
 export * from './create-storage-handler';
 export * from './data-handler';
+export * from './data-mixed-manager';
 export * from './throw-error';
+export * from './try-call';
 export * from './types';
+export * from './utils';
 export * from './with-resolvers';