@expressive/mvc 0.4.4 → 0.4.7

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;
@@ -357,6 +357,12 @@ 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>;
+declare function use(from: () => Map<unknown, unknown>): Map<any, any>;
 /**
  * Create a placeholder for specified Model type.
  */
@@ -623,4 +629,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,219 +936,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({
@@ -1158,15 +1074,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) {
@@ -1609,5 +1521,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