@expressive/mvc 0.53.6 → 0.54.0

package/dist/esm/instruction/has.js

@@ -1,73 +0,0 @@
-import { Context } from '../context';
-import { Model, update } from '../model';
-import { use } from './use';
-const APPLY = new WeakMap();
-function has(arg1, arg2) {
-    return use((key, subject) => {
-        const applied = new Set();
-        const apply = () => {
-            update(subject, key, Object.freeze(Array.from(applied)));
-        };
-        if (Model.is(arg1))
-            Context.get(subject, context => {
-                context.has(arg1, model => {
-                    let remove;
-                    let disconnect;
-                    if (applied.has(model))
-                        return;
-                    const callback = APPLY.get(model);
-                    if (callback) {
-                        const after = callback(subject);
-                        if (after === false)
-                            return;
-                        if (typeof after == "function")
-                            disconnect = after;
-                    }
-                    if (typeof arg2 == "function") {
-                        const done = arg2(model, subject);
-                        if (done === false)
-                            return false;
-                        remove = () => {
-                            if (typeof done == "function")
-                                done();
-                        };
-                    }
-                    applied.add(model);
-                    apply();
-                    const done = () => {
-                        ignore();
-                        applied.delete(model);
-                        apply();
-                        if (disconnect)
-                            disconnect();
-                        if (typeof remove == "function")
-                            remove();
-                    };
-                    const ignore = model.get(null, done);
-                    return done;
-                });
-            });
-        else {
-            if (APPLY.has(subject))
-                throw new Error(`'has' callback can only be used once per model.`);
-            APPLY.set(subject, recipient => {
-                let remove;
-                if (arg1) {
-                    remove = arg1(recipient, subject);
-                    if (remove === false)
-                        return false;
-                }
-                applied.add(recipient);
-                apply();
-                return () => {
-                    applied.delete(recipient);
-                    apply();
-                    if (typeof remove == "function")
-                        remove();
-                };
-            });
-        }
-        return { value: [] };
-    });
-}
-export { has };

package/dist/esm/instruction/has.test.js

@@ -1,354 +0,0 @@
-import { Context } from '../context';
-import { Model } from '../model';
-import { has } from './has';
-describe("recipient", () => {
-    it("will register child", () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child);
-            }
-        }
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent }).push({ child });
-        expect(parent.children).toEqual([child]);
-    });
-    it("will register a subclass", () => {
-        class Child extends Model {
-        }
-        class Child2 extends Child {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child);
-            }
-        }
-        const parent = Parent.new();
-        const child = Child2.new();
-        new Context({ parent }).push({ child });
-        expect(parent.children).toEqual([child]);
-    });
-    it("will not register superclass", () => {
-        class Child extends Model {
-        }
-        class Child2 extends Child {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child2);
-            }
-        }
-        const parent = Parent.new();
-        new Context({ parent }).push({ Child });
-        expect(parent.children.length).toBe(0);
-    });
-    it("will run callback on register", () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, gotChild);
-            }
-        }
-        const gotChild = jest.fn();
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent }).push({ child });
-        expect(gotChild).toHaveBeenCalledWith(child, parent);
-    });
-    it("will register multiple children", () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, hasChild);
-            }
-        }
-        const hasChild = jest.fn();
-        const parent = Parent.new();
-        const child1 = Child.new();
-        const child2 = Child.new();
-        new Context({ parent }).push({ child1, child2 });
-        expect(hasChild).toHaveBeenCalledTimes(2);
-        expect(parent.children).toEqual([child1, child2]);
-    });
-    it("will remove children which unmount", async () => {
-        const didRemove = jest.fn();
-        const didAdd = jest.fn(() => didRemove);
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = 0;
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, didAdd);
-            }
-        }
-        const parent = Parent.new();
-        const child1 = Child.new();
-        const child2 = Child.new();
-        const context = new Context({ parent });
-        const context2 = context.push({ child1, child2 });
-        expect(didAdd).toHaveBeenCalledTimes(2);
-        expect(parent.children).toEqual([child1, child2]);
-        context2.pop();
-        await expect(parent).toHaveUpdated();
-        expect(didRemove).toHaveBeenCalledTimes(2);
-        const child3 = Child.new();
-        const context2b = context.push({ child3 });
-        expect(parent.children).toEqual([child3]);
-        context2b.pop();
-        await expect(parent).toHaveUpdated();
-        expect(didRemove).toHaveBeenCalledTimes(3);
-        expect(parent.children.length).toBe(0);
-    });
-    it("will not register if returns false", async () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, hasChild);
-            }
-        }
-        const hasChild = jest.fn(() => false);
-        const parent = Parent.new();
-        const context = new Context({ parent });
-        context.push({
-            child: Child.new(),
-            child2: Child.new()
-        });
-        expect(hasChild).toHaveBeenCalledTimes(2);
-        expect(parent.children.length).toBe(0);
-        context.push({ child: Child.new() });
-        await expect(parent).not.toUpdate();
-        expect(hasChild).toHaveBeenCalledTimes(3);
-        expect(parent.children.length).toBe(0);
-    });
-    it("will ignore redundant child", async () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = has(Child, gotChild);
-            }
-        }
-        const gotChild = jest.fn();
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent })
-            .push({ child })
-            .push({ child });
-        expect(gotChild).toHaveBeenCalledTimes(1);
-    });
-    it("will register own type", async () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.tests = has(Test, (got, self) => {
-                    gotTest(got.toString(), self.toString());
-                });
-            }
-        }
-        const gotTest = jest.fn();
-        const test = Test.new("1");
-        const test2 = Test.new("2");
-        const test3 = Test.new("3");
-        new Context({ test }).push({ test2 }).push({ test3 });
-        expect(gotTest).toBeCalledWith("2", "1");
-        expect(gotTest).toBeCalledWith("3", "2");
-        expect(gotTest).toBeCalledTimes(2);
-    });
-    it("will register implicit", () => {
-        class Baz extends Model {
-        }
-        class Foo extends Model {
-            constructor() {
-                super(...arguments);
-                this.bar = new Bar();
-            }
-        }
-        class Bar extends Model {
-            constructor() {
-                super(...arguments);
-                this.baz = has(Baz, gotBaz);
-            }
-        }
-        const gotBaz = jest.fn();
-        const foo = Foo.new();
-        const baz = Baz.new();
-        new Context({ foo }).push({ baz });
-        expect(gotBaz).toBeCalledWith(baz, foo.bar);
-    });
-    it("will register for implicit", () => {
-        class Baz extends Model {
-        }
-        class Foo extends Model {
-            constructor() {
-                super(...arguments);
-                this.baz = has(Baz);
-            }
-        }
-        class Bar extends Model {
-            constructor() {
-                super(...arguments);
-                this.baz = new Baz();
-            }
-        }
-        const foo = Foo.new();
-        const bar = Bar.new();
-        new Context({ foo }).push({ bar });
-        expect(foo.baz).toEqual([bar.baz]);
-    });
-    it.todo("will unwrap children on export");
-});
-describe("target", () => {
-    it("will register recipients", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has();
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = has(Child);
-            }
-        }
-        const parent = Parent.new();
-        const child = Child.new();
-        const context = new Context({ parent }).push({ child });
-        expect(child.parents).toEqual([parent]);
-        context.pop();
-    });
-    it("will register multiple", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has();
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = has(Child);
-            }
-        }
-        const child = Child.new();
-        const parent = Parent.new();
-        const parent2 = Parent.new();
-        const context = new Context({ parent }).push({ child });
-        const context2 = new Context({ parent2 }).push({ child });
-        expect(child.parents).toEqual([parent, parent2]);
-        context.pop();
-        context2.pop();
-    });
-    it("will callback on register", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has(gotParent);
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = has(Child);
-            }
-        }
-        const gotParent = jest.fn();
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent }).push({ child });
-        expect(gotParent).toHaveBeenCalledWith(parent, child);
-    });
-    it("will callback before recipient does", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has(gotParent);
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, gotChild);
-            }
-        }
-        const gotChild = jest.fn();
-        const gotParent = jest.fn(() => {
-            expect(gotChild).not.toHaveBeenCalled();
-        });
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent }).push({ child });
-        expect(gotChild).toHaveBeenCalled();
-        expect(gotParent).toHaveBeenCalled();
-    });
-    it("will prevent register", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has(gotParent);
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child, gotChild);
-            }
-        }
-        const gotChild = jest.fn();
-        const gotParent = jest.fn(() => false);
-        const parent = Parent.new();
-        const child = Child.new();
-        new Context({ parent }).push({ child });
-        expect(gotParent).toHaveBeenCalled();
-        expect(gotChild).not.toHaveBeenCalled();
-    });
-    it("will callback on removal", async () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has(() => {
-                    return removedParent;
-                });
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.children = has(Child);
-            }
-        }
-        const removedParent = jest.fn();
-        const parent = Parent.new();
-        const child = Child.new();
-        const context = new Context({ parent }).push({ child });
-        context.pop();
-        expect(removedParent).toHaveBeenCalledTimes(1);
-    });
-    it("will complain if used more than once", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.parents = has();
-                this.parents2 = has();
-            }
-        }
-        expect(() => Child.new()).toThrowError(`'has' callback can only be used once per model.`);
-    });
-});
-it.todo("will require values as props if has-instruction");

package/dist/esm/instruction/ref.js

@@ -1,59 +0,0 @@
-import { context } from '../control';
-import { define, update } from '../model';
-import { use } from './use';
-function ref(arg, arg2) {
-    return use((key, subject, state) => {
-        let value = {};
-        if (arg === subject)
-            subject.get(() => {
-                for (const key in state)
-                    if (typeof arg2 == "function")
-                        define(value, key, {
-                            configurable: true,
-                            get() {
-                                const out = arg2(key);
-                                define(value, key, { value: out });
-                                return out;
-                            }
-                        });
-                    else {
-                        const get = () => state[key];
-                        const set = (value) => {
-                            update(subject, key, value);
-                        };
-                        define(set, "current", { get, set });
-                        define(set, "get", { value: get });
-                        define(value, key, { value: set });
-                    }
-            });
-        else if (typeof arg == "object")
-            throw new Error("ref instruction does not support object which is not 'this'");
-        else {
-            let unset;
-            const get = () => state[key];
-            const set = (value) => {
-                if (!update(subject, key, value) || !arg)
-                    return;
-                if (unset)
-                    unset = void unset(value);
-                if (value === null && arg2 !== false)
-                    return;
-                const ctx = context();
-                const out = arg.call(subject, value);
-                const flush = ctx();
-                unset = key => {
-                    if (typeof out == "function")
-                        out(key);
-                    flush();
-                };
-            };
-            state[key] = null;
-            value = Object.defineProperties(set, {
-                current: { get, set },
-                get: { value: get }
-            });
-        }
-        define(subject, key, { value });
-    });
-}
-export { ref };