@expressive/mvc 0.4.0 → 0.4.3

package/lib/index.esm.js

@@ -294,10 +294,16 @@ class Subscriber {
             if (!this.active || !using.has(key))
                 return;
             const handler = using.get(key);
-            if (typeof handler == "function")
-                if (handler() !== true)
-                    return;
-            const notify = this.onUpdate(key, parent);
+            let notify;
+            if (typeof handler == "function") {
+                const callback = handler();
+                if (typeof callback == "function")
+                    notify = callback;
+                else if (callback === true)
+                    notify = this.onUpdate(key, parent);
+            }
+            else
+                notify = this.onUpdate(key, parent);
             const getWhy = () => {
                 const update = getUpdate(parent.subject);
                 const applicable = update.filter(k => using.has(k));
@@ -932,10 +938,9 @@ function parent(Expects, required) {
 
 const ANY$1 = Symbol("any");
 function managedMap(control, property, initial) {
+    const managed = new ManagedMap(initial, emit);
     const context = new WeakMap();
     const lastUpdate = new Set();
-    let managed;
-    let value;
     function reset() {
         lastUpdate.clear();
     }
@@ -944,89 +949,103 @@ function managedMap(control, property, initial) {
         control.update(property);
         control.waiting.add(reset);
     }
-    function setValue(next, initial) {
-        value = next;
-        managed = create(next);
+    function setValue(next) {
         control.state.set(property, next);
-        if (!initial)
-            emit(ANY$1);
-        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.source = next;
+        emit(ANY$1);
     }
     function getValue(local) {
         if (!local)
             return managed;
         if (context.has(local))
             return context.get(local);
-        const proxy = Object.create(managed);
+        const refresh = local.onUpdate(property, control);
+        const proxy = create(managed);
         const using = new Set();
-        context.set(local, proxy);
-        local.add(property, () => {
+        const update = () => {
             if (using.has(ANY$1) || lastUpdate.has(ANY$1) && using.size)
-                return true;
-            for (const key of lastUpdate)
-                if (using.has(key))
-                    return true;
-        });
-        const watch = (key) => {
+                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);
         };
-        proxy.get = (key) => {
-            watch(key);
-            return value.get(key);
-        };
-        proxy.has = (key) => {
-            watch(key);
-            return value.has(key);
-        };
-        proxy.values = () => {
-            watch(ANY$1);
-            return value.values();
-        };
-        proxy.keys = () => {
-            watch(ANY$1);
-            return value.keys();
-        };
-        proxy.entries = () => {
-            watch(ANY$1);
-            return value.entries();
-        };
-        proxy[Symbol.iterator] = () => {
-            watch(ANY$1);
-            return value[Symbol.iterator]();
-        };
-        defineProperty(proxy, "size", {
-            get() {
-                watch(ANY$1);
-                return value.size;
-            }
-        });
         return proxy;
     }
-    setValue(initial, true);
     return {
+        value: initial,
         set: setValue,
         get: getValue
     };
+}
+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 managed = new ManagedSet(initial, emit);
     const context = new WeakMap();
     const lastUpdate = new Set();
-    let managed;
-    let value;
     function reset() {
         lastUpdate.clear();
     }
@@ -1035,77 +1054,90 @@ function managedSet(control, property, initial) {
         control.update(property);
         control.waiting.add(reset);
     }
-    function setValue(next, initial) {
-        value = next;
-        managed = create(next);
+    function setValue(next) {
+        managed.source = next;
         control.state.set(property, next);
-        if (!initial)
-            emit(ANY);
-        managed.add = (k) => {
-            emit(k);
-            return value.add(k);
-        };
-        managed.delete = (k) => {
-            emit(k);
-            return value.delete(k);
-        };
-        managed.clear = () => {
-            emit(ANY);
-            value.clear();
-        };
+        emit(ANY);
     }
     function getValue(local) {
         if (!local)
             return managed;
         if (context.has(local))
             return context.get(local);
-        const proxy = Object.create(managed);
+        const refresh = local.onUpdate(property, control);
+        const proxy = create(managed);
         const using = new Set();
-        context.set(local, proxy);
-        local.add(property, () => {
+        const update = () => {
             if (using.has(ANY) || lastUpdate.has(ANY) && using.size)
-                return true;
-            for (const key of lastUpdate)
-                if (using.has(key))
-                    return true;
-        });
-        const watch = (key) => {
+                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);
         };
-        proxy.has = (key) => {
-            watch(key);
-            return value.has(key);
-        };
-        proxy.values = () => {
-            watch(ANY);
-            return value.values();
-        };
-        proxy.keys = () => {
-            watch(ANY);
-            return value.keys();
-        };
-        proxy.entries = () => {
-            watch(ANY);
-            return value.entries();
-        };
-        proxy[Symbol.iterator] = () => {
-            watch(ANY);
-            return value[Symbol.iterator]();
-        };
-        defineProperty(proxy, "size", {
-            get() {
-                watch(ANY);
-                return value.size;
-            }
-        });
         return proxy;
     }
-    setValue(initial, true);
     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);
+    }
+    ;
+    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({