@expressive/mvc 0.4.3 → 0.4.6

package/lib/index.d.ts

@@ -35,7 +35,7 @@ declare class Subscriber<T extends Stateful = any> {
     release: Callback;
     active: boolean;
     dependant: Set<Listener>;
-    add: (key: any, value?: Callback) => void;
+    add: (key: any, value?: boolean | Callback) => void;
     constructor(parent: Controller<T>, onUpdate: Controller.OnEvent);
 }
 
@@ -220,6 +220,7 @@ declare namespace Instruction {
         get?: Getter<T>;
         set?: Setter<T> | false;
         suspense?: boolean;
+        destroy?: () => void;
     }
     interface ExplicitDescriptor extends PropertyDescriptor {
         explicit: true;
@@ -238,7 +239,7 @@ declare namespace Instruction {
  */
 declare function apply<T = any>(instruction: Instruction<T>, name?: string): T;
 
-declare namespace from {
+declare namespace get {
     type Function<T, O = any> = (this: O, on: O) => T;
     type Factory<T, O = any> = (key: string) => Function<T, O>;
     type Getter = (controller: Controller, key: string) => any;
@@ -250,16 +251,16 @@ declare namespace from {
  * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
  * @param suspend - Value will throw suspense when evaulating to undefined.
  */
-declare function from<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
-declare function from<R, T>(source: T, compute: (this: T, on: T) => R, suspend?: boolean): R;
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend?: boolean): R;
 /**
  * Implement a computed value; output is returned by function from provided factory.
  *
  * @param compute - Factory function to generate a getter to subscribe dependancies.
  * @param suspend - Value will throw suspense when evaulating to undefined.
  */
-declare function from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
-declare function from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
+declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
 
 declare namespace ref {
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
@@ -356,6 +357,10 @@ declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
+declare function use(initial: Set<unknown>): Set<any>;
+declare function use(initial: Map<unknown, unknown>): Map<any, any>;
+declare function use(from: () => Set<unknown>): Set<any>;
+declare function use(from: () => Map<unknown, unknown>): Map<any, any>;
 /**
  * Create a placeholder for specified Model type.
  */
@@ -622,4 +627,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, get as from, get, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -164,11 +164,10 @@ const Oops$a = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
-const USED = new WeakMap();
 const KEYS = new WeakMap();
-function from(source, arg1, arg2) {
+const ORDER = new WeakMap();
+function get(source, arg1, arg2) {
     return apply(function from(key) {
-        const parent = this;
         const { subject, state } = this;
         const required = arg2 === true || arg1 === true;
         let getSource;
@@ -189,14 +188,13 @@ function from(source, arg1, arg2) {
         else
             throw Oops$a.BadSource(subject, key, source);
         const setter = arg1;
-        const info = { key, parent, priority: 1 };
+        const info = { key, parent: this };
         let sub;
-        let register = USED.get(parent);
-        if (!register)
-            USED.set(parent, register = new Map());
+        let order = ORDER.get(this);
+        if (!order)
+            ORDER.set(this, order = []);
         state.set(key, undefined);
-        register.set(key, info);
-        function compute(initial) {
+        const compute = (initial) => {
             try {
                 return setter.call(sub.proxy, sub.proxy);
             }
@@ -204,8 +202,8 @@ function from(source, arg1, arg2) {
                 Oops$a.Failed(subject, key, initial).warn();
                 throw err;
             }
-        }
-        function update() {
+        };
+        const refreshValue = () => {
             let value;
             try {
                 value = compute(false);
@@ -215,26 +213,25 @@ function from(source, arg1, arg2) {
             }
             finally {
                 if (state.get(key) !== value) {
-                    parent.state.set(key, value);
-                    parent.update(key);
+                    state.set(key, value);
+                    this.update(key);
                     return value;
                 }
             }
-        }
-        function defer(_key, from) {
-            let pending = KEYS.get(from);
-            if (!pending)
-                KEYS.set(from, pending = []);
-            if (info.parent !== from)
-                update();
-            else {
-                const after = pending.findIndex(peer => (info.priority > INFO.get(peer).priority));
-                pending.splice(after + 1, 0, update);
+        };
+        const dependancyDidUpdate = (_key, source) => {
+            if (source !== this) {
+                refreshValue();
+                return;
             }
-        }
-        function create() {
+            let pending = KEYS.get(this);
+            if (!pending)
+                KEYS.set(this, pending = []);
+            pending.push(refreshValue);
+        };
+        const create = () => {
             const control = getSource();
-            sub = control.subscribe(defer);
+            sub = control.subscribe(dependancyDidUpdate);
             try {
                 const value = compute(true);
                 state.set(key, value);
@@ -245,14 +242,10 @@ function from(source, arg1, arg2) {
             }
             finally {
                 sub.commit();
-                for (const key of control.state.keys()) {
-                    const peer = register.get(key);
-                    if (peer && peer.priority >= info.priority)
-                        info.priority = peer.priority + 1;
-                }
+                order.push(refreshValue);
             }
-        }
-        INFO.set(update, info);
+        };
+        INFO.set(refreshValue, info);
         return () => {
             const value = sub ? state.get(key) : create();
             if (value === undefined && required)
@@ -265,8 +258,11 @@ function flush(control) {
     const pending = KEYS.get(control);
     if (!pending)
         return;
+    const list = ORDER.get(control);
     while (pending.length) {
-        const compute = pending.shift();
+        const compute = pending
+            .sort((a, b) => list.indexOf(b) - list.indexOf(a))
+            .pop();
         const { key } = INFO.get(compute);
         if (!control.frame.has(key))
             compute();
@@ -291,18 +287,16 @@ class Subscriber {
             }
         });
         const release = parent.addListener(key => {
-            if (!this.active || !using.has(key))
+            if (!this.active)
                 return;
             const handler = using.get(key);
             let notify;
             if (typeof handler == "function") {
                 const callback = handler();
-                if (typeof callback == "function")
-                    notify = callback;
-                else if (callback === true)
+                if (callback === true)
                     notify = this.onUpdate(key, parent);
             }
-            else
+            else if (handler === true)
                 notify = this.onUpdate(key, parent);
             const getWhy = () => {
                 const update = getUpdate(parent.subject);
@@ -324,7 +318,7 @@ class Subscriber {
             release();
         };
         this.add = (key, value) => {
-            if (value)
+            if (value !== undefined)
                 using.set(key, value);
             else if (!using.has(key))
                 using.set(key, true);
@@ -398,17 +392,15 @@ class Controller {
         else if (!frame.size)
             setTimeout(() => {
                 flush(this);
-                const callback = Array.from(waiting);
-                const keys = Array.from(frame);
-                frame.clear();
-                waiting.clear();
-                UPDATE.set(subject, keys);
+                UPDATE.set(subject, Array.from(frame));
                 setTimeout(() => {
                     UPDATE.delete(subject);
                 }, 0);
-                for (const cb of callback)
+                frame.clear();
+                for (const notify of waiting)
                     try {
-                        cb();
+                        waiting.delete(notify);
+                        notify();
                     }
                     catch (err) {
                         console.error(err);
@@ -659,6 +651,14 @@ function apply(fn, label) {
         const desc = output;
         if ("value" in desc)
             state.set(key, desc.value);
+        if ("destroy" in output) {
+            const { destroy } = output;
+            if (destroy)
+                this.addListener((key) => {
+                    if (key == null)
+                        destroy();
+                });
+        }
         const { get: onGet, set: onSet, enumerable, suspense } = desc;
         const set = onSet !== false
             ? this.ref(key, onSet)
@@ -936,172 +936,100 @@ function parent(Expects, required) {
     });
 }
 
-const ANY$1 = Symbol("any");
-function managedMap(control, property, initial) {
-    const managed = new ManagedMap(initial, emit);
+const ANY = Symbol("any");
+function keyed(control, property, initial) {
+    const managed = new Stateful(initial, emit);
     const context = new WeakMap();
-    const lastUpdate = new Set();
+    const observers = new Set();
+    const frozen = new Set();
     function reset() {
-        lastUpdate.clear();
+        frozen.clear();
     }
     function emit(key) {
-        lastUpdate.add(key);
-        control.update(property);
         control.waiting.add(reset);
+        control.update(property);
+        observers.forEach(notify => notify(key));
     }
-    function setValue(next) {
-        control.state.set(property, next);
-        managed.source = next;
-        emit(ANY$1);
-    }
-    function getValue(local) {
-        if (!local)
-            return managed;
-        if (context.has(local))
-            return context.get(local);
-        const refresh = local.onUpdate(property, control);
+    function init(local) {
         const proxy = create(managed);
         const using = new Set();
-        const update = () => {
-            if (using.has(ANY$1) || lastUpdate.has(ANY$1) && using.size)
-                refresh();
-            else
-                for (const key of lastUpdate)
-                    if (using.has(key)) {
-                        refresh();
-                        break;
-                    }
-        };
-        local.add(property, () => update);
+        function onEvent(key) {
+            if (frozen.has(local))
+                return;
+            if (key === ANY || using.has(key) || using.has(ANY)) {
+                const refresh = local.onUpdate(property, control);
+                if (refresh) {
+                    frozen.add(local);
+                    refresh();
+                }
+            }
+        }
         context.set(local, proxy);
         proxy.watch = (key) => {
             if (!local.active)
                 using.add(key);
         };
+        local.add(property, false);
+        local.dependant.add({
+            commit() {
+                if (using.size === 0)
+                    using.add(ANY);
+                observers.add(onEvent);
+            },
+            release() {
+                observers.delete(onEvent);
+            }
+        });
         return proxy;
     }
     return {
         value: initial,
-        set: setValue,
-        get: getValue
+        get(local) {
+            return local ?
+                context.get(local) || init(local) :
+                managed;
+        },
+        set(next) {
+            managed.source = next;
+            control.state.set(property, next);
+            emit(ANY);
+        },
+        destroy() {
+            observers.clear();
+        }
     };
 }
-class ManagedMap {
+class Stateful {
     constructor(source, emit) {
         this.source = source;
         this.emit = emit;
+        if (source instanceof Set)
+            assign(this, {
+                add(key) {
+                    source.add(key);
+                    emit(key);
+                    return this;
+                }
+            });
+        else
+            assign(this, {
+                get(key) {
+                    this.watch(key);
+                    return source.get(key);
+                },
+                set(key, value) {
+                    source.set(key, value);
+                    emit(key);
+                    return this;
+                }
+            });
     }
     watch(_key) { }
-    set(key, value) {
-        this.source.set(key, value);
-        this.emit(key);
-        return this;
-    }
-    ;
-    delete(key) {
-        this.emit(key);
-        return this.source.delete(key);
-    }
-    ;
-    clear() {
-        this.emit(ANY$1);
-        this.source.clear();
-    }
-    get(key) {
-        this.watch(key);
-        return this.source.get(key);
-    }
-    ;
     has(key) {
         this.watch(key);
         return this.source.has(key);
     }
     ;
-    values() {
-        this.watch(ANY$1);
-        return this.source.values();
-    }
-    keys() {
-        this.watch(ANY$1);
-        return this.source.keys();
-    }
-    entries() {
-        this.watch(ANY$1);
-        return this.source.entries();
-    }
-    ;
-    [Symbol.iterator]() {
-        this.watch(ANY$1);
-        return this.source[Symbol.iterator]();
-    }
-    ;
-    get size() {
-        this.watch(ANY$1);
-        return this.source.size;
-    }
-}
-
-const ANY = Symbol("any");
-function managedSet(control, property, initial) {
-    const managed = new ManagedSet(initial, emit);
-    const context = new WeakMap();
-    const lastUpdate = new Set();
-    function reset() {
-        lastUpdate.clear();
-    }
-    function emit(key) {
-        lastUpdate.add(key);
-        control.update(property);
-        control.waiting.add(reset);
-    }
-    function setValue(next) {
-        managed.source = next;
-        control.state.set(property, next);
-        emit(ANY);
-    }
-    function getValue(local) {
-        if (!local)
-            return managed;
-        if (context.has(local))
-            return context.get(local);
-        const refresh = local.onUpdate(property, control);
-        const proxy = create(managed);
-        const using = new Set();
-        const update = () => {
-            if (using.has(ANY) || lastUpdate.has(ANY) && using.size)
-                refresh();
-            else
-                for (const key of lastUpdate)
-                    if (using.has(key)) {
-                        refresh();
-                        break;
-                    }
-        };
-        local.add(property, () => update);
-        context.set(local, proxy);
-        proxy.watch = (key) => {
-            if (!local.active)
-                using.add(key);
-        };
-        return proxy;
-    }
-    return {
-        value: initial,
-        set: setValue,
-        get: getValue
-    };
-}
-class ManagedSet {
-    constructor(source, emit) {
-        this.source = source;
-        this.emit = emit;
-    }
-    watch(_key) { }
-    add(key) {
-        this.emit(key);
-        return this.source.add(key);
-    }
-    ;
     delete(key) {
         this.emit(key);
         return this.source.delete(key);
@@ -1111,33 +1039,28 @@ class ManagedSet {
         this.emit(ANY);
         this.source.clear();
     }
-    has(key) {
-        this.watch(key);
-        return this.source.has(key);
+    keys() {
+        this.watch(ANY);
+        return this.source.keys();
     }
-    ;
     values() {
         this.watch(ANY);
         return this.source.values();
     }
-    keys() {
-        this.watch(ANY);
-        return this.source.keys();
-    }
     entries() {
         this.watch(ANY);
         return this.source.entries();
     }
     ;
+    get size() {
+        this.watch(ANY);
+        return this.source.size;
+    }
     [Symbol.iterator]() {
         this.watch(ANY);
         return this.source[Symbol.iterator]();
     }
     ;
-    get size() {
-        this.watch(ANY);
-        return this.source.size;
-    }
 }
 
 const Oops$5 = issues({
@@ -1152,10 +1075,8 @@ function use$1(input, argument) {
                 : input();
         else if (input && typeof input !== "object")
             throw Oops$5.BadArgument(typeof input);
-        if (input instanceof Map)
-            return managedMap(this, key, input);
-        if (input instanceof Set)
-            return managedSet(this, key, input);
+        if (input instanceof Map || input instanceof Set)
+            return keyed(this, key, input);
         function onUpdate(next) {
             state.set(key, next);
             if (next) {
@@ -1598,5 +1519,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, get as from, get, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map