@expressive/mvc 0.12.0 → 0.13.1

package/lib/index.esm.js

@@ -1,8 +1,17 @@
-import React, { useState, useMemo, Suspense } from 'react';
+import React, { useState, Suspense } from 'react';
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-function unique(array) {
-    return Array.from(new Set(array));
+const UID_CACHE = new WeakMap();
+function assignWeak(into, from) {
+    for (const K in from)
+        if (K in into)
+            into[K] = from[K];
+}
+function uid(object) {
+    let uid = UID_CACHE.get(object);
+    if (!uid)
+        UID_CACHE.set(object, uid = Math.random());
+    return uid;
 }
 
 class Issue extends Error {
@@ -161,7 +170,7 @@ const Oops$d = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(model, callback, keys) {
-    return Control.for(model, control => {
+    return control(model, controller => {
         let unSet;
         let busy = false;
         function effect(value) {
@@ -186,7 +195,7 @@ function createEffect(model, callback, keys) {
         }
         if (Array.isArray(keys)) {
             invoke();
-            return control.addListener(key => {
+            return controller.addListener(key => {
                 if (key === null) {
                     if (!keys.length)
                         invoke();
@@ -195,7 +204,7 @@ function createEffect(model, callback, keys) {
                     return invoke;
             });
         }
-        const sub = control.subscribe(() => invoke);
+        const sub = controller.subscribe(() => invoke);
         model = sub.proxy;
         invoke();
         return sub.commit();
@@ -227,13 +236,13 @@ const Oops$c = issues({
 function addEventListener(source, arg1, arg2, arg3) {
     if (typeof arg1 == "string")
         arg1 = [arg1];
-    return Control.for(source, control => {
+    return control(source, controller => {
         for (const key of arg1)
             try {
                 void source[key];
             }
             catch (e) { }
-        const removeListener = control.addListener(key => {
+        const removeListener = controller.addListener(key => {
             if (!key && !arg1.length)
                 arg2.call(source, []);
             if (arg1.includes(key)) {
@@ -256,8 +265,8 @@ function awaitUpdate(source, arg1, arg2) {
             removeListener();
             reject(Oops$c.Timeout(k, message));
         };
-        const removeListener = Control.for(source, control => {
-            const pending = control.frame;
+        const removeListener = control(source, controller => {
+            const pending = controller.frame;
             if (keys === null) {
                 if (pending.size)
                     reject(Oops$c.StrictNoUpdate());
@@ -284,8 +293,8 @@ function awaitUpdate(source, arg1, arg2) {
                 return;
             }
             else
-                control.waiting.add(resolve);
-            return control.addListener(key => {
+                controller.waiting.add(resolve);
+            return controller.addListener(key => {
                 if (!key) {
                     if (keys && !keys.length)
                         resolve([]);
@@ -294,7 +303,7 @@ function awaitUpdate(source, arg1, arg2) {
                 }
                 else if (!keys || keys.includes(key)) {
                     removeListener();
-                    return keys => resolve(single ? control.state.get(key) : keys);
+                    return keys => resolve(single ? controller.state.get(key) : keys);
                 }
             });
         });
@@ -311,35 +320,6 @@ class Subscriber {
         this.active = false;
         this.dependant = new Set();
         this.watch = new Map();
-        this.commit = () => {
-            const release = this.parent.addListener(this.event);
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release = () => {
-                this.dependant.forEach(x => x.release());
-                release();
-            };
-        };
-        this.event = (key) => {
-            if (!this.active)
-                return;
-            const { parent, watch } = this;
-            const handler = watch.get(key);
-            let notify;
-            if (typeof handler == "function") {
-                const callback = handler();
-                if (callback === true)
-                    notify = this.onUpdate(key, parent);
-            }
-            else if (handler === true)
-                notify = this.onUpdate(key, parent);
-            if (!notify)
-                return;
-            parent.waiting.add(update => {
-                this.latest = update.filter(k => watch.has(k));
-            });
-            parent.waiting.add(notify);
-        };
         const proxy = create(parent.subject);
         const reset = () => this.latest = undefined;
         REGISTER$1.set(proxy, this);
@@ -351,28 +331,45 @@ class Subscriber {
             }
         });
     }
-    static get(from) {
-        return REGISTER$1.get(from);
-    }
     get using() {
         return Array.from(this.watch.keys());
     }
-    assign(apply, keys) {
-        const { waiting, subject } = this.parent;
-        this.active = false;
-        if (typeof keys !== "object")
-            keys = getOwnPropertyNames(subject);
-        for (const key of keys)
-            if (key in apply)
-                subject[key] = apply[key];
-        waiting.add(() => this.active = true);
-    }
     add(key, value) {
         if (value !== undefined)
             this.watch.set(key, value);
         else if (!this.watch.has(key))
             this.watch.set(key, true);
     }
+    commit() {
+        const release = this.parent.addListener(key => {
+            if (this.active)
+                this.onEvent(key);
+        });
+        this.active = true;
+        this.dependant.forEach(x => x.commit());
+        return this.release = () => {
+            this.dependant.forEach(x => x.release());
+            release();
+        };
+    }
+    onEvent(key) {
+        const { parent, watch } = this;
+        let handler = watch.get(key);
+        if (typeof handler == "function")
+            handler = handler();
+        if (handler) {
+            const notify = this.onUpdate(key, parent);
+            if (notify) {
+                parent.waiting.add(update => {
+                    this.latest = update.filter(k => watch.has(k));
+                });
+                parent.waiting.add(notify);
+            }
+        }
+    }
+}
+function subscriber(from) {
+    return REGISTER$1.get(from);
 }
 
 const Oops$b = issues({
@@ -392,7 +389,7 @@ class Model {
             return addEventListener(this.is, arg1, arg2, arg3);
     }
     get(arg1, arg2) {
-        const { state } = Control.for(this);
+        const { state } = control(this);
         const extract = typeof arg1 == "string"
             ? () => state.get(arg1)
             : () => {
@@ -409,19 +406,20 @@ class Model {
         return this.on(arg1, timeout).then(extract);
     }
     set(arg1, arg2) {
-        const control = Control.for(this);
+        const controller = control(this);
+        const { state } = controller;
         if (typeof arg1 == "object")
             for (const key in arg1) {
-                if (arg2 === true || (arg2 ? arg2.includes(key) : control.state.has(key))) {
-                    control.state.set(key, arg1[key]);
-                    control.update(key);
+                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
+                    state.set(key, arg1[key]);
+                    controller.update(key);
                 }
             }
         else if (typeof arg1 == "string") {
-            control.update(arg1);
+            controller.update(arg1);
             if (1 in arguments) {
-                if (control.state.has(arg1))
-                    control.state.set(arg1, arg2);
+                if (state.has(arg1))
+                    state.set(arg1, arg2);
                 else if (arg1 in this) {
                     const method = this[arg1];
                     if (typeof method == "function")
@@ -433,7 +431,7 @@ class Model {
             then: (callback) => {
                 if (!callback)
                     throw Oops$b.NoChaining();
-                control.waiting.add(callback);
+                controller.waiting.add(callback);
             }
         };
     }
@@ -441,7 +439,7 @@ class Model {
      * Clean up side effects and mark this instance for garbage-collection.
      */
     end() {
-        Control.for(this).clear();
+        control(this).clear();
     }
     /**
      * Creates a new instance of this controller.
@@ -452,7 +450,7 @@ class Model {
      */
     static new(...args) {
         const instance = new this(...args);
-        Control.for(instance);
+        control(instance);
         return instance;
     }
     /**
@@ -507,7 +505,7 @@ class Control {
             enumerable: false,
             set: this.ref(key),
             get() {
-                const sub = Subscriber.get(this);
+                const sub = subscriber(this);
                 if (sub)
                     sub.add(key);
                 return state.get(key);
@@ -567,34 +565,34 @@ class Control {
         this.followers.clear();
         listeners.forEach(x => x(null, this));
     }
-    static get(from) {
-        if (from && "is" in from)
-            from = from.is;
-        return REGISTER.get(from);
-    }
-    static for(subject, cb) {
-        const control = this.get(subject) || new this(subject);
-        if (!control.state) {
-            const { waiting } = control;
-            if (cb) {
-                let callback;
-                waiting.add(() => {
-                    callback = cb(control);
-                });
-                return () => {
-                    if (callback)
-                        callback();
-                };
-            }
-            control.state = new Map();
-            for (const key in subject)
-                control.watch(key);
-            control.waiting = new Set();
-            for (const cb of waiting)
-                cb([]);
+}
+function controller(from) {
+    if ("is" in from)
+        from = from.is;
+    return REGISTER.get(from);
+}
+function control(subject, cb) {
+    const control = controller(subject) || new Control(subject);
+    if (!control.state) {
+        const { waiting } = control;
+        if (cb) {
+            let callback;
+            waiting.add(() => {
+                callback = cb(control);
+            });
+            return () => {
+                if (callback)
+                    callback();
+            };
         }
-        return cb ? cb(control) : control;
+        control.state = new Map();
+        for (const key in subject)
+            control.watch(key);
+        control.waiting = new Set();
+        for (const cb of waiting)
+            cb([]);
     }
+    return cb ? cb(control) : control;
 }
 
 const Parent = new WeakMap();
@@ -613,8 +611,8 @@ function getRecursive(key, from) {
                 if (reset)
                     reset();
                 const value = state.get(key);
-                if (Control.get(value)) {
-                    const child = Control.for(value).subscribe(local.onUpdate);
+                if (value && controller(value)) {
+                    const child = control(value).subscribe(local.onUpdate);
                     if (local.active)
                         child.commit();
                     local.dependant.add(child);
@@ -634,24 +632,24 @@ function getRecursive(key, from) {
         return context.get(local);
     };
 }
-function setRecursive(control, key, initial) {
-    const { state, subject } = control;
+function setRecursive(controller, key, initial) {
+    const { state, subject } = controller;
     const Type = initial.constructor;
     let get;
     const onUpdate = (next) => {
         state.set(key, next);
         if (!(next instanceof Type))
             throw Oops$a.BadAssignment(`${subject}.${key}`, Type.name, String(next));
-        get = getRecursive(key, control);
+        get = getRecursive(key, controller);
         Parent.set(next, subject);
-        Control.for(next);
+        control(next);
         return true;
     };
     onUpdate(initial);
     defineProperty(subject, key, {
-        set: control.ref(key, onUpdate),
+        set: controller.ref(key, onUpdate),
         get() {
-            const local = Subscriber.get(this);
+            const local = subscriber(this);
             if (local)
                 local.add(key);
             return get(local);
@@ -699,7 +697,7 @@ function add(instruction, label) {
             get() {
                 if (!state.has(key) && shouldSuspend)
                     throw suspend(control, key);
-                const local = Subscriber.get(this);
+                const local = subscriber(this);
                 if (local)
                     local.add(key);
                 return onGet
@@ -830,7 +828,7 @@ function get(arg0, arg1, arg2) {
             let source = this;
             let setter;
             if (typeof arg0 == "function") {
-                const result = mayRetry(() => arg0.call(subject, key, subject));
+                let result = mayRetry(arg0.bind(subject, key, subject));
                 if (typeof result == "function")
                     setter = result;
                 else {
@@ -844,7 +842,7 @@ function get(arg0, arg1, arg2) {
             }
             else if (typeof arg1 == "function") {
                 // replace source controller in-case it is different
-                source = Control.for(arg0);
+                source = control(arg0);
                 setter = arg1;
             }
             else
@@ -874,7 +872,7 @@ function ref(arg, mapper) {
         if (typeof arg != "object")
             value = createRef(this, key, arg);
         else
-            Control.for(arg).state.forEach((_val, key) => {
+            control(arg).state.forEach((_val, key) => {
                 defineProperty(value, key, mapper ? {
                     configurable: true,
                     get() {
@@ -1085,7 +1083,7 @@ function use$1(input, argument) {
             if (next) {
                 get = getRecursive(key, this);
                 Parent.set(next, subject);
-                Control.for(next);
+                control(next);
             }
             if (typeof argument == "function")
                 argument(next);
@@ -1165,9 +1163,6 @@ class Lookup {
     constructor() {
         this.table = new Map();
     }
-    get local() {
-        return unique(getOwnPropertySymbols(this).map(symbol => this[symbol]));
-    }
     key(T) {
         let key = this.table.get(T);
         if (!key) {
@@ -1176,15 +1171,26 @@ class Lookup {
         }
         return key;
     }
-    get(T) {
-        return this[this.key(T)];
+    get(Type) {
+        return this[this.key(Type)];
+    }
+    has(key, input, callback) {
+        if (MVC.isTypeof(input) && input.global)
+            return input.new();
+        if (this.register.get(key) === input)
+            return typeof input == "object"
+                ? input
+                : this.get(input);
+        const instance = this.add(input);
+        this.register.set(key, input);
+        if (callback)
+            callback(instance);
+        return instance;
     }
     add(input) {
         let writable = true;
         let T;
         let I;
-        if (MVC.isTypeof(input) && input.global)
-            return input.new();
         if (typeof input == "function") {
             T = input;
             I = new input();
@@ -1196,10 +1202,9 @@ class Lookup {
         }
         do {
             const key = this.key(T);
-            const conflict = this.hasOwnProperty(key);
             defineProperty(this, key, {
-                value: conflict ? null : I,
                 configurable: true,
+                value: this.hasOwnProperty(key) ? null : I,
                 writable
             });
             T = getPrototypeOf(T);
@@ -1207,7 +1212,9 @@ class Lookup {
         return I;
     }
     push() {
-        return create(this);
+        const next = create(this);
+        next.register = new Map();
+        return next;
     }
     pop() {
         const items = new Set();
@@ -1237,7 +1244,7 @@ const Pending = new WeakMap();
 const Applied = new WeakMap();
 function tap(type, argument) {
     return add(function tap(key) {
-        if (type.global)
+        if (MVC.isTypeof(type) && type.global)
             return {
                 recursive: true,
                 value: type.get()
@@ -1284,20 +1291,13 @@ function getPending(subject) {
     return pending;
 }
 
-function use(init) {
-    const [state, update] = React.useState(() => [
-        init(() => update(state.concat()))
-    ]);
-    return state[0];
-}
-
 function useNew(source, arg1, arg2) {
     const instance = React.useMemo(() => {
         const callback = arg2 || arg1;
         const instance = Model.isTypeof(source)
             ? new source()
             : source();
-        Control.for(instance);
+        control(instance);
         if (typeof callback == "function")
             callback(instance);
         return instance;
@@ -1315,9 +1315,22 @@ function useNew(source, arg1, arg2) {
         }, []);
         return instance;
     }
-    const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
-    if (typeof arg1 == "object")
-        local.assign(arg1, arg2);
+    const state = React.useState(0);
+    const local = React.useMemo(() => {
+        const refresh = state[1].bind(null, x => x + 1);
+        return control(instance).subscribe(() => refresh);
+    }, []);
+    if (typeof arg1 == "object") {
+        const { waiting, subject } = local.parent;
+        let keys = arg2;
+        local.active = false;
+        if (!keys)
+            keys = getOwnPropertyNames(subject);
+        for (const key of keys)
+            if (key in arg1)
+                subject[key] = arg1[key];
+        waiting.add(() => local.active = true);
+    }
     React.useLayoutEffect(() => {
         local.commit();
         return () => {
@@ -1329,9 +1342,17 @@ function useNew(source, arg1, arg2) {
     return local.proxy;
 }
 
-function useValue(source, compute, suspend) {
+function use(init, deps) {
+    const state = React.useState(0);
+    return React.useMemo(() => {
+        return init(state[1].bind(null, x => x + 1));
+    }, deps);
+}
+
+function useCompute(source, compute, suspend) {
+    const deps = [uid(source)];
     const local = use(refresh => {
-        const sub = Control.for(source).subscribe(() => update);
+        const sub = control(source).subscribe(() => update);
         const spy = sub.proxy;
         let value = compute.call(spy, spy);
         let update;
@@ -1380,30 +1401,30 @@ function useValue(source, compute, suspend) {
             }
         });
         return sub;
-    });
-    React.useLayoutEffect(() => local.release, []);
+    }, deps);
+    React.useLayoutEffect(() => local.release, deps);
     return local.proxy;
 }
 
 function useTap(source, arg1, arg2) {
-    const instance = useMemo(() => {
-        if (typeof source == "object")
-            return () => source;
-        if (Model.isTypeof(source))
-            return "get" in source
-                ? () => source.get()
-                : () => useContext(source);
-        return source;
-    }, [])();
-    if (typeof arg1 == "function")
-        return useValue(instance, arg1, arg2);
-    const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
-    React.useLayoutEffect(local.commit, []);
-    if (arg1 === undefined)
+    const instance = typeof source == "object"
+        ? source
+        : "get" in source
+            ? source.get()
+            : useContext(source);
+    return typeof arg1 == "function"
+        ? useCompute(instance, arg1, arg2)
+        : useSubscribe(instance, arg1, arg2);
+}
+function useSubscribe(source, path, expect) {
+    const deps = [uid(source)];
+    const local = use(refresh => (control(source).subscribe(() => refresh)), deps);
+    React.useLayoutEffect(() => local.commit(), deps);
+    if (path === undefined)
         return local.proxy;
-    const value = local.proxy[arg1];
-    if (value === undefined && arg2)
-        throw suspend(local.parent, arg1);
+    const value = local.proxy[path];
+    if (value === undefined && expect)
+        throw suspend(local.parent, path);
     return value;
 }
 
@@ -1461,14 +1482,19 @@ class MVC extends Model {
             callback(arg2);
         return instance;
     }
-    static tap(key, expect) {
-        return useTap(this, key, expect);
+    static tap(arg1, arg2) {
+        const instance = this.get();
+        return typeof arg1 == "function"
+            ? useCompute(instance, arg1, arg2)
+            : useSubscribe(instance, arg1, arg2);
     }
     static use(a, b) {
         return useNew(this, a, b);
     }
-    static meta(path, expect) {
-        return useTap(() => this, path, expect);
+    static meta(arg1, arg2) {
+        return typeof arg1 == "function"
+            ? useCompute(this, arg1, arg2)
+            : useSubscribe(this, arg1, arg2);
     }
 }
 
@@ -1492,47 +1518,39 @@ const Oops = issues({
 });
 function Provider(props) {
     const context = useNewContext(props.for, props.and);
-    React.useLayoutEffect(() => () => context.pop(), []);
     return (React.createElement(LookupContext.Provider, { value: context }, props.fallback === false
         ? props.children
         : (React.createElement(Suspense, { fallback: props.fallback || null }, props.children))));
 }
 function useNewContext(include, assign) {
+    const init = new Set();
     const ambient = useLookup();
     const context = React.useMemo(() => {
         if (!include)
             throw Oops.NoType();
-        const next = ambient.push();
-        function register(T) {
-            const i = next.add(T);
-            if (assign)
-                assignWeak(i, assign);
-            Control.for(i).state.forEach(value => {
-                if (Parent.get(value) === i)
-                    next.add(value);
-            });
-        }
-        if (include instanceof Model || typeof include == "function")
-            register(include);
-        else
-            values(include).forEach(register);
-        for (const instance of next.local)
-            if (instance)
-                for (const apply of getPending(instance))
-                    apply(next);
-        return next;
+        return ambient.push();
     }, []);
-    if (assign)
-        context.local.forEach(i => {
-            if (i && !Parent.has(i))
-                assignWeak(i, assign);
+    function register(key, T) {
+        const instance = context.has(key, T, i => init.add(i));
+        if (assign)
+            assignWeak(instance, assign);
+    }
+    if (typeof include == "function" || include instanceof Model)
+        register(0, include);
+    else
+        entries(include).forEach(e => register(...e));
+    for (const instance of init) {
+        control(instance).state.forEach(value => {
+            if (Parent.get(value) === instance) {
+                context.add(value);
+                init.add(value);
+            }
         });
+        for (const apply of getPending(instance))
+            apply(context);
+    }
+    React.useLayoutEffect(() => () => context.pop(), []);
     return context;
-}
-function assignWeak(into, from) {
-    for (const K in from)
-        if (K in into)
-            into[K] = from[K];
 }
 
 class Global extends MVC {
@@ -1547,17 +1565,17 @@ const CONTROL = "$debug controller";
 defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
-            return Control.get(this);
+            return controller(this);
         }
     },
     [LOCAL]: {
         get() {
-            return Subscriber.get(this);
+            return subscriber(this);
         }
     },
     [STATE]: {
         get() {
-            const { state } = Control.get(this);
+            const { state } = controller(this);
             const output = {};
             state.forEach((value, key) => output[key] = value);
             return output;
@@ -1565,8 +1583,7 @@ defineProperties(Model.prototype, {
     },
     [UPDATE]: {
         get() {
-            const source = Subscriber.get(this) || Control.get(this);
-            return source && source.latest;
+            return (subscriber(this) || controller(this)).latest;
         }
     }
 });