@esportsplus/reactivity 0.1.15 → 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] };
@@ -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) {
@@ -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

@@ -5,11 +5,11 @@ type Base<T> = Omit<Reactive<T>, 'changed' | 'fn' | 'get' | 'scheduler' | 'set'
 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'>;

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.15"
+    "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;
@@ -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);
@@ -328,11 +333,11 @@ const effect = (fn: Effect['fn']) => {
     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;

package/src/types.ts

@@ -9,12 +9,12 @@ 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'>;