@expressive/mvc 0.53.6 → 0.54.1

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.test.js

@@ -1,281 +0,0 @@
-import { Model } from '../model';
-import { ref } from './ref';
-describe("property", () => {
-    it('will contain value from ref-object', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const state = Subject.new();
-        state.ref.current = "foobar";
-        await expect(state).toHaveUpdated();
-        expect(state.ref.current).toBe("foobar");
-    });
-    it('will get value from ref-object', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const state = Subject.new();
-        expect(state.ref.get()).toBeNull();
-        state.ref.current = "foobar";
-        expect(state.ref.get()).toBe("foobar");
-    });
-    it('will watch "current" of property', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const state = Subject.new();
-        const didCallback = jest.fn();
-        state.set((key) => {
-            if (key == "ref")
-                didCallback();
-        });
-        state.ref.current = "foobar";
-        await expect(state).toHaveUpdated();
-        expect(didCallback).toBeCalledWith();
-    });
-    it('will update "current" when property invoked', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const state = Subject.new();
-        const didUpdate = jest.fn();
-        state.set((key) => {
-            if (key == "ref")
-                didUpdate();
-        });
-        state.ref("foobar");
-        await expect(state).toHaveUpdated();
-        expect(didUpdate).toBeCalledWith();
-    });
-    it('will invoke callback', async () => {
-        const didTrigger = jest.fn();
-        const didUpdate = jest.fn();
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref(didTrigger);
-            }
-        }
-        const state = Subject.new();
-        expect(didTrigger).not.toBeCalled();
-        state.set(key => {
-            if (key == "ref")
-                didUpdate();
-        });
-        state.ref.current = "foobar";
-        expect(didTrigger).toBeCalledWith("foobar");
-        await expect(state).toHaveUpdated();
-        expect(didUpdate).toBeCalledWith();
-    });
-    it('will invoke return-callback on overwrite', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref(() => didTrigger);
-            }
-        }
-        const state = Subject.new();
-        const didTrigger = jest.fn();
-        state.ref.current = 1;
-        await expect(state).toHaveUpdated();
-        expect(didTrigger).not.toBeCalled();
-        state.ref.current = 2;
-        await expect(state).toHaveUpdated();
-        expect(didTrigger).toBeCalled();
-    });
-    it('will not callback when gets null', async () => {
-        const callback = jest.fn();
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref(callback);
-            }
-        }
-        const state = Subject.new();
-        state.ref("hello");
-        expect(callback).toBeCalledWith("hello");
-        state.ref(null);
-        expect(callback).not.toBeCalledWith(null);
-    });
-    it('will callback when on null if ignore false', async () => {
-        const callback = jest.fn();
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref(callback, false);
-            }
-        }
-        const state = Subject.new();
-        state.ref("hello");
-        expect(callback).toBeCalledWith("hello");
-        state.ref(null);
-        expect(callback).toBeCalledWith(null);
-    });
-    it('will reset nested effects', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.name = "World";
-                this.hello = ref((value) => {
-                    this.get(({ name }) => {
-                        effect(`${value} ${name}!`);
-                    });
-                });
-            }
-        }
-        const effect = jest.fn();
-        const state = Subject.new();
-        state.hello("Hola");
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Hola World!");
-        state.hello("Bonjour");
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Bonjour World!");
-        state.name = "Earth";
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Bonjour Earth!");
-        expect(effect).not.toBeCalledWith("Hola Earth!");
-    });
-    it('will export value of ref-properties', () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const test = Subject.new();
-        const values = { ref: "foobar" };
-        test.ref(values.ref);
-        expect(test.get()).toMatchObject(values);
-    });
-    it('will be accessible from a proxy', () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const test = Subject.new();
-        test.get(state => {
-            expect(state.ref).not.toBeUndefined();
-        });
-    });
-    it.skip('will subscribe if current accessed', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.ref = ref();
-            }
-        }
-        const test = Subject.new();
-        const effect = jest.fn(($) => {
-            void $.ref.current;
-        });
-        test.get(effect);
-        expect(effect).toBeCalledTimes(1);
-        test.ref("foobar");
-        await expect(test).toHaveUpdated();
-        expect(effect).toBeCalledTimes(2);
-    });
-});
-describe("proxy", () => {
-    class Subject extends Model {
-        constructor() {
-            super(...arguments);
-            this.foo = "foo";
-            this.bar = "bar";
-            this.refs = ref(this);
-        }
-    }
-    it("will match properties", () => {
-        const test = Subject.new();
-        for (const key in test)
-            expect(test.refs).toHaveProperty(key);
-    });
-    it("will match values via current", () => {
-        const test = Subject.new();
-        const { refs } = test;
-        for (const key in test) {
-            const value = test[key];
-            const { current } = refs[key];
-            expect(current).toBe(value);
-        }
-    });
-    it("will update values", async () => {
-        const test = Subject.new();
-        expect(test.foo).toBe("foo");
-        expect(test.bar).toBe("bar");
-        test.refs.foo("bar");
-        test.refs.bar("foo");
-        await expect(test).toHaveUpdated();
-        expect(test.foo).toBe("bar");
-        expect(test.bar).toBe("foo");
-    });
-});
-describe("mapped", () => {
-    const generateRef = jest.fn((key) => key);
-    class Test extends Model {
-        constructor() {
-            super(...arguments);
-            this.foo = "foo";
-            this.bar = "bar";
-            this.fields = ref(this, generateRef);
-        }
-    }
-    afterEach(() => {
-        generateRef.mockClear();
-    });
-    it("will run function for accessed keys", () => {
-        const { fields } = Test.new();
-        expect(fields.foo).toBe("foo");
-        expect(fields.bar).toBe("bar");
-        expect(generateRef).toBeCalledWith("foo");
-        expect(generateRef).toBeCalledWith("bar");
-    });
-    it("will run function only for accessed property", () => {
-        const { fields } = Test.new();
-        expect(fields.foo).toBe("foo");
-        expect(generateRef).toBeCalledWith("foo");
-        expect(generateRef).not.toBeCalledWith("bar");
-    });
-    it("will run function only once per property", () => {
-        const { fields } = Test.new();
-        expect(fields.foo).toBe("foo");
-        expect(fields.foo).toBe("foo");
-        expect(generateRef).toBeCalledTimes(1);
-    });
-    it("will throw if object is not this", () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.foo = "foo";
-                this.bar = "bar";
-                // @ts-expect-error
-                this.fields = ref({});
-            }
-        }
-        expect(() => Test.new()).toThrowError(`ref instruction does not support object which is not 'this'`);
-    });
-    it.skip("will not break on recursive", () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.foo = ref();
-                this.bar = ref(this);
-            }
-        }
-        Test.new();
-    });
-});