@expressive/mvc 1.0.0-beta.20 → 1.0.0-beta.24

package/lib/index.js

@@ -313,18 +313,17 @@ function eventsFor(prefix) {
 }
 
 const CONTROL = Symbol("control");
-const CREATE = Symbol("start");
 const LOCAL = Symbol("local");
 const STATE = Symbol("state");
-const Pending = new Map();
 function manage(src) {
     return src[CONTROL];
 }
-function set(instruction, label) {
-    const name = label || instruction.name || "pending";
+const Pending = new Map();
+function apply(fn, label) {
+    const name = label || fn.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
-    Pending.set(placeholder, function set(key) {
-        let output = instruction.call(this, key, this);
+    function setup(key) {
+        let output = fn.call(this, key, this);
         if (typeof output == "function") {
             const getter = output;
             output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
@@ -333,7 +332,8 @@ function set(instruction, label) {
         }
         if (output)
             defineProperty(this.subject, key, output);
-    });
+    }
+    Pending.set(placeholder, setup);
     return placeholder;
 }
 class Controller {
@@ -345,14 +345,10 @@ class Controller {
         this.waiting = [];
     }
     static setup(onto) {
-        const create = onto[CREATE];
         const control = new this(onto);
-        const after = create && create.call(onto, control);
         defineLazy(onto, CONTROL, () => {
             onto[STATE] = control.state;
             control.start();
-            if (after)
-                after();
             if (onto.didCreate)
                 onto.didCreate();
             return control;
@@ -457,56 +453,57 @@ function keys(from, using) {
     return from.select(using);
 }
 
-const attach = (from, name) => set(function attach(key) {
-    const proxyCache = new WeakMap();
-    const getCurrent = from.call(this, key);
-    function subscribe(sub) {
-        let child;
-        function start() {
-            const instance = getCurrent();
-            if (instance) {
-                child = new Subscriber(instance, sub.onUpdate);
-                if (sub.active)
-                    child.commit();
-                sub.dependant.add(child);
-                proxyCache.set(sub, child.proxy);
+function child(from, name) {
+    return apply(function child(key) {
+        const proxyCache = new WeakMap();
+        const getCurrent = from.call(this, key);
+        function subscribe(sub) {
+            let child;
+            function start() {
+                const instance = getCurrent();
+                if (instance) {
+                    child = new Subscriber(instance, sub.onUpdate);
+                    if (sub.active)
+                        child.commit();
+                    sub.dependant.add(child);
+                    proxyCache.set(sub, child.proxy);
+                }
             }
-        }
-        function refresh() {
-            if (child) {
-                child.release();
-                sub.dependant.delete(child);
-                proxyCache.set(sub, undefined);
-                child = undefined;
+            function refresh() {
+                if (child) {
+                    child.release();
+                    sub.dependant.delete(child);
+                    proxyCache.set(sub, undefined);
+                    child = undefined;
+                }
+                start();
+                sub.onUpdate();
             }
             start();
-            sub.onUpdate();
+            sub.follow(key, refresh);
         }
-        start();
-        sub.follow(key, refresh);
-    }
-    return (local) => {
-        if (!local)
-            return getCurrent();
-        if (!proxyCache.has(local))
-            subscribe(local);
-        return proxyCache.get(local);
-    };
-}, name || from.name);
+        return (local) => {
+            if (!local)
+                return getCurrent();
+            if (!proxyCache.has(local))
+                subscribe(local);
+            return proxyCache.get(local);
+        };
+    }, name || from.name);
+}
 
 const Oops$7 = issues({
     HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
 });
-const useElementLifecycle = lifecycle("element");
 function use$1(init) {
     const [state, update] = react.useState(() => [
         init(() => update(state.concat()))
     ]);
     return state[0];
 }
-function useLazy(Type, args, callback) {
+function useLazy(Type, callback) {
     const instance = react.useMemo(() => {
-        const instance = Type.create(...args || []);
+        const instance = Type.create();
         if (callback)
             callback(instance);
         return instance;
@@ -533,14 +530,9 @@ function useWatcher(target, focus, expected) {
     react.useLayoutEffect(() => hook.commit(), []);
     return hook.proxy;
 }
-function useSubscriber(target, tag) {
-    const hook = use$1(refresh => new Subscriber(target, refresh));
-    useElementLifecycle(hook, tag || 0);
-    return hook.proxy;
-}
-function useModel(Type, args, callback) {
+function useModel(Type, callback) {
     const hook = use$1(refresh => {
-        const instance = new Type(...args || []);
+        const instance = new Type();
         const control = manage(instance);
         const sub = new Subscriber(control, refresh);
         const release = control.addListener({
@@ -556,6 +548,56 @@ function useModel(Type, args, callback) {
     return hook.proxy;
 }
 
+const Oops$6 = issues({
+    CantAttachGlobal: (parent, child) => `Singleton '${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();
+function tap(type, argument) {
+    return child(function tap(key) {
+        return pendingAccess(this.subject, type, key, argument);
+    });
+}
+function pendingAccess(from, type, key, argument) {
+    if ("current" in type)
+        return () => type.current;
+    if ("current" in from.constructor)
+        throw Oops$6.CantAttachGlobal(from, type.name);
+    let instance;
+    getPending(from).push(context => {
+        instance = context.get(type);
+        if (typeof argument == "function") {
+            if (argument(instance) === false)
+                instance = undefined;
+        }
+        else if (!instance && argument)
+            throw Oops$6.AmbientRequired(type.name, from, key);
+    });
+    return () => instance;
+}
+function usePeerContext(subject) {
+    if (ContextWasUsed.has(subject)) {
+        if (ContextWasUsed.get(subject))
+            useLookup();
+        return;
+    }
+    const pending = PendingContext.get(subject);
+    if (pending) {
+        const local = useLookup();
+        for (const init of pending)
+            init(local);
+        PendingContext.delete(subject);
+    }
+    ContextWasUsed.set(subject, !!pending);
+}
+function getPending(subject) {
+    let pending = PendingContext.get(subject);
+    if (!pending)
+        PendingContext.set(subject, pending = []);
+    return pending;
+}
+
 class Lookup {
     constructor() {
         this.table = new Map();
@@ -611,7 +653,7 @@ class Lookup {
     }
 }
 
-const Oops$6 = issues({
+const Oops$5 = issues({
     NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
     NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
     BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
@@ -621,7 +663,7 @@ const useLookup = () => react.useContext(LookupContext);
 function useFromContext(Type, strict) {
     const instance = useLookup().get(Type);
     if (!instance && strict)
-        throw Oops$6.NothingInContext(Type.name);
+        throw Oops$5.NothingInContext(Type.name);
     return instance;
 }
 function Consumer(props) {
@@ -632,13 +674,13 @@ function Consumer(props) {
     if (typeof callback == "function")
         callback(Control.get(!!has));
     else
-        throw Oops$6.BadConsumerProps();
+        throw Oops$5.BadConsumerProps();
     return null;
 }
 function useNewContext(from, inject) {
     return react.useMemo(() => {
         if (!inject)
-            throw Oops$6.NoProviderType();
+            throw Oops$5.NoProviderType();
         const context = from.push(inject);
         for (const instance of context.local)
             for (const apply of getPending(instance))
@@ -681,63 +723,88 @@ function Provider(props) {
         : render);
 }
 
-const Oops$5 = issues({
-    CantAttachGlobal: (parent, child) => `Singleton '${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 tap = (type, argument) => attach(function tap(key) {
-    return pendingAccess(this.subject, type, key, argument);
-});
-function pendingAccess(from, type, key, argument) {
-    if ("current" in type)
-        return () => type.current;
-    if ("current" in from.constructor)
-        throw Oops$5.CantAttachGlobal(from, type.name);
-    let instance;
-    getPending(from).push(context => {
-        instance = context.get(type);
-        if (typeof argument == "function") {
-            if (argument(instance) === false)
-                instance = undefined;
-        }
-        else if (!instance && argument)
-            throw Oops$5.AmbientRequired(type.name, from, key);
-    });
-    return () => instance;
-}
-function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = PendingContext.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        PendingContext.delete(subject);
-    }
-    ContextWasUsed.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
-}
-
 const Oops$4 = issues({
     StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
-class State {
+const useElementLifecycle = lifecycle("element");
+const useComponentLifecycle = lifecycle("component");
+class Model {
     constructor() {
-        Controller.setup(this);
+        const control = Controller.setup(this);
         define(this, "get", this);
         define(this, "set", this);
+        defer(control, "on");
+        defer(control, "effect");
+        control.include(() => {
+            delete this.on;
+            delete this.effect;
+        });
+    }
+    tap(path, expect) {
+        const proxy = useWatcher(this, path, expect);
+        this.update("willRender", true);
+        return proxy;
+    }
+    tag(id) {
+        const hook = use$1(refresh => {
+            return new Subscriber(this, refresh);
+        });
+        useElementLifecycle(hook, id || 0);
+        return hook.proxy;
+    }
+    use(callback) {
+        const hook = use$1(refresh => {
+            if (callback)
+                callback(this);
+            return new Subscriber(this, refresh);
+        });
+        useComponentLifecycle(hook);
+        return hook.proxy;
+    }
+    on(subset, handler, squash, once) {
+        const control = manage(this);
+        const set = keys(control, subset);
+        const batch = {};
+        const remove = control.addListener(batch);
+        const callback = squash
+            ? handler.bind(this)
+            : (frame) => {
+                for (const key of frame)
+                    if (set.includes(key))
+                        handler.call(this, control.state[key], key);
+            };
+        const handle = once
+            ? (k) => { remove(); callback(k); }
+            : callback;
+        for (const key of set)
+            batch[key] = handle;
+        ensure(control, set);
+        return remove;
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        else
+            return new Promise(resolve => {
+                this.on(select, resolve, true, true);
+            });
+    }
+    effect(callback, select) {
+        const control = manage(this);
+        let target = this;
+        const effect = createEffect(callback);
+        const invoke = () => effect.call(target, target);
+        if (select) {
+            invoke();
+            return this.on(select, invoke, true);
+        }
+        else {
+            const sub = new Subscriber(control, invoke);
+            target = sub.proxy;
+            invoke();
+            return sub.commit();
+        }
     }
     import(from, subset) {
         for (const key of keys(manage(this), subset))
@@ -788,34 +855,16 @@ class State {
     toString() {
         return this.constructor.name;
     }
-    tap(path, expect) {
-        const proxy = useWatcher(this, path, expect);
-        this.update("willRender", true);
-        return proxy;
-    }
     static create(...args) {
         const instance = new this(...args);
         manage(instance);
         return instance;
     }
-    static new(args, callback) {
-        const instance = useLazy(this, args, callback);
+    static new(callback) {
+        const instance = useLazy(this, callback);
         instance.update("willRender", true);
         return instance;
     }
-    static use(args, callback) {
-        return useModel(this, args, callback);
-    }
-    static uses(props, only) {
-        return this.use([], instance => {
-            instance.import(props, only);
-        });
-    }
-    static using(props, only) {
-        const instance = this.use([]);
-        instance.import(props, only);
-        return instance;
-    }
     static find(strict) {
         return useFromContext(this, strict);
     }
@@ -830,86 +879,36 @@ class State {
     static tap(key, expect) {
         return this.find(true).tap(key, expect);
     }
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-State.CONTROL = CONTROL;
-State.STATE = STATE;
-State.INIT = CREATE;
-State.LOCAL = LOCAL;
-
-const useComponentLifecycle = lifecycle("component");
-class Model extends State {
-    [CREATE](using) {
-        defer(using, "on");
-        defer(using, "effect");
-        return () => {
-            delete this.on;
-            delete this.effect;
-        };
-    }
-    on(subset, handler, squash, once) {
-        const control = manage(this);
-        const set = keys(control, subset);
-        const batch = {};
-        const remove = control.addListener(batch);
-        const callback = squash
-            ? handler.bind(this)
-            : (frame) => {
-                for (const key of frame)
-                    if (set.includes(key))
-                        handler.call(this, control.state[key], key);
-            };
-        const handle = once
-            ? (k) => { remove(); callback(k); }
-            : callback;
-        for (const key of set)
-            batch[key] = handle;
-        ensure(control, set);
-        return remove;
-    }
-    once(select, callback, squash) {
-        if (callback)
-            return this.on(select, callback, squash, true);
-        else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
-            });
-    }
-    effect(callback, select) {
-        const control = manage(this);
-        let target = this;
-        const effect = createEffect(callback);
-        const invoke = () => effect.call(target, target);
-        if (select) {
-            invoke();
-            return this.on(select, invoke, true);
-        }
-        else {
-            const sub = new Subscriber(control, invoke);
-            target = sub.proxy;
-            invoke();
-            return sub.commit();
-        }
-    }
-    tag(id) {
-        return useSubscriber(this, id);
+    static tag(id) {
+        return this.find(true).tag(id);
     }
-    static use(args, callback) {
-        const instance = useModel(this, args, callback);
+    static use(callback) {
+        const instance = useModel(this, callback);
         useComponentLifecycle(instance[LOCAL]);
         usePeerContext(instance.get);
         return instance;
     }
-    static tag(id) {
-        return this.find(true).tag(id);
+    static uses(props, only) {
+        return this.use(instance => {
+            instance.import(props, only);
+        });
+    }
+    static using(props, only) {
+        const instance = this.use();
+        instance.import(props, only);
+        return instance;
     }
     static meta(path) {
         return useWatcher(this, path);
     }
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
 }
+Model.CONTROL = CONTROL;
+Model.STATE = STATE;
+Model.LOCAL = LOCAL;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this).start();
 });
@@ -939,73 +938,86 @@ function bootstrap(object) {
         defineProperty(control, key, breakdown[key]);
     return control;
 }
-const use = (input, argument) => attach(function use(key) {
-    let instance;
-    const update = (next) => {
-        instance =
-            next instanceof Model ? next :
-                next && bootstrap(next);
-        if (instance) {
-            Parent.set(instance, this.subject);
-            manage(instance);
+function use(input, argument) {
+    return child(function use(key) {
+        let instance;
+        const update = (next) => {
+            instance =
+                next instanceof Model ? next :
+                    next && bootstrap(next);
+            if (instance) {
+                Parent.set(instance, this.subject);
+                manage(instance);
+            }
+            if (typeof argument == "function")
+                argument(instance);
+            else if (!instance && argument !== false)
+                throw Oops$3.UndefinedNotAllowed(key);
+        };
+        if (input) {
+            instance =
+                Model.isTypeof(input) ? new input() :
+                    input instanceof Model ? input :
+                        typeof input === "function" ? input() :
+                            typeof input === "object" ? bootstrap(input) :
+                                Oops$3.BadArgument(typeof input).throw();
+            if (instance)
+                update(instance);
         }
-        if (typeof argument == "function")
-            argument(instance);
-        else if (!instance && argument !== false)
-            throw Oops$3.UndefinedNotAllowed(key);
-    };
-    if (input) {
-        instance =
-            Model.isTypeof(input) ? new input() :
-                input instanceof Model ? input :
-                    typeof input === "function" ? input() :
-                        typeof input === "object" ? bootstrap(input) :
-                            Oops$3.BadArgument(typeof input).throw();
-        if (instance)
-            update(instance);
-    }
-    else
-        argument = false;
-    this.manage(key, instance, update);
-    return () => instance;
-});
-const parent = (Expects, required) => set(function parent() {
-    const child = this.subject;
-    const expected = Expects.name;
-    const value = Parent.get(this.subject);
-    if (!value) {
-        if (required)
-            throw Oops$3.ParentRequired(expected, child);
-    }
-    else if (!(value instanceof Expects))
-        throw Oops$3.UnexpectedParent(expected, child, value);
-    return { value };
-});
+        else
+            argument = false;
+        this.manage(key, instance, update);
+        return () => instance;
+    });
+}
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const expected = Expects.name;
+        const value = Parent.get(this.subject);
+        if (!value) {
+            if (required)
+                throw Oops$3.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$3.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
 
 const Oops$2 = issues({
     DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
     BadComputedSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`
 });
-function ref(cb) {
-    return set(function ref(key) {
-        const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
-        defineProperty(refObjectFunction, "current", {
-            set: refObjectFunction,
-            get: () => this.state[key]
-        });
-        return {
-            value: refObjectFunction
-        };
+function createRef(key, cb) {
+    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = manage(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value };
     });
 }
 function on(initial, cb) {
-    return set(function on(key) {
+    return apply(function on(key) {
         this.manage(key, initial, cb && createValueEffect(cb));
     });
 }
 function memo(factory, defer) {
-    return set(function memo(key) {
+    return apply(function memo(key) {
         const source = this.subject;
         const get = () => factory.call(source);
         if (defer)
@@ -1015,7 +1027,7 @@ function memo(factory, defer) {
     });
 }
 function lazy(value) {
-    return set(function lazy(key) {
+    return apply(function lazy(key) {
         const source = this.subject;
         source[key] = value;
         defineProperty(this.state, key, {
@@ -1024,7 +1036,7 @@ function lazy(value) {
     });
 }
 function act(task) {
-    return set(function act(key) {
+    return apply(function act(key) {
         let pending = false;
         const invoke = (...args) => {
             if (pending)
@@ -1049,7 +1061,7 @@ function act(task) {
     });
 }
 function from(source, setter, getter) {
-    return set(function from(key) {
+    return apply(function from(key) {
         const { subject } = this;
         let getSource;
         // Easy mistake, using a peer, will always be unresolved.
@@ -1076,51 +1088,76 @@ function from(source, setter, getter) {
 const Oops$1 = issues({
     ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
+function pending(source, compute) {
+    return (source === undefined ?
+        suspendForValue() :
+        typeof source == "function" && !source.prototype ?
+            suspendForAsync(source) :
+            suspendForComputed(source, compute));
+}
 /**
- * Create suspense promise also interpretable as an error.
- * React will handle it but other contexts probably won't.
+ * Get value, suspend instead if undefined.
+ *
+ * Throws suspense promise also interpretable as an error.
+ * React could handle it but other contexts probably not.
  */
-function suspense(model, key) {
-    const { message, stack } = Oops$1.ValueNotReady(model, key);
+function pendingValue(via, key) {
+    const value = via.state[key];
+    if (value !== undefined)
+        return value;
+    const error = Oops$1.ValueNotReady(via.subject, key);
     const promise = new Promise(resolve => {
-        const release = model.on(key, (value) => {
-            if (value !== undefined)
-                release(), resolve();
+        const release = via.addListener({
+            [key](value) {
+                if (value !== undefined) {
+                    release();
+                    resolve();
+                }
+            }
         });
     });
-    return Object.assign(promise, { message, stack });
+    throw Object.assign(promise, {
+        toString: () => String(error),
+        message: error.message,
+        stack: error.stack
+    });
 }
-function pending(source, compute) {
-    if (typeof source == "function" && !source.prototype)
-        return suspendForAsync(source);
-    else
-        return from(source, compute, function getter(value, key) {
-            if (value === undefined)
-                throw suspense(this, key);
-            return value;
-        });
+function suspendForComputed(source, compute) {
+    function getter(_value, key) {
+        return pendingValue(manage(this), key);
+    }
+    return from(source, compute, getter);
+}
+function suspendForValue() {
+    return apply(function pending(key) {
+        this.state[key] = undefined;
+        return {
+            set: this.setter(key),
+            get: () => pendingValue(this, key)
+        };
+    });
 }
 function suspendForAsync(source) {
-    return set(function suspense(key) {
+    return apply(function suspense(key) {
+        const subject = this.subject;
         let waiting = true;
-        let output;
+        let value;
         let error;
         return () => {
-            if (waiting) {
-                const issue = Oops$1.ValueNotReady(this.subject, key);
-                const promise = source
-                    .call(this.subject, key)
-                    .catch(err => error = err)
-                    .then((value) => output = value)
-                    .finally(() => waiting = false);
-                throw Object.assign(promise, {
-                    message: issue.message,
-                    stack: issue.stack
-                });
-            }
             if (error)
                 throw error;
-            return output;
+            if (!waiting)
+                return value;
+            const issue = Oops$1.ValueNotReady(subject, key);
+            let suspend = source
+                .call(subject, key)
+                .catch(err => error = err)
+                .then(out => value = out)
+                .finally(() => waiting = false);
+            throw Object.assign(suspend, {
+                message: issue.message,
+                stack: issue.stack
+            });
         };
     });
 }
@@ -1170,9 +1207,9 @@ exports.Consumer = Consumer;
 exports.Model = Model;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
-exports.State = State;
 exports.act = act;
-exports.attach = attach;
+exports.apply = apply;
+exports.child = child;
 exports["default"] = Model;
 exports.from = from;
 exports.lazy = lazy;
@@ -1181,6 +1218,6 @@ exports.on = on;
 exports.parent = parent;
 exports.pending = pending;
 exports.ref = ref;
-exports.set = set;
 exports.tap = tap;
 exports.use = use;
+//# sourceMappingURL=index.js.map