@esportsplus/reactivity 0.0.11 → 0.0.12

package/build/methods/reactive.js

@@ -1,29 +1,50 @@
 import Reactive from '../reactive';
+function factory(value) {
+    if (typeof value === 'function') {
+        return fn(value);
+    }
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        return obj(value);
+    }
+    return new Reactive(value);
+}
+function fn(value) {
+    let fn = new Reactive(value);
+    return (...args) => {
+        let value = fn.get();
+        if (args.length && typeof value === 'function') {
+            value = value(...args);
+        }
+        return value;
+    };
+}
 function obj(values) {
     let lazy = {}, properties = {};
     for (let key in values) {
         properties[key] = {
             get() {
                 if (!lazy[key]) {
-                    lazy[key] = reactive(values[key]);
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof Reactive) {
+                    return lazy[key].get();
                 }
-                return lazy[key].get();
+                return lazy[key];
             },
             set(value) {
                 if (!lazy[key]) {
-                    lazy[key] = reactive(values[key]);
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof Reactive) {
+                    lazy[key].set(value);
+                }
+                else {
+                    lazy[key] = factory(value);
                 }
-                lazy[key].set(value);
             }
         };
     }
     return Object.defineProperties({}, properties);
 }
 ;
-function reactive(value) {
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        return obj(value);
-    }
-    return new Reactive(value);
-}
-export default (value) => reactive(value);
+export default (value) => factory(value);

package/build/reactive.d.ts

@@ -1,17 +1,15 @@
-import { Scheduler } from './types';
-type Fn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
+import { ReactiveFn, Scheduler, State } from './types';
 declare class Reactive<T> {
-    private effect;
     private fn?;
-    private observers;
-    private sources;
-    private state;
     private value;
+    effect: boolean;
     cleanup: ((old: T) => void)[] | null;
-    constructor(data: Fn<T> | T, effect?: boolean);
+    observers: Reactive<any>[] | null;
+    sources: Reactive<any>[] | null;
+    state: State;
+    constructor(data: ReactiveFn<T> | T, effect?: boolean);
     get(): T extends (...args: any[]) => any ? ReturnType<T> : T;
     set(value: T): void;
-    private mark;
     private removeParentObservers;
     private sync;
     private update;

package/build/reactive.js

@@ -1,19 +1,43 @@
 import { CLEAN, CHECK, DIRTY } from './symbols';
-let index = 0, reaction = null, queue = [], schedulers = new Set, stack = null;
+let index = 0, reaction = null, queue = [], scheduled = false, schedulers = new Set, stack = null;
+function mark(instances, state) {
+    if (!instances) {
+        return;
+    }
+    for (let i = 0, n = instances.length; i < n; i++) {
+        let instance = instances[i];
+        if (instance.state < state) {
+            if (instance.effect && instance.state === CLEAN) {
+                queue.push(instance);
+                if (!scheduled) {
+                    for (let scheduler of schedulers) {
+                        scheduler.schedule();
+                    }
+                    scheduled = true;
+                }
+            }
+            instance.state = state;
+            if (instance.observers) {
+                mark(instance.observers, CHECK);
+            }
+        }
+    }
+}
 async function task() {
     for (let i = 0, n = queue.length; i < n; i++) {
         await queue[i].get();
     }
     queue.length = 0;
+    scheduled = false;
 }
 class Reactive {
-    effect;
     fn;
+    value;
+    effect;
+    cleanup = null;
     observers = null;
     sources = null;
     state;
-    value;
-    cleanup = null;
     constructor(data, effect = false) {
         this.effect = effect;
         if (typeof data === 'function') {
@@ -49,30 +73,11 @@ class Reactive {
         return this.value;
     }
     set(value) {
-        if (this.observers && this.value !== value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].mark(DIRTY);
-            }
+        if (this.value !== value) {
+            mark(this.observers, DIRTY);
         }
         this.value = value;
     }
-    mark(state) {
-        if (this.state < state) {
-            if (this.effect && this.state === CLEAN) {
-                queue.push(this);
-                for (let scheduler of schedulers) {
-                    scheduler.schedule();
-                }
-            }
-            this.state = state;
-            if (!this.observers) {
-                return;
-            }
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].mark(CHECK);
-            }
-        }
-    }
     removeParentObservers() {
         if (!this.sources) {
             return;

package/build/types.d.ts

@@ -6,6 +6,7 @@ type Primitives = any[] | boolean | number | string | null | undefined | ((...ar
 type InferNested<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<string, Primitives> ? {
     [K in keyof T]: InferNested<T[K]>;
 } : T;
+type ReactiveFn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
 type Scheduler = {
     schedule(): void;
     tasks: {
@@ -14,4 +15,4 @@ type Scheduler = {
     };
 };
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
-export { Infer, Scheduler, State };
+export { Infer, ReactiveFn, Scheduler, State };

package/package.json

@@ -15,5 +15,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.11"
+    "version": "0.0.12"
 }

package/src/methods/reactive.ts

@@ -2,7 +2,35 @@ import { Infer } from '~/types';
 import Reactive from '~/reactive';
 
 
-// TODO: Typecheck on `values` to get rid of lazy var
+function factory<T>(value: T) {
+    if (typeof value === 'function') {
+        return fn(value);
+    }
+
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        return obj(value);
+    }
+
+    return new Reactive(value) as T;
+}
+
+function fn<T>(value: T) {
+    let fn = new Reactive(value);
+
+    return (...args: any[]) => {
+        let value = fn.get();
+
+        if (args.length && typeof value === 'function') {
+            value = value(...args);
+        }
+
+        return value as typeof value extends (...args: any[]) => any
+            ? ReturnType<typeof value>
+            : typeof value;
+    };
+}
+
+// TODO: Typecheck on `values` to get rid of lazy var?
 function obj<T>(values: T) {
     let lazy: Record<string, any> = {},
         properties: PropertyDescriptorMap = {};
@@ -11,17 +39,26 @@ function obj<T>(values: T) {
         properties[key] = {
             get() {
                 if (!lazy[key]) {
-                    lazy[key] = reactive(values[key]);
+                    lazy[key] = factory(values[key]);
+                }
+
+                if (lazy[key] instanceof Reactive) {
+                    return lazy[key].get();
                 }
 
-                return lazy[key].get();
+                return lazy[key];
             },
             set(value: unknown) {
                 if (!lazy[key]) {
-                    lazy[key] = reactive(values[key]);
+                    lazy[key] = factory(values[key]);
                 }
 
-                lazy[key].set(value);
+                if (lazy[key] instanceof Reactive) {
+                    lazy[key].set(value);
+                }
+                else {
+                    lazy[key] = factory(value);
+                }
             }
         };
     }
@@ -29,17 +66,5 @@ function obj<T>(values: T) {
     return Object.defineProperties({}, properties) as T;
 };
 
-function reactive<T>(value: T) {
-    // if (Array.isArray(value)) {
-    // TODO
-    // }
-    // TODO: Can remove isArray implementation is created
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        return obj(value);
-    }
-
-    return new Reactive(value) as T;
-}
-
 
-export default <T>(value: T) => reactive(value) as Infer<T>;
+export default <T>(value: T) => factory(value) as Infer<T>;

package/src/reactive.ts

@@ -1,43 +1,73 @@
 import { CLEAN, CHECK, DIRTY } from './symbols';
-import { Scheduler, State } from './types';
+import { ReactiveFn, Scheduler, State } from './types';
 
 
 let index = 0,
     reaction: Reactive<any> | null = null,
     queue: Reactive<any>[] = [],
+    scheduled = false,
     schedulers = new Set<Scheduler>,
     stack: Reactive<any>[] | null = null;
 
 
+function mark(instances: Reactive<any>[] | null, state: typeof CHECK | typeof DIRTY) {
+    if (!instances) {
+        return;
+    }
+
+    for (let i = 0, n = instances.length; i < n; i++) {
+        let instance = instances[i];
+
+        if (instance.state < state) {
+            // If previous state was clean we need to update effects
+            if (instance.effect && instance.state === CLEAN) {
+                queue.push(instance);
+
+                if (!scheduled) {
+                    for (let scheduler of schedulers) {
+                        scheduler.schedule();
+                    }
+
+                    scheduled = true;
+                }
+            }
+
+            instance.state = state;
+
+            if (instance.observers) {
+                mark(instance.observers, CHECK);
+            }
+        }
+    }
+}
+
 async function task() {
     for (let i = 0, n = queue.length; i < n; i++) {
         await queue[i].get();
     }
 
     queue.length = 0;
+    scheduled = false;
 }
 
 
-type Fn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
-
-
 class Reactive<T> {
-    private effect: boolean;
-    private fn?: Fn<T>;
-    private observers: Reactive<any>[] | null = null;
-    private sources: Reactive<any>[] | null = null;
-    private state: State;
+    private fn?: ReactiveFn<T>;
     private value: T;
 
 
+    effect: boolean;
     cleanup: ((old: T) => void)[] | null = null;
+    observers: Reactive<any>[] | null = null;
+    sources: Reactive<any>[] | null = null;
+    state: State;
 
 
-    constructor(data: Fn<T> | T, effect: boolean = false) {
+    constructor(data: ReactiveFn<T> | T, effect: boolean = false) {
         this.effect = effect;
 
         if (typeof data === 'function') {
-            this.fn = data as Fn<T>;
+            this.fn = data as ReactiveFn<T>;
             this.state = DIRTY;
             this.value = undefined as any;
 
@@ -75,39 +105,13 @@ class Reactive<T> {
     }
 
     set(value: T) {
-        if (this.observers && this.value !== value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].mark(DIRTY);
-            }
+        if (this.value !== value) {
+            mark(this.observers, DIRTY);
         }
 
         this.value = value;
     }
 
-
-    private mark(state: typeof CHECK | typeof DIRTY) {
-        if (this.state < state) {
-            // If previous state was clean we need to update effects
-            if (this.effect && this.state === CLEAN) {
-                queue.push(this);
-
-                for (let scheduler of schedulers) {
-                    scheduler.schedule();
-                }
-            }
-
-            this.state = state;
-
-            if (!this.observers) {
-                return;
-            }
-
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].mark(CHECK);
-            }
-        }
-    }
-
     // We don't actually delete sources here because we're replacing the entire array soon
     private removeParentObservers() {
         if (!this.sources) {

package/src/types.ts

@@ -20,6 +20,8 @@ type InferNested<T> =
             ? { [K in keyof T]: InferNested<T[K]> }
             : T;
 
+type ReactiveFn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
+
 type Scheduler = {
     schedule(): void;
     tasks: {
@@ -31,4 +33,4 @@ type Scheduler = {
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
 
 
-export { Infer, Scheduler, State };
+export { Infer, ReactiveFn, Scheduler, State };