@expressive/mvc 0.53.6 → 0.54.1

package/dist/esm/instruction/has.js

@@ -1,73 +1,76 @@
-import { Context } from '../context';
-import { Model, update } from '../model';
-import { use } from './use';
-const APPLY = new WeakMap();
+import { Context } from "../context";
+import { Model, update } from "../model";
+import { use } from "./use";
+const APPLY = /* @__PURE__ */ new WeakMap();
 function has(arg1, arg2) {
-    return use((key, subject) => {
-        const applied = new Set();
-        const apply = () => {
-            update(subject, key, Object.freeze(Array.from(applied)));
-        };
-        if (Model.is(arg1))
-            Context.get(subject, context => {
-                context.has(arg1, model => {
-                    let remove;
-                    let disconnect;
-                    if (applied.has(model))
-                        return;
-                    const callback = APPLY.get(model);
-                    if (callback) {
-                        const after = callback(subject);
-                        if (after === false)
-                            return;
-                        if (typeof after == "function")
-                            disconnect = after;
-                    }
-                    if (typeof arg2 == "function") {
-                        const done = arg2(model, subject);
-                        if (done === false)
-                            return false;
-                        remove = () => {
-                            if (typeof done == "function")
-                                done();
-                        };
-                    }
-                    applied.add(model);
-                    apply();
-                    const done = () => {
-                        ignore();
-                        applied.delete(model);
-                        apply();
-                        if (disconnect)
-                            disconnect();
-                        if (typeof remove == "function")
-                            remove();
-                    };
-                    const ignore = model.get(null, done);
-                    return done;
-                });
-            });
-        else {
-            if (APPLY.has(subject))
-                throw new Error(`'has' callback can only be used once per model.`);
-            APPLY.set(subject, recipient => {
-                let remove;
-                if (arg1) {
-                    remove = arg1(recipient, subject);
-                    if (remove === false)
-                        return false;
-                }
-                applied.add(recipient);
-                apply();
-                return () => {
-                    applied.delete(recipient);
-                    apply();
-                    if (typeof remove == "function")
-                        remove();
-                };
-            });
+  return use((key, subject) => {
+    const applied = /* @__PURE__ */ new Set();
+    const apply = () => {
+      update(subject, key, Object.freeze(Array.from(applied)));
+    };
+    if (Model.is(arg1))
+      Context.get(subject, (context) => {
+        context.has(arg1, (model) => {
+          let remove;
+          let disconnect;
+          if (applied.has(model))
+            return;
+          const callback = APPLY.get(model);
+          if (callback) {
+            const after = callback(subject);
+            if (after === false)
+              return;
+            if (typeof after == "function")
+              disconnect = after;
+          }
+          if (typeof arg2 == "function") {
+            const done2 = arg2(model, subject);
+            if (done2 === false)
+              return false;
+            remove = () => {
+              if (typeof done2 == "function")
+                done2();
+            };
+          }
+          applied.add(model);
+          apply();
+          const done = () => {
+            ignore();
+            applied.delete(model);
+            apply();
+            if (disconnect)
+              disconnect();
+            if (typeof remove == "function")
+              remove();
+          };
+          const ignore = model.get(null, done);
+          return done;
+        });
+      });
+    else {
+      if (APPLY.has(subject))
+        throw new Error(`'has' callback can only be used once per model.`);
+      APPLY.set(subject, (recipient) => {
+        let remove;
+        if (arg1) {
+          remove = arg1(recipient, subject);
+          if (remove === false)
+            return false;
         }
-        return { value: [] };
-    });
+        applied.add(recipient);
+        apply();
+        return () => {
+          applied.delete(recipient);
+          apply();
+          if (typeof remove == "function")
+            remove();
+        };
+      });
+    }
+    return { value: [] };
+  });
 }
-export { has };
+export {
+  has
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/instruction/ref.js

@@ -1,59 +1,62 @@
-import { context } from '../control';
-import { define, update } from '../model';
-import { use } from './use';
+import { context } from "../control";
+import { define, update } from "../model";
+import { use } from "./use";
 function ref(arg, arg2) {
-    return use((key, subject, state) => {
-        let value = {};
-        if (arg === subject)
-            subject.get(() => {
-                for (const key in state)
-                    if (typeof arg2 == "function")
-                        define(value, key, {
-                            configurable: true,
-                            get() {
-                                const out = arg2(key);
-                                define(value, key, { value: out });
-                                return out;
-                            }
-                        });
-                    else {
-                        const get = () => state[key];
-                        const set = (value) => {
-                            update(subject, key, value);
-                        };
-                        define(set, "current", { get, set });
-                        define(set, "get", { value: get });
-                        define(value, key, { value: set });
-                    }
+  return use((key, subject, state) => {
+    let value = {};
+    if (arg === subject)
+      subject.get(() => {
+        for (const key2 in state)
+          if (typeof arg2 == "function")
+            define(value, key2, {
+              configurable: true,
+              get() {
+                const out = arg2(key2);
+                define(value, key2, { value: out });
+                return out;
+              }
             });
-        else if (typeof arg == "object")
-            throw new Error("ref instruction does not support object which is not 'this'");
-        else {
-            let unset;
-            const get = () => state[key];
-            const set = (value) => {
-                if (!update(subject, key, value) || !arg)
-                    return;
-                if (unset)
-                    unset = void unset(value);
-                if (value === null && arg2 !== false)
-                    return;
-                const ctx = context();
-                const out = arg.call(subject, value);
-                const flush = ctx();
-                unset = key => {
-                    if (typeof out == "function")
-                        out(key);
-                    flush();
-                };
+          else {
+            const get = () => state[key2];
+            const set = (value2) => {
+              update(subject, key2, value2);
             };
-            state[key] = null;
-            value = Object.defineProperties(set, {
-                current: { get, set },
-                get: { value: get }
-            });
-        }
-        define(subject, key, { value });
-    });
+            define(set, "current", { get, set });
+            define(set, "get", { value: get });
+            define(value, key2, { value: set });
+          }
+      });
+    else if (typeof arg == "object")
+      throw new Error("ref instruction does not support object which is not 'this'");
+    else {
+      let unset;
+      const get = () => state[key];
+      const set = (value2) => {
+        if (!update(subject, key, value2) || !arg)
+          return;
+        if (unset)
+          unset = void unset(value2);
+        if (value2 === null && arg2 !== false)
+          return;
+        const ctx = context();
+        const out = arg.call(subject, value2);
+        const flush = ctx();
+        unset = (key2) => {
+          if (typeof out == "function")
+            out(key2);
+          flush();
+        };
+      };
+      state[key] = null;
+      value = Object.defineProperties(set, {
+        current: { get, set },
+        get: { value: get }
+      });
+    }
+    define(subject, key, { value });
+  });
 }
-export { ref };
+export {
+  ref
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/instruction/set.js

@@ -1,86 +1,83 @@
-import { context } from '../control';
-import { event, update } from '../model';
-import { use } from './use';
+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 use((key, subject) => {
+    const property = {};
+    if (typeof value == "function" || value instanceof Promise) {
+      let init2 = function() {
+        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((value2) => {
+            update(subject, key, value2);
+            return value2;
+          }).catch((err) => {
+            event(subject, key);
+            property.get = () => {
+              throw err;
             };
-        return property;
-    });
+          });
+        } else
+          update(subject, key, value);
+        if (0 in arguments)
+          return subject[key];
+      };
+      var init = init2;
+      if (argument)
+        init2();
+      else
+        property.get = init2;
+    } else if (value !== void 0)
+      property.value = value;
+    if (typeof argument == "function") {
+      let unset;
+      property.set = function(value2, previous) {
+        const ctx = context();
+        const out = argument.call(this, value2, previous);
+        const flush = ctx();
+        if (out === false)
+          return out;
+        if (typeof unset == "function")
+          unset(value2);
+        unset = (next) => {
+          if (typeof out == "function")
+            out(next);
+          flush();
+        };
+      };
+    } else
+      property.set = (value2) => {
+        property.get = void 0;
+        update(subject, key, value2);
+      };
+    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);
-        }
+  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();
+  }
+  return compute();
 }
-export { set };
+export {
+  set
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/instruction/use.js

@@ -1,60 +1,65 @@
-import { watch } from '../control';
-import { define, fetch, mayAdopt, Model, PARENT, STATE, update } from '../model';
-const INSTRUCT = new Map();
+import { watch } from "../control";
+import { define, fetch, mayAdopt, Model, PARENT, STATE, update } from "../model";
+const INSTRUCT = /* @__PURE__ */ new Map();
 function use(arg1, arg2) {
-    const token = Symbol("instruction");
-    if (Model.is(arg1)) {
-        const type = arg1;
-        arg1 = (key, subject) => {
-            const value = new type();
-            const desc = { set };
-            set(value);
-            PARENT.set(value, subject);
-            function set(next) {
-                if (next ? !(next instanceof type) : arg2 !== false)
-                    throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
-                update(subject, key, next);
-                if (next && typeof arg2 == "function")
-                    arg2(next);
-                return false;
-            }
-            return desc;
-        };
-    }
-    INSTRUCT.set(token, arg1);
-    return token;
+  const token = Symbol("instruction");
+  if (Model.is(arg1)) {
+    const type = arg1;
+    arg1 = (key, subject) => {
+      const value = new type();
+      const desc = { set };
+      set(value);
+      PARENT.set(value, subject);
+      function set(next) {
+        if (next ? !(next instanceof type) : arg2 !== false)
+          throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
+        update(subject, key, next);
+        if (next && typeof arg2 == "function")
+          arg2(next);
+        return false;
+      }
+      return desc;
+    };
+  }
+  INSTRUCT.set(token, arg1);
+  return token;
 }
 Model.on((_, model) => {
-    const state = STATE.get(model);
-    for (const key in model) {
-        const { value } = Object.getOwnPropertyDescriptor(model, key);
-        const instruction = INSTRUCT.get(value);
-        if (!instruction) {
-            mayAdopt(model, value);
-            continue;
-        }
-        INSTRUCT.delete(value);
-        delete model[key];
-        const output = instruction.call(model, key, model, state);
-        if (!output)
-            continue;
-        const desc = typeof output == "object" ? output : { get: output };
-        if ("value" in desc)
-            state[key] = desc.value;
-        define(model, key, {
-            enumerable: desc.enumerable !== false,
-            get() {
-                return watch(this, key, typeof desc.get == "function"
-                    ? desc.get(this)
-                    : fetch(model, key, desc.get));
-            },
-            set(next) {
-                if (desc.set === false)
-                    throw new Error(`${model}.${key} is read-only.`);
-                update(model, key, next, desc.set);
-            }
-        });
+  const state = STATE.get(model);
+  for (const key in model) {
+    const { value } = Object.getOwnPropertyDescriptor(model, key);
+    const instruction = INSTRUCT.get(value);
+    if (!instruction) {
+      mayAdopt(model, value);
+      continue;
     }
-    return null;
+    INSTRUCT.delete(value);
+    delete model[key];
+    const output = instruction.call(model, key, model, state);
+    if (!output)
+      continue;
+    const desc = typeof output == "object" ? output : { get: output };
+    if ("value" in desc)
+      state[key] = desc.value;
+    define(model, key, {
+      enumerable: desc.enumerable !== false,
+      get() {
+        return watch(
+          this,
+          key,
+          typeof desc.get == "function" ? desc.get(this) : fetch(model, key, desc.get)
+        );
+      },
+      set(next) {
+        if (desc.set === false)
+          throw new Error(`${model}.${key} is read-only.`);
+        update(model, key, next, desc.set);
+      }
+    });
+  }
+  return null;
 });
-export { use };
+export {
+  use
+};
+//# sourceMappingURL=data:application/json;base64,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