@dxyl/utils 1.3.0 → 1.3.2

package/types/PluginService.d.ts

@@ -1,17 +1,21 @@
-export type PluginObject = {};
 export type PluginServiceOPtions = {
     plugins?: IPlugin[];
     presets?: IPreset[];
 };
-export type PluginContext = {
+export type PluginContext<Ctx = any, HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
     pluginName: string;
-    register(hook: IHook): void;
-    registerMethod(name: string, fn?: IMethod): void;
+    ctx: Ctx;
+    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> & PluginService<Ctx, HookList, 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 = {
+export type IPlugin<Ctx = any, HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
     name: string;
     config?: any;
-    apply: (api: PluginContext, config?: any) => void;
+    apply: (api: PluginContext<Ctx, HookList, HookMethods>, config?: any) => void;
+    dispose?: (api: PluginContext<Ctx, HookList, HookMethods>) => void;
 };
 export type IPreset = Omit<IPlugin, 'apply'> & {
     apply: (api: PluginContext, config?: any) => ({
@@ -19,10 +23,10 @@ export type IPreset = Omit<IPlugin, 'apply'> & {
         plugins?: IPlugin[];
     });
 };
-export type IHook = {
-    name: string;
+export type IHook<T = any, F = any> = {
+    name: T;
     order?: number;
-    fn: Function;
+    fn: (...args: any[]) => F;
 };
 export declare enum HookType {
     create = "create",
@@ -30,32 +34,36 @@ export declare enum HookType {
     modify = "modify",
     event = "event"
 }
-export type HookOpts = {
-    name: string;
+export type HookOpts<T> = {
+    name: T;
     type?: HookType;
     initalValue?: any;
     args?: any;
     sync?: boolean;
 };
-export type IMethod = (...args: any[]) => void;
-export declare class PluginService {
+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<Ctx, HookList extends HookListType, HookMethods extends Record<string, IMethod> = any> {
     config?: PluginServiceOPtions;
     private hooks;
     private methods;
     private plugins;
     private extraPresets;
     private extraPlugins;
-    constructor(config?: PluginServiceOPtions);
+    context: Ctx;
+    constructor(context: Ctx, config?: PluginServiceOPtions);
     initPresetsAndPlugins(config: PluginServiceOPtions): void;
     private resolvePresets;
     private resolvePlugins;
-    private applyMethods;
-    private initPluginContext;
+    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 getPluginContext;
     private initPreset;
     private initPlugin;
     registerPlugin(plugin: IPlugin | IPreset): void;
     register(hook: IHook): void;
-    registerMethod(name: string, fn?: IMethod): void;
-    applyPlugins<T = any>(opts: HookOpts): Promise<T | void>;
-    destroy(): 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>;
+    uninstallPlugin(plugin: IPlugin | IPreset): void;
+    dispose(): 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/data/alien-signals/index.d.ts

@@ -0,0 +1,22 @@
+import { ReactiveNode } from './system';
+export declare function getActiveSub(): ReactiveNode | undefined;
+export declare function setActiveSub(sub?: ReactiveNode): ReactiveNode;
+export declare function getBatchDepth(): number;
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare function isSignal(fn: () => void): boolean;
+export declare function isComputed(fn: () => void): boolean;
+export declare function isEffect(fn: () => void): boolean;
+export declare function isEffectScope(fn: () => void): boolean;
+export declare function signal<T>(): {
+    (): T | undefined;
+    (value: T | undefined): void;
+};
+export declare function signal<T>(initialValue: T): {
+    (): T;
+    (value: T): void;
+};
+export declare function computed<T>(getter: (previousValue?: T) => T): () => T;
+export declare function effect(fn: () => void): () => void;
+export declare function effectScope(fn: () => void): () => void;
+export declare function trigger(fn: () => void): void;

package/types/data/alien-signals/system.d.ts

@@ -0,0 +1,36 @@
+export interface ReactiveNode {
+    deps?: Link;
+    depsTail?: Link;
+    subs?: Link;
+    subsTail?: Link;
+    flags: ReactiveFlags;
+}
+export interface Link {
+    version: number;
+    dep: ReactiveNode;
+    sub: ReactiveNode;
+    prevSub: Link | undefined;
+    nextSub: Link | undefined;
+    prevDep: Link | undefined;
+    nextDep: Link | undefined;
+}
+export declare const enum ReactiveFlags {
+    None = 0,
+    Mutable = 1,
+    Watching = 2,
+    RecursedCheck = 4,
+    Recursed = 8,
+    Dirty = 16,
+    Pending = 32
+}
+export declare function createReactiveSystem({ update, notify, unwatched, }: {
+    update(sub: ReactiveNode): boolean;
+    notify(sub: ReactiveNode): void;
+    unwatched(sub: ReactiveNode): void;
+}): {
+    link: (dep: ReactiveNode, sub: ReactiveNode, version: number) => void;
+    unlink: (link: Link, sub?: ReactiveNode) => Link | undefined;
+    propagate: (link: Link) => void;
+    checkDirty: (link: Link, sub: ReactiveNode) => boolean;
+    shallowPropagate: (link: Link) => void;
+};