@esportsplus/reactivity 0.1.14 → 0.1.17

package/build/macro.d.ts

@@ -6,5 +6,5 @@ declare class Macro<A extends unknown[], R> extends CustomFunction {
     constructor(fn: Function<A, R>, options?: Options);
     dispose(): void;
 }
-declare const _default: <A extends unknown[], R>(fn: () => (...args: A) => R, options?: Options) => Macro<A, R>;
+declare const _default: <A extends unknown[], R>(fn: (instance: Computed<(...args: A) => R>) => (...args: A) => R, options?: Options) => Macro<A, R>;
 export default _default;

package/build/reactive/object.d.ts

@@ -1,6 +1,6 @@
 import { Computed, Object, Options, Signal } from '../types';
 import { ReactiveArray, ReactiveObjectArray } from './array';
-type Node = Computed<unknown> | ReactiveArray<unknown> | ReactiveObjectArray<Object> | Signal<unknown>;
+type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
 declare class ReactiveObject<T extends Object> {
     nodes: Record<PropertyKey, Node>;
     constructor(data: T, options?: Options);

package/build/signal.d.ts

@@ -20,12 +20,12 @@ declare class Reactive<T> {
     once<T>(event: Event, listener: Listener<T>): void;
     set(value: T): T;
 }
-declare const computed: <T>(fn: () => T extends unknown ? T : NeverAsync<T>, options?: Options) => Computed<T>;
+declare const computed: <T>(fn: (instance: Computed<T>) => T, options?: Options) => Computed<T>;
 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 | null) => T;
+declare const root: <T>(fn: (instance: Root) => T, scheduler?: Scheduler) => T;
 declare const signal: <T>(value: T, options?: Options) => Signal<T>;
 export { computed, dispose, effect, root, signal };
 export { Reactive };

package/build/signal.js

@@ -65,6 +65,7 @@ class Reactive {
         if (this.state === DISPOSED) {
             return;
         }
+        this.dispatch('cleanup', this);
         this.dispatch('dispose', this);
         removeSourceObservers(this, 0);
         this.listeners = null;
@@ -96,7 +97,10 @@ class Reactive {
     }
     on(event, listener) {
         if (this.state === DIRTY) {
-            return;
+            if (event !== 'cleanup') {
+                throw new Error(`Reactivity: events set within computed or effects must use the 'cleanup' event name`);
+            }
+            listener.once = true;
         }
         if (this.listeners === null) {
             this.listeners = { [event]: [listener] };
@@ -155,12 +159,12 @@ function removeSourceObservers(node, start) {
         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) {
@@ -185,8 +189,9 @@ function update(node) {
     observer = node;
     observers = null;
     try {
+        node.dispatch('cleanup');
         node.dispatch('update');
-        let value = node.fn.call(node);
+        let value = node.fn.call(null, node);
         if (observers) {
             removeSourceObservers(node, index);
             if (node.sources !== null && index > 0) {
@@ -200,7 +205,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 {
@@ -249,9 +254,9 @@ const effect = (fn) => {
     update(instance);
     return instance;
 };
-const root = (fn, scheduler = null) => {
+const root = (fn, scheduler) => {
     let o = observer, s = scope;
-    if (scheduler === null) {
+    if (scheduler === undefined) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
@@ -261,7 +266,7 @@ const root = (fn, scheduler = null) => {
     scope = new Reactive(CLEAN, ROOT, null);
     scope.scheduler = scheduler;
     scope.tracking = fn.length > 0;
-    let result = fn(scope);
+    let result = fn.call(null, scope);
     observer = o;
     scope = s;
     return result;

package/build/types.d.ts

@@ -1,14 +1,15 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript';
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
 import { Reactive } from './signal';
-type Base<T> = Omit<Reactive<T>, 'changed' | 'fn' | 'scheduler' | 'task' | 'tracking'>;
+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>;
+    fn: NeverAsync<(instance: Computed<T>) => T>;
+    get(): T;
 } & Base<T>;
 type Effect = {
-    fn: NeverAsync<(node: Effect) => void>;
+    fn: NeverAsync<(instance: Effect) => void>;
     root: Root;
     task: Function;
 } & Omit<Base<void>, 'value'>;
@@ -28,10 +29,12 @@ type Root = {
     scheduler: Scheduler;
     tracking: boolean;
     value: void;
-} & Omit<Reactive<void>, 'changed' | 'fn' | 'root' | 'task'>;
+} & 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;

package/package.json

@@ -4,7 +4,7 @@
         "@esportsplus/custom-function": "^0.0.1"
     },
     "devDependencies": {
-        "@esportsplus/typescript": "^0.0.13"
+        "@esportsplus/typescript": "^0.0.15"
     },
     "main": "build/index.js",
     "name": "@esportsplus/reactivity",
@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.14"
+    "version": "0.1.17"
 }

package/src/reactive/object.ts

@@ -4,7 +4,7 @@ import { defineProperty, isArray } from '~/utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 
 
-type Node = Computed<unknown> | ReactiveArray<unknown> | ReactiveObjectArray<Object> | Signal<unknown>;
+type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
 
 
 class ReactiveObject<T extends Object> {

package/src/signal.ts

@@ -88,6 +88,7 @@ class Reactive<T> {
             return;
         }
 
+        this.dispatch('cleanup', this);
         this.dispatch('dispose', this);
 
         removeSourceObservers(this, 0);
@@ -125,9 +126,12 @@ class Reactive<T> {
     }
 
     on<T>(event: Event, listener: Listener<T>) {
-        // Events cannot be set within effects or computed's
         if (this.state === DIRTY) {
-            return;
+            if (event !== 'cleanup') {
+                throw new Error(`Reactivity: events set within computed or effects must use the 'cleanup' event name`);
+            }
+
+            listener.once = true;
         }
 
         if (this.listeners === null) {
@@ -186,7 +190,7 @@ function notify<T>(nodes: Reactive<T>[] | null, state: typeof CHECK | typeof DIR
 
         if (node.state < state) {
             if (node.type === EFFECT && node.state === CLEAN) {
-                node.root!.scheduler((node as any as Effect).task);
+                (node as Effect).root.scheduler((node as Effect).task);
             }
 
             node.state = state;
@@ -201,14 +205,14 @@ function removeSourceObservers<T>(node: Reactive<T>, start: number) {
     }
 
     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();
     }
 }
 
@@ -244,10 +248,11 @@ function update<T>(node: Reactive<T>) {
     observers = null as typeof observers;
 
     try {
+        node.dispatch('cleanup');
         node.dispatch('update');
 
         // @ts-ignore
-        let value = node.fn.call(node);
+        let value = node.fn.call(null, node);
 
         if (observers) {
             removeSourceObservers(node, index);
@@ -266,7 +271,7 @@ function update<T>(node: Reactive<T>) {
             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 {
@@ -294,12 +299,12 @@ function update<T>(node: Reactive<T>) {
 
 
 const computed = <T>(fn: Computed<T>['fn'], options?: Options) => {
-    let instance = new Reactive(DIRTY, COMPUTED, undefined as T) as any as Computed<T>;
+    let instance = new Reactive(DIRTY, COMPUTED, undefined as T);
 
     instance.changed = options?.changed || changed;
     instance.fn = fn;
 
-    return instance;
+    return instance as Computed<T>;
 };
 
 const dispose = <T extends { dispose: VoidFunction }>(dispose?: T[] | T | null) => {
@@ -318,21 +323,21 @@ const dispose = <T extends { dispose: VoidFunction }>(dispose?: T[] | T | null)
 };
 
 const effect = (fn: Effect['fn']) => {
-    let instance = new Reactive(DIRTY, EFFECT, null) as any as Effect;
+    let instance = new Reactive(DIRTY, EFFECT, null);
 
     instance.fn = fn;
     instance.task = () => instance.get();
 
-    update(instance as any as Reactive<void>);
+    update(instance);
 
-    return instance;
+    return instance as Effect;
 };
 
-const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler: Scheduler | null = null) => {
+const root = <T>(fn: NeverAsync<(instance: Root) => T>, scheduler?: Scheduler) => {
     let o = observer,
         s = scope;
 
-    if (scheduler === null) {
+    if (scheduler === undefined) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
@@ -343,10 +348,10 @@ const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler: Scheduler | null
     observer = null;
 
     scope = new Reactive(CLEAN, ROOT, null) as any as Root;
-    scope.scheduler = scheduler as Scheduler;
+    scope.scheduler = scheduler;
     scope.tracking = fn.length > 0;
 
-    let result = fn(scope);
+    let result = fn.call(null, scope);
 
     observer = o;
     scope = s;
@@ -355,11 +360,11 @@ const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler: Scheduler | null
 };
 
 const signal = <T>(value: T, options?: Options) => {
-    let instance = new Reactive(CLEAN, SIGNAL, value) as any as Signal<T>;
+    let instance = new Reactive(CLEAN, SIGNAL, value);
 
     instance.changed = options?.changed || changed;
 
-    return instance;
+    return instance as Signal<T>;
 };
 
 

package/src/types.ts

@@ -3,17 +3,18 @@ import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from '.
 import { Reactive } from './signal';
 
 
-type Base<T> = Omit<Reactive<T>, 'changed' | 'fn' | 'scheduler' | 'task' | 'tracking'>;
+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>;
+    fn: NeverAsync<(instance: Computed<T>) => T>;
+    get(): T;
 } & Base<T>;
 
 type Effect = {
-    fn: NeverAsync<(node: Effect) => void>;
+    fn: NeverAsync<(instance: Effect) => void>;
     root: Root;
     task: Function;
 } & Omit<Base<void>, 'value'>;
@@ -36,12 +37,14 @@ type Root = {
     scheduler: Scheduler;
     tracking: boolean;
     value: void;
-} & Omit<Reactive<void>, 'changed' | 'fn' | 'root' | 'task'>;
+} & 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;