@dxyl/utils 1.2.2 → 1.3.1

package/types/PluginService.d.ts

@@ -0,0 +1,65 @@
+export type PluginServiceOPtions = {
+    plugins?: IPlugin[];
+    presets?: IPreset[];
+};
+export type PluginContext<HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
+    pluginName: string;
+    register<K extends keyof HookList>(hook: IHook<K, HookList[K]>): void;
+    registerMethod<K extends keyof HookMethods>(name: K, fn?: IMethod<Parameters<HookMethods[K]>, ReturnType<HookMethods[K]>>): void;
+} & PluginMethods<HookMethods>;
+export type PluginMethods<HookMethods extends Record<string, IMethod> = any> = {
+    [k in Exclude<keyof HookMethods, 'pluginName' | 'register' | 'registerMethod'>]: IMethod<Parameters<HookMethods[k]>, ReturnType<HookMethods[k]>>;
+};
+export type IPlugin<HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
+    name: string;
+    config?: any;
+    apply: (api: PluginContext<HookList, HookMethods>, config?: any) => void;
+};
+export type IPreset = Omit<IPlugin, 'apply'> & {
+    apply: (api: PluginContext, config?: any) => ({
+        presets?: IPreset[];
+        plugins?: IPlugin[];
+    });
+};
+export type IHook<T = any, F = any> = {
+    name: T;
+    order?: number;
+    fn: (...args: any[]) => F;
+};
+export declare enum HookType {
+    create = "create",
+    add = "add",
+    modify = "modify",
+    event = "event"
+}
+export type HookOpts<T> = {
+    name: T;
+    type?: HookType;
+    initalValue?: any;
+    args?: any;
+    sync?: boolean;
+};
+export type IMethod<T extends any = any, R = any> = (...args: T extends Array<any> ? T : [T]) => R;
+export type HookListType = Record<string, any>;
+export declare class PluginService<HookList extends HookListType, HookMethods extends Record<string, IMethod> = any> {
+    config?: PluginServiceOPtions;
+    private hooks;
+    private methods;
+    private plugins;
+    private extraPresets;
+    private extraPlugins;
+    constructor(config?: PluginServiceOPtions);
+    initPresetsAndPlugins(config: PluginServiceOPtions): void;
+    private resolvePresets;
+    private resolvePlugins;
+    private getApplyMethods;
+    applyMethods<K extends Extract<keyof HookMethods, string>>(name: K, ...args: Parameters<HookMethods[K]> extends Array<any> ? Parameters<HookMethods[K]> : [Parameters<HookMethods[K]>]): ReturnType<HookMethods[K]>;
+    private initPluginContext;
+    private initPreset;
+    private initPlugin;
+    registerPlugin(plugin: IPlugin | IPreset): void;
+    register(hook: IHook): void;
+    registerMethod<K>(name: string, fn?: IMethod): void;
+    applyPlugins<K extends Extract<keyof HookList, string> = Extract<keyof HookList, string>, T = HookList[K]>(inOpts: HookOpts<K> | K): Promise<Exclude<T, void> extends never ? void : T>;
+    destroy(): void;
+}

package/types/Pool.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 对象池配置选项
+ */
+interface PoolOptions<T> {
+    /** 池子最大容量 */
+    maxSize?: number;
+    /** 对象创建函数 */
+    create: () => T;
+    /** 对象重置清理函数 */
+    reset?: (obj: T) => void;
+    /** 对象验证函数（返回对象是否可用） */
+    validate?: (obj: T) => boolean;
+    /** 池子初始化时预创建的对象数量 */
+    preAllocate?: number;
+}
+/**
+ * 通用对象池类
+ * 用于管理对象的重用，减少垃圾回收压力
+ */
+export declare class Pool<T> {
+    private available;
+    private inUse;
+    private maxSize;
+    private create;
+    private reset?;
+    private validate?;
+    private totalCreated;
+    constructor(options: PoolOptions<T>);
+    /**
+     * 从池中获取一个对象
+     * @returns 可用的对象
+     */
+    acquire(): T;
+    /**
+     * 释放对象回池中
+     * @param obj 要释放的对象
+     */
+    release(obj: T): void;
+    /**
+     * 批量释放多个对象
+     * @param objects 要释放的对象数组
+     */
+    releaseAll(objects: T[]): void;
+    /**
+     * 获取池子统计信息
+     */
+    getStats(): {
+        available: number;
+        inUse: number;
+        totalCreated: number;
+        maxSize: number;
+    };
+    /**
+     * 清空池子并释放所有资源
+     */
+    dispose(): void;
+    /**
+     * 获取当前可用的对象数量
+     */
+    get availableCount(): number;
+    /**
+     * 获取当前正在使用的对象数量
+     */
+    get inUseCount(): number;
+    /**
+     * 检查对象是否正在被使用
+     */
+    isInUse(obj: T): boolean;
+}
+/**
+ * 自动释放的包装器，使用 RAII 模式
+ */
+declare class AutoRelease<T> {
+    private pool;
+    private obj;
+    constructor(pool: Pool<T>, obj: T);
+    get value(): T;
+    release(): void;
+    [Symbol.dispose](): void;
+}
+/**
+ * 扩展的 Pool 类，支持自动释放
+ */
+export declare class AutoPool<T> extends Pool<T> {
+    /**
+     * 获取对象并返回自动释放包装器
+     */
+    autoAcquire(): AutoRelease<T>;
+}
+export {};

package/types/StackCursor.d.ts

@@ -0,0 +1,6 @@
+export type StackCursor<T> = {
+    current: T;
+};
+export declare const createCursor: <T>(defaultValue: T) => StackCursor<T>;
+export declare const push: <T>(cursor: StackCursor<T>, value: T) => void;
+export declare const pop: <T>(cursor: StackCursor<T>) => void;

package/types/Transaction.d.ts

@@ -0,0 +1,25 @@
+type TransactionWrapper = {
+    initialize: () => void;
+    close: (initData: any) => void;
+};
+/**
+         * 以AOP模式执行，在前置函数与后置函数中间执行
+         * 给目标函数添加一系列的前置和后置函数，对目标函数进行功能增强或者代码环境保护。
+         * **/
+export declare abstract class Transaction {
+    transactionWrappers: TransactionWrapper[];
+    wrapperInitData: any[];
+    constructor();
+    /**
+    *@desc 事件包装，事务都创建前置initialize函数和后置close函数
+     @abstract
+    **/
+    abstract getTransactionWrappers(): TransactionWrapper[];
+    _isInTransaction: boolean;
+    isInTransaction(): boolean;
+    reinitializeTransaction(): void;
+    perform(method: Function, scope: any, a?: any, b?: any, c?: any, d?: any, e?: any, f?: any): any;
+    initializeAll(startIndex: number): void;
+    closeAll(startIndex: number): void;
+}
+export {};

package/types/antv-util/matrix/index.d.ts

@@ -3,7 +3,7 @@
  * @param m
  * @param actions
  */
-export declare function transform(m: number[], actions: any[][]): number[];
+export declare function transform(m: number[], actions: any[][]): any[];
 /**
  * 向量 v1 到 向量 v2 夹角的方向
  * @param  {Array} v1 向量

package/types/antv-util/path/parser/params-parser.d.ts

@@ -5,6 +5,6 @@ export declare const paramsParser: {
     y2: number;
     x: number;
     y: number;
-    qx: null;
-    qy: null;
+    qx: any;
+    qy: any;
 };