@expressive/mvc 0.4.5 → 0.4.6

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,9 +944,9 @@ 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 observers = new Set();
     const frozen = new Set();
@@ -954,150 +954,48 @@ function managedMap(control, property, initial) {
         frozen.clear();
     }
     function emit(key) {
-        observers.forEach(notify => notify(key));
-        control.update(property);
         control.waiting.add(reset);
+        control.update(property);
+        observers.forEach(notify => notify(key));
     }
     function init(local) {
         const proxy = create(managed);
         const using = new Set();
-        observers.add(key => {
+        function onEvent(key) {
             if (frozen.has(local))
                 return;
-            if (using.has(key) || using.has(ANY$1) || key === ANY$1 && using.size) {
+            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);
+        }
         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) {
-        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();
-                }
+        local.add(property, false);
+        local.dependant.add({
+            commit() {
+                if (using.size === 0)
+                    using.add(ANY);
+                observers.add(onEvent);
+            },
+            release() {
+                observers.delete(onEvent);
             }
         });
-        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);
+            return local ?
+                context.get(local) || init(local) :
+                managed;
         },
         set(next) {
             managed.source = next;
@@ -1109,16 +1007,35 @@ function managedSet(control, property, initial) {
         }
     };
 }
-class ManagedSet {
+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) { }
-    add(key) {
-        this.source.add(key);
-        this.emit(key);
-        return this;
+    has(key) {
+        this.watch(key);
+        return this.source.has(key);
     }
     ;
     delete(key) {
@@ -1130,33 +1047,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({
@@ -1171,10 +1083,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) {
@@ -1629,7 +1539,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;