@expressive/mvc 0.0.1

package/lib/index.js

@@ -0,0 +1,1383 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+class Issue extends Error {
+    constructor() {
+        super(...arguments);
+        // drop first line (error factory) in stack trace.
+        this.stack = this.stack.replace(/\n.+/, "");
+    }
+    warn() {
+        console.warn(this.message);
+    }
+}
+function issues(register) {
+    const Library = {};
+    for (const name in register)
+        Library[name] = (...args) => new Issue(register[name].apply(null, args));
+    return Library;
+}
+
+const Oops$c = issues({
+    BadEffectCallback: () => `Callback for effect-callback may only return a function.`
+});
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+function define(target, key, value) {
+    defineProperty(target, key, { value });
+}
+function defineLazy(object, property, init) {
+    defineProperty(object, property, {
+        configurable: true,
+        get() {
+            const value = init.call(this);
+            defineProperty(this, property, { value });
+            return value;
+        }
+    });
+}
+function createEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet();
+        unSet = callback.call(this, value);
+        if (unSet instanceof Promise)
+            unSet = undefined;
+        if (unSet && typeof unSet !== "function")
+            throw Oops$c.BadEffectCallback();
+    };
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$c.BadEffectCallback();
+    };
+}
+function suspenseBoundary(fn) {
+    const retry = (err) => {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    };
+    const compute = () => {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
+    };
+    return compute();
+}
+
+const UPDATE = new WeakMap();
+function applyUpdate(subject, keys) {
+    UPDATE.set(subject, keys);
+    return () => {
+        setTimeout(() => {
+            UPDATE.delete(subject);
+        }, 0);
+    };
+}
+
+const CONTROL = Symbol("CONTROL");
+const WHY = Symbol("UPDATE");
+const LOCAL = Symbol("LOCAL");
+const STATE = Symbol("STATE");
+class Model {
+    constructor() {
+        define(this, CONTROL, new Controller(this));
+        define(this, "get", this);
+        define(this, "set", this);
+    }
+    get [STATE]() {
+        return this[CONTROL].state;
+    }
+    get [WHY]() {
+        return UPDATE.get(this);
+    }
+    on(select, handler, squash, once) {
+        return control(this, control => {
+            if (typeof select == "function")
+                return control.addListener(select);
+            const keys = typeof select == "string" ? [select] :
+                !select.length ? getOwnPropertyNames(control.state) :
+                    select;
+            ensure(control, keys);
+            const callback = squash
+                ? handler.bind(this)
+                : frame => frame
+                    .filter(k => keys.includes(k))
+                    .forEach(k => handler.call(this, control.state[k], k));
+            const trigger = once
+                ? frame => { remove(); callback(frame); }
+                : callback;
+            const remove = control.addListener(key => {
+                if (keys.includes(key))
+                    return trigger;
+            });
+            return remove;
+        });
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
+    }
+    effect(callback, select) {
+        const effect = createEffect(callback);
+        return control(this, control => {
+            if (!select) {
+                const sub = new Subscriber(control, () => invoke);
+                const invoke = () => {
+                    const x = sub.proxy;
+                    effect.call(x, x);
+                };
+                invoke();
+                return sub.commit();
+            }
+            const invoke = () => {
+                effect.call(this.get, this.get);
+            };
+            invoke();
+            if (!select.length) {
+                control.onDestroy.add(invoke);
+                return () => {
+                    control.onDestroy.delete(invoke);
+                };
+            }
+            return control.addListener(key => {
+                if (select.includes(key))
+                    return invoke;
+            });
+        });
+    }
+    // TODO: account for exotic properties
+    import(source, select) {
+        const { subject } = control(this);
+        if (!select)
+            select = getOwnPropertyNames(subject);
+        for (const key of select)
+            if (key in source)
+                this[key] = source[key];
+    }
+    export(subset) {
+        const { state } = control(this);
+        const output = {};
+        if (!subset)
+            subset = getOwnPropertyNames(state);
+        for (const key of subset)
+            output[key] = state[key];
+        return output;
+    }
+    update(arg, tag) {
+        const target = control(this);
+        if (typeof arg == "string") {
+            target.update(arg);
+            if (1 in arguments && arg in this) {
+                const method = this[arg];
+                if (typeof method == "function")
+                    if (typeof tag != "boolean")
+                        method.call(this, tag);
+                    else if (tag)
+                        method.call(this);
+            }
+            arg = undefined;
+        }
+        return target.requestUpdate(arg);
+    }
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
+    destroy() {
+        control(this).stop();
+    }
+    toString() {
+        return this.constructor.name;
+    }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static create(...args) {
+        const instance = new this(...args);
+        control(instance);
+        return instance;
+    }
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+defineLazy(Model, CONTROL, function () {
+    return new Controller(this);
+});
+
+class Subscriber {
+    constructor(target, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.dependant = new Set();
+        this.watch = {};
+        const parent = target instanceof Controller
+            ? target : control(target);
+        const proxy = create(parent.proxy);
+        let reset;
+        define(proxy, LOCAL, this);
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                if (reset)
+                    setTimeout(reset, 0);
+                return proxy;
+            }
+        });
+        const release = parent.addListener(key => {
+            const handler = this.watch[key];
+            if (!handler || !this.active)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, parent);
+            const getWhy = (keys) => {
+                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
+            };
+            if (notify) {
+                parent.requestUpdate(getWhy);
+                parent.requestUpdate(notify);
+            }
+        });
+        this.commit = () => {
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release;
+        };
+        this.release = () => {
+            this.dependant.forEach(x => x.release());
+            release();
+        };
+    }
+}
+
+const Oops$b = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+});
+function suspend(source, key) {
+    const error = Oops$b.ValueNotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
+                return () => {
+                    if (source.state[key] !== undefined) {
+                        release();
+                        resolve();
+                    }
+                };
+        });
+    });
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
+}
+
+const Oops$a = issues({
+    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.`,
+    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
+});
+const INIT = new WeakSet();
+const INFO = new WeakMap();
+const USED = new WeakMap();
+const KEYS = new WeakMap();
+function from(source, arg1, arg2) {
+    return apply(function from(key) {
+        const parent = this;
+        const { subject, state } = this;
+        let getSource;
+        let required = arg2 === true || arg1 === true;
+        if (typeof arg1 == "boolean")
+            arg1 = undefined;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$a.PeerNotAllowed(subject, key);
+        // replace source controller in-case it is different
+        if (typeof source == "object")
+            getSource = () => control(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            arg1 = source.call(subject, key);
+            getSource = () => this;
+        }
+        // Regular function is too ambiguous so not allowed.
+        else
+            throw Oops$a.BadComputedSource(subject, key, source);
+        let sub;
+        const setter = arg1;
+        const info = { key, parent, priority: 1 };
+        let register = USED.get(parent);
+        if (!register) {
+            register = new Map();
+            USED.set(parent, register);
+        }
+        register.set(key, info);
+        function compute(initial) {
+            try {
+                return setter.call(sub.proxy, sub.proxy);
+            }
+            catch (err) {
+                Oops$a.ComputeFailed(subject, key, !!initial).warn();
+                throw err;
+            }
+        }
+        function update() {
+            let value;
+            try {
+                value = compute(false);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                if (state[key] !== value) {
+                    parent.update(key, value);
+                    return value;
+                }
+            }
+        }
+        function defer(_key, from) {
+            let pending = KEYS.get(from);
+            if (!pending)
+                KEYS.set(from, pending = []);
+            if (info.parent !== from)
+                update();
+            else {
+                const after = pending.findIndex(peer => (info.priority > INFO.get(peer).priority));
+                pending.splice(after + 1, 0, update);
+            }
+        }
+        function create(early) {
+            sub = new Subscriber(getSource(), defer);
+            defineProperty(state, key, {
+                value: undefined,
+                writable: true
+            });
+            try {
+                return state[key] = compute(true);
+            }
+            catch (e) {
+                if (early)
+                    Oops$a.ComputedEarly(key).warn();
+                throw e;
+            }
+            finally {
+                sub.commit();
+                for (const key in sub.watch) {
+                    const peer = register.get(key);
+                    if (peer && peer.priority >= info.priority)
+                        info.priority = peer.priority + 1;
+                }
+            }
+        }
+        INIT.add(create);
+        INFO.set(update, info);
+        defineProperty(state, key, {
+            get: create,
+            configurable: true,
+            enumerable: true
+        });
+        return () => {
+            const value = parent.state[key];
+            if (value === undefined && required)
+                throw suspend(this, key);
+            return value;
+        };
+    });
+}
+function ensure(on, keys) {
+    for (const key of keys) {
+        const desc = getOwnPropertyDescriptor(on.state, key);
+        const getter = desc && desc.get;
+        if (INIT.has(getter))
+            getter(true);
+    }
+}
+function flush(on) {
+    const handled = on.frame;
+    const pending = KEYS.get(on);
+    if (!pending)
+        return;
+    while (pending.length) {
+        const why = [...handled];
+        const compute = pending.shift();
+        const { key } = INFO.get(compute);
+        if (!handled.has(key))
+            compute(why);
+    }
+    KEYS.delete(on);
+}
+
+const Oops$9 = issues({
+    StrictUpdate: () => `Strict update() did not find pending updates.`,
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+const PENDING = new Map();
+const READY = new WeakSet();
+class Controller {
+    constructor(subject) {
+        this.subject = subject;
+        this.state = {};
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.onDestroy = new Set();
+        this.followers = new Set();
+        this.proxy = Object.create(subject);
+    }
+    start() {
+        for (const key in this.subject)
+            this.manage(key);
+        this.emit([]);
+    }
+    stop() {
+        this.followers.clear();
+        this.onDestroy.forEach(x => x());
+    }
+    manage(key) {
+        const { proxy, state, subject } = this;
+        const { value: entry } = getOwnPropertyDescriptor(subject, key);
+        if (typeof entry == "function")
+            return;
+        if (typeof entry == "symbol") {
+            const instruction = PENDING.get(entry);
+            if (instruction)
+                instruction.call(this, key, this);
+            return;
+        }
+        state[key] = entry;
+        const set = this.ref(key);
+        defineProperty(subject, key, {
+            enumerable: false,
+            get: () => state[key],
+            set
+        });
+        defineProperty(proxy, key, {
+            enumerable: false,
+            get() {
+                const local = this[LOCAL];
+                if (local && !local.watch[key])
+                    local.watch[key] = true;
+                return state[key];
+            },
+            set
+        });
+    }
+    ref(key, handler) {
+        const { state, subject } = this;
+        return (value) => {
+            if (state[key] == value)
+                return;
+            if (handler)
+                switch (handler.call(subject, value, state)) {
+                    case true:
+                        this.update(key);
+                    case false:
+                        return;
+                }
+            this.update(key, value);
+        };
+    }
+    addListener(listener) {
+        this.followers.add(listener);
+        return () => {
+            this.followers.delete(listener);
+        };
+    }
+    emit(keys) {
+        const waiting = [...this.waiting];
+        this.waiting.clear();
+        applyUpdate(this.subject, keys)();
+        for (const callback of waiting)
+            try {
+                callback(keys);
+            }
+            catch (err) {
+                console.error(err);
+            }
+    }
+    update(key, value) {
+        if (1 in arguments)
+            this.state[key] = value;
+        if (this.frame.has(key))
+            return;
+        if (!this.frame.size)
+            setTimeout(() => {
+                flush(this);
+                const keys = Object.freeze([...this.frame]);
+                this.frame.clear();
+                this.emit(keys);
+            }, 0);
+        this.frame.add(key);
+        for (const callback of this.followers) {
+            const event = callback(key, this);
+            if (typeof event == "function")
+                this.waiting.add(event);
+        }
+    }
+    requestUpdate(arg) {
+        if (typeof arg == "function") {
+            this.waiting.add(arg);
+            return;
+        }
+        if (arg === true && this.frame.size < 1)
+            return Promise.reject(Oops$9.StrictUpdate());
+        return {
+            then: (callback) => {
+                if (callback)
+                    if (this.frame.size || arg !== false)
+                        this.waiting.add(callback);
+                    else
+                        callback(false);
+                else
+                    throw Oops$9.NoChaining();
+            }
+        };
+    }
+}
+function control(subject, cb) {
+    let control = subject[CONTROL];
+    const ready = READY.has(control);
+    if (!control) {
+        control = new Controller(subject);
+        define(subject, CONTROL, control);
+    }
+    if (!cb) {
+        if (!ready) {
+            READY.add(control);
+            control.start();
+        }
+        return control;
+    }
+    if (!ready) {
+        let done;
+        control.requestUpdate(() => {
+            done = cb(control);
+        });
+        return () => done && done();
+    }
+    return cb(control);
+}
+
+function apply(fn, label) {
+    const name = label || fn.name || "pending";
+    const placeholder = Symbol(`${name} instruction`);
+    function setup(key) {
+        const { proxy, state, subject } = this;
+        const control = this;
+        PENDING.delete(placeholder);
+        delete subject[key];
+        let output = fn.call(this, key, this);
+        if (typeof output == "function")
+            output = { get: output };
+        if (typeof output != "object")
+            return;
+        if ("explicit" in output && output.explicit) {
+            defineProperty(subject, key, output);
+            return false;
+        }
+        if ("recursive" in output && output.recursive)
+            output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
+        const desc = output;
+        if ("value" in desc)
+            state[key] = desc.value;
+        const { get: onGet, set: onSet, enumerable, suspense } = desc;
+        let set = onSet === false
+            ? undefined
+            : this.ref(key, onSet);
+        function get() {
+            if (!(key in state) && suspense)
+                throw suspend(control, key);
+            const local = this[LOCAL];
+            if (local && !(key in local.watch))
+                local.watch[key] = true;
+            const value = state[key];
+            if (!onGet)
+                return value;
+            return local
+                ? onGet(value, local)
+                : onGet(value);
+        }
+        for (const x of [subject, proxy])
+            defineProperty(x, key, { enumerable, get, set });
+    }
+    PENDING.set(placeholder, setup);
+    return placeholder;
+}
+function recursive(source, key) {
+    return forSubscriber((parent, context) => {
+        let child;
+        function init() {
+            if (child) {
+                child.release();
+                parent.dependant.delete(child);
+                context.set(parent, undefined);
+                child = undefined;
+            }
+            const value = source.state[key];
+            if (value && CONTROL in value) {
+                child = new Subscriber(value, parent.onUpdate);
+                if (parent.active)
+                    child.commit();
+                parent.dependant.add(child);
+                context.set(parent, child.proxy);
+            }
+        }
+        init();
+        parent.watch[key] = init;
+    });
+}
+function forSubscriber(fn) {
+    const context = new WeakMap();
+    return (value, local) => {
+        if (!local)
+            return value;
+        if (!context.has(local)) {
+            const output = fn(local, context);
+            if (output) {
+                context.set(local, output);
+                return output;
+            }
+        }
+        return context.get(local);
+    };
+}
+
+const Oops$8 = issues({
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
+});
+function act(task) {
+    return apply(function act(key) {
+        let pending = false;
+        const invoke = (...args) => {
+            if (pending)
+                return Promise.reject(Oops$8.DuplicateAction(key));
+            pending = true;
+            this.update(key);
+            return new Promise(res => {
+                res(task.apply(this.subject, args));
+            }).finally(() => {
+                pending = false;
+                this.update(key);
+            });
+        };
+        this.state[key] = undefined;
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            set: false
+        };
+    });
+}
+
+class Managed extends Array {
+    constructor(onUpdate) {
+        super();
+        this.lastUpdate = [0, 0];
+        this.update = (from, to) => {
+            this.lastUpdate = [from, to];
+            onUpdate();
+        };
+    }
+    push(...items) {
+        const length = this.length;
+        const end = super.push(...items);
+        this.update(length, end);
+        return end;
+    }
+    unshift(...items) {
+        const end = super.push(...items);
+        this.update(0, end);
+        return end;
+    }
+    splice(start, deleteCount, ...rest) {
+        this.update(start, deleteCount !== rest.length ? Infinity : deleteCount);
+        return super.splice(start, deleteCount, ...rest);
+    }
+}
+function array() {
+    return apply(function array(key) {
+        const array = new Managed(() => this.update(key));
+        const access = forSubscriber(context => {
+            const local = Object.create(array);
+            const update = context.onUpdate(key, this);
+            let rangeA = 0;
+            let rangeB = 0;
+            function onUpdate() {
+                const [lastA, lastB] = array.lastUpdate;
+                if (rangeA <= lastB && rangeB >= lastA)
+                    return update;
+            }
+            function listen(eventA, eventB) {
+                if (context.active)
+                    return;
+                context.watch[key] = onUpdate;
+                rangeA = Math.min(rangeA, eventA);
+                rangeB = Math.max(rangeB, eventB);
+            }
+            local[Symbol.iterator] = () => {
+                listen(0, Infinity);
+                return array[Symbol.iterator]();
+            };
+            return local;
+        });
+        return {
+            get: access,
+            set: false,
+            value: array
+        };
+    });
+}
+
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = control(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value, explicit: true };
+    });
+}
+function createRef(key, cb) {
+    const refObjectFunction = this.ref(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+
+const Oops$7 = issues({
+    NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
+    BadFactory: () => `Set instruction can only accept a factory or undefined.`,
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+});
+function set(factory, argument) {
+    return apply(function set(key) {
+        let set;
+        let get;
+        let suspense;
+        const required = argument === true || argument === undefined;
+        if (factory === undefined)
+            suspense = true;
+        else if (typeof factory === "function")
+            get = pendingFactory(this, key, factory, required);
+        else
+            throw Oops$7.BadFactory();
+        if (typeof argument == "function")
+            set = createValueEffect(argument);
+        else
+            set = (value) => {
+                if (value === undefined && required)
+                    throw Oops$7.NonOptional(this.subject, key);
+            };
+        return {
+            set,
+            get,
+            suspense
+        };
+    });
+}
+function pendingFactory(parent, key, fn, required) {
+    const { subject, state } = parent;
+    let pending;
+    let error;
+    const init = () => {
+        const output = suspenseBoundary(() => {
+            return fn.call(subject, key, subject);
+        });
+        if (output instanceof Promise) {
+            pending = output
+                .catch(err => error = err)
+                .then(val => state[key] = val)
+                .finally(() => {
+                pending = undefined;
+                parent.update(key);
+            });
+            return;
+        }
+        return state[key] = output;
+    };
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$7.ValueNotReady(subject, key);
+        Object.assign(pending, {
+            message: issue.message,
+            stack: issue.stack
+        });
+        throw pending;
+    };
+    if (required)
+        try {
+            init();
+        }
+        catch (err) {
+            Oops$7.FactoryFailed(subject, key).warn();
+            throw err;
+        }
+    return () => {
+        if (pending)
+            return suspend();
+        if (error)
+            throw error;
+        if (key in state)
+            return state[key];
+        let output = init();
+        return pending
+            ? suspend()
+            : output;
+    };
+}
+
+const Parent = new WeakMap();
+const Oops$6 = issues({
+    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
+    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+});
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const value = Parent.get(child);
+        const expected = Expects.name;
+        if (!value) {
+            if (required !== false)
+                throw Oops$6.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$6.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
+
+const Oops$5 = issues({
+    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
+});
+function use$1(input, argument) {
+    return apply(function use(key) {
+        const { subject } = this;
+        const onUpdate = (next) => {
+            this.state[key] = next;
+            if (next) {
+                Parent.set(next, subject);
+                control(next);
+            }
+            if (typeof argument == "function")
+                argument(next);
+            return true;
+        };
+        if (input) {
+            const value = Model.isTypeof(input)
+                ? new input() :
+                typeof input === "object"
+                    ? input :
+                    typeof input === "function"
+                        ? input()
+                        : null;
+            if (value === null)
+                throw Oops$5.BadArgument(typeof input);
+            if (value)
+                onUpdate(value);
+        }
+        return {
+            set: onUpdate,
+            recursive: true
+        };
+    });
+}
+
+class Lookup {
+    constructor() {
+        this.table = new Map();
+    }
+    get local() {
+        return [
+            ...new Set(getOwnPropertySymbols(this).map(symbol => this[symbol]))
+        ];
+    }
+    key(T) {
+        let key = this.table.get(T);
+        if (!key) {
+            key = Symbol(T.name);
+            this.table.set(T, key);
+        }
+        return key;
+    }
+    get(T) {
+        return this[this.key(T)];
+    }
+    push(I) {
+        const next = create(this);
+        if (I instanceof Model || typeof I == "function")
+            next.register(I);
+        else
+            for (const i of values(I))
+                next.register(i);
+        return next;
+    }
+    register(I) {
+        let writable = true;
+        let T;
+        if (I instanceof Model) {
+            T = I.constructor;
+            writable = false;
+        }
+        else {
+            T = I;
+            I = I.create();
+        }
+        do {
+            const key = this.key(T);
+            const conflict = this.hasOwnProperty(key);
+            defineProperty(this, key, {
+                value: conflict ? null : I,
+                configurable: true,
+                writable
+            });
+            T = getPrototypeOf(T);
+        } while (T !== Model);
+        return I;
+    }
+    pop() {
+        for (const key of getOwnPropertySymbols(this)) {
+            const entry = getOwnPropertyDescriptor(this, key);
+            if (entry.writable && entry.value)
+                entry.value.destroy();
+        }
+    }
+}
+
+const LookupContext = React__default["default"].createContext(new Lookup());
+const useLookup = () => React__default["default"].useContext(LookupContext);
+const Oops$4 = issues({
+    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
+});
+function useInContext(Type, arg) {
+    const instance = useLookup().get(Type);
+    if (!instance && arg !== false)
+        throw Oops$4.NothingInContext(Type.name);
+    return typeof arg == "string" ?
+        instance[arg] :
+        instance;
+}
+
+const Oops$3 = issues({
+    CantAttachGlobal: (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();
+function tap(type, argument) {
+    return apply(function tap(key) {
+        if ("set" in type)
+            return {
+                recursive: true,
+                value: type.get()
+            };
+        const { subject } = this;
+        if ("set" in subject.constructor)
+            throw Oops$3.CantAttachGlobal(subject, type.name);
+        getPending(subject).push(context => {
+            let instance = context.get(type);
+            if (typeof argument == "function") {
+                if (argument(instance) === false)
+                    instance = undefined;
+            }
+            else if (!instance && argument)
+                throw Oops$3.AmbientRequired(type.name, subject, key);
+            this.update(key, instance);
+        });
+        return {
+            recursive: true,
+            suspense: true
+        };
+    });
+}
+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;
+}
+
+function use(init) {
+    const [state, update] = React__default["default"].useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
+}
+
+function useModel(source, arg, arg2) {
+    const instance = React__default["default"].useMemo(() => {
+        const cb = arg2 || arg;
+        const instance = typeof source == "function" ?
+            source.prototype instanceof Model ?
+                new source() :
+                source() :
+            source;
+        control(instance);
+        if (typeof cb == "function")
+            cb(instance);
+        return instance;
+    }, []);
+    if (Array.isArray(arg)) {
+        const update = React.useState(0)[1];
+        React__default["default"].useLayoutEffect(() => {
+            if (arg.length && instance instanceof Model)
+                instance.on(arg, () => update(x => x + 1), true);
+            return () => {
+                if (Model.isTypeof(source))
+                    instance.destroy();
+            };
+        }, []);
+        return instance;
+    }
+    else {
+        const local = use(refresh => (new Subscriber(instance, () => refresh)));
+        if (typeof arg == "object") {
+            local.active = false;
+            if (typeof arg2 !== "object")
+                arg2 = getOwnPropertyNames(instance);
+            for (const key of arg2)
+                if (key in arg)
+                    instance[key] = arg[key];
+            React__default["default"].useLayoutEffect(() => {
+                local.active = true;
+            });
+        }
+        React__default["default"].useLayoutEffect(() => {
+            local.commit();
+            return () => {
+                local.release();
+                if (Model.isTypeof(source))
+                    instance.destroy();
+            };
+        }, []);
+        return local.proxy;
+    }
+}
+
+function useFrom(target, compute, suspend) {
+    const local = use(refresh => {
+        const sub = new Subscriber(target, () => update);
+        const spy = sub.proxy;
+        let value = compute.call(spy, spy);
+        let update;
+        let retry;
+        const set = (next) => {
+            value = next;
+            if (retry) {
+                retry();
+                retry = undefined;
+            }
+            else
+                refresh();
+        };
+        if (value instanceof Promise) {
+            value.then(set);
+            value = undefined;
+        }
+        else {
+            sub.commit();
+            update = () => {
+                const next = compute.call(spy, spy);
+                if (value != next)
+                    set(next);
+            };
+        }
+        defineProperty(sub, "proxy", {
+            get() {
+                if (value === undefined && suspend)
+                    throw new Promise(res => retry = res);
+                return value;
+            }
+        });
+        return sub;
+    });
+    React__default["default"].useLayoutEffect(() => local.release, []);
+    return local.proxy;
+}
+
+function useTap(source, path, expect) {
+    const instance = React.useMemo(() => {
+        if (typeof source == "object")
+            return () => source;
+        if ("get" in source)
+            return () => source.get();
+        if ("prototype" in source)
+            return () => useInContext(source);
+        else
+            return source;
+    }, [])();
+    if (typeof path == "function")
+        return useFrom(instance, path, expect);
+    const local = use(refresh => {
+        const parent = control(instance);
+        const sub = new Subscriber(parent, () => refresh);
+        if (typeof path == "string") {
+            const source = sub.proxy;
+            defineProperty(sub, "proxy", {
+                get() {
+                    const value = source[path];
+                    if (value === undefined && expect)
+                        throw suspend(parent, path);
+                    return value;
+                }
+            });
+        }
+        return sub;
+    });
+    React__default["default"].useLayoutEffect(local.commit, []);
+    return local.proxy;
+}
+
+/* istanbul ignore file */
+class MVC extends Model {
+    tap(path, expect) {
+        return useTap(this, path, expect);
+    }
+    use(arg, callback) {
+        return useModel(this, arg, callback);
+    }
+    static get(required) {
+        return useInContext(this, required);
+    }
+    static tap(key, expect) {
+        return useTap(this, key, expect);
+    }
+    static new(arg) {
+        const instance = React__default["default"].useMemo(() => {
+            const instance = new this();
+            control(instance);
+            if (typeof arg == "function")
+                arg(instance);
+            else if (arg)
+                getOwnPropertyNames(instance).forEach(key => {
+                    if (key in arg)
+                        instance[key] = arg[key];
+                });
+            return instance;
+        }, []);
+        usePeerContext(instance.get);
+        return instance;
+    }
+    static use(a, b) {
+        const instance = useModel(this, a, b);
+        usePeerContext(instance.get);
+        return instance;
+    }
+    /**
+     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
+    */
+    static uses(apply, keys) {
+        return this.use(instance => {
+            instance.import(apply, keys);
+        });
+    }
+    /**
+     * @deprecated is now replaced by overload of `use` method.
+    */
+    static using(apply, keys) {
+        return this.use(apply, keys);
+    }
+    static meta(path, expect) {
+        return useTap(() => this, path, expect);
+    }
+}
+
+const Oops$2 = issues({
+    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+});
+function Consumer(props) {
+    const { get, has, children, of: Control } = props;
+    if (typeof children == "function")
+        return children(useTap(Control));
+    const callback = has || get;
+    if (typeof callback == "function")
+        callback(useInContext(Control, !!has));
+    else
+        throw Oops$2.BadConsumerProps();
+    return null;
+}
+
+const Oops$1 = issues({
+    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`
+});
+function Provider(props) {
+    const context = useNewContext(props.of);
+    const render = props.children;
+    useAppliedProps(context, props);
+    React__default["default"].useLayoutEffect(() => () => context.pop(), []);
+    return React__default["default"].createElement(LookupContext.Provider, { value: context }, typeof render == "function"
+        ? React__default["default"].createElement(RenderFunction, { context, render })
+        : render);
+}
+function useNewContext(inject) {
+    const from = useLookup();
+    return React__default["default"].useMemo(() => {
+        if (!inject)
+            throw Oops$1.NoProviderType();
+        const context = from.push(inject);
+        for (const instance of context.local)
+            if (instance)
+                for (const apply of getPending(instance))
+                    apply(context);
+        return context;
+    }, []);
+}
+function useAppliedProps(within, props) {
+    const update = React__default["default"].useMemo(() => {
+        const targets = within.local;
+        return function integrate(props) {
+            for (const [key, value] of entries(props))
+                if (key != "of" && key != "children")
+                    for (const into of targets)
+                        if (into && key in into)
+                            into[key] = value;
+        };
+    }, []);
+    update(props);
+}
+function RenderFunction(props) {
+    const hook = use(refresh => {
+        const targets = props.context.local;
+        if (targets.length == 1)
+            return new Subscriber(targets[0], () => refresh);
+        return {};
+    });
+    if (hook.commit)
+        React__default["default"].useLayoutEffect(hook.commit, []);
+    return props.render(hook.proxy);
+}
+
+const Oops = issues({
+    GlobalDoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
+    GlobalExists: (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 {
+    static create(...args) {
+        const Type = this;
+        if (Active.has(Type))
+            throw Oops.GlobalExists(this.name);
+        const instance = super.create(...args);
+        Active.set(Type, 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(updates) {
+        const instance = Active.get(this) || this.create();
+        instance.import(updates);
+        return instance.update(false);
+    }
+    static get(arg) {
+        const instance = Active.get(this);
+        if (!instance && arg !== false)
+            throw Oops.GlobalDoesNotExist(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();
+    }
+    destroy() {
+        super.destroy();
+        Active.delete(this.constructor);
+    }
+}
+
+exports.CONTROL = CONTROL;
+exports.Consumer = Consumer;
+exports.Global = Global;
+exports.LOCAL = LOCAL;
+exports.Model = MVC;
+exports.Provider = Provider;
+exports.STATE = STATE;
+exports.WHY = WHY;
+exports.act = act;
+exports.apply = apply;
+exports.array = array;
+exports["default"] = MVC;
+exports.from = from;
+exports.parent = parent;
+exports.ref = ref;
+exports.set = set;
+exports.tap = tap;
+exports.use = use$1;
+exports.useFrom = useFrom;
+exports.useInContext = useInContext;
+exports.useModel = useModel;
+exports.useTap = useTap;
+//# sourceMappingURL=index.js.map