@expressive/mvc 0.34.0 → 0.35.0-alpha.0

package/lib/index.js

@@ -1,803 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-const { assign, create, defineProperty, entries, freeze, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-
-const REGISTER = new WeakMap();
-const OBSERVER = new WeakMap();
-const INSTRUCT = new Map();
-const PENDING$1 = new WeakMap();
-const PARENTS = new WeakMap();
-const LIFECYCLE = {
-    ready: new Set(),
-    dispatch: new Set(),
-    update: new Set(),
-    didUpdate: new Set(),
-};
-class Control {
-    static on(event, callback) {
-        LIFECYCLE[event].add(callback);
-        return () => LIFECYCLE[event].delete(callback);
-    }
-    constructor(subject, id) {
-        this.state = {};
-        this.frame = freeze({});
-        this.listeners = new Map();
-        this.id = `${subject.constructor}-${id ? String(id) : uid()}`;
-        this.subject = subject;
-        REGISTER.set(subject, this);
-        if (id !== false)
-            PENDING$1.set(this, new Set(LIFECYCLE.ready));
-    }
-    watch(key, output) {
-        const { state, subject, listeners } = this;
-        const { set, enumerable = true } = output;
-        if ("value" in output)
-            state[key] = output.value;
-        defineProperty(subject, key, {
-            enumerable,
-            set: set === false
-                ? undefined
-                : (next) => {
-                    const previous = state[key];
-                    if (next !== previous) {
-                        state[key] = next;
-                        if (set && set.call(subject, next, previous) === false)
-                            state[key] = previous;
-                        else
-                            this.update(key);
-                    }
-                },
-            get() {
-                const value = output.get
-                    ? output.get(this)
-                    : state[key];
-                const observer = OBSERVER.get(this);
-                if (observer) {
-                    const keys = listeners.get(observer);
-                    listeners.set(observer, new Set(keys).add(key));
-                    return watch(value, observer);
-                }
-                return value;
-            }
-        });
-    }
-    update(key, value) {
-        const { state, subject, listeners } = this;
-        if (!listeners || 1 in arguments && value === state[key])
-            return;
-        if (isFrozen(this.frame)) {
-            this.frame = {};
-            enqueue(() => {
-                freeze(this.frame);
-                listeners.forEach((subs, cb) => {
-                    if (!subs) {
-                        const notify = cb(undefined, subject);
-                        if (notify)
-                            enqueue(notify);
-                    }
-                });
-            });
-        }
-        if (1 in arguments)
-            state[key] = value;
-        if (key in this.frame)
-            return;
-        this.frame[key] = state[key];
-        for (const [cb, keys] of listeners)
-            if (!keys || keys.has(key)) {
-                const notify = cb(key, subject);
-                if (notify === null)
-                    listeners.delete(cb);
-                else if (notify)
-                    enqueue(notify);
-            }
-    }
-    fetch(key, required) {
-        const { state, subject } = this;
-        return () => {
-            if (key in state || required === false) {
-                const value = state[key];
-                if (value !== undefined || !required)
-                    return value;
-            }
-            const error = new Error(`${subject}.${key} is not yet available.`);
-            const promise = new Promise((resolve, reject) => {
-                function check() {
-                    if (state[key] !== undefined) {
-                        remove();
-                        resolve();
-                    }
-                }
-                const remove = this.addListener((k) => {
-                    if (k === key)
-                        return check;
-                    if (k === null)
-                        reject(new Error(`${subject} is destroyed.`));
-                });
-            });
-            throw assign(promise, {
-                toString: () => String(error),
-                name: "Suspense",
-                message: error.message,
-                stack: error.stack
-            });
-        };
-    }
-    addListener(fn) {
-        this.listeners.set(fn, undefined);
-        return () => this.listeners.delete(fn);
-    }
-    clear() {
-        this.listeners.forEach((_, fn) => fn(null, this));
-        this.listeners.clear();
-        freeze(this.state);
-    }
-}
-Control.watch = watch;
-Control.for = control;
-Control.add = add;
-function control(subject, ready) {
-    const self = REGISTER.get(subject.is);
-    const pending = PENDING$1.get(self);
-    if (typeof ready == "function") {
-        if (pending) {
-            let done;
-            pending.add(() => done = ready(self));
-            return () => done && done();
-        }
-        return ready(self);
-    }
-    if (pending && ready) {
-        for (const key in subject) {
-            const { value } = getOwnPropertyDescriptor(subject, key);
-            const instruction = INSTRUCT.get(value);
-            let desc = { value };
-            if (instruction) {
-                INSTRUCT.delete(value);
-                delete subject[key];
-                const out = instruction.call(self, key, self);
-                desc = typeof out == "function" ? { get: out } : out;
-            }
-            if (desc)
-                self.watch(key, desc);
-        }
-        PENDING$1.delete(self);
-        pending.forEach(cb => cb(self));
-    }
-    return self;
-}
-function enqueue(event) {
-    const { update, didUpdate, dispatch } = LIFECYCLE;
-    if (!dispatch.size)
-        setTimeout(() => {
-            update.forEach(x => x());
-            dispatch.forEach(event => {
-                try {
-                    event();
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            });
-            dispatch.clear();
-            didUpdate.forEach(x => x());
-        }, 0);
-    dispatch.add(event);
-}
-function parent(from, assign) {
-    if (!assign)
-        return PARENTS.get(from);
-    PARENTS.set(from, assign);
-}
-function watch(value, argument) {
-    const control = REGISTER.get(value);
-    if (control) {
-        if (!OBSERVER.has(value))
-            REGISTER.set(value = create(value), control);
-        OBSERVER.set(value, argument);
-    }
-    return value;
-}
-function add(instruction) {
-    const placeholder = Symbol("instruction");
-    INSTRUCT.set(placeholder, instruction);
-    return placeholder;
-}
-/** Random alphanumberic of length 6. Will always start with a letter. */
-function uid() {
-    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
-}
-
-class Model {
-    constructor(id) {
-        defineProperty(this, "is", { value: this });
-        new Control(this, id);
-    }
-    get(arg1) {
-        return typeof arg1 == "function"
-            ? effect(this, arg1)
-            : extract(this);
-    }
-    set(arg1, arg2) {
-        return typeof arg1 == "function"
-            ? control(this, c => c.addListener(k => k && arg1(k)))
-            : nextUpdate(this, arg1, arg2);
-    }
-    /** Mark this instance for garbage collection. */
-    null() {
-        control(this).clear();
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new(...args) {
-        const instance = new this(...args);
-        control(instance, true);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     * Determines if provided class is a subtype of this one.
-     * If so, language server will make available all static
-     * methods and properties of this class.
-     */
-    static is(maybe) {
-        return typeof maybe == "function" && maybe.prototype instanceof this;
-    }
-}
-defineProperty(Model.prototype, "toString", {
-    value() {
-        return control(this).id;
-    }
-});
-defineProperty(Model, "toString", {
-    value() {
-        return this.name;
-    }
-});
-
-function extract(target) {
-    const cache = new Map();
-    function get(value) {
-        if (value instanceof Model) {
-            let flat = cache.get(value);
-            if (!flat) {
-                cache.set(value, flat = {});
-                const { state } = control(value);
-                entries(state).forEach(([key, value]) => {
-                    flat[key] = get(value);
-                });
-            }
-            return flat;
-        }
-        return value;
-    }
-    return get(target);
-}
-function nextUpdate(target, arg1, arg2) {
-    return new Promise((resolve, reject) => {
-        control(target, self => {
-            if (isFrozen(self.frame) && typeof arg1 != "number") {
-                resolve(false);
-                return;
-            }
-            const callback = () => resolve(self.frame);
-            const remove = self.addListener((key) => {
-                if (!arg2 || key && arg2(key) === true) {
-                    remove();
-                    if (timeout)
-                        clearTimeout(timeout);
-                    return callback;
-                }
-            });
-            const timeout = typeof arg1 == "number" && setTimeout(() => {
-                remove();
-                reject(arg1);
-            }, arg1);
-        });
-    });
-}
-function effect(target, callback) {
-    return control(target, self => {
-        let refresh;
-        let unSet;
-        function invoke() {
-            if (unSet)
-                unSet();
-            try {
-                const out = callback.call(target, target);
-                unSet = typeof out == "function" ? out : undefined;
-            }
-            catch (err) {
-                if (err instanceof Promise) {
-                    err.then(() => (refresh = invoke)());
-                    refresh = undefined;
-                }
-                else
-                    console.error(err);
-            }
-        }
-        target = watch(target, () => refresh);
-        self.addListener(key => {
-            if (!refresh)
-                return refresh;
-            if (key === null && unSet)
-                unSet();
-        });
-        invoke();
-        refresh = invoke;
-        return () => {
-            refresh = null;
-        };
-    });
-}
-function attempt(fn) {
-    function retry(err) {
-        if (err instanceof Promise)
-            return err.then(compute);
-        else
-            throw err;
-    }
-    function compute() {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
-    }
-    return compute();
-}
-
-function run(task) {
-    return add((key, control) => {
-        let pending = false;
-        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
-            if (pending)
-                return Promise.reject(new Error(`Invoked action ${key} but one is already active.`));
-            pending = true;
-            control.update(key);
-            try {
-                return yield attempt(() => task.apply(control.subject, args));
-            }
-            finally {
-                pending = false;
-                control.update(key);
-            }
-        });
-        defineProperty(invoke, "active", {
-            get: () => pending
-        });
-        return {
-            value: invoke,
-            set: false
-        };
-    });
-}
-
-function get(arg0, arg1) {
-    return add((key, control) => {
-        let { subject } = control;
-        if (typeof arg0 == "symbol")
-            throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
-        let source = resolve => resolve(subject);
-        if (arg0 instanceof Model)
-            subject = arg0;
-        else if (Model.is(arg0)) {
-            const hasParent = parent(subject);
-            if (!hasParent) {
-                if (arg1 === true)
-                    throw new Error(`New ${subject} created standalone but requires parent of type ${arg0}.`);
-                if (!get.from)
-                    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
-                const fetch = get.from(subject);
-                source = (resolve) => {
-                    fetch(context => {
-                        const model = context.get(arg0);
-                        if (model)
-                            resolve(model);
-                        else if (arg1 !== false)
-                            throw new Error(`Attempted to find an instance of ${arg0} in context. It is required by ${subject}, but one could not be found.`);
-                    });
-                };
-            }
-            else if (!arg0 || hasParent instanceof arg0)
-                subject = hasParent;
-            else
-                throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-        }
-        else if (typeof arg0 == "function")
-            arg1 = arg0.call(subject, key, subject);
-        if (typeof arg1 == "function")
-            return compute(control, key, source, arg1);
-        source(got => control.update(key, got));
-        return control.fetch(key, arg1 !== false);
-    });
-}
-const ORDER = new WeakMap();
-const PENDING = new Set();
-let OFFSET = 0;
-function compute(parent, key, source, setter) {
-    const { state, subject } = parent;
-    let proxy;
-    let isAsync;
-    let reset;
-    function compute(initial) {
-        if (key in parent.frame)
-            return;
-        let next;
-        try {
-            next = setter.call(proxy, proxy);
-        }
-        catch (err) {
-            // TODO: address possibility of loop
-            if (err instanceof Promise)
-                throw err.finally(compute);
-            console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
-            if (initial)
-                throw err;
-            console.error(err);
-        }
-        if (next !== state[key]) {
-            if (key in state || isAsync)
-                parent.update(key);
-            state[key] = next;
-        }
-    }
-    function connect(model) {
-        let done;
-        if (reset)
-            reset();
-        reset = () => done = true;
-        proxy = watch(model, (_, updated) => {
-            if (done)
-                return null;
-            if (updated == subject)
-                PENDING.add(compute);
-            else
-                compute();
-        });
-        output.get = () => {
-            if (PENDING.delete(compute))
-                compute();
-            return state[key];
-        };
-        try {
-            compute(true);
-        }
-        finally {
-            ORDER.set(compute, OFFSET++);
-        }
-    }
-    const output = {
-        get() {
-            output.get = parent.fetch(key);
-            source(connect);
-            isAsync = true;
-            return output.get();
-        }
-    };
-    return output;
-}
-Control.on("update", () => {
-    while (PENDING.size) {
-        let compute;
-        for (const item of PENDING)
-            if (!compute || ORDER.get(item) < ORDER.get(compute))
-                compute = item;
-        PENDING.delete(compute);
-        compute();
-    }
-});
-
-function ref(arg, arg2) {
-    return add((key, source) => {
-        const { subject, state } = source;
-        let value = {};
-        if (arg === subject)
-            for (const key in state)
-                defineProperty(value, key, typeof arg2 == "function" ? {
-                    configurable: true,
-                    get() {
-                        const out = arg2(key);
-                        defineProperty(value, key, { value: out });
-                        return out;
-                    }
-                } : {
-                    value: createRef(source, key)
-                });
-        else if (typeof arg == "object")
-            throw new Error("ref instruction does not support object which is not 'this'");
-        else {
-            let unSet;
-            const set = (value) => {
-                source.update(key, value);
-                if (!arg)
-                    return;
-                if (unSet)
-                    unSet = void unSet(value);
-                if (value !== null || arg2 === false) {
-                    const out = arg.call(subject, value);
-                    if (typeof out == "function")
-                        unSet = out;
-                }
-            };
-            value = defineProperty(set, "current", {
-                get: () => state[key],
-                set
-            });
-        }
-        defineProperty(subject, key, { value });
-    });
-}
-function createRef(src, key) {
-    const refObjectFunction = src.update.bind(src, key);
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => src.state[key]
-    });
-    return refObjectFunction;
-}
-
-function set(value, argument) {
-    return add((key, control) => {
-        const { state, subject } = control;
-        const output = {};
-        if (typeof value == "function" || value instanceof Promise) {
-            function init() {
-                try {
-                    if (typeof value == "function")
-                        value = attempt(value.bind(subject, key, subject));
-                    if (value instanceof Promise) {
-                        const pending = value
-                            .then(value => {
-                            output.get = undefined;
-                            control.update(key, value);
-                            return value;
-                        })
-                            .catch(err => {
-                            output.get = () => { throw err; };
-                            control.update(key);
-                        });
-                        assign(pending, {
-                            message: `${subject}.${key} is not yet available.`,
-                            stack: new Error().stack
-                        });
-                        if (argument !== false)
-                            return output.get = () => {
-                                throw pending;
-                            };
-                    }
-                    else
-                        control.update(key, value);
-                }
-                catch (err) {
-                    console.warn(`Generating initial value for ${subject}.${key} failed.`);
-                    throw err;
-                }
-            }
-            if (argument)
-                init();
-            else
-                output.get = () => {
-                    const get = key in state ? null : init();
-                    return get ? get() : state[key];
-                };
-        }
-        else {
-            if (value !== undefined)
-                output.value = value;
-            else
-                output.get = control.fetch(key);
-            if (typeof argument == "function") {
-                let unSet;
-                output.set = function (value, previous) {
-                    const out = argument.call(this, value, previous);
-                    if (out === false)
-                        return out;
-                    if (typeof unSet == "function")
-                        unSet = void unSet(value);
-                    if (typeof out == "function")
-                        unSet = out;
-                };
-            }
-        }
-        return output;
-    });
-}
-
-function use(input, argument) {
-    return add((key, source) => {
-        const { subject, state } = source;
-        if (typeof input === "function")
-            input = new input();
-        function set(next) {
-            if (input instanceof Model && !(next instanceof input.constructor))
-                throw new Error(`${subject}.${key} expected Model of type ${input.constructor} but got ${next}.`);
-            if (next instanceof Model) {
-                parent(next, subject);
-                control(next, true);
-            }
-            else if (next) {
-                const subject = create(next);
-                const control = new Control(subject, false);
-                for (const key in control.state = next)
-                    control.watch(key, {});
-                next = subject;
-            }
-            state[key] = next;
-            if (typeof argument == "function")
-                argument(next);
-        }
-        set(input);
-        return { set };
-    });
-}
-
-class Context {
-    constructor() {
-        this.table = new WeakMap();
-        this.layer = new Map();
-    }
-    has(T) {
-        let key = this.table.get(T);
-        if (!key) {
-            key = Symbol(T.name);
-            this.table.set(T, key);
-        }
-        return key;
-    }
-    get(Type) {
-        const result = this[this.has(Type)];
-        if (result === null)
-            throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-        return result;
-    }
-    include(inputs) {
-        const init = new Map();
-        for (const key in inputs) {
-            const input = inputs[key];
-            const exists = this.layer.get(key);
-            if (!exists) {
-                const instance = this.add(input);
-                this.layer.set(key, input);
-                init.set(instance, true);
-            }
-            // Context must force-reset becasue inputs are no longer safe.
-            else if (exists !== input) {
-                this.pop();
-                this.key = uid();
-                return this.include(inputs);
-            }
-        }
-        for (const [model] of init)
-            values(control(model, true).state).forEach(value => {
-                if (parent(value) === model) {
-                    this.add(value, true);
-                    init.set(value, false);
-                }
-            });
-        return init;
-    }
-    add(input, implicit) {
-        let writable = true;
-        let T;
-        let I;
-        if (typeof input == "function") {
-            T = input;
-            I = new input();
-        }
-        else {
-            I = input;
-            T = I.constructor;
-            writable = false;
-        }
-        do {
-            const key = this.has(T);
-            const value = this.hasOwnProperty(key) ? null : I;
-            if (value || I !== this[key] && !implicit)
-                defineProperty(this, key, {
-                    configurable: true,
-                    value,
-                    writable
-                });
-            T = getPrototypeOf(T);
-        } while (T !== Model);
-        return I;
-    }
-    push() {
-        const next = create(this);
-        next.layer = new Map();
-        return next;
-    }
-    pop() {
-        const items = new Set();
-        for (const key of getOwnPropertySymbols(this)) {
-            const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable && entry.value)
-                items.add(entry.value);
-            delete this[key];
-        }
-        for (const model of items)
-            model.null();
-        this.layer.clear();
-    }
-}
-
-const STATE = "__state";
-const UPDATE = "__update";
-const CONTROL = "__control";
-const PARENT = "__parent";
-Object.defineProperties(Model.prototype, {
-    [CONTROL]: {
-        get() {
-            return control(this);
-        }
-    },
-    [STATE]: {
-        get() {
-            return Object.assign({}, control(this).state);
-        }
-    },
-    [UPDATE]: {
-        get() {
-            return control(this).frame;
-        }
-    },
-    [PARENT]: {
-        get() {
-            return parent(this);
-        }
-    }
-});
-const Debug = {
-    CONTROL,
-    STATE,
-    UPDATE,
-    PARENT
-};
-
-exports.Context = Context;
-exports.Control = Control;
-exports.Debug = Debug;
-exports.Model = Model;
-exports["default"] = Model;
-exports.get = get;
-exports.ref = ref;
-exports.run = run;
-exports.set = set;
-exports.use = use;