@esportsplus/reactivity 0.4.7 → 0.5.0

package/src/types.ts

@@ -1,82 +1,61 @@
-import { Function, NeverAsync, Prettify } from '@esportsplus/utilities'
+import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
+import { oncleanup } from './signal';
 import { ReactiveArray } from './reactive/array';
 import { ReactiveObject } from './reactive/object';
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Reactive as ReactiveBase } from './signal';
 
 
-type Base<T> = Omit<ReactiveBase<T>, 'changed' | 'fn' | 'get' | 'scheduler' | 'set' | 'task' | 'tracking'>;
-
-type Changed = (a: unknown, b: unknown) => boolean;
-
-type Computed<T> = {
-    changed: Changed;
-    fn: NeverAsync<(instance: Computed<T>) => T>;
-    get(): T;
-} & Base<T>;
-
-type Effect = {
-    fn: NeverAsync<(instance: Effect) => void>;
-    root: Root;
-    task: Function;
-} & Omit<Base<void>, 'value'>;
+interface Computed<T> extends Signal<T> {
+    [REACTIVE]: true;
+    cleanup: VoidFunction | VoidFunction[] | null;
+    deps: Link | null;
+    depsTail: Link | null;
+    fn: (oc?: typeof oncleanup) => T;
+    height: number;
+    nextHeap: Computed<unknown> | undefined;
+    prevHeap: Computed<unknown>;
+    state:
+        typeof STATE_CHECK |
+        typeof STATE_DIRTY |
+        typeof STATE_IN_HEAP |
+        typeof STATE_NONE |
+        typeof STATE_RECOMPUTING;
+}
 
 type Infer<T> =
     T extends (...args: unknown[]) => unknown
         ? ReturnType<T>
         : T extends (infer U)[]
             ? ReactiveArray<U>
-            : T extends ReactiveObject<T>
-                ? ReactiveObject<T>
+            : T extends ReactiveObject<any>
+                ? T
                 : T extends Record<PropertyKey, unknown>
                     ? { [K in keyof T]: T[K] }
                     : T;
 
-type Event = 'cleanup' | 'dispose' | 'update' | string;
-
-type Listener<D> = {
-    once?: boolean;
-
-    <V>(data: D, value: V): void;
-};
-
-type Options = {
-    changed?: Changed;
-};
+interface Link {
+    dep: Signal<unknown> | Computed<unknown>;
+    sub: Computed<unknown>;
+    nextDep: Link | null;
+    nextSub: Link | null;
+    prevSub: Link | null;
+}
 
 type Reactive<T> = T extends Record<PropertyKey, unknown>
     ? ReactiveObject<T>
     : ReactiveArray<T>;
 
-type Root = {
-    scheduler: Scheduler;
-    tracking: boolean;
-    value: void;
-} & Omit<ReactiveBase<void>, 'root'>;
-
-type Scheduler = (fn: Function) => unknown;
-
 type Signal<T> = {
-    changed: Changed;
-    get(): T;
-    set(value: T): T;
-} & Base<T>;
-
-type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
-
-type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
+    [REACTIVE]: true;
+    subs: Link | null;
+    subsTail: Link | null;
+    value: T;
+};
 
 
 export type {
-    Changed, Computed,
-    Effect, Event,
-    Function,
+    Computed,
     Infer,
-    Listener,
-    NeverAsync,
-    Options,
-    Prettify,
-    Reactive, ReactiveArray, ReactiveObject, Root,
-    Scheduler, Signal, State,
-    Type
+    Link,
+    Signal,
+    Reactive, ReactiveArray, ReactiveObject
 };

package/build/macro.d.ts

@@ -1,9 +0,0 @@
-import CustomFunction from '@esportsplus/custom-function';
-import { Options } from './types.js';
-declare class Macro<A extends unknown[], R> extends CustomFunction {
-    private factory;
-    constructor(fn: Macro<A, R>['factory']['fn'], options?: Options);
-    dispose(): void;
-}
-declare const _default: <A extends unknown[], R>(fn: Macro<A, R>["factory"]["fn"], options?: Options) => Macro<A, R>;
-export default _default;

package/build/macro.js

@@ -1,17 +0,0 @@
-import CustomFunction from '@esportsplus/custom-function';
-import { computed } from './signal.js';
-class Macro extends CustomFunction {
-    factory;
-    constructor(fn, options = {}) {
-        super((...args) => {
-            return this.factory.get()(...args);
-        });
-        this.factory = computed(fn, options);
-    }
-    dispose() {
-        this.factory.dispose();
-    }
-}
-export default (fn, options = {}) => {
-    return new Macro(fn, options);
-};

package/src/macro.ts

@@ -1,26 +0,0 @@
-import CustomFunction from '@esportsplus/custom-function';
-import { computed } from './signal';
-import { Computed, Options } from './types';
-
-
-class Macro<A extends unknown[], R> extends CustomFunction {
-    private factory: Computed<(...args: A) => R>;
-
-
-    constructor(fn: Macro<A,R>['factory']['fn'], options: Options = {}) {
-        super((...args: A) => {
-            return this.factory.get()(...args);
-        });
-        this.factory = computed(fn, options);
-    }
-
-
-    dispose() {
-        this.factory.dispose();
-    }
-}
-
-
-export default <A extends unknown[], R>(fn: Macro<A,R>['factory']['fn'], options: Options = {}) => {
-    return new Macro(fn, options);
-};