@esportsplus/reactivity 0.0.4 → 0.0.6

package/build/index.d.ts

@@ -1,9 +1,28 @@
 import { Queue } from './types';
+type Infer<T> = T extends (...args: any[]) => any ? InferValue<ReturnType<T>> : InferValue<T>;
+type InferValue<T> = T extends Record<string, any> ? T : Reactive<T>;
+declare class Reactive<T> {
+    private effect;
+    private fn?;
+    private observers;
+    private queue;
+    private sources;
+    private state;
+    private value;
+    cleanup: ((old: T) => void)[] | null;
+    constructor(input: ((fn: VoidFunction) => T) | T, queue?: Queue | null, effect?: boolean);
+    get(): T;
+    set(value: T): void;
+    private mark;
+    private removeParentObservers;
+    private sync;
+    private update;
+}
 declare const effect: (queue: Queue) => <T>(value: () => T) => void;
-declare const reactive: <T>(value: T) => T;
+declare const reactive: <T>(value: T) => Infer<T>;
 declare const _default: {
     effect: (queue: Queue) => <T>(value: () => T) => void;
-    reactive: <T_1>(value: T_1) => T_1;
+    reactive: <T_1>(value: T_1) => Infer<T_1>;
 };
 export default _default;
 export { effect, reactive };

package/build/index.js

@@ -10,10 +10,10 @@ class Reactive {
     state;
     value;
     cleanup = null;
-    constructor(_, queue = null, effect = false) {
+    constructor(input, queue = null, effect = false) {
         this.effect = effect;
-        if (typeof _ === 'function') {
-            this.fn = _;
+        if (typeof input === 'function') {
+            this.fn = input;
             this.state = DIRTY;
             this.value = undefined;
             if (effect) {
@@ -23,7 +23,7 @@ class Reactive {
         }
         else {
             this.state = CLEAN;
-            this.value = _;
+            this.value = input;
         }
     }
     get() {
@@ -166,10 +166,18 @@ const effect = (queue) => {
     };
 };
 const reactive = (value) => {
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        return obj(value);
+    let v;
+    if (typeof value === 'function') {
+        let fn = new Reactive(value);
+        v = (...args) => fn.get()(...args);
     }
-    return new Reactive(value);
+    else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        v = obj(value);
+    }
+    else {
+        v = new Reactive(value);
+    }
+    return v;
 };
 export default { effect, reactive };
 export { effect, reactive };

package/build/obj.d.ts

@@ -1,2 +1,2 @@
-declare const factory: <T = Record<string, any>>(values: T) => T;
+declare const factory: <T extends Record<string, any>>(values: T) => {};
 export default factory;

package/package.json

@@ -2,8 +2,8 @@
     "author": "ICJR",
     "description": "Reactivity",
     "devDependencies": {
-        "tsc-alias": "^1.8.1",
-        "typescript": "^4.9.3"
+        "tsc-alias": "^1.8.2",
+        "typescript": "^4.9.4"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/reactivity",
@@ -15,5 +15,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.4"
+    "version": "0.0.6"
 }

package/src/index.ts

@@ -3,6 +3,15 @@ import { Queue, State } from './types';
 import obj from './obj';
 
 
+// We only unwrap the top level function
+type Infer<T> =
+    T extends (...args: any[]) => any
+        ? InferValue<ReturnType<T>>
+        : InferValue<T>;
+
+type InferValue<T> = T extends Record<string, any> ? T : Reactive<T>;
+
+
 let index = 0,
     reaction: Reactive<any> | null = null,
     stack: Reactive<any>[] | null = null;
@@ -21,11 +30,11 @@ class Reactive<T> {
     cleanup: ((old: T) => void)[] | null = null;
 
 
-    constructor(_: ((fn: VoidFunction) => T) | T, queue: Queue | null = null, effect: boolean = false) {
+    constructor(input: ((fn: VoidFunction) => T) | T, queue: Queue | null = null, effect: boolean = false) {
         this.effect = effect;
 
-        if (typeof _ === 'function') {
-            this.fn = _ as (onCleanup: (fn: VoidFunction) => void) => T;
+        if (typeof input === 'function') {
+            this.fn = input as (onCleanup: (fn: VoidFunction) => void) => T;
             this.state = DIRTY;
             this.value = undefined as any;
 
@@ -36,7 +45,7 @@ class Reactive<T> {
         }
         else {
             this.state = CLEAN;
-            this.value = _;
+            this.value = input;
         }
     }
 
@@ -229,12 +238,22 @@ const effect = (queue: Queue) => {
     };
 };
 
-const reactive = <T>(value: T): T => {
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        return obj(value);
+const reactive = <T>(value: T) => {
+    let v;
+
+    if (typeof value === 'function') {
+        let fn = new Reactive(value);
+
+        v = (...args: any[]) => fn.get()(...args);
+    }
+    else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        v = obj(value);
+    }
+    else {
+        v = new Reactive(value);
     }
 
-    return new Reactive(value) as T;
+    return v as Infer<T>;
 };
 
 

package/src/obj.ts

@@ -1,7 +1,7 @@
 import { reactive } from './index';
 
 
-function setup(value: any) {
+function setup(value: unknown) {
     // if (Array.isArray(value)) {
     // TODO: Need a solution
     // }
@@ -15,7 +15,7 @@ function setup(value: any) {
 
 
 // TODO: Typecheck on values tro get rid of lazy var
-const factory = <T = Record<string, any>>(values: T) => {
+const factory = <T extends Record<string, any>>(values: T) => {
     let lazy: Record<string, any> = {},
         properties: PropertyDescriptorMap = {};
 
@@ -38,7 +38,7 @@ const factory = <T = Record<string, any>>(values: T) => {
         };
     }
 
-    return Object.defineProperties({}, properties) as T;
+    return Object.defineProperties({}, properties);
 };