@expressive/mvc 0.4.5 → 0.4.6

package/lib/index.d.ts

@@ -239,7 +239,7 @@ declare namespace Instruction {
  */
 declare function apply<T = any>(instruction: Instruction<T>, name?: string): T;
 
-declare namespace from {
+declare namespace get {
     type Function<T, O = any> = (this: O, on: O) => T;
     type Factory<T, O = any> = (key: string) => Function<T, O>;
     type Getter = (controller: Controller, key: string) => any;
@@ -251,16 +251,16 @@ declare namespace from {
  * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
  * @param suspend - Value will throw suspense when evaulating to undefined.
  */
-declare function from<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
-declare function from<R, T>(source: T, compute: (this: T, on: T) => R, suspend?: boolean): R;
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend?: boolean): R;
 /**
  * Implement a computed value; output is returned by function from provided factory.
  *
  * @param compute - Factory function to generate a getter to subscribe dependancies.
  * @param suspend - Value will throw suspense when evaulating to undefined.
  */
-declare function from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
-declare function from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
+declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
 
 declare namespace ref {
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
@@ -627,4 +627,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, get as from, get, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -166,7 +166,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;
@@ -936,9 +936,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();
@@ -946,150 +946,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;
@@ -1101,16 +999,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) {
@@ -1122,33 +1039,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({
@@ -1163,10 +1075,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) {
@@ -1609,5 +1519,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, get as from, get, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map