@expressive/mvc 0.53.6 → 0.54.0

package/dist/esm/control.js

@@ -1,182 +0,0 @@
-/** 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

@@ -1,183 +0,0 @@
-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);
-    });
-});

package/dist/esm/index.js

@@ -1,8 +0,0 @@
-export { get } from './instruction/get';
-export { ref } from './instruction/ref';
-export { set } from './instruction/set';
-export { use } from './instruction/use';
-export { has } from './instruction/has';
-export { Model, Model as default } from './model';
-export { createEffect, createProxy, addListener } from './control';
-export { Context } from './context';

package/dist/esm/instruction/get.js

@@ -1,87 +0,0 @@
-import { Context } from '../context';
-import { createEffect } from '../control';
-import { fetch, METHOD, Model, PARENT, event, update } from '../model';
-import { use } from './use';
-const STALE = new WeakSet();
-function get(arg0, arg1) {
-    return use((key, subject, state) => {
-        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.`);
-        if (Model.is(arg0)) {
-            const hasParent = PARENT.get(subject);
-            // TODO: notify on discovered context 
-            function assign(value) {
-                if (typeof arg1 == "function")
-                    value.get(x => arg1(x, key));
-                update(subject, key, value);
-            }
-            if (!hasParent) {
-                if (arg1 === true)
-                    throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
-                Context.get(subject, (context) => {
-                    const model = context.get(arg0);
-                    if (model)
-                        assign(model);
-                    else if (arg1 !== false)
-                        throw new Error(`Required ${arg0} not found in context for ${subject}.`);
-                });
-            }
-            else if (!arg0 || hasParent instanceof arg0)
-                assign(hasParent);
-            else
-                throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-            return {
-                get: arg1 !== false
-            };
-        }
-        let from = subject;
-        if (arg0 instanceof Model) {
-            from = arg0;
-        }
-        else {
-            const fn = METHOD.get(arg0) || arg0;
-            arg1 = ((p, k) => fn.call(p, k, p));
-        }
-        const source = resolve => resolve(from);
-        const getter = arg1;
-        let reset;
-        let isAsync;
-        let proxy;
-        function connect(model) {
-            reset = createEffect(model, current => {
-                proxy = current;
-                if (!(key in state) || STALE.delete(compute))
-                    compute(!reset);
-                return (didUpdate) => {
-                    if (didUpdate) {
-                        STALE.add(compute);
-                        event(subject, key, true);
-                    }
-                };
-            }, false);
-        }
-        function compute(initial) {
-            let next;
-            try {
-                next = getter.call(proxy, proxy, key);
-            }
-            catch (err) {
-                console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
-                if (initial)
-                    throw err;
-                console.error(err);
-            }
-            update(subject, key, next, !isAsync);
-        }
-        return () => {
-            if (!proxy) {
-                source(connect);
-                isAsync = true;
-            }
-            if (STALE.delete(compute))
-                compute();
-            return fetch(subject, key, !proxy);
-        };
-    });
-}
-export { get };