@expressive/mvc 0.9.6 → 0.10.1

package/lib/index.esm.js

@@ -1,6 +1,9 @@
 import React, { useState, useMemo } from 'react';
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+function unique(array) {
+    return Array.from(new Set(array));
+}
 
 class Issue extends Error {
     constructor() {
@@ -651,6 +654,7 @@ function createValueEffect(callback) {
 function ref(arg, mapper) {
     return add(function ref(key) {
         let value = {};
+        this.state.set(key, undefined);
         if (typeof arg != "object")
             value = createRef(this, key, arg);
         else
@@ -947,31 +951,31 @@ const Oops$6 = issues({
     StrictNoUpdate: () => `Update is not expected but one is in progress!`
 });
 function addEventListener(source, arg1, arg2, arg3) {
+    if (typeof arg1 == "string")
+        arg1 = [arg1];
+    return Control.for(source, control => {
+        for (const key of arg1)
+            try {
+                void source[key];
+            }
+            catch (e) { }
+        const removeListener = control.addListener(key => {
+            if (!key && !arg1.length)
+                arg2.call(source, []);
+            if (arg1.includes(key)) {
+                if (arg3)
+                    removeListener();
+                return arg2.bind(source);
+            }
+        });
+        return removeListener;
+    });
+}
+function awaitUpdate(source, arg1, arg2) {
     const single = typeof arg1 == "string";
     const keys = typeof arg1 == "string" ? [arg1] :
         typeof arg1 == "object" ? arg1 :
             undefined;
-    if (typeof arg2 == "function" && keys)
-        return Control.for(source, control => {
-            for (const key of keys)
-                try {
-                    void source[key];
-                }
-                catch (e) { }
-            const invoke = single
-                ? () => arg2.call(source, control.state.get(arg1), arg1)
-                : (frame) => arg2.call(source, frame);
-            const removeListener = control.addListener(key => {
-                if (!key && !keys.length)
-                    invoke([]);
-                if (keys.includes(key)) {
-                    if (arg3)
-                        removeListener();
-                    return invoke;
-                }
-            });
-            return removeListener;
-        });
     return new Promise((resolve, reject) => {
         const timeout = (message) => {
             const k = keys ? keys.join(", ") : "any";
@@ -1036,34 +1040,47 @@ class Model {
     on(arg1, arg2, arg3) {
         if (typeof arg1 == "function")
             return createEffect(this.is, arg1, arg2);
-        return addEventListener(this.is, arg1, arg2, arg3);
+        if (typeof arg2 != "function")
+            return awaitUpdate(this.is, arg1, arg2);
+        if (arg1)
+            return addEventListener(this.is, arg1, arg2, arg3);
     }
-    export(subset) {
+    get(arg1, arg2) {
         const { state } = Control.for(this);
-        const output = {};
-        const keys = subset || state.keys();
-        for (const key of keys)
-            output[key] = state.get(key);
-        return output;
+        const extract = typeof arg1 == "string"
+            ? () => state.get(arg1)
+            : () => {
+                const output = {};
+                for (const key of arg1 || state.keys())
+                    output[key] = state.get(key);
+                return output;
+            };
+        if (!arg1 || arg2 === undefined)
+            return extract();
+        if (typeof arg2 == "function")
+            return this.on(arg1, () => arg2(extract()));
+        const timeout = typeof arg2 == "number" ? arg2 : undefined;
+        return this.on(arg1, timeout).then(extract);
     }
-    update(arg1, arg2) {
+    set(arg1, arg2) {
         const control = Control.for(this);
-        if (typeof arg1 == "object") {
-            for (const key in arg1)
+        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);
                 }
-        }
+            }
         else if (typeof arg1 == "string") {
             control.update(arg1);
-            if (1 in arguments && arg1 in this) {
-                const method = this[arg1];
-                if (typeof method == "function")
-                    if (typeof arg2 != "boolean")
+            if (1 in arguments) {
+                if (control.state.has(arg1))
+                    control.state.set(arg1, arg2);
+                else if (arg1 in this) {
+                    const method = this[arg1];
+                    if (typeof method == "function")
                         method.call(this, arg2);
-                    else if (arg2)
-                        method.call(this);
+                }
             }
         }
         return {
@@ -1077,7 +1094,7 @@ class Model {
     /**
      * Clean up side effects and mark this instance for garbage-collection.
      */
-    destroy() {
+    end() {
         Control.for(this).clear();
     }
     /**
@@ -1116,9 +1133,7 @@ class Lookup {
         this.table = new Map();
     }
     get local() {
-        return [
-            ...new Set(getOwnPropertySymbols(this).map(symbol => this[symbol]))
-        ];
+        return unique(getOwnPropertySymbols(this).map(symbol => this[symbol]));
     }
     key(T) {
         let key = this.table.get(T);
@@ -1131,10 +1146,7 @@ class Lookup {
     get(T) {
         return this[this.key(T)];
     }
-    push() {
-        return create(this);
-    }
-    inject(T, I, writable) {
+    add(T, I, writable) {
         do {
             const key = this.key(T);
             const conflict = this.hasOwnProperty(key);
@@ -1146,6 +1158,9 @@ class Lookup {
             T = getPrototypeOf(T);
         } while (T !== Model);
     }
+    push() {
+        return create(this);
+    }
     pop() {
         const items = new Set();
         for (const key of getOwnPropertySymbols(this)) {
@@ -1154,40 +1169,33 @@ class Lookup {
                 items.add(entry.value);
         }
         for (const model of items)
-            model.destroy();
+            model.end();
     }
 }
 const LookupContext = React.createContext(new Lookup());
 const useLookup = () => React.useContext(LookupContext);
-function useContext(Type, arg) {
+function useContext(Type, required) {
     const instance = useLookup().get(Type);
-    if (!instance && arg !== false)
+    if (!instance && required !== false)
         throw Oops$4.NotFound(Type.name);
-    switch (typeof arg) {
-        case "string":
-            return instance[arg];
-        case "function":
-            React.useLayoutEffect(() => arg(instance), []);
-        default:
-            return instance;
-    }
+    return instance;
 }
 
 const Oops$3 = issues({
     NotAllowed: (parent, child) => `Global '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
     AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
 });
-const PendingContext = new WeakMap();
-const ContextWasUsed = new WeakMap();
+const Pending = new WeakMap();
+const Applied = new WeakMap();
 function tap(type, argument) {
     return add(function tap(key) {
-        if ("set" in type)
+        if (type.global)
             return {
                 recursive: true,
                 value: type.get()
             };
         const { subject } = this;
-        if ("set" in subject.constructor)
+        if (subject.constructor.global)
             throw Oops$3.NotAllowed(subject, type.name);
         getPending(subject).push(context => {
             let instance = context.get(type);
@@ -1207,24 +1215,24 @@ function tap(type, argument) {
     });
 }
 function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
+    if (Applied.has(subject)) {
+        if (Applied.get(subject))
             useLookup();
         return;
     }
-    const pending = PendingContext.get(subject);
+    const pending = Pending.get(subject);
     if (pending) {
         const local = useLookup();
         for (const init of pending)
             init(local);
-        PendingContext.delete(subject);
+        Pending.delete(subject);
     }
-    ContextWasUsed.set(subject, !!pending);
+    Applied.set(subject, !!pending);
 }
 function getPending(subject) {
-    let pending = PendingContext.get(subject);
+    let pending = Pending.get(subject);
     if (!pending)
-        PendingContext.set(subject, pending = []);
+        Pending.set(subject, pending = []);
     return pending;
 }
 
@@ -1235,9 +1243,9 @@ function use(init) {
     return state[0];
 }
 
-function useModel(source, arg, arg2) {
+function useNew(source, arg1, arg2) {
     const instance = React.useMemo(() => {
-        const callback = arg2 || arg;
+        const callback = arg2 || arg1;
         const instance = Model.isTypeof(source) ?
             source.new() :
             source();
@@ -1247,27 +1255,27 @@ function useModel(source, arg, arg2) {
         return instance;
     }, []);
     usePeerContext(instance);
-    if (Array.isArray(arg)) {
+    if (Array.isArray(arg1)) {
         const update = useState(0)[1];
         React.useLayoutEffect(() => {
-            if (arg.length && instance instanceof Model)
-                instance.on(arg, () => update(x => x + 1));
+            if (arg1.length && instance instanceof Model)
+                instance.on(arg1, () => update(x => x + 1));
             return () => {
                 if (Model.isTypeof(source))
-                    instance.destroy();
+                    instance.end();
             };
         }, []);
         return instance;
     }
     const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
-    if (typeof arg == "object")
-        local.assign(arg, arg2);
+    if (typeof arg1 == "object")
+        local.assign(arg1, arg2);
     React.useLayoutEffect(() => {
         local.commit();
         return () => {
             local.release();
             if (Model.isTypeof(source))
-                instance.destroy();
+                instance.end();
         };
     }, []);
     return local.proxy;
@@ -1316,9 +1324,11 @@ function useValue(source, compute, suspend) {
         }
         defineProperty(sub, "proxy", {
             get() {
-                if (value === undefined && suspend)
+                if (value !== undefined)
+                    return value;
+                if (suspend)
                     throw new Promise(res => retry = res);
-                return value;
+                return null;
             }
         });
         return sub;
@@ -1333,7 +1343,7 @@ function useTap(source, arg1, arg2) {
             return () => source;
         if (Model.isTypeof(source))
             return "get" in source
-                ? () => source.get(true)
+                ? () => source.get()
                 : () => useContext(source);
         return source;
     }, [])();
@@ -1349,22 +1359,72 @@ function useTap(source, arg1, arg2) {
     return value;
 }
 
+const Global$1 = new WeakMap();
+const Oops$2 = issues({
+    DoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.new() before attempting to access, or consider using ${name}.use() instead.`,
+    AlreadyExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
+});
 class MVC extends Model {
-    static get(arg) {
-        return useContext(this, arg);
+    end(force) {
+        const type = this.constructor;
+        if (type.keepAlive && !force)
+            return false;
+        super.end();
+        Global$1.delete(type);
+        return true;
+    }
+    static new(...args) {
+        if (Global$1.has(this))
+            if (this.keepAlive)
+                return Global$1.get(this);
+            else
+                throw Oops$2.AlreadyExists(this.name);
+        const instance = super.new(...args);
+        if (this.global)
+            Global$1.set(this, instance);
+        return instance;
+    }
+    static get(arg1, arg2) {
+        let instance;
+        const required = arg1 === undefined || arg1 === true;
+        if (this.global) {
+            instance = Global$1.get(this);
+            if (!instance && required)
+                throw Oops$2.DoesNotExist(this.name);
+        }
+        else
+            instance = useContext(this, required);
+        function callback(effect) {
+            try {
+                React.useLayoutEffect(() => effect(instance), []);
+            }
+            catch (err) {
+                if (instance)
+                    instance.on(effect, []);
+                else
+                    effect(undefined);
+            }
+        }
+        if (typeof arg1 === "string")
+            return instance[arg1];
+        if (typeof arg1 === "function" && instance)
+            callback(arg1);
+        else if (arg2)
+            callback(arg2);
+        return instance;
     }
     static tap(key, expect) {
         return useTap(this, key, expect);
     }
     static use(a, b) {
-        return useModel(this, a, b);
+        return useNew(this, a, b);
     }
     static meta(path, expect) {
         return useTap(() => this, path, expect);
     }
 }
 
-const Oops$2 = issues({
+const Oops$1 = issues({
     BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
 function Consumer(props) {
@@ -1375,58 +1435,50 @@ function Consumer(props) {
     if (typeof callback == "function")
         callback(useContext(type, !!has));
     else
-        throw Oops$2.BadProps();
+        throw Oops$1.BadProps();
     return null;
 }
 
-const Oops$1 = issues({
+const Oops = issues({
     NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
 });
 function Provider(props) {
-    const context = useNewContext(props.for);
+    const context = useNewContext(props.for, props.and);
     const render = props.children;
-    useAppliedProps(context, props);
     React.useLayoutEffect(() => () => context.pop(), []);
     return React.createElement(LookupContext.Provider, { value: context }, typeof render == "function"
         ? React.createElement(RenderFunction, { context, render })
         : render);
 }
-function useNewContext(include) {
+function useNewContext(include, assign) {
     const ambient = useLookup();
-    return React.useMemo(() => {
+    const context = React.useMemo(() => {
         if (!include)
-            throw Oops$1.NoType();
-        const layer = ambient.push();
+            throw Oops.NoType();
+        const next = ambient.push();
         function register(I) {
             if (I instanceof Model)
-                layer.inject(I.constructor, I, false);
+                next.add(I.constructor, I, false);
             else
-                layer.inject(I, I.new(), true);
+                next.add(I, I.new(), true);
         }
         if (include instanceof Model || typeof include == "function")
             register(include);
         else
             values(include).forEach(register);
-        for (const instance of layer.local)
+        for (const instance of next.local)
             if (instance)
                 for (const apply of getPending(instance))
-                    apply(layer);
-        return layer;
-    }, []);
-}
-function useAppliedProps(context, props) {
-    const apply = React.useMemo(() => {
-        return (props) => {
-            entries(props).forEach(([key, value]) => {
-                if (key == "for" || key == "children")
-                    return;
-                for (const into of context.local)
-                    if (into && key in into)
-                        into[key] = value;
-            });
-        };
+                    apply(next);
+        return next;
     }, []);
-    apply(props);
+    if (assign) {
+        for (const key in assign)
+            for (const into of context.local)
+                if (into && key in into)
+                    into[key] = assign[key];
+    }
+    return context;
 }
 function RenderFunction(props) {
     const hook = use(refresh => {
@@ -1440,57 +1492,9 @@ function RenderFunction(props) {
     return props.render(hook.proxy);
 }
 
-const Oops = issues({
-    DoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.new() before attempting to access, or consider using ${name}.use() instead.`,
-    AlreadyExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
-});
-const Active = new WeakMap();
 class Global extends MVC {
-    constructor() {
-        super();
-        Active.set(this.constructor, this);
-    }
-    destroy(force) {
-        const type = this.constructor;
-        if (type.keepAlive && !force)
-            return false;
-        Control.for(this).clear();
-        Active.delete(type);
-        return true;
-    }
-    static new(...args) {
-        if (Active.has(this))
-            if (this.keepAlive)
-                return Active.get(this);
-            else
-                throw Oops.AlreadyExists(this.name);
-        const instance = new this(...args);
-        Control.for(instance);
-        return instance;
-    }
-    /**
-     * Update the active instance of this class.
-     * Returns a thenable; resolves after successful update.
-     * If instance does not already exist, one will be created.
-     */
-    static set(values) {
-        return this.get(true).update(values);
-    }
-    static get(arg) {
-        const instance = Active.get(this);
-        if (!instance && arg !== false)
-            throw Oops.DoesNotExist(this.name);
-        return (typeof arg == "string" ?
-            instance[arg] :
-            instance);
-    }
-    /** Destroy current instance of Global, if it exists. */
-    static reset() {
-        const current = Active.get(this);
-        if (current)
-            current.destroy(true);
-    }
 }
+Global.global = true;
 Global.keepAlive = true;
 
 const LOCAL = "$debug local";
@@ -1530,5 +1534,5 @@ const Debug = {
     UPDATE
 };
 
-export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use$1 as use, useContext, useModel, useTap, useValue };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use$1 as use, useContext, useNew, useTap };
 //# sourceMappingURL=index.esm.js.map