@dxyl/utils 1.3.1 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxyl/utils",
-  "version": "1.3.1",
+  "version": "1.3.4",
   "description": "Collected many useful mathematical tools",
   "publishConfig": {
     "access": "public"

package/types/Disposable.d.ts

@@ -1,19 +1,23 @@
-export interface IDisposable {
+interface IDispose {
+    dispose: () => void;
+}
+export interface IDisposable extends IDispose {
     isDisposed(): boolean;
-    dispose(): void;
     disposeLater(): void;
 }
-type DPRegisterOptions = {
-    dispose?: () => void;
+type DPRegisterOptions<T> = {
+    dispose?: (obj: T) => void;
 };
-export declare const addDisposable: (target: IDisposable) => void;
+export declare const addDisposable: (target: IDispose) => void;
 export declare class DisposableManager {
-    static add: (target: IDisposable) => void;
-    static mixin(target: any, options?: DPRegisterOptions): void;
+    static add: (target: IDispose) => void;
+    static mixin<T>(target: {
+        new (...args: any[]): T;
+    }, options?: DPRegisterOptions<T>): void;
     private disposables;
     private persistentDisposables;
-    add(disposable: IDisposable): void;
-    addPersistent(disposable: IDisposable): void;
+    add(disposable: IDispose): void;
+    addPersistent(disposable: IDispose): void;
     destroy(): void;
     dispose(): void;
     run(fn: () => void): void;

package/types/PluginService.d.ts

@@ -2,18 +2,20 @@ export type PluginServiceOPtions = {
     plugins?: IPlugin[];
     presets?: IPreset[];
 };
-export type PluginContext<HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
+export type PluginContext<Ctx = any, HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
     pluginName: string;
+    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>;
+} & 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<HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
+export type IPlugin<Ctx = any, HookList extends HookListType = any, HookMethods extends Record<string, IMethod> = any> = {
     name: string;
     config?: any;
-    apply: (api: PluginContext<HookList, HookMethods>, 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) => ({
@@ -41,25 +43,27 @@ export type HookOpts<T> = {
 };
 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> {
+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 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 getPluginContext;
     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;
+    uninstallPlugin(plugin: IPlugin | IPreset): void;
+    dispose(): void;
 }

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

package/types/data/signals.d.ts

@@ -1,8 +1,3 @@
-/**
- * @desc 信息
- * @ref preact-signals
-
-*/
 declare const BRAND_SYMBOL: unique symbol;
 type Node = {
     _source: Signal;
@@ -51,14 +46,19 @@ declare class Signal<T = any> {
     _node?: Node;
     /** @internal */
     _targets?: Node;
-    constructor(value?: T);
+    constructor(value?: T, options?: SignalOptions<T>);
     /** @internal */
     _refresh(): boolean;
     /** @internal */
     _subscribe(node: Node): void;
     /** @internal */
     _unsubscribe(node: Node): void;
+    /** @internal */
+    _watched?(this: Signal<T>): void;
+    /** @internal */
+    _unwatched?(this: Signal<T>): void;
     subscribe(fn: (value: T) => void): () => void;
+    name?: string;
     valueOf(): T;
     toString(): string;
     toJSON(): T;
@@ -67,26 +67,35 @@ declare class Signal<T = any> {
     get value(): T;
     set value(value: T);
 }
+export interface SignalOptions<T = any> {
+    watched?: (this: Signal<T>) => void;
+    unwatched?: (this: Signal<T>) => void;
+    name?: string;
+}
 /** @internal */
-declare function Signal(this: Signal, value?: unknown): void;
+declare function Signal(this: Signal, value?: unknown, options?: SignalOptions): void;
 /**
  * Create a new plain signal.
  *
  * @param value The initial value for the signal.
  * @returns A new signal.
  */
-export declare function signal<T>(value: T): Signal<T>;
+export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
 export declare function signal<T = undefined>(): Signal<T | undefined>;
+/**
+ * The base class for computed signals.
+ */
 declare class Computed<T = any> extends Signal<T> {
     _fn: () => T;
     _sources?: Node;
     _globalVersion: number;
     _flags: number;
-    constructor(fn: () => T);
+    constructor(fn: () => T, options?: SignalOptions<T>);
     _notify(): void;
     get value(): T;
 }
-declare function Computed(this: Computed, fn: () => unknown): void;
+/** @internal */
+declare function Computed(this: Computed, fn: () => unknown, options?: SignalOptions): void;
 declare namespace Computed {
     var prototype: Computed<any>;
 }
@@ -111,21 +120,32 @@ interface ReadonlySignal<T = any> {
  * @param fn The effect callback.
  * @returns A new read-only signal.
  */
-declare function computed<T>(fn: () => T): ReadonlySignal<T>;
-type EffectFn = () => void | (() => void);
+declare function computed<T>(fn: () => T, options?: SignalOptions<T>): ReadonlySignal<T>;
+type EffectFn = ((this: {
+    dispose: () => void;
+}) => void | (() => void)) | (() => void | (() => void));
+/**
+ * The base class for reactive effects.
+ */
 declare class Effect {
     _fn?: EffectFn;
     _cleanup?: () => void;
     _sources?: Node;
     _nextBatchedEffect?: Effect;
     _flags: number;
-    constructor(fn: EffectFn);
+    name?: string;
+    constructor(fn: EffectFn, options?: EffectOptions);
     _callback(): void;
     _start(): () => void;
     _notify(): void;
     _dispose(): void;
+    dispose(): void;
 }
-declare function Effect(this: Effect, fn: EffectFn): void;
+export interface EffectOptions {
+    name?: string;
+}
+/** @internal */
+declare function Effect(this: Effect, fn: EffectFn, options?: EffectOptions): void;
 /**
  * Create an effect to run arbitrary code in response to signal changes.
  *
@@ -139,6 +159,5 @@ declare function Effect(this: Effect, fn: EffectFn): void;
  * @param fn The effect callback.
  * @returns A function for disposing the effect.
  */
-declare function effect(fn: EffectFn): () => void;
-export { computed, effect, batch, untracked, Signal };
-export type { ReadonlySignal };
+declare function effect(fn: EffectFn, options?: EffectOptions): () => void;
+export { computed, effect, batch, untracked, Signal, ReadonlySignal, Effect, Computed, };

package/types/index.d.ts

@@ -19,6 +19,7 @@ export * as reactivity from './data/reactivity';
 export * as signals from './data/signals';
 export * as redux from './data/redux';
 export * as mobx from './data/mobx';
+export * as alienSignals from './data/alien-signals';
 export * as tapable from './tapable';
 export { Options } from './Options';
 export { default as compose } from './compose';