@expressive/mvc 0.4.6 → 0.4.7

package/lib/index.d.ts

@@ -357,6 +357,8 @@ 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<K = any>(initial: SetConstructor): Set<K>;
+declare function use<K = any, V = any>(initial: MapConstructor): Map<K, V>;
 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>;

package/lib/index.esm.js

@@ -938,129 +938,133 @@ function parent(Expects, required) {
 
 const ANY = Symbol("any");
 function keyed(control, property, initial) {
-    const managed = new Stateful(initial, emit);
-    const context = new WeakMap();
-    const observers = new Set();
+    const context = new Map();
+    const users = new Map();
+    const watched = new WeakMap();
+    const update = new Set();
     const frozen = new Set();
+    let managed;
+    manage(initial);
     function reset() {
         frozen.clear();
     }
+    function watch(on, key) {
+        const include = watched.get(on);
+        if (include)
+            include.add(key);
+    }
     function emit(key) {
         control.waiting.add(reset);
         control.update(property);
-        observers.forEach(notify => notify(key));
+        update.forEach(notify => notify(key));
+    }
+    function manage(current) {
+        managed = create(current);
+        context.clear();
+        assign(managed, {
+            delete(key) {
+                emit(key);
+                return current.delete(key);
+            },
+            clear() {
+                emit(ANY);
+                current.clear();
+            },
+            has(key) {
+                watch(this, key);
+                return current.has(key);
+            },
+            keys() {
+                watch(this, ANY);
+                return current.keys();
+            },
+            values() {
+                watch(this, ANY);
+                return current.values();
+            },
+            entries() {
+                watch(this, ANY);
+                return current.entries();
+            },
+            [Symbol.iterator]() {
+                watch(this, ANY);
+                return current[Symbol.iterator]();
+            },
+        }, current instanceof Set
+            ? {
+                add(key) {
+                    current.add(key);
+                    emit(key);
+                    return this;
+                }
+            }
+            : {
+                get(key) {
+                    watch(this, ANY);
+                    return current.get(key);
+                },
+                set(key, value) {
+                    current.set(key, value);
+                    emit(key);
+                    return this;
+                }
+            });
+        defineProperty(managed, "size", {
+            get() {
+                watch(this, ANY);
+                return current.size;
+            }
+        });
     }
-    function init(local) {
+    function subscribe(local) {
         const proxy = create(managed);
-        const using = new Set();
-        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();
+        let watch = users.get(local);
+        if (!watch) {
+            const using = watch = new Set();
+            users.set(local, using);
+            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();
+                    }
                 }
             }
+            local.add(property, false);
+            local.dependant.add({
+                commit() {
+                    if (using.size === 0)
+                        using.add(ANY);
+                    update.add(onEvent);
+                },
+                release() {
+                    update.delete(onEvent);
+                }
+            });
         }
+        watched.set(proxy, watch);
         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,
         get(local) {
             return local ?
-                context.get(local) || init(local) :
+                context.get(local) || subscribe(local) :
                 managed;
         },
         set(next) {
-            managed.source = next;
             control.state.set(property, next);
+            manage(next);
             emit(ANY);
         },
         destroy() {
-            observers.clear();
+            update.clear();
         }
     };
-}
-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) { }
-    has(key) {
-        this.watch(key);
-        return this.source.has(key);
-    }
-    ;
-    delete(key) {
-        this.emit(key);
-        return this.source.delete(key);
-    }
-    ;
-    clear() {
-        this.emit(ANY);
-        this.source.clear();
-    }
-    keys() {
-        this.watch(ANY);
-        return this.source.keys();
-    }
-    values() {
-        this.watch(ANY);
-        return this.source.values();
-    }
-    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]();
-    }
-    ;
 }
 
 const Oops$5 = issues({
@@ -1070,9 +1074,7 @@ function use$1(input, argument) {
     return apply(function use(key) {
         const { state, subject } = this;
         if (typeof input === "function")
-            input = Model.isTypeof(input)
-                ? new input()
-                : input();
+            input = "prototype" in input ? new input() : input();
         else if (input && typeof input !== "object")
             throw Oops$5.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)