@esportsplus/reactivity 0.0.6 → 0.0.8

package/build/index.d.ts

@@ -1,28 +1,12 @@
-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) => Infer<T>;
+import { scheduler } from './reactive';
+import { effect, reactive } from './methods';
 declare const _default: {
-    effect: (queue: Queue) => <T>(value: () => T) => void;
-    reactive: <T_1>(value: T_1) => Infer<T_1>;
+    effect: <T>(value: () => T) => void;
+    reactive: <T_1>(value: T_1) => import("./types").Infer<T_1>;
+    scheduler: {
+        add: (scheduler: import("./types").Scheduler) => void;
+        delete: (scheduler: import("./types").Scheduler) => void;
+    };
 };
 export default _default;
-export { effect, reactive };
+export { effect, reactive, scheduler };

package/build/index.js

@@ -1,183 +1,4 @@
-import { CLEAN, CHECK, DIRTY } from './symbols';
-import obj from './obj';
-let index = 0, reaction = null, stack = null;
-class Reactive {
-    effect;
-    fn;
-    observers = null;
-    queue = null;
-    sources = null;
-    state;
-    value;
-    cleanup = null;
-    constructor(input, queue = null, effect = false) {
-        this.effect = effect;
-        if (typeof input === 'function') {
-            this.fn = input;
-            this.state = DIRTY;
-            this.value = undefined;
-            if (effect) {
-                this.queue = queue;
-                this.update();
-            }
-        }
-        else {
-            this.state = CLEAN;
-            this.value = input;
-        }
-    }
-    get() {
-        if (reaction) {
-            if (!stack && reaction.sources && reaction.sources[index] == this) {
-                index++;
-            }
-            else {
-                if (!stack) {
-                    stack = [this];
-                }
-                else {
-                    stack.push(this);
-                }
-            }
-        }
-        if (this.fn) {
-            this.sync();
-        }
-        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);
-            }
-        }
-        this.value = value;
-    }
-    mark(state) {
-        if (this.state < state) {
-            if (this.state === CLEAN && this.effect) {
-                if (!this.queue) {
-                    throw new Error('Effects cannot be updated without a queue');
-                }
-                this.queue.add(async () => {
-                    await this.get();
-                });
-            }
-            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;
-        }
-        for (let i = index; i < this.sources.length; i++) {
-            let source = this.sources[i];
-            source.observers[source.observers.findIndex((v) => v === this)] = source.observers[source.observers.length - 1];
-            source.observers.pop();
-        }
-    }
-    sync() {
-        if (this.state === CHECK && this.sources) {
-            for (let i = 0, n = this.sources.length; i < n; i++) {
-                this.sources[i].sync();
-                if (this.state === DIRTY) {
-                    break;
-                }
-            }
-        }
-        if (this.state === DIRTY) {
-            this.update();
-        }
-        this.state = CLEAN;
-    }
-    update() {
-        let previous = {
-            index: index,
-            reaction: reaction,
-            stack: stack,
-            value: this.value
-        };
-        index = 0;
-        reaction = this;
-        stack = [];
-        try {
-            if (this.cleanup) {
-                for (let i = 0, n = this.cleanup.length; i < n; i++) {
-                    this.cleanup[i](this.value);
-                }
-                this.cleanup.length = 0;
-            }
-            this.value = this.fn((fn) => {
-                if (!this.cleanup) {
-                    this.cleanup = [fn];
-                }
-                else {
-                    this.cleanup.push(fn);
-                }
-            });
-            if (stack.length) {
-                this.removeParentObservers();
-                if (this.sources && index > 0) {
-                    this.sources.length = index + stack.length;
-                    for (let i = 0; i < stack.length; i++) {
-                        this.sources[index + i] = stack[i];
-                    }
-                }
-                else {
-                    this.sources = stack;
-                }
-                for (let i = index; i < this.sources.length; i++) {
-                    let source = this.sources[i];
-                    if (!source.observers) {
-                        source.observers = [this];
-                    }
-                    else {
-                        source.observers.push(this);
-                    }
-                }
-            }
-            else if (this.sources && index < this.sources.length) {
-                this.removeParentObservers();
-                this.sources.length = index;
-            }
-        }
-        finally {
-            index = previous.index;
-            reaction = previous.reaction;
-            stack = previous.stack;
-        }
-        if (this.observers && previous.value !== this.value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].state = DIRTY;
-            }
-        }
-        this.state = CLEAN;
-    }
-}
-const effect = (queue) => {
-    return (value) => {
-        new Reactive(value, queue, true);
-    };
-};
-const reactive = (value) => {
-    let v;
-    if (typeof value === 'function') {
-        let fn = new Reactive(value);
-        v = (...args) => fn.get()(...args);
-    }
-    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 };
+import { scheduler } from './reactive';
+import { effect, reactive } from './methods';
+export default { effect, reactive, scheduler };
+export { effect, reactive, scheduler };

package/build/methods/effect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: <T>(value: () => T) => void;
+export default _default;

package/build/methods/effect.js

@@ -0,0 +1,4 @@
+import Reactive from '../reactive';
+export default (value) => {
+    new Reactive(value, true);
+};

package/build/methods/index.d.ts

@@ -0,0 +1,3 @@
+import effect from './effect';
+import reactive from './reactive';
+export { effect, reactive };

package/build/methods/index.js

@@ -0,0 +1,3 @@
+import effect from './effect';
+import reactive from './reactive';
+export { effect, reactive };

package/build/methods/reactive.d.ts

@@ -0,0 +1,3 @@
+import { Infer } from '../types';
+declare const reactive: <T>(value: T) => Infer<T>;
+export default reactive;

package/{src/obj.ts → build/methods/reactive.js}

@@ -1,45 +1,39 @@
-import { reactive } from './index';
-
-
-function setup(value: unknown) {
-    // if (Array.isArray(value)) {
-    // TODO: Need a solution
-    // }
-    // TODO: Can remove isArray once solution is found ^
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        return factory(value);
-    }
-
-    return reactive(value);
-}
-
-
-// TODO: Typecheck on values tro get rid of lazy var
-const factory = <T extends Record<string, any>>(values: T) => {
-    let lazy: Record<string, any> = {},
-        properties: PropertyDescriptorMap = {};
-
+import Reactive from '../reactive';
+function obj(values) {
+    let lazy = {}, properties = {};
     for (let key in values) {
         properties[key] = {
             get() {
                 if (!lazy[key]) {
                     lazy[key] = setup(values[key]);
                 }
-
                 return lazy[key].get();
             },
-            set(value: unknown) {
+            set(value) {
                 if (!lazy[key]) {
                     lazy[key] = setup(values[key]);
                 }
-
                 lazy[key].set(value);
             }
         };
     }
-
     return Object.defineProperties({}, properties);
+}
+;
+function setup(value) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        return obj(value);
+    }
+    return reactive(value);
+}
+const reactive = (value) => {
+    let v;
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        v = obj(value);
+    }
+    else {
+        v = new Reactive(value);
+    }
+    return v;
 };
-
-
-export default factory;
+export default reactive;

package/build/obj.d.ts

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

package/build/reactive.d.ts

@@ -0,0 +1,23 @@
+import { Scheduler } from './types';
+declare class Reactive<T> {
+    private effect;
+    private fn?;
+    private observers;
+    private sources;
+    private state;
+    private value;
+    cleanup: ((old: T) => void)[] | null;
+    constructor(input: ((fn: VoidFunction) => T) | T, effect?: boolean);
+    get(): T;
+    set(value: T): void;
+    private mark;
+    private removeParentObservers;
+    private sync;
+    private update;
+}
+declare const scheduler: {
+    add: (scheduler: Scheduler) => void;
+    delete: (scheduler: Scheduler) => void;
+};
+export default Reactive;
+export { scheduler };

package/build/reactive.js

@@ -0,0 +1,175 @@
+import { CLEAN, CHECK, DIRTY } from './symbols';
+let index = 0, reaction = null, queue = [], schedulers = new Set, stack = null;
+async function task() {
+    for (let i = 0, n = queue.length; i < n; i++) {
+        await queue[i].get();
+    }
+    queue.length = 0;
+}
+class Reactive {
+    effect;
+    fn;
+    observers = null;
+    sources = null;
+    state;
+    value;
+    cleanup = null;
+    constructor(input, effect = false) {
+        this.effect = effect;
+        if (typeof input === 'function') {
+            this.fn = input;
+            this.state = DIRTY;
+            this.value = undefined;
+            if (effect) {
+                this.update();
+            }
+        }
+        else {
+            this.state = CLEAN;
+            this.value = input;
+        }
+    }
+    get() {
+        if (reaction) {
+            if (!stack && reaction.sources && reaction.sources[index] == this) {
+                index++;
+            }
+            else {
+                if (!stack) {
+                    stack = [this];
+                }
+                else {
+                    stack.push(this);
+                }
+            }
+        }
+        if (this.fn) {
+            this.sync();
+        }
+        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);
+            }
+        }
+        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;
+        }
+        for (let i = index; i < this.sources.length; i++) {
+            let source = this.sources[i];
+            source.observers[source.observers.findIndex((v) => v === this)] = source.observers[source.observers.length - 1];
+            source.observers.pop();
+        }
+    }
+    sync() {
+        if (this.state === CHECK && this.sources) {
+            for (let i = 0, n = this.sources.length; i < n; i++) {
+                this.sources[i].sync();
+                if (this.state === DIRTY) {
+                    break;
+                }
+            }
+        }
+        if (this.state === DIRTY) {
+            this.update();
+        }
+        this.state = CLEAN;
+    }
+    update() {
+        let previous = {
+            index: index,
+            reaction: reaction,
+            stack: stack,
+            value: this.value
+        };
+        index = 0;
+        reaction = this;
+        stack = [];
+        try {
+            if (this.cleanup) {
+                for (let i = 0, n = this.cleanup.length; i < n; i++) {
+                    this.cleanup[i](this.value);
+                }
+                this.cleanup.length = 0;
+            }
+            this.value = this.fn((fn) => {
+                if (!this.cleanup) {
+                    this.cleanup = [fn];
+                }
+                else {
+                    this.cleanup.push(fn);
+                }
+            });
+            if (stack.length) {
+                this.removeParentObservers();
+                if (this.sources && index > 0) {
+                    this.sources.length = index + stack.length;
+                    for (let i = 0; i < stack.length; i++) {
+                        this.sources[index + i] = stack[i];
+                    }
+                }
+                else {
+                    this.sources = stack;
+                }
+                for (let i = index; i < this.sources.length; i++) {
+                    let source = this.sources[i];
+                    if (!source.observers) {
+                        source.observers = [this];
+                    }
+                    else {
+                        source.observers.push(this);
+                    }
+                }
+            }
+            else if (this.sources && index < this.sources.length) {
+                this.removeParentObservers();
+                this.sources.length = index;
+            }
+        }
+        finally {
+            index = previous.index;
+            reaction = previous.reaction;
+            stack = previous.stack;
+        }
+        if (this.observers && previous.value !== this.value) {
+            for (let i = 0; i < this.observers.length; i++) {
+                this.observers[i].state = DIRTY;
+            }
+        }
+        this.state = CLEAN;
+    }
+}
+const scheduler = {
+    add: (scheduler) => {
+        scheduler.tasks.add(task);
+        schedulers.add(scheduler);
+    },
+    delete: (scheduler) => {
+        scheduler.tasks.delete(task);
+        schedulers.delete(scheduler);
+    }
+};
+export default Reactive;
+export { scheduler };

package/build/types.d.ts

@@ -1,6 +1,16 @@
 import { CLEAN, CHECK, DIRTY } from './symbols';
-type Queue = {
-    add: (fn: () => Promise<void> | void) => void;
+import Reactive from './reactive';
+type Fn = () => Promise<unknown> | unknown;
+type Infer<T> = T extends (...args: any[]) => any ? Reactive<T> : T extends Record<string, any> ? InferNested<T> : Reactive<T>;
+type InferNested<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<string, any> ? {
+    [K in keyof T]: InferNested<T[K]>;
+} : T;
+type Scheduler = {
+    schedule(): void;
+    tasks: {
+        add: (fn: Fn) => void;
+        delete: (fn: Fn) => void;
+    };
 };
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
-export { Queue, State };
+export { Infer, Scheduler, State };

package/package.json

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

package/src/index.ts

@@ -1,261 +1,6 @@
-import { CLEAN, CHECK, DIRTY } from './symbols';
-import { Queue, State } from './types';
-import obj from './obj';
+import { scheduler } from './reactive';
+import { effect, reactive } from './methods';
 
 
-// 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;
-
-
-class Reactive<T> {
-    private effect: boolean;
-    private fn?: (onCleanup: (fn: VoidFunction) => void) => T;
-    private observers: Reactive<any>[] | null = null;
-    private queue: Queue | null = null;
-    private sources: Reactive<any>[] | null = null;
-    private state: State;
-    private value: T;
-
-
-    cleanup: ((old: T) => void)[] | null = null;
-
-
-    constructor(input: ((fn: VoidFunction) => T) | T, queue: Queue | null = null, effect: boolean = false) {
-        this.effect = effect;
-
-        if (typeof input === 'function') {
-            this.fn = input as (onCleanup: (fn: VoidFunction) => void) => T;
-            this.state = DIRTY;
-            this.value = undefined as any;
-
-            if (effect) {
-                this.queue = queue;
-                this.update();
-            }
-        }
-        else {
-            this.state = CLEAN;
-            this.value = input;
-        }
-    }
-
-
-    get(): T {
-        if (reaction) {
-            if (!stack && reaction.sources && reaction.sources[index] == this) {
-                index++;
-            }
-            else {
-                if (!stack) {
-                    stack = [this];
-                }
-                else {
-                    stack.push(this);
-                }
-            }
-        }
-
-        if (this.fn) {
-            this.sync();
-        }
-
-        return this.value;
-    }
-
-    set(value: T) {
-        if (this.observers && this.value !== value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].mark(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.state === CLEAN && this.effect) {
-                if (!this.queue) {
-                    throw new Error('Effects cannot be updated without a queue');
-                }
-
-                this.queue.add(async () => {
-                    await this.get();
-                });
-            }
-
-            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) {
-            return;
-        }
-
-        for (let i = index; i < this.sources.length; i++) {
-            let source = this.sources[i];
-
-            source.observers![ source.observers!.findIndex((v) => v === this) ] = source.observers![source.observers!.length - 1];
-            source.observers!.pop();
-        }
-    }
-
-    // Update if dirty or if a parent is dirty
-    private sync() {
-        // If we are potentially dirty, see if we have a parent who has actually changed value
-        if (this.state === CHECK && this.sources) {
-            for (let i = 0, n = this.sources.length; i < n; i++) {
-                this.sources[i].sync();
-
-                // Stop the loop here so we won't trigger updates on other parents unnecessarily
-                // If our computation changes to no longer use some sources, we don't
-                // want to update() a source we used last time, but now don't use.
-                if ((this.state as State) === DIRTY) {
-                    break;
-                }
-            }
-        }
-
-        // If we were already dirty or marked dirty by the step above, update.
-        if (this.state === DIRTY) {
-            this.update();
-        }
-
-        // By now, we're clean
-        this.state = CLEAN;
-    }
-
-    private update() {
-        let previous = {
-                index: index,
-                reaction: reaction,
-                stack: stack,
-                value: this.value
-            };
-
-        index = 0;
-        reaction = this;
-        stack = [];
-
-        try {
-            if (this.cleanup) {
-                for (let i = 0, n = this.cleanup.length; i < n; i++) {
-                    this.cleanup[i]( this.value );
-                }
-
-                this.cleanup.length = 0;
-            }
-
-            this.value = this.fn!(
-                (fn: VoidFunction) => {
-                    if (!this.cleanup) {
-                        this.cleanup = [fn];
-                    }
-                    else {
-                        this.cleanup.push(fn);
-                    }
-                }
-            );
-
-            // If sources have changed, update source & observer links
-            if (stack.length) {
-                // Remove all old sources' observers links to us
-                this.removeParentObservers();
-
-                // Update source up links
-                if (this.sources && index > 0) {
-                    this.sources.length = index + stack.length;
-
-                    for (let i = 0; i < stack.length; i++) {
-                        this.sources[index + i] = stack[i];
-                    }
-                }
-                else {
-                    this.sources = stack;
-                }
-
-                // Add ourselves to the end of the parent observers array
-                for (let i = index; i < this.sources.length; i++) {
-                    let source = this.sources[i];
-
-                    if (!source.observers) {
-                        source.observers = [this];
-                    }
-                    else {
-                        source.observers.push( this );
-                    }
-                }
-            }
-            // Remove all old sources' observers links to us
-            else if (this.sources && index < this.sources.length) {
-                this.removeParentObservers();
-                this.sources.length = index;
-            }
-        }
-        finally {
-            index = previous.index;
-            reaction = previous.reaction;
-            stack = previous.stack;
-        }
-
-        // Handle diamond depenendencies if we're the parent of a diamond.
-        if (this.observers && previous.value !== this.value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].state = DIRTY;
-            }
-        }
-
-        this.state = CLEAN;
-    }
-}
-
-
-const effect = (queue: Queue) => {
-    return <T>(value: () => T) => {
-        new Reactive(value, queue, true);
-    };
-};
-
-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 v as Infer<T>;
-};
-
-
-export default { effect, reactive };
-export { effect, reactive };
+export default { effect, reactive, scheduler };
+export { effect, reactive, scheduler };

package/src/methods/effect.ts

@@ -0,0 +1,6 @@
+import Reactive from '~/reactive';
+
+
+export default <T>(value: () => T): void => {
+    new Reactive(value, true);
+};

package/src/methods/index.ts

@@ -0,0 +1,5 @@
+import effect from './effect';
+import reactive from './reactive';
+
+
+export { effect, reactive };

package/src/methods/reactive.ts

@@ -0,0 +1,59 @@
+import { Infer } from '~/types';
+import Reactive from '~/reactive';
+
+
+// TODO: Typecheck on `values` to get rid of lazy var
+function obj<T>(values: T) {
+    let lazy: Record<string, any> = {},
+        properties: PropertyDescriptorMap = {};
+
+    for (let key in values) {
+        properties[key] = {
+            get() {
+                if (!lazy[key]) {
+                    lazy[key] = setup(values[key]);
+                }
+
+                return lazy[key].get();
+            },
+            set(value: unknown) {
+                if (!lazy[key]) {
+                    lazy[key] = setup(values[key]);
+                }
+
+                lazy[key].set(value);
+            }
+        };
+    }
+
+    return Object.defineProperties({}, properties) as T;
+};
+
+function setup<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 reactive(value) as T;
+}
+
+
+const reactive = <T>(value: T) => {
+    let v: unknown;
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        v = obj(value);
+    }
+    else {
+        v = new Reactive(value);
+    }
+
+    return v as Infer<T>;
+};
+
+
+export default reactive;

package/src/reactive.ts

@@ -0,0 +1,245 @@
+import { CLEAN, CHECK, DIRTY } from './symbols';
+import { Scheduler, State } from './types';
+
+
+let index = 0,
+    reaction: Reactive<any> | null = null,
+    queue: Reactive<any>[] = [],
+    schedulers = new Set<Scheduler>,
+    stack: Reactive<any>[] | null = null;
+
+
+async function task() {
+    for (let i = 0, n = queue.length; i < n; i++) {
+        await queue[i].get();
+    }
+
+    queue.length = 0;
+}
+
+
+class Reactive<T> {
+    private effect: boolean;
+    private fn?: (onCleanup: (fn: VoidFunction) => void) => T;
+    private observers: Reactive<any>[] | null = null;
+    private sources: Reactive<any>[] | null = null;
+    private state: State;
+    private value: T;
+
+
+    cleanup: ((old: T) => void)[] | null = null;
+
+
+    constructor(input: ((fn: VoidFunction) => T) | T, effect: boolean = false) {
+        this.effect = effect;
+
+        if (typeof input === 'function') {
+            this.fn = input as (onCleanup: (fn: VoidFunction) => void) => T;
+            this.state = DIRTY;
+            this.value = undefined as any;
+
+            if (effect) {
+                this.update();
+            }
+        }
+        else {
+            this.state = CLEAN;
+            this.value = input;
+        }
+    }
+
+
+    get(): T {
+        if (reaction) {
+            if (!stack && reaction.sources && reaction.sources[index] == this) {
+                index++;
+            }
+            else {
+                if (!stack) {
+                    stack = [this];
+                }
+                else {
+                    stack.push(this);
+                }
+            }
+        }
+
+        if (this.fn) {
+            this.sync();
+        }
+
+        return this.value;
+    }
+
+    set(value: T) {
+        if (this.observers && this.value !== value) {
+            for (let i = 0; i < this.observers.length; i++) {
+                this.observers[i].mark(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) {
+            return;
+        }
+
+        for (let i = index; i < this.sources.length; i++) {
+            let source = this.sources[i];
+
+            source.observers![ source.observers!.findIndex((v) => v === this) ] = source.observers![source.observers!.length - 1];
+            source.observers!.pop();
+        }
+    }
+
+    // Update if dirty or if a parent is dirty
+    private sync() {
+        // If we are potentially dirty, see if we have a parent who has actually changed value
+        if (this.state === CHECK && this.sources) {
+            for (let i = 0, n = this.sources.length; i < n; i++) {
+                this.sources[i].sync();
+
+                // Stop the loop here so we won't trigger updates on other parents unnecessarily
+                // If our computation changes to no longer use some sources, we don't
+                // want to update() a source we used last time, but now don't use.
+                if ((this.state as State) === DIRTY) {
+                    break;
+                }
+            }
+        }
+
+        // If we were already dirty or marked dirty by the step above, update.
+        if (this.state === DIRTY) {
+            this.update();
+        }
+
+        // By now, we're clean
+        this.state = CLEAN;
+    }
+
+    private update() {
+        let previous = {
+                index: index,
+                reaction: reaction,
+                stack: stack,
+                value: this.value
+            };
+
+        index = 0;
+        reaction = this;
+        stack = [];
+
+        try {
+            if (this.cleanup) {
+                for (let i = 0, n = this.cleanup.length; i < n; i++) {
+                    this.cleanup[i]( this.value );
+                }
+
+                this.cleanup.length = 0;
+            }
+
+            this.value = this.fn!(
+                (fn: VoidFunction) => {
+                    if (!this.cleanup) {
+                        this.cleanup = [fn];
+                    }
+                    else {
+                        this.cleanup.push(fn);
+                    }
+                }
+            );
+
+            // If sources have changed, update source & observer links
+            if (stack.length) {
+                // Remove all old sources' observers links to us
+                this.removeParentObservers();
+
+                // Update source up links
+                if (this.sources && index > 0) {
+                    this.sources.length = index + stack.length;
+
+                    for (let i = 0; i < stack.length; i++) {
+                        this.sources[index + i] = stack[i];
+                    }
+                }
+                else {
+                    this.sources = stack;
+                }
+
+                // Add ourselves to the end of the parent observers array
+                for (let i = index; i < this.sources.length; i++) {
+                    let source = this.sources[i];
+
+                    if (!source.observers) {
+                        source.observers = [this];
+                    }
+                    else {
+                        source.observers.push( this );
+                    }
+                }
+            }
+            // Remove all old sources' observers links to us
+            else if (this.sources && index < this.sources.length) {
+                this.removeParentObservers();
+                this.sources.length = index;
+            }
+        }
+        finally {
+            index = previous.index;
+            reaction = previous.reaction;
+            stack = previous.stack;
+        }
+
+        // Handle diamond depenendencies if we're the parent of a diamond.
+        if (this.observers && previous.value !== this.value) {
+            for (let i = 0; i < this.observers.length; i++) {
+                this.observers[i].state = DIRTY;
+            }
+        }
+
+        this.state = CLEAN;
+    }
+}
+
+
+const scheduler = {
+    add: (scheduler: Scheduler) => {
+        scheduler.tasks.add(task);
+        schedulers.add(scheduler);
+    },
+    delete: (scheduler: Scheduler) => {
+        scheduler.tasks.delete(task);
+        schedulers.delete(scheduler);
+    }
+};
+
+
+export default Reactive;
+export { scheduler };

package/src/types.ts

@@ -1,11 +1,32 @@
 import { CLEAN, CHECK, DIRTY } from './symbols';
+import Reactive from './reactive';
 
 
-type Queue = {
-    add: (fn: () => Promise<void> | void) => void;
+type Fn = () => Promise<unknown> | unknown;
+
+type Infer<T> =
+    T extends (...args: any[]) => any
+        ? Reactive<T>
+        : T extends Record<string, any>
+                ? InferNested<T>
+                : Reactive<T>;
+
+type InferNested<T> =
+    T extends (...args: any[]) => any
+        ? ReturnType<T>
+        : T extends Record<string, any>
+            ? { [K in keyof T]: InferNested<T[K]> }
+            : T;
+
+type Scheduler = {
+    schedule(): void;
+    tasks: {
+        add: (fn: Fn) => void;
+        delete: (fn: Fn) => void;
+    }
 };
 
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
 
 
-export { Queue, State };
+export { Infer, Scheduler, State };