@cmtlyt/lingshu-toolkit 0.3.0 → 0.4.0

package/dist/shared/allx/utils.js

@@ -0,0 +1,94 @@
+import { createError } from "../throw-error/index.js";
+import { withResolvers } from "../with-resolvers/index.js";
+function detectCycle(from, to, waitingForGraph) {
+    const visited = new Set();
+    const queue = [
+        to
+    ];
+    let head = 0;
+    while(head < queue.length){
+        const node = queue[head++];
+        if (node === from) return true;
+        if (visited.has(node)) continue;
+        visited.add(node);
+        const deps = waitingForGraph.get(node);
+        if (deps) {
+            const depsIter = deps.values();
+            for(let dep = depsIter.next(); !dep.done; dep = depsIter.next())queue.push(dep.value);
+        }
+    }
+    return false;
+}
+function getCached(results, depName, allSettled) {
+    if (Reflect.getOwnPropertyDescriptor(results, depName)) {
+        const cached = results[depName];
+        if (allSettled) return 'rejected' === cached.status ? Promise.reject(cached.reason) : Promise.resolve(cached.value);
+        return Promise.resolve(cached);
+    }
+}
+function createDepResolver(waitingFor, resolverMap, currentTask, depName) {
+    waitingFor.set(currentTask, (waitingFor.get(currentTask) || new Set()).add(depName));
+    const depResolvers = resolverMap.get(depName) || withResolvers();
+    resolverMap.set(depName, depResolvers);
+    return depResolvers.promise.then((value)=>{
+        waitingFor.get(currentTask)?.delete(depName);
+        return value;
+    }, (error)=>{
+        waitingFor.get(currentTask)?.delete(depName);
+        throw error;
+    });
+}
+function cleanWaitingForGraph(waitingForGraph, depName) {
+    waitingForGraph.forEach((deps, task)=>{
+        deps.delete(depName);
+        if (0 === deps.size) waitingForGraph.delete(task);
+    });
+}
+function createDepProxy(tasks, results, options) {
+    const resolverMap = new Map();
+    const taskNameSet = new Set(Reflect.ownKeys(tasks));
+    const waitingForGraph = new Map();
+    const resolveDepFor = (depName, value)=>{
+        const resolver = resolverMap.get(depName);
+        if (resolver) {
+            resolver.resolve(value);
+            resolverMap.delete(depName);
+        }
+        cleanWaitingForGraph(waitingForGraph, depName);
+    };
+    const rejectDepFor = (depName, error)=>{
+        const resolver = resolverMap.get(depName);
+        if (resolver) {
+            resolver.reject(error);
+            resolverMap.delete(depName);
+        }
+        cleanWaitingForGraph(waitingForGraph, depName);
+    };
+    const createContextFor = (currentTask)=>new Proxy({}, {
+            get (_, depName) {
+                if (!taskNameSet.has(depName)) return Promise.reject(createError('allx', `Unknown task "${String(depName)}"`));
+                const cached = getCached(results, depName, options.allSettled);
+                if (cached) return cached;
+                if (detectCycle(currentTask, depName, waitingForGraph)) return Promise.reject(createError('allx', `Circular dependency detected: "${String(currentTask)}" -> "${String(depName)}"`));
+                return createDepResolver(waitingForGraph, resolverMap, currentTask, depName);
+            }
+        });
+    return {
+        taskNameSet,
+        createContextFor,
+        resolveDepFor,
+        rejectDepFor
+    };
+}
+function getValueFormatFunc(options) {
+    if (!options) return (value, _type = 'fulfilled')=>value;
+    if (options.allSettled) return (value, status = 'fulfilled')=>'fulfilled' === status ? {
+            status,
+            value
+        } : {
+            status,
+            reason: value
+        };
+    return (value, _type = 'fulfilled')=>value;
+}
+export { createDepProxy, getValueFormatFunc };

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

@@ -1,3 +1,3 @@
 import type { AnimationBaseOptions, AnimationOptions, AnimationResult } from './types';
-export declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions): Generator<T, void, unknown>;
-export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions): AnimationResult;
+export declare function stepAnimation<T>(from: T, to: T, step: number, options?: AnimationBaseOptions<T>): Generator<any, void, unknown>;
+export declare function animation<T>(from: T, to: T, duration: number, options?: AnimationOptions<T>): AnimationResult;

package/dist/shared/animation/index.js

@@ -1,16 +1,7 @@
 import { $dt, $t, dataHandler } from "../data-handler/index.js";
 import { throwError } from "../throw-error/index.js";
-import { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop } from "./utils.js";
-function* stepAnimation(from, to, step, options = {}) {
-    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
-    const { parser: valueParser = identity, formatter: valueFormatter = identity } = options;
-    const [validFrom, validTo] = matchValid(from, to, valueParser);
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
-    for(let i = 0; i <= step; i++){
-        const value = getNextValue(i / step);
-        yield value;
-    }
-}
+import { identity, noop } from "../utils/base.js";
+import { createNextTick, createRunningControllerSignal, getNextValueHandler, matchValid } from "./utils.js";
 const validInfo = $dt({
     autoStart: $t.boolean(true),
     easing: $t["function"](()=>identity),
@@ -19,17 +10,32 @@ const validInfo = $dt({
     onClear: $t["function"](()=>noop),
     onUpdate: $t["function"](()=>noop),
     onComplete: $t["function"](()=>noop),
+    formatterValue: $t["function"](()=>identity),
     formatter: $t["function"](()=>identity),
     parser: $t["function"](()=>identity)
 });
+function* stepAnimation(from, to, step, options = {}) {
+    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
+    const validOptions = dataHandler(options, validInfo, {
+        unwrap: true
+    });
+    const { parser: valueParser = identity, formatterValue = identity, formatter } = validOptions;
+    const [validFrom, validTo] = matchValid(from, to, valueParser);
+    const getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
+    for(let i = 0; i <= step; i++){
+        const value = formatter(getNextValue(i / step));
+        yield value;
+    }
+}
 function animation(from, to, duration, options = {}) {
     if (duration <= 0 || !Number.isInteger(duration)) throwError('animation', 'duration must be a positive integer', RangeError);
     const validOptions = dataHandler(options, validInfo, {
         unwrap: true
     });
     const [validFrom, validTo] = matchValid(from, to, validOptions.parser);
-    const { autoStart, easing, onComplete, onUpdate, formatter: valueFormatter } = validOptions;
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
+    const { autoStart, easing, onComplete, onUpdate, formatterValue, formatter } = validOptions;
+    const _getNextValue = getNextValueHandler(validFrom, validTo, formatterValue);
+    const getNextValue = (...args)=>formatter(_getNextValue(...args));
     let startTime = 0;
     let hasStarted = false;
     const rcSignal = createRunningControllerSignal(()=>{

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

@@ -1,9 +1,11 @@
-export type Formatter = (value: number) => any;
-export interface AnimationBaseOptions {
+export type FormatterValue = (value: number) => any;
+export type Formatter<T> = (value: T) => any;
+export interface AnimationBaseOptions<T> {
     parser?: (value: any) => number;
-    formatter?: Formatter;
+    formatterValue?: FormatterValue;
+    formatter?: Formatter<T>;
 }
-export interface AnimationOptions extends AnimationBaseOptions {
+export interface AnimationOptions<T> extends AnimationBaseOptions<T> {
     autoStart?: boolean;
     easing?: (time: number) => number;
     onStart?: () => void;

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

@@ -1,12 +1,10 @@
 import { type Resolver } from '../with-resolvers';
-import type { AnimationOptions, Formatter } from './types';
-export declare const noop: () => undefined;
-export declare const identity: <T>(_v: T) => T;
-export declare function getNextValueHandler(from: any, to: any, valueFormatter: Formatter): (progress: number) => any;
+import type { AnimationOptions, FormatterValue } from './types';
+export declare function getNextValueHandler<T>(from: T, to: T, valueFormatter: FormatterValue): (progress: number) => any;
 export declare function matchValid(from: any, to: any, valueParser: (value: any) => number): number[] | unknown[][] | [Record<PropertyKey, any>, Record<PropertyKey, any>];
 export declare function createNextTick(resolvers: Resolver<any>, rcSignal: RCSignal): (callback: (...args: any[]) => void) => boolean;
 export declare function tryRun(callback: () => any, resolvers: Resolver<any>, customErrorHandler?: (err: any) => void): Promise<void>;
-export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions>): {
+export declare function createRunningControllerSignal(startFn: () => void, options: Required<AnimationOptions<any>>): {
     stopSignal: boolean;
     resolvers: Resolver<boolean>;
     stop: () => void;

package/dist/shared/animation/utils.js

@@ -1,10 +1,6 @@
 import { throwType } from "../throw-error/index.js";
+import { getType } from "../utils/base.js";
 import { withResolvers } from "../with-resolvers/index.js";
-const noop = ()=>void 0;
-const identity = (_v)=>_v;
-function getType(_v) {
-    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
-}
 function getNextValueHandler(from, to, valueFormatter) {
     const type = getType(from);
     const context = {
@@ -135,4 +131,4 @@ function createRunningControllerSignal(startFn, options) {
     };
     return ctrl;
 }
-export { createNextTick, createRunningControllerSignal, getNextValueHandler, identity, matchValid, noop, tryRun };
+export { createNextTick, createRunningControllerSignal, getNextValueHandler, matchValid, tryRun };

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

@@ -1,8 +1,6 @@
 import { logger } from "../logger/index.js";
 import { throwType } from "../throw-error/index.js";
-function getType(_v) {
-    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
-}
+import { getType } from "../utils/base.js";
 function typeHandler(type, verifyFn) {
     return (fullback)=>(_v, actions)=>{
             if (verifyFn ? verifyFn(_v) : getType(_v) === type) return true;

package/dist/shared/data-mixed-manager/__test__/basic.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/build-options.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/constructor-options.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/data-management.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/edge-cases.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/events.browser.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/events.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/fixed-slots.test.d.ts

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

package/dist/shared/data-mixed-manager/__test__/insert-mode.test.d.ts

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

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

@@ -0,0 +1,8 @@
+export declare const SLOT_TYPE: {
+    readonly fixed: {
+        readonly fixedFlag: symbol;
+    };
+    readonly insert: {
+        readonly insertFlag: symbol;
+    };
+};

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

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

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

@@ -0,0 +1,128 @@
+import type { PickRequired } from '../types/base';
+import type { BuildOptions, DataMixedManagerOptions, DMMEventHandler, EventDetailMap, InputSlotConfig, MixedDataItem } from './types';
+/**
+ * 通用数据管理器类
+ * 支持定坑逻辑处理，不包含具体业务逻辑
+ *
+ * @template T - 数据类型
+ */
+declare class DataMixedManager<T> extends EventTarget {
+    addEventListener<E extends keyof EventDetailMap<T>>(type: E, listener: DMMEventHandler<T, E> | null, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<E extends keyof EventDetailMap<T>>(type: E, listener: DMMEventHandler<T, E> | null, options?: EventListenerOptions | boolean): void;
+    /** 实例配置 */
+    private readonly options;
+    /** 位置到定坑配置的映射 */
+    private readonly fixedSlots;
+    /** 普通数据列表 */
+    private readonly dataList;
+    /** 混合后的数据 */
+    private readonly mixedData;
+    /** 最后混合的定坑位置 */
+    private lastMixedSlotIdx;
+    /** 上次处理的数据长度 */
+    private prevDataLength;
+    /** 是否正在批量更新 */
+    private isBatching;
+    constructor(options?: DataMixedManagerOptions<T>);
+    /**
+     * 初始化事件监听
+     * @param listener - 事件监听
+     */
+    private initListener;
+    private getTypeText;
+    private buildSlotConfig;
+    /**
+     * 添加定坑配置
+     * @param config - 定坑配置
+     * @param buildOptions - 构建选项
+     * @returns 返回添加后的定坑位置
+     */
+    addFixedSlot(config: InputSlotConfig<T>, buildOptions?: BuildOptions): number;
+    /**
+     * 重新排序定坑位置
+     * 当插入模式为 before 或 after 时，需要调整后续定坑的位置
+     * @param config - 定坑配置
+     * @returns 返回调整后的定坑配置
+     */
+    private reorderFixedSlots;
+    /**
+     * 批量添加定坑配置
+     * @param configs - 定坑配置数组
+     * @param buildOptions - 构建选项
+     * @returns 返回添加后的定坑位置数组
+     */
+    addFixedSlots(configs: InputSlotConfig<T>[], buildOptions?: BuildOptions): number[];
+    /**
+     * 移除指定位置的定坑配置
+     * @param position - 要移除的定坑位置
+     * @param buildOptions - 构建选项
+     */
+    deleteFixedSlot(position: number, buildOptions?: BuildOptions): void;
+    /**
+     * 批量移除定坑配置
+     * @param positions - 要移除的定坑位置数组
+     * @param buildOptions - 构建选项
+     */
+    deleteFixedSlots(positions: number[], buildOptions?: BuildOptions): void;
+    /**
+     * 批量更新
+     * @param callback - 更新回调
+     */
+    private batchUpdate;
+    /**
+     * 清除所有定坑配置
+     * @param buildOptions - 构建选项
+     */
+    clearFixedSlots(buildOptions?: BuildOptions): void;
+    /**
+     * 追加新的数据列表到普通数据列表末尾
+     * @param list - 要追加的数据数组
+     * @param buildOptions - 构建选项，lazy 为 true 时延迟构建
+     */
+    appendList(list: T[], buildOptions?: BuildOptions): void;
+    /**
+     * 清空普通数据列表
+     */
+    clearList(): void;
+    /**
+     * 获取混合后的数据
+     * @param buildOptions - 构建选项
+     * @returns 返回混合后的数据项数组
+     */
+    getMixedData(buildOptions?: Omit<BuildOptions, 'lazy'>): MixedDataItem<T>[];
+    /**
+     * 分发事件
+     * 同时在实例和 window 对象上触发事件
+     * @param name - 事件名称
+     * @param data - 事件数据
+     */
+    private dispatch;
+    /**
+     * 重新构建混合数据
+     * 全局定坑：定坑位置始终固定在全局位置，普通数据在定坑位置之外填充
+     * 定坑位置不会因为普通数据的变化而改变
+     */
+    private buildMixedData;
+    /**
+     * 切片获取指定范围内的定坑位置
+     * @param startIdx - 起始位置
+     * @param endIdx - 结束位置，默认为正无穷
+     * @returns 返回过滤后的定坑位置数组
+     */
+    private sliceSlots;
+    /**
+     * 插入数据（插卡模式）
+     * 在指定位置插入数据，会触发全量重建
+     * @param config - 定坑配置，必须指定插入模式
+     * @returns 返回插入后的实际位置
+     */
+    insertSlot(config: PickRequired<InputSlotConfig<T>, 'insertMode'>): number;
+    insertSlots(configs: PickRequired<InputSlotConfig<T>, 'insertMode'>[]): number[];
+}
+/**
+ * 创建数据管理器实例的工厂函数
+ * @template T - 数据类型
+ * @returns 返回一个新的 DataMixedManager 实例
+ */
+export declare function dataMixedManager<T>(options?: DataMixedManagerOptions<T>): DataMixedManager<T>;
+export {};

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