@expressive/mvc 0.27.0 → 0.28.0

package/lib/index.esm.js

@@ -42,160 +42,7 @@ function issues(register) {
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$8 = issues({
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Destoryed: () => "Model is destroyed."
-});
-function suspense(source, key) {
-    const error = Oops$8.NotReady(source.subject, key);
-    const watch = source.observers.get(key);
-    const promise = new Promise((resolve, reject) => {
-        function onUpdate(key) {
-            if (key)
-                return () => {
-                    if (source.state[key] !== undefined) {
-                        watch.delete(onUpdate);
-                        resolve();
-                    }
-                };
-            if (key === null)
-                reject(Oops$8.Destoryed());
-        }
-        watch.add(onUpdate);
-    });
-    return assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-function mayRetry(fn) {
-    const retry = (err) => {
-        if (err instanceof Promise)
-            return err.then(compute);
-        else
-            throw err;
-    };
-    const compute = () => {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
-    };
-    return compute();
-}
-
 const Oops$7 = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-function createEffect(source, callback) {
-    return control(source, self => {
-        let { subject } = self;
-        let unSet;
-        let busy = false;
-        function invoke() {
-            if (busy)
-                return;
-            const output = mayRetry(() => {
-                if (typeof unSet == "function")
-                    unSet();
-                unSet = callback.call(subject, subject);
-                if (unSet instanceof Promise)
-                    unSet = undefined;
-                if (unSet && typeof unSet !== "function")
-                    throw Oops$7.BadCallback();
-            });
-            if (output instanceof Promise) {
-                output.finally(() => busy = false);
-                busy = true;
-            }
-        }
-        let refresh;
-        subject = watch(subject, () => refresh);
-        self.followers.add(key => (key === null || refresh === null ? refresh : undefined));
-        invoke();
-        refresh = invoke;
-        return () => refresh = null;
-    });
-}
-function createValueEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet(value);
-        const out = callback.call(this, value, this);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$7.BadCallback();
-    };
-}
-
-const Oops$6 = issues({
-    KeysExpected: (key) => `Key "${key}" was expected in current update.`
-});
-function addEventListener(source, select, callback, once) {
-    return control(source, self => {
-        const { subject } = self;
-        if (typeof select == "string")
-            select = [select];
-        if (select)
-            for (const key of select)
-                try {
-                    void subject[key];
-                }
-                catch (e) {
-                    // TODO: should this be caught?
-                }
-        const removeListener = self.addListener(key => {
-            if (key === null)
-                callback.call(subject, null);
-            else if (!select || select.includes(key)) {
-                if (once)
-                    removeListener();
-                return () => callback.call(subject, self.latest);
-            }
-        });
-        return removeListener;
-    });
-}
-function awaitUpdate(source, select, timeout) {
-    return new Promise((resolve, reject) => {
-        if (timeout === 0) {
-            const self = control(source, true);
-            if (!self.frame.size)
-                resolve(false);
-            else if (typeof select == "string" && !self.frame.has(select))
-                reject(Oops$6.KeysExpected(select));
-            else {
-                const remove = self.addListener(() => {
-                    remove();
-                    return () => resolve(self.latest);
-                });
-            }
-        }
-        else {
-            const remove = addEventListener(source, select, resolve, true);
-            if (timeout > 0)
-                setTimeout(() => {
-                    remove();
-                    resolve(false);
-                }, timeout);
-        }
-    });
-}
-
-const Oops$5 = issues({
     NotFound: (name) => `Could not find ${name} in context.`
 });
 function get$1(argument) {
@@ -210,7 +57,7 @@ function get$1(argument) {
                     ? Control.watch(got, k => k ? onUpdate : undefined)
                     : got;
             else if (argument !== false)
-                throw Oops$5.NotFound(this);
+                throw Oops$7.NotFound(this);
             return {
                 mount() {
                     onUpdate = refresh;
@@ -226,7 +73,7 @@ function get$1(argument) {
         let proxy;
         const found = context.get(this);
         if (!found)
-            throw Oops$5.NotFound(this);
+            throw Oops$7.NotFound(this);
         function forceUpdate(action) {
             if (typeof action == "function")
                 action = action();
@@ -316,7 +163,7 @@ function use$1(apply, repeat) {
                                 instance[key] = props[key];
                     if (!repeat)
                         shouldApply = false;
-                    instance.on(0).then(() => onUpdate = refresh);
+                    instance.set(0).then(() => onUpdate = refresh);
                 }
                 return local;
             }
@@ -325,59 +172,182 @@ function use$1(apply, repeat) {
     return render(apply);
 }
 
-class Model {
-    constructor(id) {
-        new Control(this, id);
-    }
-    /**
-     * Reference to `this` without a subscription.
-     * Use to obtain full reference from a destructure.
-     */
-    get is() {
-        return this;
-    }
-    on(arg1, arg2, arg3) {
-        if (typeof arg1 == "function")
-            return createEffect(this, arg1);
-        if (typeof arg1 == "number") {
-            arg2 = arg1;
-            arg1 = undefined;
+const Oops$6 = issues({
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    Destoryed: () => "Model is destroyed."
+});
+function suspense(source, key) {
+    const error = Oops$6.NotReady(source.subject, key);
+    const watch = source.observers.get(key);
+    const promise = new Promise((resolve, reject) => {
+        function onUpdate(key) {
+            if (key)
+                return () => {
+                    if (source.state[key] !== undefined) {
+                        watch.delete(onUpdate);
+                        resolve();
+                    }
+                };
+            if (key === null)
+                reject(Oops$6.Destoryed());
         }
-        return typeof arg2 == "function"
-            ? addEventListener(this, arg1, arg2, arg3)
-            : awaitUpdate(this, arg1, arg2);
-    }
-    get(arg1, arg2) {
-        const { state } = control(this, true);
-        function values() {
-            if (typeof arg1 == "string")
-                return state[arg1];
-            if (!arg1)
-                return Object.assign({}, state);
-            const output = {};
-            for (const key of arg1)
-                output[key] = state[key];
-            return output;
+        watch.add(onUpdate);
+    });
+    return assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
+}
+function mayRetry(fn) {
+    const retry = (err) => {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    };
+    const compute = () => {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
         }
-        return typeof arg2 == "function"
-            ? this.on(arg1, () => arg2(values()))
-            : values();
+    };
+    return compute();
+}
+
+const Oops$5 = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+function createEffect(source, callback) {
+    return control(source, self => {
+        let { subject } = self;
+        let unSet;
+        let busy = false;
+        function invoke() {
+            if (busy)
+                return;
+            const output = mayRetry(() => {
+                if (typeof unSet == "function")
+                    unSet();
+                unSet = callback.call(subject, subject);
+                if (unSet instanceof Promise)
+                    unSet = undefined;
+                if (unSet && typeof unSet !== "function")
+                    throw Oops$5.BadCallback();
+            });
+            if (output instanceof Promise) {
+                output.finally(() => busy = false);
+                busy = true;
+            }
+        }
+        let refresh;
+        subject = watch(subject, () => refresh);
+        self.followers.add(key => (key === null || refresh === null ? refresh : undefined));
+        invoke();
+        refresh = invoke;
+        return () => refresh = null;
+    });
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$5.BadCallback();
+    };
+}
+
+function getMethod(argument, callback, once) {
+    if (typeof argument == "function")
+        return createEffect(this, argument);
+    const self = control(this, true);
+    function get() {
+        if (typeof argument == "string")
+            return self.state[argument];
+        if (!argument)
+            return Object.assign({}, self.state);
+        const output = {};
+        for (const key of argument)
+            output[key] = self.state[key];
+        return output;
     }
-    set(arg1, arg2) {
-        const controller = control(this, true);
-        const { state } = controller;
-        if (typeof arg1 == "string") {
-            controller.update(arg1);
-            if (1 in arguments && arg1 in state)
-                state[arg1] = arg2;
+    if (typeof callback != "function")
+        return get();
+    const select = typeof argument == "string" ? [argument] : argument;
+    if (select)
+        for (const key of select)
+            try {
+                const value = self.subject[key];
+                if (!(key in self.state))
+                    self.watch(key, { value });
+            }
+            catch (e) {
+                // TODO: should this be caught?
+            }
+    const remove = self.addListener(key => {
+        if (!select || select.includes(key)) {
+            if (once)
+                remove();
+            return () => callback(get(), self.latest);
         }
-        else if (typeof arg1 == "object")
+    });
+    return remove;
+}
+function setMethod(arg1, arg2) {
+    const self = control(this, true);
+    const { state } = self;
+    let timeout = 0;
+    switch (typeof arg1) {
+        case "string":
+            if (1 in arguments)
+                if (arg1 in state)
+                    state[arg1] = arg2;
+                else
+                    self.watch(arg1, { value: arg2 });
+            self.update(arg1);
+            break;
+        case "object":
             for (const key in state)
                 if (key in arg1 && (!arg2 || arg2.includes(key))) {
                     state[key] = arg1[key];
-                    controller.update(key);
+                    self.update(key);
                 }
-        return this.on(0);
+            break;
+        default:
+            timeout = arg1;
+    }
+    return new Promise((resolve) => {
+        if (!self.frame.size && timeout === 0)
+            resolve(false);
+        const remove = self.addListener(() => {
+            remove();
+            return () => resolve(self.latest);
+        });
+        if (timeout > 0)
+            setTimeout(() => {
+                remove();
+                resolve(false);
+            }, timeout);
+    });
+}
+
+class Model {
+    constructor(id) {
+        new Control(this, id);
     }
     /** Mark this instance for garbage collection. */
     null() {
@@ -407,10 +377,29 @@ class Model {
 }
 Model.get = get$1;
 Model.use = use$1;
-defineProperty(Model.prototype, "toString", {
-    configurable: true,
-    value() {
-        return `${this.constructor.name}-${control(this).id}`;
+defineProperties(Model.prototype, {
+    get: { value: getMethod },
+    set: { value: setMethod },
+    is: {
+        configurable: true,
+        get() {
+            // TODO: Remove this method on 1.0
+            throw new Error("Model.is property is now is only available from a hook.");
+        }
+    },
+    on: {
+        configurable: true,
+        writable: true,
+        value() {
+            // TODO: Remove this method on 1.0
+            throw new Error("Model.on() is deprecated. Use Model.get or Model.set instead.");
+        }
+    },
+    toString: {
+        configurable: true,
+        value() {
+            return `${this.constructor.name}-${control(this).id}`;
+        }
     }
 });
 defineProperty(Model, "toString", {
@@ -433,10 +422,12 @@ class Control {
         this.frame = new Set();
         this.followers = new Set();
         this.observers = new Map([["", this.followers]]);
-        this.id = typeof id == "undefined" ? uid() : id;
         this.subject = subject;
         REGISTER.set(subject, this);
-        PENDING$1.set(this, new Set(Control.ready));
+        if (id !== false) {
+            this.id = id === undefined ? uid() : id;
+            PENDING$1.set(this, new Set(Control.ready));
+        }
     }
     add(key) {
         const { value } = getOwnPropertyDescriptor(this.subject, key);
@@ -536,7 +527,7 @@ Control.for = control;
 Control.apply = apply;
 Control.watch = watch;
 function control(subject, ready) {
-    const control = REGISTER.get(subject.is);
+    const control = REGISTER.get(subject);
     const pending = PENDING$1.get(control);
     if (typeof ready == "function") {
         if (!pending)
@@ -589,11 +580,14 @@ function parent(child, assign) {
         return PARENTS.get(child);
     PARENTS.set(child, assign);
 }
-function watch(on, cb) {
-    if (!on.hasOwnProperty("is"))
-        on = defineProperty(create(on), "is", { value: on });
-    OBSERVER.set(on, cb);
-    return on;
+function watch(value, cb) {
+    if (!OBSERVER.has(value)) {
+        const control = REGISTER.get(value);
+        value = defineProperty(create(value), "is", { value });
+        REGISTER.set(value, control);
+    }
+    OBSERVER.set(value, cb);
+    return value;
 }
 function apply(instruction) {
     const placeholder = Symbol("instruction");
@@ -901,28 +895,11 @@ function use(input, argument) {
     });
 }
 function manage(next) {
-    const methods = {
-        on(key, event) {
-            const callback = () => event(next[key], key);
-            if (!(key in next))
-                control.watch(key, { value: subject[key] });
-            callback();
-            return control.addListener(k => {
-                if (k === key)
-                    return callback;
-                if (typeof k !== "string")
-                    return k;
-            });
-        },
-        set(key, value) {
-            if (key in next)
-                subject[key] = value;
-            else
-                control.watch(key, { value });
-        }
-    };
-    const subject = assign(create(next), methods);
-    const control = new Control(subject);
+    const subject = assign(create(next), {
+        get: getMethod,
+        set: setMethod
+    });
+    const control = new Control(subject, false);
     for (const key in control.state = next)
         control.watch(key, {});
     return subject;
@@ -987,7 +964,7 @@ class Context {
             I = new input();
         }
         else {
-            I = input.is;
+            I = control(input).subject;
             T = I.constructor;
             writable = false;
         }