@expressive/mvc 0.4.2 → 0.4.5

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;
@@ -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.
  */

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();
+const ORDER = new WeakMap();
 function from(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)
@@ -938,202 +938,217 @@ function parent(Expects, required) {
 
 const ANY$1 = Symbol("any");
 function managedMap(control, property, initial) {
-    const lastUpdate = new Set();
+    const managed = new ManagedMap(initial, emit);
     const context = new WeakMap();
-    const assoc = new WeakMap();
-    let managed;
-    let value;
+    const observers = new Set();
+    const frozen = new Set();
     function reset() {
-        lastUpdate.clear();
+        frozen.clear();
     }
     function emit(key) {
-        lastUpdate.add(key);
+        observers.forEach(notify => notify(key));
         control.update(property);
         control.waiting.add(reset);
     }
-    function setValue(next, initial) {
-        value = next;
-        managed = create(next);
-        control.state.set(property, next);
-        if (!initial)
-            emit(ANY$1);
-        const watch = (key, on) => {
-            const local = assoc.get(on);
-            if (local)
-                local(key);
-        };
-        managed.set = (k, v) => {
-            emit(k);
-            return value.set(k, v);
-        };
-        managed.delete = (k) => {
-            emit(k);
-            return value.delete(k);
-        };
-        managed.clear = () => {
-            emit(ANY$1);
-            value.clear();
-        };
-        managed.get = function (key) {
-            watch(key, this);
-            return value.get(key);
-        };
-        managed.has = function (key) {
-            watch(key, this);
-            return value.has(key);
-        };
-        managed.values = function () {
-            watch(ANY$1, this);
-            return value.values();
-        };
-        managed.keys = function () {
-            watch(ANY$1, this);
-            return value.keys();
-        };
-        managed.entries = function () {
-            watch(ANY$1, this);
-            return value.entries();
-        };
-        managed[Symbol.iterator] = function () {
-            watch(ANY$1, this);
-            return value[Symbol.iterator]();
-        };
-        defineProperty(managed, "size", {
-            get() {
-                watch(ANY$1, this);
-                return value.size;
+    function init(local) {
+        const proxy = create(managed);
+        const using = new Set();
+        observers.add(key => {
+            if (frozen.has(local))
+                return;
+            if (using.has(key) || using.has(ANY$1) || key === ANY$1 && using.size) {
+                const refresh = local.onUpdate(property, control);
+                if (refresh) {
+                    frozen.add(local);
+                    refresh();
+                }
             }
         });
-    }
-    function getValue(local) {
-        if (!local)
-            return managed;
-        if (context.has(local))
-            return context.get(local);
-        const refresh = local.onUpdate(property, control);
-        const proxy = Object.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, false);
         context.set(local, proxy);
-        assoc.set(proxy, (key) => {
+        proxy.watch = (key) => {
             if (!local.active)
                 using.add(key);
-        });
-        local.add(property, () => update);
+        };
         return proxy;
     }
-    setValue(initial, true);
     return {
-        set: setValue,
-        get: getValue
+        value: initial,
+        get(local) {
+            if (!local)
+                return managed;
+            if (context.has(local))
+                return context.get(local);
+            return init(local);
+        },
+        set(next) {
+            managed.source = next;
+            control.state.set(property, next);
+            emit(ANY$1);
+        },
+        destroy() {
+            observers.clear();
+        }
     };
+}
+class ManagedMap {
+    constructor(source, emit) {
+        this.source = source;
+        this.emit = emit;
+    }
+    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 lastUpdate = new Set();
+    const managed = new ManagedSet(initial, emit);
     const context = new WeakMap();
-    const assoc = new WeakMap();
-    let managed;
-    let value;
+    const observers = new Set();
+    const frozen = new Set();
     function reset() {
-        lastUpdate.clear();
+        frozen.clear();
     }
     function emit(key) {
-        lastUpdate.add(key);
+        observers.forEach(notify => notify(key));
         control.update(property);
         control.waiting.add(reset);
     }
-    function setValue(next, initial) {
-        value = next;
-        managed = create(next);
-        control.state.set(property, next);
-        if (!initial)
-            emit(ANY);
-        const watch = (key, on) => {
-            const local = assoc.get(on);
-            if (local)
-                local(key);
-        };
-        managed.add = (k) => {
-            emit(k);
-            return value.add(k);
-        };
-        managed.delete = (k) => {
-            emit(k);
-            return value.delete(k);
-        };
-        managed.clear = () => {
-            emit(ANY);
-            value.clear();
-        };
-        managed.has = function (key) {
-            watch(key, this);
-            return value.has(key);
-        };
-        managed.values = function () {
-            watch(ANY, this);
-            return value.values();
-        };
-        managed.keys = function () {
-            watch(ANY, this);
-            return value.keys();
-        };
-        managed.entries = function () {
-            watch(ANY, this);
-            return value.entries();
-        };
-        managed[Symbol.iterator] = function () {
-            watch(ANY, this);
-            return value[Symbol.iterator]();
-        };
-        defineProperty(managed, "size", {
-            get() {
-                watch(ANY, this);
-                return value.size;
+    function init(local) {
+        const proxy = create(managed);
+        const using = new Set();
+        observers.add(key => {
+            if (frozen.has(local))
+                return;
+            if (using.has(key) || using.has(ANY) || key === ANY && using.size) {
+                const refresh = local.onUpdate(property, control);
+                if (refresh) {
+                    frozen.add(local);
+                    refresh();
+                }
             }
         });
-    }
-    function getValue(local) {
-        if (!local)
-            return managed;
-        if (context.has(local))
-            return context.get(local);
-        const refresh = local.onUpdate(property, control);
-        const proxy = Object.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, false);
         context.set(local, proxy);
-        assoc.set(proxy, (key) => {
+        proxy.watch = (key) => {
             if (!local.active)
                 using.add(key);
-        });
-        local.add(property, () => update);
+        };
         return proxy;
     }
-    setValue(initial, true);
     return {
-        set: setValue,
-        get: getValue
+        value: initial,
+        get(local) {
+            if (!local)
+                return managed;
+            if (context.has(local))
+                return context.get(local);
+            return init(local);
+        },
+        set(next) {
+            managed.source = next;
+            control.state.set(property, next);
+            emit(ANY);
+        },
+        destroy() {
+            observers.clear();
+        }
     };
+}
+class ManagedSet {
+    constructor(source, emit) {
+        this.source = source;
+        this.emit = emit;
+    }
+    watch(_key) { }
+    add(key) {
+        this.source.add(key);
+        this.emit(key);
+        return this;
+    }
+    ;
+    delete(key) {
+        this.emit(key);
+        return this.source.delete(key);
+    }
+    ;
+    clear() {
+        this.emit(ANY);
+        this.source.clear();
+    }
+    has(key) {
+        this.watch(key);
+        return this.source.has(key);
+    }
+    ;
+    values() {
+        this.watch(ANY);
+        return this.source.values();
+    }
+    keys() {
+        this.watch(ANY);
+        return this.source.keys();
+    }
+    entries() {
+        this.watch(ANY);
+        return this.source.entries();
+    }
+    ;
+    [Symbol.iterator]() {
+        this.watch(ANY);
+        return this.source[Symbol.iterator]();
+    }
+    ;
+    get size() {
+        this.watch(ANY);
+        return this.source.size;
+    }
 }
 
 const Oops$5 = issues({