donar 0.0.1

package/dist/types/src/hooks/state.d.ts

@@ -0,0 +1,44 @@
+import { SetStateAction } from 'react';
+/**
+ * @author sonion
+ * @description 创建静态的state, 不会触发组件重新渲染
+ * @param {T} initialValue - 初始值
+ */
+export declare function useStaticState<T>(initialValue: T): [() => T, (t: T) => void, (t?: T) => T];
+export declare function useStaticState<T>(initialValue?: undefined): [() => T | undefined, (t: T) => void, (t?: T) => T | undefined];
+/**
+ * @author sonion
+ * @description 创建最新的回调函数，不触发重新执行，同时避免闭包问题。
+ * 作用类似19.2的useEffectEvent，但原理和用法不同。
+ * @param {T} dep - 依赖函数、依赖函数数组、依赖函数对象
+ * @returns {()=>T} - 获取最新回调函数、依赖函数数组、依赖函数对象的方法
+ */
+export declare function useLatestCallback<T extends (...args: never) => unknown>(dep: T): () => T;
+export declare function useLatestCallback<T extends (...args: never) => unknown>(dep?: T | undefined): () => T | undefined;
+/**
+ * @author sonion
+ * @description 创建相同值不触发组件重新渲染的state。和useCreateSafeRef类似，但useCreateSafeRef更专注于ref
+ * @param params - 参数对象
+ * @param {T} params.initialValue - 初始值
+ * @param {(val: T) => void} [params.onChange] - 变化回调
+ * @param {(prev: T, next: T) => boolean} [params.hasDiff] - 对比函数，默认对比引用是否不相同。
+ * @param {boolean} [params.onlyEvent] - 是否仅触发事件，不更新值，避免重渲染
+ */
+export declare function useDistinctState<T>(params: {
+    initialValue: T | (() => T);
+    onChange?: (val: T) => void;
+    hasDiff?: (prev?: T, next?: T) => boolean;
+    onlyEvent: true;
+}): [undefined, (val: SetStateAction<T>) => void, () => T];
+export declare function useDistinctState<T>(params: {
+    initialValue: T | (() => T);
+    onChange?: (val: T) => void;
+    hasDiff?: (prev?: T, next?: T) => boolean;
+    onlyEvent?: false;
+}): [T, (val: SetStateAction<T>) => void, () => T];
+/**
+ * @author sonion
+ * @description 创建安全的Ref引用
+ * @param {(oldNode?: T, newNode?: T) => boolean} [hasDiff] - 对比函数，默认对比引用是否不相同。
+ */
+export declare const useCreateSafeRef: <T extends object = HTMLElement>(hasDiff?: (oldNode?: T, newNode?: T) => boolean) => readonly [T | undefined, (node: T | null) => void, import('react').MutableRefObject<boolean>];

package/dist/types/src/hooks/storage.d.ts

@@ -0,0 +1,25 @@
+import { useDistinctState } from './state';
+type StorageParams<T> = Omit<Parameters<typeof useDistinctState<T>>[0], 'onlyEvent'> & {
+    /** 储存的key */
+    key: string;
+    /** 储存类型。 localStorage 或 sessionStorage */
+    storage?: typeof localStorage | typeof sessionStorage;
+    /** 初始化类型检查函数，检查不通过使用初始值。可避免类型不对引起的错误 */
+    checkType?: (val: T) => boolean;
+    /** tab关闭前的回调, 相同key的不同回调只有初始生效。 */
+    beforeunload?: () => void;
+};
+/**
+ * @author sonion
+ * @description 本地储存
+ * @param params - 参数对象
+ * @param params.key - 储存的key
+ * @param params.initialValue - 初始值
+ * @param [params.hasDiff] - 对比函数，默认对比引用是否不相同。
+ * @param params.onChange - 变化回调
+ * @param [params.storage] - 储存类型。 localStorage 或 sessionStorage
+ * @param [params.checkType] - 初始化类型检查函数，检查不通过使用初始值。可避免类型不对引起的错误
+ * @param [params.beforeunload] - tab关闭前的回调, 相同key的不同回调只有初始生效。
+ */
+export declare const useStorage: <T>({ key, initialValue, hasDiff, onChange, storage, checkType, beforeunload, }: StorageParams<T>) => readonly [T, (value: T | ((val: T) => T)) => void];
+export {};

package/dist/types/src/hooks/timer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author sonion
+ * @description 自管理定时器的interval
+ * @param {()=>void} cb - 回调函数
+ * @param {number} duration - 时间间隔
+ * @returns {[() => void, () => void]} - [启动函数, 清除函数]
+ */
+export declare const useInterval: (cb: () => void, duration: number) => (() => void)[];
+/**
+ * @author sonion
+ * @description 自管理定时器的rAfInterval
+ * @param {()=>void} cb - 回调函数
+ * @param {number} duration - 时间间隔
+ * @returns {[() => void, () => void]} - [启动函数, 清除函数]
+ */
+export declare const useRAfInterval: (cb: () => void, duration: number) => readonly [() => void, () => void];

package/dist/types/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './hooks';
+export * from './utils';

package/dist/types/src/test/emiter-test.d.ts

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

package/dist/types/src/test/index.d.ts

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

package/dist/types/src/test/retry-async-test.d.ts

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

package/dist/types/src/utils/class-singleton.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author sonion
+ * @description 构造函数转单例工具
+ * @param className - 要转单例的构造函数
+ */
+export declare const singleton: <T extends new (...args: ConstructorParameters<T>) => R, R extends object = InstanceType<T>>(className: T) => T;

package/dist/types/src/utils/concurrency.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author sonion
+ * @description 并发控制器
+ * @param {number} concurrency - 并发数
+ */
+export declare class ConcurrencyController<T> {
+    /** 任务队列 */
+    private queue;
+    /** 并发数 */
+    private concurrency;
+    /** 当前运行中的任务数 */
+    private running;
+    constructor(concurrency?: number);
+    push(task: () => Promise<T>): Promise<T>;
+    run(): void;
+    private next;
+}

package/dist/types/src/utils/debounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @author sonion
+ * @description 防抖
+ * @param {(...args: unknown[])=>void} fn - 防抖的函数
+ * @param {number} delay - 毫秒
+ * @returns {(...args: unknown[])=>void} - 防抖后的函数
+ */
+export declare const debounce: <A extends unknown[], R, T = unknown>(fn: (this: T, ...args: A) => R, delay: number) => ((this: T, ...args: A) => void);

package/dist/types/src/utils/deep-copy.d.ts

@@ -0,0 +1,11 @@
+type DeepCloneResult = Record<string | symbol, unknown>;
+type DeepCloneParamReturn = DeepCloneResult | Array<unknown>;
+/**
+ * @author sonion
+ * @description 解决了循环引用、原型一致的深度克隆 // 原生structuredClone 没解决Symbol、原型链，兼容到22年8月
+ * @param {DeepCloneParamReturn} value 要克隆的对象
+ * @param {boolean} [isCopyProto] 是否拷贝原型链 -默认值：true
+ * @returns {DeepCloneParamReturn} - 克隆后的对象
+ */
+export declare const deepClone: <T extends DeepCloneParamReturn, U extends DeepCloneParamReturn>(value: T, isCopyProto?: boolean) => U;
+export {};

package/dist/types/src/utils/dev.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface Console {
+        clog: typeof console.log;
+    }
+}
+type ClogParams = Parameters<typeof console.log>;
+export declare const clog: (...args: ClogParams) => void;
+export {};

package/dist/types/src/utils/download.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author sonion
+ * @description 浏览器原生下载。需要content-disposition: attachment; filename=xxx响应头支持
+ * a元素、window.open；target为_self短时间打开多个，后面的会覆盖前面的。为_blank时都会拦截，但window.open可以通过返回值检测是否被拦截
+ * @param {string} url - 下载链接
+ */
+export declare const browserNativeDownload: (url: string) => Promise<boolean>;
+/**
+ * @author sonion
+ * @description blob下载
+ * @param {Blob} blob - 下载的blob数据
+ * @param {string} fileName - 下载的文件名
+ * @param {boolean} [inline] - 是否内联下载(不开新tab) 默认内联
+ */
+export declare const blobDownload: (blob: Blob, fileName: string, inline?: boolean) => void;

package/dist/types/src/utils/event-emitter/helpers.d.ts

@@ -0,0 +1,36 @@
+import { RecordTypedMap } from '../record-typed-map';
+/**
+ * @author sonion
+ * @description 判断对象自身是否有指定属性
+ * @param obj 要判断的对象
+ * @param property 属性名
+ * @returns {boolean} - 是否有指定属性
+ */
+export declare const hasOwnProperty: <T extends Partial<Record<keyof T, unknown>>>(obj: T, property: string) => boolean;
+/** 事件处理函数类型 */
+export type EventHandler<P> = undefined extends P ? (payload?: P) => void : (payload: P) => void;
+/** 事件处理函数配置类型 */
+export type EventHandlerOptions = {
+    /** 是否仅触发一次 */
+    once?: boolean;
+    /** 取消信号 */
+    signal?: AbortSignal;
+};
+/** 事件处理函数集合 */
+export type EventCollection<P> = Map<EventHandler<P>, EventHandlerOptions | undefined>;
+/**
+ * @author sonion
+ * @description 创建事件处理集合，同名事件的集合
+ * 泛型 A，事件处理韩式参数类型
+ * @returns 事件处理函数集合
+ */
+export declare const createEventCollection: <K extends keyof T, T extends Record<string, unknown>>() => EventCollection<T[K]>;
+/** 事件中心数据类型 `Map<事件名, Map<事件处理函数, 配置参数>>` */
+export type EventCenter<T extends Record<string, unknown>> = RecordTypedMap<{
+    [K in keyof T]: EventCollection<T[K]>;
+}>;
+export type EventOptionExecutor<T extends Record<string, unknown>> = Record<keyof EventHandlerOptions, <K extends keyof T>(events: EventCenter<T>, eventName: K, eventExecutorParams: [EventHandler<T[K]>, EventHandlerOptions | undefined]) => void>;
+export declare const createEventOptionExecutor: <T extends Record<string, unknown>>() => {
+    once: <K extends keyof T>(events: EventCenter<T>, eventName: K, eventExecutorParams: [EventHandler<T[K]>, EventHandlerOptions | undefined]) => void;
+    signal: <K extends keyof T>(events: EventCenter<T>, eventName: K, eventExecutorParams: [EventHandler<T[K]>, EventHandlerOptions | undefined]) => void;
+};

package/dist/types/src/utils/event-emitter/index.d.ts

@@ -0,0 +1,65 @@
+import { EventHandler, EventHandlerOptions } from './helpers';
+type NonFunction = null | undefined | number | string | boolean | symbol | bigint | {
+    [key: string]: unknown;
+};
+/** 返回包含 undefined 类型的键 */
+type KeysWithUndefined<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+/** 返回不包含 undefined 类型的键 */
+type KeysWithoutUndefined<T> = {
+    [K in keyof T]: undefined extends T[K] ? never : K;
+}[keyof T];
+/**
+ * @author sonion
+ * @description 自定义事件中心。
+ * @example
+ * const eventCenter = new EventEmitter();
+ * eventCenter.on('onChange', data=>console.log('没有配置的事件。参数：', data));
+ * eventCenter.on('onTest', data=>console.log('once 配置为 true 的事件。参数：', data), {once: true});
+ * const controller = new AbortController(); // 创建取消信号
+ * eventCenter.on('tap', data=>console.log('配置了 signal 的事件。参数：', data), {signal: controller.signal})
+ * controller.abort() // 取消
+ * eventCenter.emit('onChange', {happy: true});
+ */
+export declare class EventEmitter<T extends Record<string, NonFunction>> {
+    /** Map<事件名, Map<事件处理函数, 配置参数>> */
+    private events;
+    /** 配置对象执行器，不同配置参数的不同处理。在emit中执行 */
+    private eventOptionExecutor;
+    /** 自定义调度器，怎么执行事件处理函数 */
+    private scheduler;
+    constructor(scheduler?: (eventHandel: () => void) => void);
+    /**
+     * @author sonion
+     * @description 注册事件
+     * @param eventName 事件名
+     * @param callback 事件处理函数
+     * @param options 配置对象。once：是否只运行一次, signal取消信号
+     */
+    addEventListener<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>, options?: EventHandlerOptions): void;
+    /**
+     * @author sonion
+     * @description 移除事件
+     * @param eventName 事件名
+     * @param callback 事件处理函数
+     */
+    removeEventListener<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>): void;
+    on<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>, options?: EventHandlerOptions): void;
+    off<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>): void;
+    /**
+     * @author sonion
+     * @description 清空事件列表
+     * @param {string | void} [eventName] - 要清除的事件名。不传就清空所有事件列表
+     */
+    clear(eventName?: keyof T): boolean;
+    /**
+     * @author sonion
+     * @description 发布事件
+     * @param eventName 事件名
+     * @param data 事件参数
+     */
+    emit<K extends KeysWithoutUndefined<T>>(eventName: K, data: T[K]): void;
+    emit<K extends KeysWithUndefined<T>>(eventName: K, data?: T[K]): void;
+}
+export {};

package/dist/types/src/utils/fetch-xhr/helpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @author sonion
+ * @description
+ * @param xhr - XMLHttpRequest 实例对象
+ * @param headers 请求头参数
+ */
+export declare const setRequestHeaders: (xhr: XMLHttpRequest, headers: RequestInit["headers"]) => void;
+/**
+ * @author sonion
+ * @description 处理请求体，将 ReadableStream 类型转换为 Blob 类型
+ * @param body - 请求体
+ * @param signal - 信号量
+ */
+export declare const handleRequestBody: (body: RequestInit["body"], signal?: AbortSignal | null) => Promise<string | ArrayBuffer | ArrayBufferView<ArrayBuffer> | Blob | FormData | URLSearchParams | null | undefined>;
+/**
+ * @author sonion
+ * @description 获取响应头
+ * @param {XMLHttpRequest} xhr XMLHttpRequest对象
+ */
+export declare const getResponseHeaders: (xhr: XMLHttpRequest) => Headers;
+/**
+ * @author sonion
+ * @description 自定义超时错误类
+ */
+export declare class CustomTimeoutError extends DOMException {
+    readonly isTimeout = true;
+    constructor(msg?: string);
+}

package/dist/types/src/utils/fetch-xhr/index.d.ts

@@ -0,0 +1,25 @@
+import { CustomTimeoutError } from './helpers';
+export { CustomTimeoutError };
+type RequestInitFields = 'body' | 'method' | 'headers' | 'credentials' | 'signal';
+export interface FetchXHRInit extends Pick<RequestInit, RequestInitFields> {
+    /**
+     * @description 超时时间，单位毫秒
+     */
+    timeout?: number;
+    /**
+     * @description 上传进度回调
+     */
+    onUploadProgress?: (loaded: number, total: number, e: ProgressEvent) => void;
+    /**
+     * @description 下载进度回调
+     */
+    onDownloadProgress?: (loaded: number, total: number, e: ProgressEvent) => void;
+}
+/**
+ * @author sonion
+ * @description 基于 XMLHttpRequest 实现的 fetch 函数。
+ * 除增加 timeout、onUploadProgress、onDownloadProgress 外，其他与 fetch 一致。
+ * @param url 请求地址
+ * @param init 请求配置。
+ */
+export declare const fetchXHR: (url: string, init?: FetchXHRInit) => Promise<Response>;

package/dist/types/src/utils/hash.d.ts

@@ -0,0 +1,8 @@
+export type SupportedHashType = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+/**
+ * @author sonion
+ * @description 字符串转哈希
+ * @param {string} message - 要转换的字符串
+ * @param {SupportedHashType} algorithm - 哈希算法，默认SHA-1
+ */
+export declare function stringToHash(message: string, algorithm?: SupportedHashType): Promise<string>;

package/dist/types/src/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from './thenable';
+export * from './concurrency';
+export * from './debounce';
+export * from './hash';
+export * from './download';
+export * from './deep-copy';
+export * from './raf-interval';
+export * from './json-convert';
+export * from './fetch-xhr';
+export * from './class-singleton';
+export * from './event-emitter';
+export * from './micro-queue-scheduler';
+export * from './record-typed-map';
+export * from './retry-async';
+export * from './is-deep-plain-equal';

package/dist/types/src/utils/is-deep-plain-equal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author sonion
+ * @param value 要判断的值
+ * @description 是否为null或undefined
+ */
+export declare const isNil: (value: unknown) => value is null | undefined;
+/**
+ * @author sonion
+ * @description 深度比较两个未知类型的值是否相等。支持 Plain Object。
+ * 不支持比较函数、Symbol、Date、RegExp等。
+ * @param a 要比较的第一个值
+ * @param b 要比较的第二个值
+ * @returns 如果两个值相等则返回 true，否则返回 false
+ */
+export declare const isDeepPlainEqual: (a: unknown, b: unknown) => boolean;

package/dist/types/src/utils/json-convert.d.ts

@@ -0,0 +1,66 @@
+/** 小驼峰命名支持用小划线分割 */
+type CamelToSnakeRaw<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Lowercase<First> ? `${First}${CamelToSnakeRaw<Rest>}` : `_${Lowercase<First>}${CamelToSnakeRaw<Rest>}` : S;
+/** 去掉开头的下划线 */
+type TrimLeadingUnderscore<S extends string> = S extends `_${infer R}` ? R : S;
+/** 小驼峰命名转换为蛇形命名类型 */
+type CamelToSnake<S extends string> = TrimLeadingUnderscore<CamelToSnakeRaw<S>>;
+/** 蛇形命名转换为小驼峰命名类型 */
+type SnakeToCamel<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Lowercase<Head>}${Capitalize<SnakeToCamel<Tail>>}` : Lowercase<S>;
+/** 小驼峰命名转换为大驼峰命名类型 */
+type CamelToPascal<S extends string> = Capitalize<S>;
+/** 大驼峰命名转换为小驼峰命名类型 */
+type PascalToCamel<S extends string> = Uncapitalize<S>;
+/** 转换模式 */
+export declare const ConvertMode: {
+    readonly SnakeToCamel: "snakeToCamel";
+    readonly CamelToSnake: "camelToSnake";
+    readonly CamelToPascal: "camelToPascal";
+    readonly PascalToCamel: "pascalToCamel";
+};
+/** 转换模式类型 */
+export type ConvertMode = (typeof ConvertMode)[keyof typeof ConvertMode];
+type TransformMap<K extends string> = {
+    snakeToCamel: SnakeToCamel<K>;
+    camelToSnake: CamelToSnake<K>;
+    camelToPascal: CamelToPascal<K>;
+    pascalToCamel: PascalToCamel<K>;
+};
+/** 通用：深度转换对象所有键名（保留函数与数组）*/
+type ConvertKeys<T, M extends ConvertMode, IGN extends readonly string[] = readonly []> = T extends (...args: never) => unknown ? T : T extends readonly unknown[] ? {
+    [I in keyof T]: ConvertKeys<T[I], M, IGN>;
+} : T extends object ? {
+    [K in keyof T as K extends string ? K extends IGN[number] ? K : TransformMap<K>[M] : K]: ConvertKeys<T[K], M, IGN>;
+} : T;
+/**
+ * @author sonion
+ * @description 深度遍历JSON，将所有键名从蛇形转换为小驼峰
+ * @param obj 要处理的JSON对象或数组
+ * @param ignoreKeys 忽略转换的键名数组。⚠️ ignoreKeys必须是使用 as const断言的数组，否则类型会失效
+ * @example convertSnake2Camel({ a_b: 1, c_d: { e_f: 2 } }, ['c_d'] as const)
+ */
+declare const convertSnake2Camel: <T extends Record<keyof T, unknown> | Record<keyof T, unknown>[], K extends readonly string[] = readonly []>(obj: T, ignoreKeys?: K) => ConvertKeys<T, typeof ConvertMode.SnakeToCamel, K>;
+/**
+ * @author sonion
+ * @description 深度遍历JSON，将所有键名从小驼峰转换为蛇形
+ * @param obj 要处理的JSON对象或数组
+ * @param ignoreKeys 忽略转换的键名数组。⚠️ ignoreKeys必须是使用 as const断言的数组，否则类型会失效
+ * @example convertCamel2Snake({ aB: 1, cD: { eF: 2 } }, ['cD'] as const)
+ */
+declare const convertCamel2Snake: <T extends Record<keyof T, unknown> | Record<keyof T, unknown>[], K extends readonly string[] = readonly []>(obj: T, ignoreKeys?: K) => ConvertKeys<T, typeof ConvertMode.CamelToSnake, K>;
+/**
+ * @author sonion
+ * @description 深度遍历JSON，将所有键名从小驼峰转换为大驼峰
+ * @param obj 要处理的JSON对象或数组
+ * @param ignoreKeys 忽略转换的键名数组。⚠️ ignoreKeys必须是使用 as const断言的数组，否则类型会失效
+ * @example convertCamel2Pascal({ aB: 1, cD: { eF: 2 } }, ['cD'] as const)
+ */
+declare const convertCamel2Pascal: <T extends Record<keyof T, unknown> | Record<keyof T, unknown>[], K extends readonly string[] = readonly []>(obj: T, ignoreKeys?: K) => ConvertKeys<T, typeof ConvertMode.CamelToPascal, K>;
+/**
+ * @author sonion
+ * @description 深度遍历JSON，将所有键名从大驼峰转换为小驼峰
+ * @param obj 要处理的JSON对象或数组
+ * @param ignoreKeys 忽略转换的键名数组。⚠️ ignoreKeys必须是使用 as const断言的数组，否则类型会失效
+ * @example convertPascal2Camel({ AB: 1, CD: { EF: 2 } }, ['CD'] as const)
+ */
+declare const convertPascal2Camel: <T extends Record<keyof T, unknown> | Record<keyof T, unknown>[], K extends readonly string[] = readonly []>(obj: T, ignoreKeys?: K) => ConvertKeys<T, typeof ConvertMode.PascalToCamel, K>;
+export { convertSnake2Camel, convertCamel2Snake, convertCamel2Pascal, convertPascal2Camel, };

package/dist/types/src/utils/micro-queue-scheduler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @author sonion
+ * @description 创建微队列调度器 - 将同一个同步执行阶段中的所有任务合并到一个微任务中执行。
+ * @returns 调度器函数
+ *
+ * 使用场景：
+ * - 批量合并异步任务，保证它们在同一个微任务中执行
+ * - 避免频繁创建多个 Promise 微任务，提高性能
+ * @example
+ * const scheduler = createMicroQueueScheduler();
+ * scheduler(() => console.log("task1"));
+ * scheduler(() => console.log("task2"));
+ */
+export declare const createMicroQueueScheduler: () => ((fn: () => void) => Promise<void>);

package/dist/types/src/utils/raf-interval.d.ts

@@ -0,0 +1,16 @@
+export type RAfIntervalReturn = Record<'stop', () => void>;
+/**
+ * @author sonion
+ * @description rAf版setInterval。可利用rAf页面隐藏暂停的特性，实现页面隐藏时暂停，页面显示时继续
+ * @param {() => void} fn - 回调函数
+ * @param {number} wait - 间隔时间 毫秒
+ * @returns {RAfIntervalReturn} - 返回取消函数
+ */
+export declare const rAfInterval: (fn: () => void, wait: number) => RAfIntervalReturn;
+/**
+ * @author sonion
+ * @description 清除rAf版setInterval定时器
+ * @param {RAfIntervalReturn} intervalId - 手写定时器的返回值
+ * @returns {void}
+ */
+export declare const clearRAfInterval: (intervalId: RAfIntervalReturn | (() => void) | undefined) => void;

package/dist/types/src/utils/record-typed-map.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @author sonion
+ * @description 一个带有精确类型约束的 Map。
+ *
+ * 与普通 `Map<keyof T, T[keyof T]>` 不同，
+ * 它保证键和值的类型一一对应：
+ * - 键只能是对象 T 的属性名
+ * - 值必须是该属性对应的类型
+ * - 因使用 object 约束泛型，键只能是 string|number|symbol
+ *
+ * 这样可以避免宽泛的联合类型，提供类似对象的强类型体验。
+ * @example
+ * interface Config {
+ *   port: number;
+ *   host: string;
+ * }
+ *
+ * const map = new RecordTypedMap<Config>();
+ * map.set("port", 3000);   // ✅ 正确
+ * map.set("host", "localhost"); // ✅ 正确
+ * map.set("port", "oops"); // ❌ 类型错误
+ */
+export declare class RecordTypedMap<T extends object> extends Map<keyof T, T[keyof T]> {
+    constructor(obj?: T);
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): this;
+}

package/dist/types/src/utils/retry-async.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author sonion
+ * @description 重试任务，直到成功或达到最大重试次数
+ * @param task - 要重试的任务函数，需返回 Promise
+ * @param count - 最大重试次数，默认 5 次
+ * @param delay - 每次重试间隔时间，默认 0 毫秒。可传函数，根据重试次数、错误信息动态计算。
+ * @returns Promise<R> - 任务成功时的返回值
+ */
+export declare const retryAsync: <R>(task: () => Promise<R>, count?: number, delay?: number | ((attemptIndex?: number, beforeError?: Error) => number)) => Promise<R>;

package/dist/types/src/utils/thenable.d.ts

@@ -0,0 +1,15 @@
+type SafeAwaitResult<T> = [true, null, T] | [false, Error, null];
+/**
+ * @author sonion
+ * @description 安全的 await 函数。
+ * @param {Promise<T>} promise 要执行的 Promise 函数
+ * @returns {Promise<SafeAwaitResult<T>>} - 返回一个元组，第一个元素为是否成功，第二个元素为错误信息，第三个元素为数据
+ */
+export declare const safeAwait: <T>(promise: Promise<T>) => Promise<SafeAwaitResult<T>>;
+/**
+ * @author sonion
+ * @description Promise.try 的polyfill实现
+ * @param p - promise 或 一个返回 promise 的函数
+ */
+export declare const promiseTry: <T>(p: PromiseLike<T> | (() => PromiseLike<T>)) => Promise<T>;
+export {};

package/dist/types/utils.d.ts

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

package/dist/utils.esm.js

@@ -0,0 +1,2 @@
+import { S as e, T as t, _ as n, a as r, b as i, c as a, d as o, f as s, g as c, h as l, i as u, l as d, m as f, n as p, o as m, p as h, r as g, s as _, t as v, u as y, v as b, w as x, x as S, y as C } from "./js/utils.CVb1iSAU.js";
+export { e as ConcurrencyController, y as ConvertMode, d as CustomTimeoutError, u as EventEmitter, r as RecordTypedMap, b as blobDownload, C as browserNativeDownload, l as clearRAfInterval, o as convertCamel2Pascal, s as convertCamel2Snake, h as convertPascal2Camel, f as convertSnake2Camel, m as createMicroQueueScheduler, S as debounce, n as deepClone, a as fetchXHR, v as isDeepPlainEqual, p as isNil, x as promiseTry, c as rAfInterval, g as retryAsync, t as safeAwait, _ as singleton, i as stringToHash };

package/eslint.config.ts

@@ -0,0 +1,48 @@
+import { defineConfig, globalIgnores } from 'eslint/config';
+import globals from 'globals';
+import jslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import prettier from 'eslint-config-prettier';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import react from 'eslint-plugin-react';
+import jsdoc from 'eslint-plugin-jsdoc';
+
+export default defineConfig([
+  globalIgnores(['dist', 'node_modules']), // 忽略 dist 和 node_modules 目录
+  {
+    files: ['**/*.{ts,tsx,js,jsx}'], // 对所有 TS TSX JS JSX 文件应用规则
+    languageOptions: {
+      ecmaVersion: 2020, // 语法检查 支持的 ES 版本
+      globals: globals.browser, // 浏览器全局变量
+      // env: globals.node, // Node.js 环境变量
+    },
+    settings: {
+      react: {
+        version: 'detect', // 自动检测 React 版本
+      },
+      jsdoc: {
+        mode: 'typescript',
+      },
+    },
+    extends: [
+      prettier, // ✅ 关闭和 Prettier 冲突的规则
+      jslint.configs.recommended, // ✅ JavaScript 规则
+      ...tseslint.configs.recommended, // ✅ TypeScript 规则
+      reactHooks.configs.flat.recommended, // ✅ React Hooks 扁平插件配置对象
+      reactRefresh.configs.vite, // ✅ React Refresh 插件注册; 扁平插件配置对象, vite 环境下需要配置
+      react.configs.flat.recommended, // ✅ React 扁平插件配置对象
+      jsdoc.configs['flat/recommended'], // ✅ JSDoc 扁平插件配置对象
+    ],
+    rules: {
+      'jsdoc/no-undefined-types': 'off', // JSDoc 里的泛型会报错
+      'jsdoc/require-returns': 'off', // 关闭 JSDoc 缺少返回值规则
+      'jsdoc/require-returns-type': 'off', // 关闭 JSDoc 缺少返回值类型规则
+      'jsdoc/require-param-type': 'off', // 关闭 JSDoc 缺少参数类型规则
+      'react/react-in-jsx-scope': 'off', // 关闭 React 17+ ，JSX 可以空标签
+      'react-hooks/exhaustive-deps': 'warn', // 不完整的依赖项
+      '@typescript-eslint/no-unused-expressions': 'off', // 关闭未使用表达式校验，开启React常用的短路规则可能误判
+      '@typescript-eslint/no-unused-vars': ['warn'], // 警告未使用变量 如遇到 与tsconfig.json 冲突，以ts为准
+    },
+  },
+]);

package/lint-staged.config.ts

@@ -0,0 +1,13 @@
+export default {
+  // tsc 不用插件只能全局检查。用函数忽略 lint-staged 传入文件，直接全量检查
+  '{src,packages,apps}/**/*.{ts,tsx,vue}': () => ['tsc --noEmit'],
+  '{src,packages,apps}/**/*.{js,jsx,ts,tsx,vue}': [
+    'eslint',
+    'oxfmt',
+  ],
+  '{src,packages,apps}/**/*.{css,scss,less,md,mdx,html,json,yml,yaml}': [
+    'oxfmt',
+  ],
+  '{src,packages,apps}/**/*.{js,jsx,ts,tsx,vue,css,scss,less,md,mdx,html,json,yml,yaml}':
+    ['cspell lint'],
+};

package/oxfmt.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "oxfmt";
+
+export default defineConfig({
+  singleQuote: true, // 单引号
+  semi: true, // 分号
+  trailingComma: "es5", // 允许对象和数组尾随逗号
+  arrowParens: "always", // 箭头函数参数是否添加括号
+  bracketSpacing: true, // 对象字面量是否添加空格
+  useTabs: false, // 是否tab缩进
+  tabWidth: 2, // 缩进空格数
+  printWidth: 80, // 行宽限制
+  sortPackageJson: true, // 是否排序package.json
+  ignorePatterns: [], // 忽略的文件模式
+});