@expressive/mvc 0.4.4 → 0.4.7

package/lib/index.js

@@ -174,7 +174,7 @@ const Oops$a = issues({
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function from(source, arg1, arg2) {
+function get(source, arg1, arg2) {
     return apply(function from(key) {
         const { subject, state } = this;
         const required = arg2 === true || arg1 === true;
@@ -944,219 +944,135 @@ 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 observers = new Set();
+const ANY = Symbol("any");
+function keyed(control, property, initial) {
+    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) {
-        observers.forEach(notify => notify(key));
-        control.update(property);
         control.waiting.add(reset);
-    }
-    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();
+        control.update(property);
+        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;
+            }
         });
-        local.add(property, false);
-        context.set(local, proxy);
-        proxy.watch = (key) => {
-            if (!local.active)
-                using.add(key);
-        };
-        return proxy;
-    }
-    return {
-        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 managed = new ManagedSet(initial, emit);
-    const context = new WeakMap();
-    const observers = new Set();
-    const frozen = new Set();
-    function reset() {
-        frozen.clear();
-    }
-    function emit(key) {
-        observers.forEach(notify => notify(key));
-        control.update(property);
-        control.waiting.add(reset);
-    }
-    function init(local) {
+    function subscribe(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();
+        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.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);
-        };
         return proxy;
     }
     return {
         value: initial,
         get(local) {
-            if (!local)
-                return managed;
-            if (context.has(local))
-                return context.get(local);
-            return init(local);
+            return 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 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({
@@ -1166,15 +1082,11 @@ 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)
-            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) {
@@ -1629,7 +1541,8 @@ exports.act = act;
 exports.apply = apply;
 exports.array = array;
 exports["default"] = MVC;
-exports.from = from;
+exports.from = get;
+exports.get = get;
 exports.parent = parent;
 exports.put = put;
 exports.ref = ref;