@expressive/mvc 0.53.6 → 0.54.0

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;
-}

package/dist/esm/model.js

@@ -1,278 +0,0 @@
-import { addListener, createEffect, event, pending, PENDING_KEYS, watch } from './control';
-export const define = Object.defineProperty;
-/** Register for all active models via string identifiers (usually unique). */
-const ID = new WeakMap();
-/** Internal state assigned to models. */
-const STATE = new WeakMap();
-/** External listeners for any given Model. */
-const NOTIFY = new WeakMap();
-/** Parent-child relationships. */
-const PARENT = new WeakMap();
-/** List of methods defined by a given type. */
-const METHODS = new WeakMap();
-/** Reference bound instance methods to real ones. */
-const METHOD = new WeakMap();
-class Model {
-    constructor(...args) {
-        prepare(this);
-        define(this, "is", { value: this });
-        init(this, args);
-    }
-    get(arg1, arg2) {
-        const self = this.is;
-        if (typeof arg1 == "function") {
-            let pending = new Set();
-            return createEffect(self, (proxy) => {
-                const cb = arg1.call(proxy, proxy, pending);
-                return cb === null ? null : ((update) => {
-                    pending = PENDING_KEYS.get(self);
-                    if (typeof cb == "function")
-                        cb(update);
-                });
-            });
-        }
-        if (arg1 === undefined)
-            return snapshot(self);
-        if (typeof arg2 == "function")
-            return addListener(self, arg2, arg1);
-        return arg1 === null
-            ? Object.isFrozen(STATE.get(self))
-            : fetch(self, arg1, arg2);
-    }
-    set(arg1, arg2) {
-        const self = this.is;
-        if (typeof arg1 == "function")
-            return addListener(self, key => {
-                if (typeof key == "string")
-                    return arg1.call(self, key, self);
-            });
-        if (arg1 && typeof arg1 == "object") {
-            const methods = METHODS.get(self.constructor);
-            for (const key in arg1)
-                if (methods.has(key))
-                    self[key] = arg1[key];
-                else if (key in self)
-                    update(self, key, arg1[key], arg2 === true);
-        }
-        else
-            event(self, arg1);
-        return pending(self);
-    }
-    /**
-     * Iterate over managed properties in this instance of Model.
-     * Yeilds the key and current value for each property.
-     */
-    [Symbol.iterator]() {
-        return Object.entries(STATE.get(this.is))[Symbol.iterator]();
-    }
-    /**
-     * Create and activate a new instance of this model.
-     *
-     * **Important** - Unlike `new this(...)` - this method also activates state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new(...args) {
-        const instance = new this(...args);
-        event(instance);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     * Determines if provided class is a subtype of this one.
-     * If so, language server will make available all static
-     * methods and properties of this class.
-     */
-    static is(maybe) {
-        return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
-    }
-    /**
-     * Register a callback to run when any instance of this Model is updated.
-     */
-    static on(listener) {
-        let notify = NOTIFY.get(this);
-        if (!notify)
-            NOTIFY.set(this, notify = new Set);
-        notify.add(listener);
-        return () => notify.delete(listener);
-    }
-}
-define(Model.prototype, "toString", {
-    value() {
-        return ID.get(this.is);
-    }
-});
-define(Model, "toString", {
-    value() {
-        return this.name;
-    }
-});
-/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */
-function prepare(model) {
-    let T = model.constructor;
-    if (T === Model)
-        throw new Error("Cannot create base Model.");
-    const chain = [];
-    let keys = new Set();
-    ID.set(model, `${T}-${uid()}`);
-    while (T.name) {
-        for (const cb of NOTIFY.get(T) || [])
-            addListener(model, cb);
-        if (T === Model)
-            break;
-        else
-            chain.unshift(T);
-        T = Object.getPrototypeOf(T);
-    }
-    for (const type of chain) {
-        if (METHODS.has(type)) {
-            keys = METHODS.get(type);
-            continue;
-        }
-        METHODS.set(type, keys = new Set(keys));
-        for (const [key, { value }] of Object.entries(Object.getOwnPropertyDescriptors(type.prototype))) {
-            if (!value || key == "constructor")
-                continue;
-            function bind(method = value) {
-                const value = method.bind(this.is);
-                METHOD.set(value, method);
-                define(this.is, key, { value, writable: true });
-                return value;
-            }
-            keys.add(key);
-            define(type.prototype, key, { get: bind, set: bind });
-        }
-    }
-}
-/**
- * Apply model arguemnts, run callbacks and observe properties.
- * Accumulate and handle cleanup events.
- **/
-function init(model, args) {
-    const methods = METHODS.get(model.constructor);
-    const state = {};
-    STATE.set(model, state);
-    args = args.flat().filter(arg => {
-        if (typeof arg != "string")
-            return true;
-        ID.set(model, arg);
-    });
-    addListener(model, () => {
-        if (!PARENT.has(model))
-            PARENT.set(model, null);
-        args.forEach((arg) => {
-            const use = typeof arg == "function"
-                ? arg.call(model, model)
-                : arg;
-            if (use instanceof Promise)
-                use.catch(err => {
-                    console.error(`Async error in constructor for ${model}:`);
-                    console.error(err);
-                });
-            else if (typeof use == "function")
-                addListener(model, use, null);
-            else if (typeof use == "object")
-                for (const key in use)
-                    if (key in model || methods.has(key))
-                        model[key] = use[key];
-        });
-        for (const key in model) {
-            const desc = Object.getOwnPropertyDescriptor(model, key);
-            if ("value" in desc) {
-                update(model, key, desc.value, true);
-                define(model, key, {
-                    configurable: false,
-                    get() {
-                        return watch(this, key, state[key]);
-                    },
-                    set(value) {
-                        update(model, key, value);
-                        mayAdopt(model, value);
-                    }
-                });
-            }
-        }
-        addListener(model, () => {
-            for (const [_, value] of model)
-                if (value instanceof Model && PARENT.get(value) === model)
-                    value.set(null);
-            Object.freeze(state);
-        }, null);
-        return null;
-    });
-}
-function mayAdopt(parent, child) {
-    if (child instanceof Model && !PARENT.has(child)) {
-        PARENT.set(child, parent);
-        event(child);
-    }
-}
-function fetch(subject, property, required) {
-    const state = STATE.get(subject);
-    if (property in state || required === false) {
-        const value = state[property];
-        if (value !== undefined || !required)
-            return value;
-    }
-    const error = new Error(`${subject}.${property} is not yet available.`);
-    const promise = new Promise((resolve, reject) => {
-        addListener(subject, key => {
-            if (key === property) {
-                resolve(state[key]);
-                return null;
-            }
-            if (key === null)
-                reject(new Error(`${subject} is destroyed.`));
-        });
-    });
-    throw Object.assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */
-let EXPORT;
-function snapshot(model) {
-    const values = {};
-    let isNotRecursive;
-    if (!EXPORT) {
-        isNotRecursive = true;
-        EXPORT = new Map([[model, values]]);
-    }
-    for (let [key, value] of model) {
-        if (EXPORT.has(value))
-            value = EXPORT.get(value);
-        else if (value && typeof value == "object" && "get" in value && typeof value.get === "function")
-            EXPORT.set(value, value = value.get());
-        values[key] = value;
-    }
-    if (isNotRecursive)
-        EXPORT = undefined;
-    return Object.freeze(values);
-}
-function update(subject, key, value, arg) {
-    const state = STATE.get(subject);
-    if (Object.isFrozen(state))
-        throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);
-    const previous = state[key];
-    if (typeof arg == "function") {
-        const out = arg.call(subject, value, previous);
-        if (out === false)
-            return false;
-        if (typeof out == "function")
-            value = out();
-    }
-    if (value === previous)
-        return;
-    state[key] = value;
-    if (arg !== true)
-        event(subject, key);
-    return true;
-}
-/** Random alphanumberic of length 6; always starts with a letter. */
-function uid() {
-    return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
-}
-export { event, fetch, mayAdopt, METHOD, Model, PARENT, STATE, uid, update, };