@expressive/mvc 0.53.3 → 0.53.6

package/dist/esm/context.js

@@ -0,0 +1,137 @@
+import { Model, PARENT, define, uid } from './model';
+const LOOKUP = new WeakMap();
+const KEYS = new Map();
+function key(T, upstream) {
+    let K = KEYS.get(T);
+    if (!K)
+        KEYS.set(T, K = Symbol(typeof T == "symbol" ? "get " + T.description : String(T)));
+    return upstream ? key(K) : K;
+}
+function keys(from, upstream) {
+    const keys = new Set();
+    do {
+        keys.add(key(from, upstream));
+    } while ((from = Object.getPrototypeOf(from)) !== Model);
+    return keys;
+}
+class Context {
+    static get(from, callback) {
+        const waiting = LOOKUP.get(from);
+        if (waiting instanceof Context) {
+            if (callback)
+                callback(waiting);
+            return waiting;
+        }
+        if (callback)
+            if (waiting)
+                waiting.push(callback);
+            else
+                LOOKUP.set(from, [callback]);
+    }
+    constructor(inputs) {
+        this.layer = new Map();
+        this.cleanup = new Set();
+        if (inputs)
+            this.include(inputs);
+    }
+    /** Run callback when a specified type is registered to a **child** context. */
+    has(Type, callback) {
+        define(this, key(Type, true), { value: callback });
+    }
+    /** Find specified type registered to a parent context. Returns undefined if none are found. */
+    get(Type) {
+        const result = this[key(Type)];
+        if (result === null)
+            throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+        return result;
+    }
+    push(inputs) {
+        const next = Object.create(this);
+        next.layer = new Map();
+        next.cleanup = new Set();
+        if (inputs)
+            next.include(inputs);
+        return next;
+    }
+    pop() {
+        for (const key of Object.getOwnPropertySymbols(this))
+            delete this[key];
+        this.cleanup.forEach(cb => cb());
+        this.layer.clear();
+    }
+    include(inputs, forEach) {
+        const init = new Map();
+        if (typeof inputs == "function" || inputs instanceof Model)
+            inputs = { 0: inputs };
+        Object.entries(inputs).forEach(([K, V]) => {
+            if (Model.is(V) || V instanceof Model)
+                return;
+            if (K && K != V)
+                V = `${V} (as '${K}')`;
+            throw new Error(`Context may only include instance or class \`extends Model\` but got ${V}.`);
+        });
+        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 because inputs are no longer safe.
+            else if (exists !== input) {
+                this.pop();
+                this.id = uid();
+                this.include(inputs);
+            }
+        }
+        for (const [model, explicit] of init) {
+            model.set();
+            if (typeof forEach == "function")
+                forEach(model, explicit);
+            else if (forEach && explicit)
+                model.set(forEach);
+            for (const [_key, value] of model)
+                if (PARENT.get(value) === model) {
+                    this.add(value, true);
+                    init.set(value, false);
+                }
+        }
+    }
+    add(input, implicit) {
+        let T;
+        let I;
+        if (typeof input == "function") {
+            Model.is(input);
+            T = input;
+            I = new input();
+            this.cleanup.add(() => I.set(null));
+        }
+        else {
+            T = input.constructor;
+            I = input;
+        }
+        keys(T, true).forEach(K => {
+            const result = this[K];
+            if (!result)
+                return;
+            const callback = result(I);
+            if (callback)
+                this.cleanup.add(callback);
+        });
+        keys(T).forEach(K => {
+            const value = this.hasOwnProperty(K) ? null : I;
+            if (value || this[K] !== I && !implicit)
+                define(this, K, {
+                    configurable: true,
+                    value
+                });
+        });
+        const waiting = LOOKUP.get(I);
+        if (waiting instanceof Array)
+            waiting.forEach(cb => cb(this));
+        LOOKUP.set(I, this);
+        return I;
+    }
+}
+export { Context };

package/dist/esm/context.test.js

@@ -0,0 +1,211 @@
+import { Context } from './context';
+import { Model } from './model';
+class Example extends Model {
+}
+;
+class Example2 extends Example {
+}
+;
+it("will add instance to context", () => {
+    const example = Example.new();
+    const context = new Context();
+    context.include(example);
+    expect(context.get(Example)).toBe(example);
+});
+it("will create instance in context", () => {
+    const context = new Context(Example);
+    expect(context.get(Example)).toBeInstanceOf(Example);
+});
+it("will not create base Model", () => {
+    // @ts-expect-error
+    const attempt = () => new Context({ Model });
+    expect(attempt).toThrowError("Cannot create base Model.");
+});
+it("will include children of Model", () => {
+    class Test extends Model {
+        constructor() {
+            super(...arguments);
+            this.example = new Example();
+        }
+    }
+    const context = new Context({ Test });
+    expect(context.get(Example)).toBeInstanceOf(Example);
+});
+it("will not include initialized child", () => {
+    class Test extends Model {
+        constructor() {
+            super(...arguments);
+            // this will be initialized before parent is
+            this.example = Example.new();
+        }
+    }
+    const context = new Context({ Test });
+    expect(context.get(Example)).toBeUndefined();
+});
+it("will access upstream controller", () => {
+    const example = Example.new();
+    const context = new Context({ example });
+    const context2 = context.push();
+    expect(context2.get(Example)).toBe(example);
+});
+it("will register all subtypes", () => {
+    const example2 = new Example2();
+    const context = new Context({ example2 });
+    expect(context.get(Example2)).toBe(example2);
+    expect(context.get(Example)).toBe(example2);
+});
+it("will return undefined if not found", () => {
+    const context = new Context();
+    const got = context.get(Example);
+    expect(got).toBeUndefined();
+});
+it("will complain if multiple registered", () => {
+    const context = new Context({
+        e1: Example,
+        e2: Example
+    });
+    const fetch = () => context.get(Example);
+    expect(fetch).toThrowError(`Did find Example in context, but multiple were defined.`);
+});
+it("will ignore if multiple but same", () => {
+    const example = Example.new();
+    const context = new Context({
+        e1: example,
+        e2: example
+    });
+    const got = context.get(Example);
+    expect(got).toBe(example);
+});
+it("will destroy modules created by layer", () => {
+    class Test extends Model {
+        constructor() {
+            super();
+            this.destroyed = jest.fn();
+            this.get(null, this.destroyed);
+        }
+    }
+    class Test1 extends Test {
+    }
+    ;
+    class Test2 extends Test {
+    }
+    ;
+    class Test3 extends Test {
+    }
+    ;
+    const test2 = Test2.new();
+    const context1 = new Context({ Test1 });
+    const context2 = context1.push({ test2, Test3 });
+    const test1 = context2.get(Test1);
+    const test3 = context2.get(Test3);
+    context2.pop();
+    expect(test1.destroyed).not.toBeCalled();
+    expect(test2.destroyed).not.toBeCalled();
+    expect(test3.destroyed).toBeCalled();
+});
+describe("include", () => {
+    class Foo extends Model {
+    }
+    class Bar extends Model {
+    }
+    class FooBar extends Model {
+        constructor() {
+            super(...arguments);
+            this.foo = new Foo();
+        }
+    }
+    it("will register in batch", () => {
+        const foo = Foo.new();
+        const bar = Bar.new();
+        const context = new Context({ foo, bar });
+        expect(context.get(Foo)).toBe(foo);
+        expect(context.get(Bar)).toBe(bar);
+    });
+    it("will callback once per unique added", () => {
+        const foo = Foo.new();
+        const bar = Bar.new();
+        const cb = jest.fn();
+        const context = new Context();
+        context.include({ foo, bar }, cb);
+        expect(cb).toBeCalledWith(foo, true);
+        expect(cb).toBeCalledWith(bar, true);
+        expect(cb).toBeCalledTimes(2);
+        context.include({ foo, bar }, cb);
+        expect(cb).toBeCalledTimes(2);
+        const foo2 = Foo.new();
+        context.include({ foo, bar, foo2 }, cb);
+        expect(cb).toBeCalledWith(foo2, true);
+        expect(cb).toBeCalledTimes(3);
+    });
+    it("will assign to newly added instances", () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value = 0;
+            }
+        }
+        const t1 = Test.new();
+        const t2 = Test.new();
+        const context = new Context();
+        context.include({ t1 }, { value: 1 });
+        expect(t1.value).toBe(1);
+        t1.value = 2;
+        context.include({ t1, t2 }, { value: 3 });
+        // t1 is already in context, should not be reassigned.
+        expect(t1.value).toBe(2);
+        expect(t2.value).toBe(3);
+    });
+    // This will be made more elegant later.
+    it("will hard-reset if inputs differ", () => {
+        const bazDidDie = jest.fn();
+        class Baz extends Model {
+            constructor() {
+                super();
+                this.get(() => bazDidDie);
+            }
+        }
+        const foo = Foo.new();
+        const bar = Bar.new();
+        const context = new Context({ foo, bar, Baz });
+        const idPriorToUpdate = context.id;
+        const baz = context.get(Baz);
+        context.include({ foo, bar: Bar.new(), Baz });
+        // key should change despite technically same layer.
+        expect(context.id).not.toBe(idPriorToUpdate);
+        // expect all instances did get replaced.
+        expect(context.get(Bar)).not.toBe(bar);
+        // expect Baz will have been force-replaced.
+        expect(bazDidDie).toBeCalled();
+        const newBaz = context.get(Baz);
+        expect(newBaz).toBeInstanceOf(Baz);
+        expect(newBaz).not.toBe(baz);
+    });
+    it("will register children implicitly", () => {
+        const foobar = FooBar.new();
+        const context = new Context({ foobar });
+        expect(context.get(FooBar)).toBe(foobar);
+        expect(context.get(Foo)).toBe(foobar.foo);
+    });
+    it("will prefer explicit over implicit", () => {
+        const foo = Foo.new();
+        const foobar = FooBar.new();
+        const context = new Context({ foobar, foo });
+        expect(context.get(FooBar)).toBe(foobar);
+        expect(context.get(Foo)).not.toBe(foobar.foo);
+        expect(context.get(Foo)).toBe(foo);
+    });
+});
+it("will throw on bad include", () => {
+    const context = new Context();
+    expect(() => context.include(undefined)).toThrowError();
+});
+it("will throw on base Model include", () => {
+    const context = new Context();
+    // @ts-ignore
+    expect(() => context.include({ Model })).toThrowError("Cannot create base Model.");
+});
+it("will throw on bad include property", () => {
+    const context = new Context();
+    // @ts-ignore
+    expect(() => context.include({ Thing: undefined })).toThrowError("Context may only include instance or class `extends Model` but got undefined (as 'Thing').");
+});

package/dist/esm/control.js

@@ -0,0 +1,182 @@
+/** Placeholder event determines if model is initialized or not. */
+const onReady = () => null;
+const LISTENERS = new WeakMap();
+/** Events pending for a given object. */
+const PENDING = new WeakMap();
+/** Update register. */
+const PENDING_KEYS = new WeakMap();
+/** Central event dispatch. Bunches all updates to occur at same time. */
+const DISPATCH = new Set();
+const OBSERVER = new WeakMap();
+function addListener(subject, callback, select) {
+    let listeners = LISTENERS.get(subject);
+    if (!listeners)
+        LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));
+    const filter = select === undefined ? undefined : new Set([select]);
+    if (!listeners.has(onReady) && !filter)
+        callback.call(subject, true, subject);
+    listeners.set(callback, filter);
+    return () => listeners.delete(callback);
+}
+function emit(model, key) {
+    const listeners = LISTENERS.get(model);
+    const notReady = listeners.has(onReady);
+    if (key === true && !notReady)
+        return;
+    let pending = PENDING.get(model);
+    if (pending) {
+        pending.add(key);
+        return;
+    }
+    PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));
+    for (const key of pending)
+        for (const [callback, filter] of listeners)
+            if (!filter || filter.has(key)) {
+                const after = callback.call(model, key, model);
+                if (after)
+                    enqueue(after);
+                else if (after === null)
+                    listeners.delete(callback);
+            }
+    if (key === null)
+        listeners.clear();
+    PENDING.delete(model);
+}
+function event(subject, key, silent) {
+    if (key === null)
+        return emit(subject, key);
+    if (!key)
+        return emit(subject, true);
+    let pending = PENDING_KEYS.get(subject);
+    if (!pending) {
+        PENDING_KEYS.set(subject, pending = new Set());
+        if (!silent)
+            enqueue(() => {
+                emit(subject, false);
+                PENDING_KEYS.delete(subject);
+            });
+    }
+    pending.add(key);
+    if (!silent)
+        emit(subject, key);
+}
+function pending(subject) {
+    if (PENDING_KEYS.has(subject))
+        return {
+            then: (res) => new Promise(res => {
+                const remove = addListener(subject, key => {
+                    if (key !== true) {
+                        remove();
+                        return res.bind(null, Array.from(PENDING_KEYS.get(subject)));
+                    }
+                });
+            }).then(res)
+        };
+}
+function enqueue(eventHandler) {
+    if (!DISPATCH.size)
+        setTimeout(() => {
+            DISPATCH.forEach(event => {
+                try {
+                    event();
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+            DISPATCH.clear();
+        }, 0);
+    DISPATCH.add(eventHandler);
+}
+function createProxy(from, observer) {
+    const proxy = Object.create(from);
+    OBSERVER.set(proxy, observer);
+    return proxy;
+}
+function watch(from, key, value) {
+    const access = OBSERVER.get(from);
+    return access ? access(from, key, value) : value;
+}
+function createEffect(target, callback, argument) {
+    const listeners = LISTENERS.get(target);
+    let unset;
+    let reset;
+    function invoke() {
+        let stale;
+        const subscriber = createProxy(target, access);
+        LISTENERS.set(subscriber, listeners);
+        function onUpdate() {
+            if (stale)
+                return null;
+            stale = true;
+            if (reset && unset) {
+                unset(true);
+                unset = undefined;
+            }
+            return reset;
+        }
+        function access(from, key, value) {
+            if (value === undefined && argument)
+                throw new Error(`${from}.${key} is required in this context.`);
+            const listeners = LISTENERS.get(from);
+            let listener = listeners.get(onUpdate);
+            if (!listener)
+                listeners.set(onUpdate, listener = new Set);
+            listener.add(key);
+            const nested = LISTENERS.get(value);
+            if (nested)
+                LISTENERS.set(value = createProxy(value, access), nested);
+            return value;
+        }
+        try {
+            const ctx = context(argument === false);
+            const ret = callback.call(subscriber, subscriber);
+            const flush = ctx();
+            reset = ret === null ? null : invoke;
+            unset = key => {
+                if (typeof ret == "function")
+                    ret(key);
+                flush();
+            };
+        }
+        catch (err) {
+            if (err instanceof Promise) {
+                reset = undefined;
+                err.then(invoke);
+            }
+            else
+                throw err;
+        }
+    }
+    function cleanup() {
+        if (unset)
+            unset(false);
+        reset = null;
+    }
+    ;
+    if (EffectContext && argument !== false)
+        EffectContext.add(cleanup);
+    addListener(target, key => {
+        if (key === true)
+            invoke();
+        else if (!reset)
+            return reset;
+        if (key === null && unset)
+            unset(null);
+    });
+    return cleanup;
+}
+let EffectContext;
+export function context(ignore) {
+    if (ignore)
+        return () => () => { };
+    const current = EffectContext;
+    const ctx = EffectContext = new Set;
+    return () => {
+        EffectContext = current;
+        return () => {
+            ctx.forEach(fn => fn());
+        };
+    };
+}
+export { addListener, createEffect, createProxy, event, PENDING_KEYS, pending, watch };

package/dist/esm/control.test.js

@@ -0,0 +1,183 @@
+import { createEffect, createProxy } from './control';
+import { set } from './instruction/set';
+import { use } from './instruction/use';
+import { mockError } from './mocks';
+import { Model } from './model';
+describe("effect", () => {
+    it("will run after properties", () => {
+        const mock = jest.fn();
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.property = use((_key, _model, state) => {
+                    this.get(() => mock(state));
+                });
+                this.foo = 1;
+                this.bar = 2;
+            }
+        }
+        Test.new();
+        expect(mock).toBeCalledWith({ foo: 1, bar: 2 });
+    });
+    it("will enforce values if required", () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.property = undefined;
+            }
+        }
+        const test = Test.new("ID");
+        const attempt = () => {
+            createEffect(test, $ => {
+                expect($.property);
+            }, true);
+        };
+        expect(attempt).toThrowError(`ID.property is required in this context.`);
+    });
+    it("will still get events after silent ones", async () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value1 = 1;
+                this.value2 = 2;
+            }
+        }
+        const test = Test.new();
+        const didGetValue = jest.fn();
+        test.get($ => {
+            didGetValue($.value1, $.value2);
+        });
+        expect(didGetValue).toBeCalledWith(1, 2);
+        test.set({ value1: 10 }, true);
+        test.set({ value2: 20 });
+        await expect(test).toHaveUpdated();
+        expect(didGetValue).toBeCalledWith(10, 20);
+        expect(didGetValue).toBeCalledTimes(2);
+    });
+    it("will cleanup nested effects", async () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.foo = 1;
+                this.bar = 2;
+            }
+        }
+        const test = Test.new();
+        const didInvoke = jest.fn();
+        const done = createEffect(test, ({ foo }) => {
+            createEffect(test, ({ bar }) => {
+                didInvoke({ foo, bar });
+            });
+        });
+        expect(didInvoke).toBeCalledTimes(1);
+        expect(didInvoke).toBeCalledWith({ foo: 1, bar: 2 });
+        await test.set({ bar: 3 });
+        expect(didInvoke).toBeCalledWith({ foo: 1, bar: 3 });
+        await test.set({ foo: 2, bar: 4 });
+        expect(didInvoke).toBeCalledWith({ foo: 2, bar: 4 });
+        expect(didInvoke).not.toBeCalledWith({ foo: 1, bar: 4 });
+        await test.set({ bar: 2 });
+        expect(didInvoke).toBeCalledWith({ foo: 2, bar: 2 });
+        done();
+        await test.set({ bar: 1 });
+        expect(didInvoke).not.toBeCalledWith({ foo: 2, bar: 1 });
+        expect(didInvoke).toBeCalledTimes(4);
+    });
+});
+describe("suspense", () => {
+    it("will seem to throw error outside react", () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value = set();
+            }
+        }
+        const instance = Test.new("ID");
+        let didThrow;
+        try {
+            void instance.value;
+        }
+        catch (err) {
+            didThrow = err;
+        }
+        expect(String(didThrow)).toMatchInlineSnapshot(`"Error: ID.value is not yet available."`);
+    });
+    it("will reject if model destroyed before resolved", async () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value = set();
+            }
+        }
+        const instance = Test.new("ID");
+        let didThrow;
+        try {
+            void instance.value;
+        }
+        catch (err) {
+            didThrow = err;
+        }
+        instance.set(null);
+        await expect(didThrow).rejects.toThrowError(`ID is destroyed.`);
+    });
+});
+describe("errors", () => {
+    const error = mockError();
+    it("will throw sync error to the console", async () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value = 1;
+            }
+        }
+        ;
+        const test = Test.new();
+        test.set(() => {
+            throw new Error("sync error");
+        });
+        const attempt = () => test.value = 2;
+        expect(attempt).toThrowError(`sync error`);
+    });
+    it("will log async error to the console", async () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.value = 1;
+            }
+        }
+        ;
+        const expected = new Error("async error");
+        const test = Test.new();
+        test.get($ => {
+            if ($.value == 2)
+                throw expected;
+        });
+        test.value = 2;
+        await expect(test).toHaveUpdated();
+        expect(error).toBeCalledWith(expected);
+    });
+});
+describe("proxy", () => {
+    it("will create a proxy object", () => {
+        class Test extends Model {
+            constructor() {
+                super(...arguments);
+                this.foo = 1;
+                this.bar = 2;
+                this.baz = 3;
+            }
+        }
+        const test = Test.new("Test");
+        const getter = jest.fn((self, key, value) => {
+            return `${self}.${key}=${value}`;
+        });
+        const proxy = createProxy(test, getter);
+        expect(proxy.foo).toBe(`Test.foo=1`);
+        expect(getter).toBeCalledWith(test, "foo", 1);
+        expect(proxy.bar).toBe(`Test.bar=2`);
+        expect(getter).toBeCalledWith(test, "bar", 2);
+        expect(proxy.baz).toBe(`Test.baz=3`);
+        expect(getter).toBeCalledWith(test, "baz", 3);
+        expect(getter).toBeCalledTimes(3);
+    });
+});