@expressive/mvc 0.53.6 → 0.54.1

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

@@ -1,305 +0,0 @@
-import { Context } from '../context';
-import { Model } from '../model';
-import { use } from './use';
-describe("instruction", () => {
-    it("will run on create", () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.property = use((key) => {
-                    didRunInstruction(key);
-                });
-            }
-        }
-        const didRunInstruction = jest.fn();
-        Test.new();
-        expect(didRunInstruction).toBeCalledWith("property");
-    });
-    describe("symbol", () => {
-        it("will use symbol as placeholder", async () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.value = use(() => ({ value: 1 }));
-                }
-            }
-            const test = new Test();
-            if (typeof test.value !== "symbol")
-                throw new Error("value is not a symbol");
-            else
-                expect(test.value.description).toBe("instruction");
-            await test.set();
-            expect(test.value).toBe(1);
-        });
-        it("will be deleted prior to instruction", () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.value = use(() => {
-                        expect("value" in this).toBe(false);
-                    });
-                }
-            }
-            Test.new();
-        });
-        it("will ignore normal symbol", () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.value = Symbol("hello");
-                }
-            }
-            const test = Test.new();
-            expect(typeof test.value).toBe("symbol");
-        });
-    });
-    describe("getter", () => {
-        it("will run upon access", () => {
-            const mockAccess = jest.fn((_subscriber) => "foobar");
-            const mockApply = jest.fn((_key) => mockAccess);
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use(mockApply);
-                }
-            }
-            const instance = Test.new();
-            expect(mockApply).toBeCalledWith("property", expect.any(Test), {});
-            expect(mockAccess).not.toBeCalled();
-            expect(instance.property).toBe("foobar");
-            expect(mockAccess).toBeCalledWith(instance);
-        });
-        it("will pass subscriber if within one", () => {
-            const didGetValue = jest.fn();
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use(() => didGetValue);
-                }
-            }
-            const state = Test.new();
-            state.get(own => {
-                void own.property;
-            });
-            expect(didGetValue).toBeCalledWith(state);
-        });
-        it("will not throw suspense if get (required) is false", async () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.value = use(() => ({ get: false }));
-                }
-            }
-            const test = Test.new('ID');
-            const effect = jest.fn((test) => void test.value);
-            test.get(effect);
-            test.value = "foo";
-            await expect(test).toHaveUpdated();
-            expect(effect).toBeCalledTimes(2);
-        });
-    });
-    describe("setter", () => {
-        it("will reject update if false", () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.value = use(() => ({ set: false }));
-                }
-            }
-            const test = Test.new('ID');
-            const assign = () => test.value = "foo";
-            expect(assign).toThrowError(`ID.value is read-only.`);
-        });
-        it("will prevent update if returns false", async () => {
-            const didSetValue = jest.fn((newValue) => {
-                if (newValue == "ignore")
-                    return false;
-            });
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use(() => {
-                        return {
-                            value: "foobar",
-                            set: didSetValue
-                        };
-                    });
-                }
-            }
-            const test = Test.new();
-            expect(test.property).toBe("foobar");
-            test.property = "test";
-            expect(didSetValue).toBeCalledWith("test", "foobar");
-            expect(test.property).toBe("test");
-            await expect(test).toHaveUpdated();
-            test.property = "ignore";
-            expect(didSetValue).toBeCalledWith("ignore", "test");
-            expect(test.property).toBe("test");
-            await expect(test).not.toHaveUpdated();
-        });
-        // duplicate test?
-        it("will revert update if returns false", async () => {
-            let ignore = false;
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use(() => {
-                        return {
-                            value: 0,
-                            set: (value) => ignore
-                                ? false
-                                : () => value + 10
-                        };
-                    });
-                }
-            }
-            const instance = Test.new();
-            expect(instance.property).toBe(0);
-            instance.property = 10;
-            expect(instance.property).toBe(20);
-            await expect(instance).toHaveUpdated();
-            ignore = true;
-            instance.property = 0;
-            expect(instance.property).toBe(20);
-            await expect(instance).not.toHaveUpdated();
-        });
-        it("will not duplicate explicit update", () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use(() => ({
-                        value: "foobar",
-                        set: (value) => () => value + "!"
-                    }));
-                }
-            }
-            const test = Test.new();
-            const didUpdate = jest.fn();
-            test.set(didUpdate);
-            expect(test.property).toBe("foobar");
-            test.property = "test";
-            expect(test.property).toBe("test!");
-            expect(didUpdate).toBeCalledTimes(1);
-        });
-        it("will not update on reassignment", () => {
-            class Test extends Model {
-                constructor() {
-                    super(...arguments);
-                    this.property = use((key) => ({
-                        value: "foobar",
-                        set: (value) => {
-                            return () => value + "!";
-                        }
-                    }));
-                }
-            }
-            const test = Test.new();
-            const didUpdate = jest.fn();
-            test.set(didUpdate);
-            expect(test.property).toBe("foobar");
-            test.property = "test";
-            expect(test.property).toBe("test!");
-            expect(didUpdate).toBeCalledTimes(1);
-        });
-    });
-});
-describe("model", () => {
-    it("will init upon access", () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = "foo";
-            }
-        }
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = use(Child, mockInit);
-            }
-        }
-        const mockInit = jest.fn();
-        Test.new();
-        expect(mockInit).toBeCalledTimes(1);
-    });
-    it("will not create base Model", () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                // @ts-expect-error
-                this.child = use(Model);
-            }
-        }
-        const attempt = () => Test.new();
-        expect(attempt).toThrowError("Cannot create base Model.");
-    });
-    it('will run callback on every assign', () => {
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = "foo";
-            }
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = use(Child, callback);
-            }
-        }
-        const callback = jest.fn();
-        const parent = Parent.new();
-        // Initial assignment
-        expect(callback).toBeCalledTimes(1);
-        parent.child = new Child();
-        expect(callback).toBeCalledTimes(2);
-    });
-    it.todo("will run callback after assign completes");
-    it.todo("will run cleanup on reassign");
-    it('will only reassign a matching model', () => {
-        class Child extends Model {
-        }
-        class Unrelated extends Model {
-        }
-        ;
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = use(Child);
-            }
-        }
-        const parent = Parent.new("ID");
-        expect(() => {
-            parent.child = Unrelated.new("ID");
-        }).toThrowError(`ID.child expected Model of type Child but got Unrelated.`);
-        expect(() => {
-            // @ts-expect-error
-            parent.child = undefined;
-        }).toThrowError(`ID.child expected Model of type Child but got undefined.`);
-    });
-    it('will allow undefined', () => {
-        class Child extends Model {
-        }
-        class Parent extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = use(Child, false);
-            }
-        }
-        const parent = Parent.new("ID");
-        expect(parent.child).toBeInstanceOf(Child);
-        parent.child = undefined;
-        expect(parent.child).toBeUndefined();
-    });
-    it("will be provided by parent", () => {
-        class Child extends Model {
-        }
-        ;
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = use(Child);
-            }
-        }
-        const context = new Context({ Test });
-        expect(context.get(Child)).toBeInstanceOf(Child);
-    });
-});

package/dist/esm/mocks.js

@@ -1,20 +0,0 @@
-export function mockPromise() {
-    const methods = {};
-    const promise = new Promise((res, rej) => {
-        methods.resolve = res;
-        methods.reject = rej;
-    });
-    return Object.assign(promise, methods);
-}
-export function mockWarn() {
-    const warn = jest.spyOn(console, "warn");
-    afterEach(() => warn.mockReset());
-    afterAll(() => warn.mockRestore());
-    return warn;
-}
-export function mockError() {
-    const error = jest.spyOn(console, "error");
-    afterEach(() => error.mockReset());
-    afterAll(() => error.mockRestore());
-    return error;
-}