@esportsplus/reactivity 0.1.13 → 0.1.15

package/build/signal.d.ts

@@ -1,43 +1,23 @@
-import { Changed, Event, Function, Listener, NeverAsync, Options, Scheduler, State, Type } from './types';
-declare class Core<T> {
+import { Computed, Changed, Effect, Event, Function, Listener, NeverAsync, Options, Root, Scheduler, Signal, State, Type } from './types';
+declare class Reactive<T> {
+    changed: Changed | null;
+    fn: Computed<T>['fn'] | Effect['fn'] | null;
     listeners: Record<Event, (Listener<any> | null)[]> | null;
-    observers: Core<any>[] | null;
+    observers: Reactive<any>[] | null;
     root: Root | null;
-    sources: Core<any>[] | null;
+    scheduler: Scheduler | null;
+    sources: Reactive<any>[] | null;
     state: State;
-    updating: boolean;
+    task: Function | null;
+    tracking: boolean | null;
+    type: Type;
     value: T;
-    constructor(state: State, value: T);
-    get type(): Type | never;
+    constructor(state: State, type: Type, value: T);
     dispatch<D>(event: Event, data?: D): void;
     dispose(): void;
+    get(): T;
     on<T>(event: Event, listener: Listener<T>): void;
     once<T>(event: Event, listener: Listener<T>): void;
-}
-declare class Computed<T> extends Core<T> {
-    changed: Changed;
-    fn: NeverAsync<() => T>;
-    constructor(fn: Computed<T>['fn'], options?: Options);
-    get type(): Type;
-    get(): T;
-}
-declare class Effect extends Core<null> {
-    fn: NeverAsync<(node: Effect) => void>;
-    task: Function;
-    constructor(fn: Effect['fn']);
-    get type(): Type;
-}
-declare class Root extends Core<null> {
-    scheduler: Scheduler;
-    tracking: boolean;
-    constructor(scheduler: Scheduler, tracking: boolean);
-    get type(): Type;
-}
-declare class Signal<T> extends Core<T> {
-    changed: Changed;
-    constructor(data: T, options?: Options);
-    get type(): Type;
-    get(): T;
     set(value: T): T;
 }
 declare const computed: <T>(fn: () => T extends unknown ? T : NeverAsync<T>, options?: Options) => Computed<T>;
@@ -45,7 +25,7 @@ declare const dispose: <T extends {
     dispose: VoidFunction;
 }>(dispose?: T | T[] | null | undefined) => T | T[] | null | undefined;
 declare const effect: (fn: Effect['fn']) => Effect;
-declare const root: <T>(fn: (root: Root) => T, scheduler?: Scheduler) => T;
+declare const root: <T>(fn: (root: Root) => T, scheduler?: Scheduler | null) => T;
 declare const signal: <T>(value: T, options?: Options) => Signal<T>;
 export { computed, dispose, effect, root, signal };
-export { Computed, Effect, Root, Signal };
+export { Reactive };

package/build/signal.js

@@ -1,17 +1,22 @@
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
 import { isArray } from './utilities';
 let index = 0, observer = null, observers = null, scope = null;
-class Core {
+class Reactive {
+    changed = null;
+    fn = null;
     listeners = null;
     observers = null;
     root;
+    scheduler = null;
     sources = null;
     state;
-    updating = false;
+    task = null;
+    tracking = null;
+    type;
     value;
-    constructor(state, value) {
+    constructor(state, type, value) {
         let root = null;
-        if (this.type !== ROOT) {
+        if (type !== ROOT) {
             if (scope !== null) {
                 root = scope;
             }
@@ -19,7 +24,7 @@ class Core {
                 root = observer.root;
             }
             if (root == null) {
-                if (this.type === EFFECT) {
+                if (type === EFFECT) {
                     throw new Error(`Reactivity: 'effect' cannot be created without a reactive root`);
                 }
             }
@@ -29,16 +34,14 @@ class Core {
         }
         this.root = root;
         this.state = state;
+        this.type = type;
         this.value = value;
     }
-    get type() {
-        throw new Error(`Reactivity: reactive primitives require 'type' getters`);
-    }
     dispatch(event, data) {
         if (this.listeners === null || this.listeners[event] === undefined) {
             return;
         }
-        let listeners = this.listeners[event], parameter = {
+        let listeners = this.listeners[event], values = {
             data,
             value: this.value
         };
@@ -48,7 +51,7 @@ class Core {
                 continue;
             }
             try {
-                listener(parameter);
+                listener(values);
                 if (listener.once !== undefined) {
                     listeners[i] = null;
                 }
@@ -69,9 +72,31 @@ class Core {
         this.sources = null;
         this.state = DISPOSED;
     }
+    get() {
+        if (this.state === DISPOSED) {
+            return this.value;
+        }
+        if (observer !== null) {
+            if (observers === null) {
+                if (observer.sources !== null && observer.sources[index] == this) {
+                    index++;
+                }
+                else {
+                    observers = [this];
+                }
+            }
+            else {
+                observers.push(this);
+            }
+        }
+        if (this.type === COMPUTED || this.type === EFFECT) {
+            sync(this);
+        }
+        return this.value;
+    }
     on(event, listener) {
-        if (this.updating) {
-            listener.once = true;
+        if (this.state === DIRTY) {
+            return;
         }
         if (this.listeners === null) {
             this.listeners = { [event]: [listener] };
@@ -96,61 +121,15 @@ class Core {
         listener.once = true;
         this.on(event, listener);
     }
-}
-class Computed extends Core {
-    changed;
-    fn;
-    constructor(fn, options) {
-        super(DIRTY, undefined);
-        this.changed = options?.changed || changed;
-        this.fn = fn;
-    }
-    get type() {
-        return COMPUTED;
-    }
-    get() {
-        return read(this);
-    }
-}
-class Effect extends Core {
-    fn;
-    task;
-    constructor(fn) {
-        super(DIRTY, null);
-        this.fn = fn;
-        this.task = () => read(this);
-        update(this);
-    }
-    get type() {
-        return EFFECT;
-    }
-}
-class Root extends Core {
-    scheduler;
-    tracking;
-    constructor(scheduler, tracking) {
-        super(CLEAN, null);
-        this.scheduler = scheduler;
-        this.tracking = tracking;
-    }
-    get type() {
-        return ROOT;
-    }
-}
-class Signal extends Core {
-    changed;
-    constructor(data, options) {
-        super(CLEAN, data);
-        this.changed = options?.changed || changed;
-    }
-    get type() {
-        return SIGNAL;
-    }
-    get() {
-        return read(this);
-    }
     set(value) {
-        return write(this, value);
+        if (this.type !== SIGNAL && observer !== this) {
+            throw new Error(`Reactivity: 'set' method is only available on signals`);
+        }
+        if (this.changed(this.value, value)) {
+            this.value = value;
+            notify(this.observers, DIRTY);
+        }
+        return this.value;
     }
 }
 function changed(a, b) {
@@ -171,39 +150,17 @@ function notify(nodes, state) {
         }
     }
 }
-function read(node) {
-    if (node.state === DISPOSED) {
-        return node.value;
-    }
-    if (observer !== null) {
-        if (observers === null) {
-            if (observer.sources !== null && observer.sources[index] == node) {
-                index++;
-            }
-            else {
-                observers = [node];
-            }
-        }
-        else {
-            observers.push(node);
-        }
-    }
-    if (node.type === COMPUTED || node.type === EFFECT) {
-        sync(node);
-    }
-    return node.value;
-}
 function removeSourceObservers(node, start) {
     if (node.sources === null) {
         return;
     }
     for (let i = start, n = node.sources.length; i < n; i++) {
-        let source = node.sources[i];
-        if (source.observers === null) {
+        let observers = node.sources[i].observers;
+        if (observers === null) {
             continue;
         }
-        source.observers[source.observers.indexOf(node)] = source.observers[source.observers.length - 1];
-        source.observers.pop();
+        observers[observers.indexOf(node)] = observers[observers.length - 1];
+        observers.pop();
     }
 }
 function sync(node) {
@@ -229,9 +186,7 @@ function update(node) {
     observers = null;
     try {
         node.dispatch('update');
-        node.updating = true;
         let value = node.fn.call(node);
-        node.updating = false;
         if (observers) {
             removeSourceObservers(node, index);
             if (node.sources !== null && index > 0) {
@@ -245,7 +200,7 @@ function update(node) {
             }
             for (let i = index, n = node.sources.length; i < n; i++) {
                 let source = node.sources[i];
-                if (!source.observers) {
+                if (source.observers === null) {
                     source.observers = [node];
                 }
                 else {
@@ -258,12 +213,7 @@ function update(node) {
             node.sources.length = index;
         }
         if (node.type === COMPUTED) {
-            write(node, value);
-        }
-    }
-    catch {
-        if (node.state === DIRTY) {
-            removeSourceObservers(node, 0);
+            node.set(value);
         }
     }
     finally {
@@ -273,15 +223,11 @@ function update(node) {
     }
     node.state = CLEAN;
 }
-function write(node, value) {
-    if (node.changed(node.value, value)) {
-        node.value = value;
-        notify(node.observers, DIRTY);
-    }
-    return value;
-}
 const computed = (fn, options) => {
-    return new Computed(fn, options);
+    let instance = new Reactive(DIRTY, COMPUTED, undefined);
+    instance.changed = options?.changed || changed;
+    instance.fn = fn;
+    return instance;
 };
 const dispose = (dispose) => {
     if (dispose == null) {
@@ -297,25 +243,33 @@ const dispose = (dispose) => {
     return dispose;
 };
 const effect = (fn) => {
-    return new Effect(fn);
+    let instance = new Reactive(DIRTY, EFFECT, null);
+    instance.fn = fn;
+    instance.task = () => instance.get();
+    update(instance);
+    return instance;
 };
-const root = (fn, scheduler) => {
+const root = (fn, scheduler = null) => {
     let o = observer, s = scope;
-    if (scheduler === undefined) {
+    if (scheduler === null) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
         scheduler = scope.scheduler;
     }
     observer = null;
-    scope = new Root(scheduler, fn.length > 0);
+    scope = new Reactive(CLEAN, ROOT, null);
+    scope.scheduler = scheduler;
+    scope.tracking = fn.length > 0;
     let result = fn(scope);
     observer = o;
     scope = s;
     return result;
 };
 const signal = (value, options) => {
-    return new Signal(value, options);
+    let instance = new Reactive(CLEAN, SIGNAL, value);
+    instance.changed = options?.changed || changed;
+    return instance;
 };
 export { computed, dispose, effect, root, signal };
-export { Computed, Effect, Root, Signal };
+export { Reactive };

package/build/types.d.ts

@@ -1,7 +1,18 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript';
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Computed, Effect, Root, Signal } from './signal';
+import { Reactive } from './signal';
+type Base<T> = Omit<Reactive<T>, 'changed' | 'fn' | 'get' | 'scheduler' | 'set' | 'task' | 'tracking'>;
 type Changed = (a: unknown, b: unknown) => boolean;
+type Computed<T> = {
+    changed: Changed;
+    fn: NeverAsync<() => T>;
+    get(): T;
+} & Base<T>;
+type Effect = {
+    fn: NeverAsync<(node: Effect) => void>;
+    root: Root;
+    task: Function;
+} & Omit<Base<void>, 'value'>;
 type Event = string;
 type Listener<D> = {
     once?: boolean;
@@ -14,7 +25,17 @@ type Object = Record<PropertyKey, unknown>;
 type Options = {
     changed?: Changed;
 };
+type Root = {
+    scheduler: Scheduler;
+    tracking: boolean;
+    value: void;
+} & Omit<Reactive<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;
 export type { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.13"
+    "version": "0.1.15"
 }

package/src/signal.ts

@@ -1,28 +1,33 @@
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Changed, Event, Function, Listener, NeverAsync, Options, Scheduler, State, Type } from './types';
+import { Computed, Changed, Effect, Event, Function, Listener, NeverAsync, Options, Root, Scheduler, Signal, State, Type } from './types';
 import { isArray } from './utilities';
 
 
 let index = 0,
-    observer: Core<any> | null = null,
-    observers: Core<any>[] | null = null,
+    observer: Reactive<any> | null = null,
+    observers: Reactive<any>[] | null = null,
     scope: Root | null = null;
 
 
-class Core<T> {
+class Reactive<T> {
+    changed: Changed | null = null;
+    fn: Computed<T>['fn'] | Effect['fn'] | null = null;
     listeners: Record<Event, (Listener<any> | null)[]> | null = null;
-    observers: Core<any>[] | null = null;
+    observers: Reactive<any>[] | null = null;
     root: Root | null;
-    sources: Core<any>[] | null = null;
+    scheduler: Scheduler | null = null;
+    sources: Reactive<any>[] | null = null;
     state: State;
-    updating: boolean = false;
+    task: Function | null = null;
+    tracking: boolean | null = null;
+    type: Type;
     value: T;
 
 
-    constructor(state: State, value: T) {
+    constructor(state: State, type: Type, value: T) {
         let root = null;
 
-        if (this.type !== ROOT) {
+        if (type !== ROOT) {
             if (scope !== null) {
                 root = scope;
             }
@@ -31,7 +36,7 @@ class Core<T> {
             }
 
             if (root == null) {
-                if (this.type === EFFECT) {
+                if (type === EFFECT) {
                     throw new Error(`Reactivity: 'effect' cannot be created without a reactive root`);
                 }
             }
@@ -42,22 +47,18 @@ class Core<T> {
 
         this.root = root;
         this.state = state;
+        this.type = type;
         this.value = value;
     }
 
 
-    get type(): Type | never {
-        throw new Error(`Reactivity: reactive primitives require 'type' getters`);
-    }
-
-
     dispatch<D>(event: Event, data?: D) {
         if (this.listeners === null || this.listeners[event] === undefined) {
             return;
         }
 
         let listeners = this.listeners[event],
-            parameter = {
+            values = {
                 data,
                 value: this.value
             };
@@ -70,7 +71,7 @@ class Core<T> {
             }
 
             try {
-                listener(parameter);
+                listener(values);
 
                 if (listener.once !== undefined) {
                     listeners[i] = null;
@@ -97,9 +98,36 @@ class Core<T> {
         this.state = DISPOSED;
     }
 
+    get() {
+        if (this.state === DISPOSED) {
+            return this.value;
+        }
+
+        if (observer !== null) {
+            if (observers === null) {
+                if (observer.sources !== null && observer.sources[index] == this) {
+                    index++;
+                }
+                else {
+                    observers = [this];
+                }
+            }
+            else {
+                observers.push(this);
+            }
+        }
+
+        if (this.type === COMPUTED || this.type === EFFECT) {
+            sync(this);
+        }
+
+        return this.value;
+    }
+
     on<T>(event: Event, listener: Listener<T>) {
-        if (this.updating) {
-            listener.once = true;
+        // Events cannot be set within effects or computed's
+        if (this.state === DIRTY) {
+            return;
         }
 
         if (this.listeners === null) {
@@ -128,87 +156,18 @@ class Core<T> {
         listener.once = true;
         this.on(event, listener);
     }
-}
-
-class Computed<T> extends Core<T> {
-    changed: Changed;
-    fn: NeverAsync<() => T>;
-
-
-    constructor(fn: Computed<T>['fn'], options?: Options) {
-        super(DIRTY, undefined as T);
-        this.changed = options?.changed || changed;
-        this.fn = fn;
-    }
-
-
-    get type(): Type {
-        return COMPUTED;
-    }
-
-
-    get() {
-        return read(this);
-    }
-}
-
-class Effect extends Core<null> {
-    fn: NeverAsync<(node: Effect) => void>;
-    task: Function;
-
-
-    constructor(fn: Effect['fn']) {
-        super(DIRTY, null);
-        this.fn = fn;
-        this.task = () => read(this);
-
-        update(this);
-    }
-
-
-    get type(): Type {
-        return EFFECT;
-    }
-}
-
-class Root extends Core<null> {
-    scheduler: Scheduler;
-    tracking: boolean;
-
-
-    constructor(scheduler: Scheduler, tracking: boolean) {
-        super(CLEAN, null);
-        this.scheduler = scheduler;
-        this.tracking = tracking;
-    }
-
-
-    get type(): Type {
-        return ROOT;
-    }
-}
-
-class Signal<T> extends Core<T> {
-    changed: Changed;
-
-
-    constructor(data: T, options?: Options) {
-        super(CLEAN, data);
-        this.changed = options?.changed || changed;
-    }
-
-
-    get type(): Type {
-        return SIGNAL;
-    }
 
+    set(value: T): T {
+        if (this.type !== SIGNAL && observer !== this) {
+            throw new Error(`Reactivity: 'set' method is only available on signals`);
+        }
 
-    get() {
-        return read(this);
-    }
+        if (this.changed!(this.value, value)) {
+            this.value = value;
+            notify(this.observers, DIRTY);
+        }
 
-    set(value: T): T {
-        return write(this, value);
+        return this.value;
     }
 }
 
@@ -217,7 +176,7 @@ function changed(a: unknown, b: unknown) {
     return a !== b;
 }
 
-function notify<T>(nodes: Core<T>[] | null, state: typeof CHECK | typeof DIRTY) {
+function notify<T>(nodes: Reactive<T>[] | null, state: typeof CHECK | typeof DIRTY) {
     if (nodes === null) {
         return;
     }
@@ -236,50 +195,24 @@ function notify<T>(nodes: Core<T>[] | null, state: typeof CHECK | typeof DIRTY)
     }
 }
 
-function read<T>(node: Core<T>) {
-    if (node.state === DISPOSED) {
-        return node.value;
-    }
-
-    if (observer !== null) {
-        if (observers === null) {
-            if (observer.sources !== null && observer.sources[index] == node) {
-                index++;
-            }
-            else {
-                observers = [node];
-            }
-        }
-        else {
-            observers.push(node);
-        }
-    }
-
-    if (node.type === COMPUTED || node.type === EFFECT) {
-        sync(node);
-    }
-
-    return node.value;
-}
-
-function removeSourceObservers<T>(node: Core<T>, start: number) {
+function removeSourceObservers<T>(node: Reactive<T>, start: number) {
     if (node.sources === null) {
         return;
     }
 
     for (let i = start, n = node.sources.length; i < n; i++) {
-        let source = node.sources[i];
+        let observers = node.sources[i].observers;
 
-        if (source.observers === null) {
+        if (observers === null) {
             continue;
         }
 
-        source.observers[source.observers.indexOf(node)] = source.observers[source.observers.length - 1];
-        source.observers.pop();
+        observers[observers.indexOf(node)] = observers[observers.length - 1];
+        observers.pop();
     }
 }
 
-function sync<T>(node: Core<T>) {
+function sync<T>(node: Reactive<T>) {
     if (node.state === CHECK && node.sources !== null) {
         for (let i = 0, n = node.sources.length; i < n; i++) {
             sync(node.sources[i]);
@@ -294,14 +227,14 @@ function sync<T>(node: Core<T>) {
     }
 
     if (node.state === DIRTY) {
-        update(node as Computed<T> | Effect);
+        update(node);
     }
     else {
         node.state = CLEAN;
     }
 }
 
-function update<T>(node: Computed<T> | Effect) {
+function update<T>(node: Reactive<T>) {
     let i = index,
         o = observer,
         os = observers;
@@ -312,13 +245,10 @@ function update<T>(node: Computed<T> | Effect) {
 
     try {
         node.dispatch('update');
-        node.updating = true;
 
         // @ts-ignore
         let value = node.fn.call(node);
 
-        node.updating = false;
-
         if (observers) {
             removeSourceObservers(node, index);
 
@@ -336,7 +266,7 @@ function update<T>(node: Computed<T> | Effect) {
             for (let i = index, n = node.sources.length; i < n; i++) {
                 let source = node.sources[i];
 
-                if (!source.observers) {
+                if (source.observers === null) {
                     source.observers = [node];
                 }
                 else {
@@ -350,12 +280,7 @@ function update<T>(node: Computed<T> | Effect) {
         }
 
         if (node.type === COMPUTED) {
-            write(node as Computed<T>, value as T);
-        }
-    }
-    catch {
-        if (node.state === DIRTY) {
-            removeSourceObservers(node, 0);
+            node.set(value as T);
         }
     }
     finally {
@@ -367,18 +292,14 @@ function update<T>(node: Computed<T> | Effect) {
     node.state = CLEAN;
 }
 
-function write<T>(node: Computed<T> | Signal<T>, value: T) {
-    if (node.changed(node.value, value)) {
-        node.value = value;
-        notify(node.observers, DIRTY);
-    }
 
-    return value;
-}
+const computed = <T>(fn: Computed<T>['fn'], options?: Options) => {
+    let instance = new Reactive(DIRTY, COMPUTED, undefined as T);
 
+    instance.changed = options?.changed || changed;
+    instance.fn = fn;
 
-const computed = <T>(fn: Computed<T>['fn'], options?: Options) => {
-    return new Computed(fn, options);
+    return instance as Computed<T>;
 };
 
 const dispose = <T extends { dispose: VoidFunction }>(dispose?: T[] | T | null) => {
@@ -397,14 +318,21 @@ const dispose = <T extends { dispose: VoidFunction }>(dispose?: T[] | T | null)
 };
 
 const effect = (fn: Effect['fn']) => {
-    return new Effect(fn);
+    let instance = new Reactive(DIRTY, EFFECT, null);
+
+    instance.fn = fn;
+    instance.task = () => instance.get();
+
+    update(instance);
+
+    return instance as Effect;
 };
 
-const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler?: Scheduler) => {
+const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler: Scheduler | null = null) => {
     let o = observer,
         s = scope;
 
-    if (scheduler === undefined) {
+    if (scheduler === null) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
@@ -413,7 +341,10 @@ const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler?: Scheduler) => {
     }
 
     observer = null;
-    scope = new Root(scheduler, fn.length > 0);
+
+    scope = new Reactive(CLEAN, ROOT, null) as any as Root;
+    scope.scheduler = scheduler as Scheduler;
+    scope.tracking = fn.length > 0;
 
     let result = fn(scope);
 
@@ -424,9 +355,13 @@ const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler?: Scheduler) => {
 };
 
 const signal = <T>(value: T, options?: Options) => {
-    return new Signal(value, options);
+    let instance = new Reactive(CLEAN, SIGNAL, value);
+
+    instance.changed = options?.changed || changed;
+
+    return instance as Signal<T>;
 };
 
 
 export { computed, dispose, effect, root, signal };
-export { Computed, Effect, Root, Signal };
+export { Reactive };

package/src/types.ts

@@ -1,10 +1,24 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript'
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Computed, Effect, Root, Signal } from './signal';
+import { Reactive } from './signal';
 
 
+type Base<T> = Omit<Reactive<T>, 'changed' | 'fn' | 'get' | 'scheduler' | 'set' | 'task' | 'tracking'>;
+
 type Changed = (a: unknown, b: unknown) => boolean;
 
+type Computed<T> = {
+    changed: Changed;
+    fn: NeverAsync<() => T>;
+    get(): T;
+} & Base<T>;
+
+type Effect = {
+    fn: NeverAsync<(node: Effect) => void>;
+    root: Root;
+    task: Function;
+} & Omit<Base<void>, 'value'>;
+
 type Event = string;
 
 type Listener<D> = {
@@ -19,8 +33,20 @@ type Options = {
     changed?: Changed;
 };
 
+type Root = {
+    scheduler: Scheduler;
+    tracking: boolean;
+    value: void;
+} & Omit<Reactive<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;