@expressive/mvc 0.53.3 → 0.53.6

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

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

package/dist/esm/instruction/set.js

@@ -0,0 +1,86 @@
+import { context } from '../control';
+import { event, update } from '../model';
+import { use } from './use';
+function set(value, argument) {
+    return use((key, subject) => {
+        const property = {};
+        if (typeof value == "function" || value instanceof Promise) {
+            function init() {
+                if (typeof value == "function")
+                    try {
+                        value = attempt(value.bind(subject, key));
+                    }
+                    catch (err) {
+                        console.warn(`Generating initial value for ${subject}.${key} failed.`);
+                        throw err;
+                    }
+                property.get = argument === true;
+                if (value instanceof Promise) {
+                    value
+                        .then(value => {
+                        update(subject, key, value);
+                        return value;
+                    })
+                        .catch(err => {
+                        event(subject, key);
+                        property.get = () => { throw err; };
+                    });
+                }
+                else
+                    update(subject, key, value);
+                if (0 in arguments)
+                    return subject[key];
+            }
+            if (argument)
+                init();
+            else
+                property.get = init;
+        }
+        else if (value !== undefined)
+            property.value = value;
+        if (typeof argument == "function") {
+            let unset;
+            property.set = function (value, previous) {
+                const ctx = context();
+                const out = argument.call(this, value, previous);
+                const flush = ctx();
+                if (out === false)
+                    return out;
+                if (typeof unset == "function")
+                    unset(value);
+                unset = (next) => {
+                    if (typeof out == "function")
+                        out(next);
+                    flush();
+                };
+            };
+        }
+        else
+            property.set = value => {
+                property.get = undefined;
+                update(subject, key, value);
+            };
+        return property;
+    });
+}
+function attempt(fn) {
+    function retry(err) {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    }
+    function compute() {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
+    }
+    return compute();
+}
+export { set };