@cmtlyt/lingshu-toolkit 0.3.0 → 0.5.0

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

@@ -0,0 +1,66 @@
+import { throwType } from "../throw-error/index.js";
+import { tryCall } from "../try-call/index.js";
+import { isFunction, isNullOrUndef } from "../utils/verify.js";
+import { getBody, targetUrlParser, urlParamsParser } from "./utils.js";
+async function baseRequest(config, getResponse) {
+    const { baseUrl, url, method: _method, parser, data, tdto, tvo, onResponse, ...rest } = config;
+    const targetUrl = targetUrlParser(url, baseUrl);
+    const method = _method?.toUpperCase();
+    const requestInfo = tryCall(()=>{
+        if (isNullOrUndef(method) || 'GET' === method || 'HEAD' === method) {
+            const queryKeys = Object.keys(data || {});
+            for(let i = 0; i < queryKeys.length; ++i)targetUrl.searchParams.append(queryKeys[i], data[queryKeys[i]]);
+            return new Request(targetUrl, {
+                ...rest,
+                method
+            });
+        }
+        const body = getBody(data, tdto);
+        return new Request(targetUrl, {
+            ...rest,
+            method,
+            body
+        });
+    });
+    const responseInfo = await getResponse(requestInfo);
+    const resResult = await tryCall(()=>{
+        if (onResponse) return onResponse(responseInfo, config);
+        if (!parser) return responseInfo.json();
+        if ('stream' === parser) return responseInfo.body;
+        const responseHandler = responseInfo[parser];
+        if (isFunction(responseHandler)) return Reflect.apply(responseHandler, responseInfo, []);
+        throwType('apiController.responseParser', 'Invalid parser');
+    });
+    return tvo ? tvo(resResult) : resResult;
+}
+async function mockRequest(config) {
+    const { onRequest, ...rest } = config;
+    return baseRequest(config, async (requestInfo)=>{
+        const reqResult = await (onRequest && onRequest(requestInfo, config));
+        const responseBody = getBody(reqResult);
+        return new Response(responseBody, {
+            ...rest
+        });
+    });
+}
+async function networkRequest(config) {
+    return baseRequest(config, fetch);
+}
+function request(config) {
+    const url = urlParamsParser(config.url, config.params);
+    const { requestMode, requestModeMap } = config;
+    const customRequest = (requestModeMap || {})[requestMode || ''];
+    if (customRequest) return customRequest({
+        ...config,
+        url
+    });
+    if ('mock' === requestMode) return mockRequest({
+        ...config,
+        url
+    });
+    return networkRequest({
+        ...config,
+        url
+    });
+}
+export { request };

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

@@ -0,0 +1,141 @@
+import type { AnyFunc, Cast, Equal, Func } from '../types/base';
+import type { Pack as TPack } from '../types/pack';
+type Empty = {
+    __EMPTY__: never;
+};
+/** 请求方法 */
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | (string & {});
+type Parser = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes' | 'stream' | (string & {});
+type RequestMode<E extends string = string & {}> = 'mock' | 'network' | E;
+type EmptyUnwrap<UserR = Empty, T = any> = Equal<UserR, Empty> extends true ? T : UserR;
+interface ParserResultMap<UserR = Empty> {
+    json: EmptyUnwrap<UserR>;
+    text: string;
+    blob: Blob;
+    arrayBuffer: ArrayBuffer;
+    formData: FormData;
+    bytes: Uint8Array;
+    stream: ReadableStream | null;
+}
+type ParserResult<P extends Parser, UserR = Empty> = P extends keyof ParserResultMap ? ParserResultMap<UserR>[P] : EmptyUnwrap<UserR>;
+type ParserReturn<RM extends RequestMode, P extends Parser, ReqOutput, UserR = Empty> = RM extends 'network' ? ParserResult<P, UserR> : EmptyUnwrap<UserR, RM extends 'mock' ? ReqOutput : any>;
+type URLParamParser<U extends string, Param extends string = never> = U extends `${string}/:${infer P}/${infer Rest}` ? URLParamParser<`/${Rest}`, Param | P> : U extends `${string}/:${infer P}` ? P | Param : Param;
+type CheckNonParamUrlAPIConfig<A extends APIConfig> = Equal<URLParamParser<A['url']>, never>;
+export interface BaseAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> extends RequestInit {
+    /**
+     * 请求地址
+     *
+     * @example '/api/user'
+     * @example 'https://example.com/api/user'
+     */
+    url: Url;
+    params?: Record<URLParamParser<Url>, string | number>;
+    /** 请求模式 */
+    requestMode?: RequestMode<ReqModeMapKeys>;
+    /** 请求方法 */
+    method?: RequestMethod | Lowercase<RequestMethod>;
+    /**
+     * 响应体解析方式
+     * 如果存在 onResponse 的话, 则会使用 onResponse 的返回值, 如果想要屏蔽 onResponse 的继承, 则应该设置 onResponse 为 null
+     *
+     * @default 'json'
+     */
+    parser?: Parser;
+    /**
+     * transform data transfer object
+     *
+     * @tips GET/HEAD 方法因为是无 body 的请求, 不会触发 tdto 的转换
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    tdto?: ((data: Input) => any) | null;
+    /**
+     * transform view object
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    tvo?: ((data: Awaited<FindNonAny<[ResOutput, ReturnType<NonNullable<DefaultConfig['onResponse']>>]>>) => Output) | null;
+    /**
+     * 请求前 hook
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    onRequest?: ((req: Request, config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => ReqOutput) | null;
+    /**
+     * 响应前 hook
+     * 会覆盖 parser 的解析方式
+     *
+     * @description hook 顺序: tdto -> onRequest -> onResponse/parser -> tvo
+     */
+    onResponse?: ((res: Response, config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => ResOutput) | null;
+}
+export interface DefaultAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, ReqModeMapKeys extends string = string & {}> extends Omit<BaseAPIConfig<Input, Output, ReqOutput, ResOutput, DefaultAPIConfig, ReqModeMapKeys>, 'url'> {
+    /** 基本地址 */
+    baseUrl?: string;
+    /** 请求模式 map */
+    requestModeMap?: Record<ReqModeMapKeys, (config: RequestAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>) => any>;
+}
+export interface RequestAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, ReqModeMapKeys extends string = string & {}> extends DefaultAPIConfig<Input, Output, ReqOutput, ResOutput, ReqModeMapKeys>, APIConfig<Input, Output, ReqOutput, ResOutput, DefaultAPIConfig, ReqModeMapKeys> {
+    /** 请求数据 */
+    data?: Input;
+    oriUrl: string;
+}
+/**
+ * API config
+ */
+export type APIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> = BaseAPIConfig<Input, Output, ReqOutput, ResOutput, DefaultConfig, ReqModeMapKeys, Url>;
+export type CallAPIConfig<Input = any, Output = any, ReqOutput = any, ResOutput = any, DefaultConfig extends DefaultAPIConfig = DefaultAPIConfig, ReqModeMapKeys extends string = string & {}, Url extends string = string> = Omit<APIConfig<Input, Output, ReqOutput, ResOutput, DefaultConfig, ReqModeMapKeys, Url>, 'url'>;
+export type DefineAPIConfig<U extends string> = APIConfig<any, any, any, any, any, any, U>;
+/** API map */
+export interface APIMap<U extends string = string & {}> {
+    [key: string]: DefineAPIConfig<U> | APIMap<U>;
+}
+export type IsUnknownAny<T> = Equal<T, any> extends true ? true : Equal<T, unknown> extends true ? true : false;
+export type FindNonAny<T extends any[], Other = Empty> = T extends [infer F, ...infer Last] ? IsUnknownAny<F> extends true ? FindNonAny<Last, Other> : F extends Other ? FindNonAny<Last, Other> : F : any;
+type APIHandlerArgs<I, C extends CallAPIConfig, Custom, NonParamUrl extends boolean> = FindNonAny<[
+    NonParamUrl extends true ? any : [I, C & Required<Pick<C, 'params'>>],
+    Custom extends true ? [I?, C?] : [I?],
+    [I?]
+]>;
+type DefineRequestModes<D extends DefaultAPIConfig> = keyof NonNullable<D['requestModeMap']> & string;
+type RealProp<P extends keyof DefaultAPIConfig & keyof APIConfig, C extends Pick<APIConfig, P>, A extends Pick<APIConfig, P>, D extends DefaultAPIConfig, Other = Empty> = FindNonAny<[C[P], A[P], D[P]], Other>;
+type OnResponseReturn<OnResponse> = OnResponse extends AnyFunc ? ReturnType<OnResponse> : any;
+type CustomCallConfigUnwrap<C extends CallAPIConfig, Custom extends boolean> = Custom extends true ? {
+    [K in keyof C as undefined extends C[K] ? never : K]: C[K];
+} : Record<never, Empty>;
+interface Pack<T> extends TPack<T> {
+    __value: T;
+}
+type PackUnwrap<P> = P extends Pack<any> ? P['__value'] : P;
+interface OriginalPack<T> extends TPack<T> {
+    __originValue: T;
+}
+type OriginalPackUnwrap<P> = P extends OriginalPack<any> ? P['__originValue'] : Promise<P>;
+type CustomRequestModeReturn<RealRM extends RequestMode, InputD extends DefaultAPIConfig, CustomReq = NonNullable<InputD['requestModeMap']>[RealRM]> = IsUnknownAny<RealRM> extends true ? any : Equal<RealRM, string> extends true ? any : CustomReq extends AnyFunc ? OriginalPack<ReturnType<CustomReq>> : any;
+type UserInputResult<UserR, CustomRequestResult> = IsUnknownAny<CustomRequestResult> extends true ? UserR : IsUnknownAny<UserR> extends true ? any : UserR extends CustomRequestResult ? OriginalPack<UserR> : UserR;
+type APIHandlerResult<AConfig extends APIConfig, CallConfig extends CallAPIConfig = APIConfig, UserR = Empty, InputDefault extends DefaultAPIConfig = DefaultAPIConfig, ReqOutput = any, Custom extends boolean = false, CC extends CallAPIConfig = CustomCallConfigUnwrap<CallConfig, Custom>, CustomRequestResult = CustomRequestModeReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, InputDefault>> = OriginalPackUnwrap<Awaited<PackUnwrap<FindNonAny<[
+    UserInputResult<EmptyUnwrap<UserR>, OriginalPackUnwrap<CustomRequestResult>>,
+    CustomRequestResult,
+    ReturnType<Cast<RealProp<'tvo', CC, AConfig, InputDefault>, AnyFunc>>,
+    OnResponseReturn<RealProp<'onResponse', CC, AConfig, InputDefault>>,
+    ParserReturn<NonNullable<RealProp<'requestMode', CC, AConfig, InputDefault>>, NonNullable<RealProp<'parser', CC, AConfig, InputDefault>>, ReqOutput, UserR>
+], undefined | null>>>>;
+type APIInputType<A extends Pick<APIConfig, 'tdto'> = APIConfig, D extends Pick<DefaultAPIConfig, 'tdto'> = DefaultAPIConfig> = Parameters<Cast<FindNonAny<[A['tdto'], D['tdto']], undefined | null>, (...args: any[]) => any>>[0];
+type PropResult<A extends APIConfig, P extends keyof A> = A[P] extends AnyFunc ? ReturnType<A[P]> : unknown;
+export type APITransformMethod<A extends APIConfig, InputD extends DefaultAPIConfig = DefaultAPIConfig, Custom extends boolean = false, NonParamUrl extends boolean = CheckNonParamUrlAPIConfig<A>, I extends APIInputType<A, InputD> = APIInputType<A, InputD>> = (<R = Empty, C extends CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']> = CallAPIConfig<I, any, PropResult<A, 'onRequest'>, PropResult<A, 'onResponse'>, InputD, DefineRequestModes<InputD>, A['url']>>(...args: APIHandlerArgs<Equal<I, APIInputType<A, InputD>> extends true ? APIInputType<C, {
+    tdto: Func<[I]>;
+}> : I, C, Custom, NonParamUrl>) => APIHandlerResult<A, Cast<C, Partial<APIConfig>>, R, InputD, ReturnType<Cast<RealProp<'onRequest', C, A, InputD>, AnyFunc>>, Custom>) & APIInstance<A, InputD>;
+export type APIInstance<A, D> = {
+    $: A;
+    $$: DefaultAPIConfig extends D ? undefined : D;
+    $$r: DefaultAPIConfig;
+} & APIInstanceHandler;
+interface APIInstanceHandler {
+    $updateBaseUrl(baseUrl?: string): void;
+}
+export type APIMapTransformMethods<M extends APIMap | Record<string, APIConfig>, D extends DefaultAPIConfig = DefaultAPIConfig> = {
+    [K in keyof M as M[K] extends APIConfig ? CheckNonParamUrlAPIConfig<M[K]> extends true ? K : never : K]: M[K] extends APIConfig ? APITransformMethod<M[K], D, false> : APIMapTransformMethods<Cast<M[K], APIMap>, D>;
+} & {
+    [K in keyof M as M[K] extends APIConfig ? `${K & string}Custom` : never]: APITransformMethod<Cast<M[K], APIConfig>, D, true>;
+} & APIInstance<M, D>;
+export {};

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

@@ -0,0 +1,22 @@
+import type { APIConfig, APIInstance, APIMap, DefaultAPIConfig } from './types';
+export declare function isAbsUrl(url?: string): boolean;
+export declare function targetUrlParser(_url: string, _baseUrl: string): URL;
+export declare function urlParamsParser(url: string, params: Record<string, string> | undefined): string;
+export declare function getBody(data: any, tdto?: APIConfig['tdto']): any;
+export declare function instanceMemberGetter(prop: string, instanceObj: Record<string, any>): any;
+export declare function createInstance(apiMap: APIConfig | APIMap, realDefaultConfig: DefaultAPIConfig, defaultConfig?: DefaultAPIConfig): {
+    $: APIMap<string & {}> | APIConfig;
+    $$: any;
+    $$r: DefaultAPIConfig<any, any, any, any, string & {}>;
+    $updateBaseUrl(baseUrl: string | undefined): void;
+};
+export declare function getInstanceMemberOrApi(target: APIMap, prop: string, receiver: any, instanceObj: APIInstance<any, any>): {
+    instanceMember: any;
+    api?: undefined;
+    isCustom?: undefined;
+} | {
+    api: APIMap<string & {}> | import("./types").DefineAPIConfig<string & {}>;
+    isCustom: boolean;
+    instanceMember?: undefined;
+} | undefined;
+export declare function apiNamesCheck(_apiMap: APIMap, isDeep?: boolean): string[];

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

@@ -0,0 +1,96 @@
+import { logger } from "../logger/index.js";
+import { throwError, throwType } from "../throw-error/index.js";
+import { getType, isPlainNumber, isString } from "../utils/index.js";
+const ABSOLUTE_URL_REG = /^[a-z][a-z\d+\-.]*:/im;
+function isAbsUrl(url) {
+    if (!url) return false;
+    return ABSOLUTE_URL_REG.test(url);
+}
+function targetUrlParser(_url, _baseUrl) {
+    if (isAbsUrl(_url)) return new URL(_url);
+    if (!isAbsUrl(_baseUrl)) throwType('apiController.request', 'baseUrl 配置不合法, 必须是绝对路径');
+    const baseUrl = new URL(_baseUrl);
+    const basePath = '/' === baseUrl.pathname ? '' : baseUrl.pathname.replace(/\/$/, '');
+    const relativePath = _url.startsWith('/') ? _url : `/${_url}`;
+    const url = `${basePath}${relativePath}`;
+    return new URL(url, baseUrl);
+}
+function urlParamsParser(url, params) {
+    if (!url.includes('/:')) return url;
+    if (!params) throwType('apiController.parseParams', 'url 中存在 params 参数, params 配置不能为空, 请使用 custom 方法调用并传递 params 配置');
+    const urlSplit = url.split('/');
+    const emptyKeys = [];
+    for(let i = 1; i < urlSplit.length; ++i){
+        if (':' !== urlSplit[i][0]) continue;
+        const param = urlSplit[i].slice(1);
+        const originValue = params[param];
+        if (!(isPlainNumber(originValue) || originValue)) {
+            emptyKeys.push(param);
+            continue;
+        }
+        const paramValue = encodeURIComponent(String(originValue));
+        urlSplit[i] = paramValue;
+    }
+    if (emptyKeys.length) throwType('apiController.parseParams', `params 配置中缺少 [${emptyKeys.join(', ')}] 参数`);
+    return urlSplit.join('/');
+}
+function getBody(data, tdto) {
+    const _body = tdto ? tdto(data) : data;
+    const bodyType = getType(_body);
+    switch(bodyType){
+        case 'object':
+        case 'array':
+        case 'number':
+        case 'boolean':
+        case 'function':
+            return JSON.stringify(_body);
+        default:
+            return _body;
+    }
+}
+function instanceMemberGetter(prop, instanceObj) {
+    return instanceObj[prop];
+}
+function createInstance(apiMap, realDefaultConfig, defaultConfig) {
+    return {
+        $: apiMap,
+        $$: defaultConfig,
+        $$r: realDefaultConfig,
+        $updateBaseUrl (baseUrl) {
+            if (isAbsUrl(baseUrl)) realDefaultConfig.baseUrl = baseUrl;
+            else {
+                const { origin } = globalThis.location || {};
+                if (!origin) throwError('apiController.$updateBaseUrl', 'location.origin is undefined');
+                const normalizedPath = (baseUrl || '/').startsWith('/') ? baseUrl || '' : `/${baseUrl}`;
+                realDefaultConfig.baseUrl = `${origin}${normalizedPath}`;
+            }
+        }
+    };
+}
+function getInstanceMemberOrApi(target, prop, receiver, instanceObj) {
+    if (Reflect.getOwnPropertyDescriptor(instanceObj, prop)) return {
+        instanceMember: instanceMemberGetter(prop, instanceObj)
+    };
+    const hasExactProp = isString(prop) && Reflect.has(target, prop);
+    const isCustom = isString(prop) && prop.endsWith('Custom') && !hasExactProp;
+    const name = isCustom ? prop.slice(0, -6) : prop;
+    if (!Reflect.getOwnPropertyDescriptor(target, name)) return;
+    const api = Reflect.get(target, name, receiver);
+    if (isCustom && !isString(api.url)) return;
+    return {
+        api,
+        isCustom
+    };
+}
+function apiNamesCheck(_apiMap, isDeep = false) {
+    const apiNames = Reflect.ownKeys(_apiMap);
+    const warnNames = [];
+    for(let i = 0; i < apiNames.length; i++){
+        const name = apiNames[i];
+        if (name.endsWith('Custom')) warnNames.push(name);
+        if (!isString(_apiMap[name].url)) warnNames.push(...apiNamesCheck(_apiMap[name], true));
+    }
+    if (!isDeep && warnNames.length > 0) logger.warn('apiController.createApiWithMap', 'api 命名不应该使用 Custom 结尾, 因为这是一个内部实现的方法', warnNames);
+    return warnNames;
+}
+export { apiNamesCheck, createInstance, getBody, getInstanceMemberOrApi, instanceMemberGetter, isAbsUrl, targetUrlParser, urlParamsParser };

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