@expressive/mvc 0.33.0 → 0.35.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,681 @@
+// src/control.ts
+var DISPATCH = /* @__PURE__ */ new Set();
+var OBSERVER = /* @__PURE__ */ new WeakMap();
+var LISTENER = /* @__PURE__ */ new WeakMap();
+var EXPIRED = /* @__PURE__ */ new WeakSet();
+function onReady() {
+  return null;
+}
+function addListener(to, fn) {
+  let subs = LISTENER.get(to);
+  if (!subs)
+    LISTENER.set(to, subs = /* @__PURE__ */ new Map([[onReady, null]]));
+  if (!subs.has(onReady))
+    fn(true, to);
+  subs.set(fn, null);
+  return () => subs.delete(fn);
+}
+function watch(from, key, value) {
+  const listeners = LISTENER.get(from);
+  const observer = OBSERVER.get(from);
+  if (observer) {
+    listeners.set(
+      observer,
+      new Set(listeners.get(observer)).add(key)
+    );
+    const nested = LISTENER.get(value);
+    if (nested) {
+      LISTENER.set(value = Object.create(value), nested);
+      OBSERVER.set(value, observer);
+    }
+  }
+  return value;
+}
+function event(source, key) {
+  LISTENER.get(source).forEach((select, callback, subs) => {
+    let after;
+    if (!select || select.has(key)) {
+      if (after = callback.call(source, key, source))
+        queue(after);
+    }
+    if (after === null || key === null)
+      subs.delete(callback);
+  });
+}
+function queue(event2) {
+  if (!DISPATCH.size)
+    setTimeout(() => {
+      DISPATCH.forEach((event3) => {
+        try {
+          event3();
+        } catch (err) {
+          console.error(err);
+        }
+      });
+      DISPATCH.clear();
+    }, 0);
+  DISPATCH.add(event2);
+}
+function effect(target, callback) {
+  const listeners = LISTENER.get(target);
+  let refresh;
+  let unSet;
+  function invoke() {
+    const local = Object.create(target);
+    const update2 = () => {
+      if (EXPIRED.has(update2))
+        return null;
+      EXPIRED.add(update2);
+      if (refresh && unSet) {
+        unSet();
+        unSet = void 0;
+      }
+      return refresh;
+    };
+    LISTENER.set(local, listeners);
+    OBSERVER.set(local, update2);
+    try {
+      const out = callback.call(local, local);
+      unSet = typeof out == "function" && out;
+      refresh = out === null ? out : invoke;
+    } catch (err) {
+      if (err instanceof Promise) {
+        refresh = void 0;
+        err.then(invoke).catch(console.error);
+      } else if (refresh)
+        console.error(err);
+      else
+        throw err;
+    }
+  }
+  addListener(target, (key) => {
+    if (key === true)
+      invoke();
+    else if (!refresh)
+      return refresh;
+    if (key === null && unSet)
+      unSet();
+  });
+  return () => {
+    refresh = null;
+  };
+}
+
+// src/model.ts
+var ID = /* @__PURE__ */ new WeakMap();
+var PARENT = /* @__PURE__ */ new WeakMap();
+var INSTRUCT = /* @__PURE__ */ new Map();
+var PENDING = /* @__PURE__ */ new WeakMap();
+var STATE = /* @__PURE__ */ new WeakMap();
+var Model = class _Model {
+  constructor(id) {
+    const state = {};
+    Object.defineProperty(this, "is", { value: this });
+    ID.set(this, `${this.constructor}-${id ? String(id) : uid()}`);
+    STATE.set(this, state);
+    function onNull(key) {
+      if (key === null)
+        Object.freeze(state);
+    }
+    addListener(this, () => {
+      for (const key in this) {
+        const { value } = Object.getOwnPropertyDescriptor(this, key);
+        const instruction = INSTRUCT.get(value);
+        let desc = {
+          enumerable: true,
+          set: (x) => update(this, key, x),
+          get() {
+            return watch(this, key, state[key]);
+          }
+        };
+        if (instruction) {
+          INSTRUCT.delete(value);
+          delete this[key];
+          desc = instruction(this, key, state);
+        } else
+          state[key] = value;
+        if (desc)
+          Object.defineProperty(this, key, desc);
+      }
+      addListener(this, onNull);
+      return null;
+    });
+  }
+  get(arg1, arg2) {
+    const self = this.is;
+    if (typeof arg1 == "string")
+      return fetch(self, arg1, arg2);
+    if (arg1)
+      return effect(self, arg1);
+    const cache = /* @__PURE__ */ new WeakMap();
+    function get2(value) {
+      if (value instanceof _Model) {
+        if (cache.has(value))
+          return cache.get(value);
+        const model = value;
+        cache.set(value, value = {});
+        for (const [key, val] of model)
+          value[key] = get2(val);
+      }
+      return value;
+    }
+    return get2(self);
+  }
+  set(arg1, arg2, arg3) {
+    const self = this.is;
+    if (typeof arg1 == "function")
+      return addListener(self, (key) => {
+        if (typeof key == "string")
+          return arg1(key);
+      });
+    if (typeof arg1 == "string" || arg1 === null)
+      return 1 in arguments ? update(self, arg1, arg2, arg3) : update(self, arg1);
+    return new Promise((resolve, reject) => {
+      if (typeof arg1 != "number" && !PENDING.has(self)) {
+        resolve(false);
+        return;
+      }
+      const remove = addListener(this, (key) => {
+        if (key === true || typeof arg2 == "function" && typeof key == "string" && arg2(key) !== true)
+          return;
+        if (timeout)
+          clearTimeout(timeout);
+        remove();
+        return resolve.bind(null, PENDING.get(self));
+      });
+      const timeout = typeof arg1 == "number" && setTimeout(() => {
+        remove();
+        reject(arg1);
+      }, arg1);
+    });
+  }
+  /** Iterate over managed properties in this instance of Model. */
+  [Symbol.iterator]() {
+    return Object.entries(STATE.get(this.is))[Symbol.iterator]();
+  }
+  /**
+   * Creates a new instance of this controller.
+   * 
+   * Beyond `new this(...)`, method will activate managed-state.
+   * 
+   * @param args - arguments sent to constructor
+   */
+  static new(...args) {
+    const instance = new this(...args);
+    event(instance, true);
+    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 typeof maybe == "function" && maybe.prototype instanceof this;
+  }
+};
+Object.defineProperty(Model.prototype, "toString", {
+  value() {
+    return ID.get(this.is);
+  }
+});
+Object.defineProperty(Model, "toString", {
+  value() {
+    return this.name;
+  }
+});
+function add(instruction) {
+  const placeholder = Symbol("instruction");
+  INSTRUCT.set(placeholder, (subject, key, state) => {
+    const output = instruction.call(subject, key, subject, state);
+    if (!output)
+      return;
+    const desc = typeof output == "object" ? output : { get: output };
+    const { enumerable = true } = desc;
+    if ("value" in desc)
+      state[key] = desc.value;
+    return {
+      enumerable,
+      set(next) {
+        let { set: set2 } = desc;
+        if (set2 === false)
+          throw new Error(`${subject}.${key} is read-only.`);
+        if (typeof set2 == "function") {
+          const result = set2.call(subject, next, state[key]);
+          if (result === false)
+            return;
+          if (typeof result == "function")
+            next = result();
+          set2 = false;
+        }
+        update(subject, key, next, !!set2);
+      },
+      get() {
+        return watch(
+          this,
+          key,
+          typeof desc.get == "function" ? desc.get(this) : fetch(subject, key, desc.get)
+        );
+      }
+    };
+  });
+  return placeholder;
+}
+function fetch(subject, property, required) {
+  const state = STATE.get(subject);
+  if (property in state || required === false) {
+    const value = state[property];
+    if (value !== void 0 || !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
+  });
+}
+function update(subject, key, value, silent) {
+  const state = STATE.get(subject);
+  let pending = PENDING.get(subject);
+  if (typeof key == "string") {
+    if (2 in arguments) {
+      const previous = state[key];
+      if (value === previous)
+        return true;
+      state[key] = value;
+      if (silent === true)
+        return;
+    }
+    if (!pending) {
+      PENDING.set(subject, pending = {});
+      queue(() => {
+        event(subject, false);
+        PENDING.delete(subject);
+      });
+    }
+    const skip = key in pending;
+    pending[key] = state[key];
+    if (skip)
+      return;
+  }
+  event(subject, key);
+}
+function uid() {
+  return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+}
+
+// src/instruction/run.ts
+function run(task) {
+  return add((key, subject) => {
+    let pending = false;
+    async function invoke(...args) {
+      if (pending)
+        return Promise.reject(
+          new Error(`Invoked action ${key} but one is already active.`)
+        );
+      pending = true;
+      subject.set(key);
+      try {
+        return await attempt(() => task.apply(subject, args));
+      } finally {
+        pending = false;
+        subject.set(key);
+      }
+    }
+    Object.defineProperty(invoke, "active", {
+      get: () => pending
+    });
+    return {
+      value: invoke,
+      set: false
+    };
+  });
+}
+function attempt(fn) {
+  function retry(err) {
+    if (err instanceof Promise)
+      return err.then(compute2);
+    else
+      throw err;
+  }
+  function compute2() {
+    try {
+      const output = fn();
+      return output instanceof Promise ? output.catch(retry) : output;
+    } catch (err) {
+      return retry(err);
+    }
+  }
+  return compute2();
+}
+
+// src/context.ts
+var Context = class {
+  constructor(inputs) {
+    this.table = /* @__PURE__ */ new WeakMap();
+    this.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      this.include(inputs);
+  }
+  static resolve(from, callback) {
+    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
+  }
+  has(T) {
+    let key = this.table.get(T);
+    if (!key) {
+      key = Symbol(T.name);
+      this.table.set(T, key);
+    }
+    return key;
+  }
+  get(Type) {
+    const result = this[this.has(Type)];
+    if (result === null)
+      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+    return result;
+  }
+  include(inputs) {
+    const init = /* @__PURE__ */ new Map();
+    for (const key in inputs) {
+      const input = inputs[key];
+      const exists = this.layer.get(key);
+      if (!exists) {
+        const instance = this.add(input);
+        this.layer.set(key, input);
+        init.set(instance, true);
+      } else if (exists !== input) {
+        this.pop();
+        this.key = uid();
+        return this.include(inputs);
+      }
+    }
+    for (const [model] of init)
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    return init;
+  }
+  add(input, implicit) {
+    let writable = true;
+    let T;
+    let I;
+    if (typeof input == "function") {
+      T = input;
+      I = input.new();
+    } else {
+      I = input;
+      T = I.constructor;
+      writable = false;
+    }
+    do {
+      const key = this.has(T);
+      const value = this.hasOwnProperty(key) ? null : I;
+      if (value || I !== this[key] && !implicit)
+        Object.defineProperty(this, key, {
+          configurable: true,
+          value,
+          writable
+        });
+      T = Object.getPrototypeOf(T);
+    } while (T !== Model);
+    return I;
+  }
+  push() {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    return next;
+  }
+  pop() {
+    const items = /* @__PURE__ */ new Set();
+    for (const key of Object.getOwnPropertySymbols(this)) {
+      const entry = Object.getOwnPropertyDescriptor(this, key);
+      if (entry.writable && entry.value)
+        items.add(entry.value);
+      delete this[key];
+    }
+    for (const model of items)
+      model.set(null);
+    this.layer.clear();
+  }
+};
+
+// src/instruction/get.ts
+function get(arg0, arg1) {
+  return add((key, subject) => {
+    let from = subject;
+    if (typeof arg0 == "symbol")
+      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${from}.${key}. This is not allowed.`);
+    let source = (resolve) => resolve(from);
+    if (arg0 instanceof Model)
+      from = arg0;
+    else if (Model.is(arg0)) {
+      const hasParent = PARENT.get(from);
+      if (!hasParent) {
+        if (arg1 === true)
+          throw new Error(`${from} may only exist as a child of type ${arg0}.`);
+        source = (resolve) => {
+          Context.resolve(from, (context) => {
+            const model = context.get(arg0);
+            if (model)
+              resolve(model);
+            else if (arg1 !== false)
+              throw new Error(`Required ${arg0} not found in context for ${from}.`);
+          });
+        };
+      } else if (!arg0 || hasParent instanceof arg0)
+        from = hasParent;
+      else
+        throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+    } else if (typeof arg0 == "function")
+      arg1 = arg0.call(from, key, from);
+    if (typeof arg1 == "function")
+      return compute(subject, key, source, arg1);
+    source((got) => subject.set(key, got));
+    return { get: arg1 };
+  });
+}
+var STALE = /* @__PURE__ */ new WeakSet();
+function compute(subject, key, source, setter) {
+  let reset;
+  let isAsync;
+  let proxy;
+  function connect(model) {
+    reset = model.get((current) => {
+      proxy = current;
+      if (!reset)
+        compute2(true);
+      else if (STALE.delete(compute2))
+        compute2();
+      return () => {
+        STALE.add(compute2);
+        subject.set(key);
+      };
+    });
+  }
+  function compute2(initial) {
+    let next;
+    try {
+      next = setter.call(proxy, proxy);
+    } catch (err) {
+      console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+      if (initial)
+        throw err;
+      console.error(err);
+    }
+    subject.set(key, next, !isAsync);
+  }
+  return () => {
+    if (!proxy) {
+      source(connect);
+      isAsync = true;
+    }
+    if (STALE.delete(compute2))
+      compute2();
+    return fetch(subject, key, !proxy);
+  };
+}
+
+// src/instruction/ref.ts
+var define = Object.defineProperty;
+function ref(arg, arg2) {
+  return add((key, subject, state) => {
+    let value = {};
+    if (arg === subject)
+      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 {
+          const ref2 = (value2) => subject.set(key2, value2);
+          define(ref2, "current", {
+            get: () => state[key2],
+            set: ref2
+          });
+          define(value, key2, { value: ref2 });
+        }
+    else if (typeof arg == "object")
+      throw new Error("ref instruction does not support object which is not 'this'");
+    else {
+      let unSet;
+      const set2 = (value2) => {
+        if (subject.set(key, value2) || !arg)
+          return;
+        if (unSet)
+          unSet = void unSet(value2);
+        if (value2 !== null || arg2 === false) {
+          const out = arg.call(subject, value2);
+          if (typeof out == "function")
+            unSet = out;
+        }
+      };
+      value = define(set2, "current", {
+        get: () => state[key],
+        set: set2
+      });
+    }
+    define(subject, key, { value });
+  });
+}
+
+// src/instruction/set.ts
+function set(value, argument) {
+  return add((key, subject) => {
+    const output = {};
+    if (typeof value == "function" || value instanceof Promise) {
+      let init2 = function() {
+        if (typeof value == "function")
+          try {
+            value = attempt(value.bind(subject, key, subject));
+          } catch (err) {
+            console.warn(`Generating initial value for ${subject}.${key} failed.`);
+            throw err;
+          }
+        output.get = typeof argument == "boolean" ? argument : void 0;
+        if (value instanceof Promise) {
+          value.then((value2) => {
+            subject.set(key, value2);
+            return value2;
+          }).catch((err) => {
+            subject.set(key);
+            output.get = () => {
+              throw err;
+            };
+          });
+        } else
+          subject.set(key, value);
+        if (0 in arguments)
+          return subject[key];
+      };
+      var init = init2;
+      if (argument)
+        init2();
+      else
+        output.get = init2;
+    } else if (value !== void 0)
+      output.value = value;
+    if (typeof argument == "function") {
+      let unSet;
+      output.set = function(value2, previous) {
+        const out = argument.call(this, value2, previous);
+        if (out === false)
+          return out;
+        if (typeof unSet == "function")
+          unSet = void unSet(value2);
+        if (typeof out == "function")
+          unSet = out;
+      };
+    } else
+      output.set = (value2) => {
+        output.get = void 0;
+        subject.set(key, value2);
+      };
+    return output;
+  });
+}
+
+// src/instruction/use.ts
+function use(value, argument) {
+  return add((property, subject) => {
+    if (typeof value === "function")
+      value = new value();
+    const output = { set: set2, value };
+    function set2(next) {
+      if (value instanceof Model && !(next instanceof value.constructor))
+        throw new Error(`${subject}.${property} expected Model of type ${value.constructor} but got ${next}.`);
+      if (next instanceof Model) {
+        PARENT.set(next, subject);
+        event(next, true);
+      } else if (next) {
+        const proxy = Object.create(next);
+        for (const key in proxy)
+          Object.defineProperty(proxy, key, {
+            enumerable: true,
+            get: () => next[key],
+            set(value2) {
+              if (value2 != next[key]) {
+                next[key] = value2;
+                subject.set(property);
+              }
+            }
+          });
+        output.get = () => proxy;
+      }
+      if (typeof argument == "function")
+        argument(next);
+    }
+    set2(value);
+    return output;
+  });
+}
+export {
+  Context,
+  Model,
+  add,
+  Model as default,
+  get,
+  ref,
+  run,
+  set,
+  use
+};

package/package.json

@@ -11,21 +11,23 @@
     "access": "public"
   },
   "keywords": [
+    "expressive",
     "mvc"
   ],
-  "main": "lib/index.js",
-  "module": "lib/index.esm.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "files": [
-    "lib"
+    "dist/index.js",
+    "dist/index.mjs",
+    "dist/index.d.ts"
   ],
   "scripts": {
-    "build": "rollup --config",
-    "watch": "jest --watchAll",
-    "test": "jest --collectCoverage",
-    "prebuild": "rm -rf lib/",
+    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "test": "tsc --noEmit && jest --collectCoverage",
+    "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.33.0",
-  "gitHead": "b6cd486f362d8188fcf11dde504978c45638ab40"
+  "version": "0.35.0-alpha.0",
+  "gitHead": "17db508f601400ac08e6f821376e7a9403525d5b"
 }