@expressive/mvc 0.37.0 → 0.39.0

package/dist/index.d.ts

@@ -181,6 +181,7 @@ declare class Model {
      * Register a callback to run when any instance of this Model is updated.
      */
     static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>): () => boolean;
+    static at<T extends Model>(this: Model.Type<T>, from: Model, cb: (got: T | undefined) => void): void;
 }
 
 declare function add<T = any>(instruction: Model.Instruction): T;
@@ -196,9 +197,9 @@ declare namespace get {
  * will be made available to child upon this request.
  *
  * @param Type - Type of controller compatible with this class.
- * @param required - If true, will throw if Model is created without a parent.
+ * @param expectParent - If true, will throw if Model is created without a parent.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required?: true): T;
+declare function get<T extends Model>(Type: Model.Type<T>, asParent?: true): T;
 /**
  * Fetches and assigns the controller which spawned this host.
  * When parent assigns an instance via `use()` directive, it
@@ -207,7 +208,7 @@ declare function get<T extends Model>(Type: Model.Type<T>, required?: true): T;
  * @param Type - Type of controller compatible with this class.
  * @param required - If false, property may be undefined. Otherwise will throw suspense.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required: boolean): T | undefined;
+declare function get<T extends Model>(Type: Model.Type<T>, required?: false): T | undefined;
 /**
  * Implement a computed value from a foreign model. Output will be generated by provided function,
  * where the foreign model will be passed to that function.
@@ -345,19 +346,29 @@ declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
 /** Create a managed object with observable entries. */
 declare function use<T extends {}, O = use.Object<T>>(data: T, ready?: (object: O) => void): O;
 
+declare namespace has {
+    type Callback<T = any> = (model: T) => void | boolean | (() => void);
+}
+declare function has<T extends Model>(type: Model.Type<T>, one: true): T;
+declare function has<T extends Model>(type: Model.Type<T>, required: boolean): T | undefined;
+declare function has<T extends Model>(type: Model.Type<T>, arg?: has.Callback<T>): Set<T>;
+
 declare namespace Context {
     type Input = Model | Model.New<Model> | Record<string | number, Model | Model.New<Model>>;
 }
 declare class Context {
-    static get(from: Model, callback: (context: Context) => void): void;
-    key: string;
-    protected table: WeakMap<Model.Type<Model>, symbol>;
+    static request<T extends Model>(type: Model.Type<T>, from: Model, callback: (got: T) => void): void;
+    id: string;
+    protected downstream: WeakMap<Model.Type<Model>, symbol>;
+    protected upstream: WeakMap<Model.Type<Model>, symbol>;
     protected layer: Map<string | number, Model | Model.Type<Model>>;
     constructor(inputs?: Context.Input);
-    protected has(T: Model.Type): keyof this;
+    key(T: Model.Type, upstream?: boolean): keyof this;
+    has(model: Model): (() => void) | undefined;
     get<T extends Model>(Type: Model.Type<T>): T | undefined;
     include(inputs: Context.Input): Map<Model, boolean>;
-    protected add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
+    put<T extends Model>(T: Model.New<T>, I: T | ((model: T) => void), implicit?: boolean, writable?: boolean): void;
+    add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
     push(inputs?: Context.Input): this;
     pop(): void;
 }
@@ -379,4 +390,4 @@ declare global {
     }
 }
 
-export { Context, Model, add, Model as default, get, ref, set, use };
+export { Context, Model, add, Model as default, get, has, ref, set, use };

package/dist/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   add: () => add,
   default: () => Model,
   get: () => get,
+  has: () => has,
   ref: () => ref,
   set: () => set,
   use: () => use
@@ -295,6 +296,9 @@ var Model = class _Model {
     notify.add(listener);
     return () => notify.delete(listener);
   }
+  static at(from, cb) {
+    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
+  }
 };
 define(Model.prototype, "toString", {
   value() {
@@ -412,111 +416,6 @@ Model.on((_, subject) => {
   return null;
 });
 
-// src/context.ts
-var Context = class {
-  constructor(inputs) {
-    this.table = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get() {
-    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();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [0]: inputs };
-    else if (!inputs)
-      reject(inputs);
-    Object.entries(inputs).forEach(([K, V]) => {
-      if (!(Model.is(V) || V instanceof Model))
-        reject(`${V} as ${K}`);
-    });
-    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,
-          writable,
-          value
-        });
-      T = Object.getPrototypeOf(T);
-    } while (T !== Model);
-    return I;
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      next.include(inputs);
-    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();
-  }
-};
-function reject(argument) {
-  throw new Error(`Context can only include Model or instance but got ${argument}.`);
-}
-
 // src/instruction/get.ts
 function get(arg0, arg1) {
   return add((key, subject) => {
@@ -532,10 +431,9 @@ function get(arg0, arg1) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          Context.get(from, (context) => {
-            const model = context.get(arg0);
-            if (model)
-              resolve(model);
+          arg0.at(from, (got) => {
+            if (got)
+              resolve(got);
             else if (arg1 !== false)
               throw new Error(`Required ${arg0} not found in context for ${from}.`);
           });
@@ -753,12 +651,180 @@ function use(value, argument) {
     return output;
   });
 }
+
+// src/context.ts
+var Expects = /* @__PURE__ */ new WeakMap();
+var Context = class {
+  constructor(inputs) {
+    this.downstream = /* @__PURE__ */ new WeakMap();
+    this.upstream = /* @__PURE__ */ new WeakMap();
+    this.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      this.include(inputs);
+  }
+  static request(type, from, callback) {
+    let map = Expects.get(from);
+    if (!map)
+      Expects.set(from, map = /* @__PURE__ */ new Map());
+    map.set(type, callback);
+  }
+  key(T, upstream) {
+    const table = upstream ? this.upstream : this.downstream;
+    let key = table.get(T);
+    if (!key) {
+      key = Symbol(T.name + (upstream ? " request" : ""));
+      table.set(T, key);
+    }
+    return key;
+  }
+  has(model) {
+    const key = this.key(model.constructor, true);
+    const result = this[key];
+    if (typeof result == "function")
+      return result(model);
+  }
+  get(Type) {
+    const result = this[this.key(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();
+    if (typeof inputs == "function" || inputs instanceof Model)
+      inputs = { [0]: inputs };
+    else if (!inputs)
+      reject(inputs);
+    Object.entries(inputs).forEach(([K, V]) => {
+      if (!(Model.is(V) || V instanceof Model))
+        reject(`${V} as ${K}`);
+    });
+    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.id = uid();
+        return this.include(inputs);
+      }
+    }
+    for (const [model] of init) {
+      this.has(model);
+      const expects = Expects.get(model);
+      if (expects)
+        for (let [T, callback] of expects)
+          this.put(T, callback);
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    }
+    return init;
+  }
+  put(T, I, implicit, writable) {
+    do {
+      const key = this.key(T, typeof I == "function");
+      const value = this.hasOwnProperty(key) ? null : I;
+      if (value || this[key] !== I && !implicit)
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable,
+          value
+        });
+      T = Object.getPrototypeOf(T);
+    } while (T !== Model);
+  }
+  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;
+    }
+    this.put(T, I, implicit, writable);
+    return I;
+  }
+  push(inputs) {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      next.include(inputs);
+    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();
+  }
+};
+function reject(argument) {
+  throw new Error(`Context can only include Model or instance but got ${argument}.`);
+}
+
+// src/instruction/has.ts
+function has(type, argument) {
+  return add((key, subject, state) => {
+    if (typeof argument == "boolean") {
+      Context.request(type, subject, (model) => {
+        const remove = () => {
+          drop();
+          if (state[key] === model)
+            delete state[key];
+        };
+        subject.set(key, model);
+        const drop = model.get(null, remove);
+        return remove;
+      });
+      return { get: argument };
+    }
+    const children = /* @__PURE__ */ new Set();
+    Context.request(type, subject, (model) => {
+      if (children.has(model))
+        return;
+      const remove = typeof argument == "function" ? argument(model) : void 0;
+      if (remove === false)
+        return;
+      children.add(model);
+      subject.set(key);
+      const done = () => {
+        drop();
+        if (typeof remove == "function")
+          remove();
+        children.delete(model);
+        subject.set(key);
+      };
+      const drop = model.get(null, done);
+      return done;
+    });
+    return {
+      value: children
+    };
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Context,
   Model,
   add,
   get,
+  has,
   ref,
   set,
   use

package/dist/index.mjs

@@ -262,6 +262,9 @@ var Model = class _Model {
     notify.add(listener);
     return () => notify.delete(listener);
   }
+  static at(from, cb) {
+    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
+  }
 };
 define(Model.prototype, "toString", {
   value() {
@@ -379,111 +382,6 @@ Model.on((_, subject) => {
   return null;
 });
 
-// src/context.ts
-var Context = class {
-  constructor(inputs) {
-    this.table = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get() {
-    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();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [0]: inputs };
-    else if (!inputs)
-      reject(inputs);
-    Object.entries(inputs).forEach(([K, V]) => {
-      if (!(Model.is(V) || V instanceof Model))
-        reject(`${V} as ${K}`);
-    });
-    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,
-          writable,
-          value
-        });
-      T = Object.getPrototypeOf(T);
-    } while (T !== Model);
-    return I;
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      next.include(inputs);
-    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();
-  }
-};
-function reject(argument) {
-  throw new Error(`Context can only include Model or instance but got ${argument}.`);
-}
-
 // src/instruction/get.ts
 function get(arg0, arg1) {
   return add((key, subject) => {
@@ -499,10 +397,9 @@ function get(arg0, arg1) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          Context.get(from, (context) => {
-            const model = context.get(arg0);
-            if (model)
-              resolve(model);
+          arg0.at(from, (got) => {
+            if (got)
+              resolve(got);
             else if (arg1 !== false)
               throw new Error(`Required ${arg0} not found in context for ${from}.`);
           });
@@ -720,12 +617,180 @@ function use(value, argument) {
     return output;
   });
 }
+
+// src/context.ts
+var Expects = /* @__PURE__ */ new WeakMap();
+var Context = class {
+  constructor(inputs) {
+    this.downstream = /* @__PURE__ */ new WeakMap();
+    this.upstream = /* @__PURE__ */ new WeakMap();
+    this.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      this.include(inputs);
+  }
+  static request(type, from, callback) {
+    let map = Expects.get(from);
+    if (!map)
+      Expects.set(from, map = /* @__PURE__ */ new Map());
+    map.set(type, callback);
+  }
+  key(T, upstream) {
+    const table = upstream ? this.upstream : this.downstream;
+    let key = table.get(T);
+    if (!key) {
+      key = Symbol(T.name + (upstream ? " request" : ""));
+      table.set(T, key);
+    }
+    return key;
+  }
+  has(model) {
+    const key = this.key(model.constructor, true);
+    const result = this[key];
+    if (typeof result == "function")
+      return result(model);
+  }
+  get(Type) {
+    const result = this[this.key(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();
+    if (typeof inputs == "function" || inputs instanceof Model)
+      inputs = { [0]: inputs };
+    else if (!inputs)
+      reject(inputs);
+    Object.entries(inputs).forEach(([K, V]) => {
+      if (!(Model.is(V) || V instanceof Model))
+        reject(`${V} as ${K}`);
+    });
+    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.id = uid();
+        return this.include(inputs);
+      }
+    }
+    for (const [model] of init) {
+      this.has(model);
+      const expects = Expects.get(model);
+      if (expects)
+        for (let [T, callback] of expects)
+          this.put(T, callback);
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    }
+    return init;
+  }
+  put(T, I, implicit, writable) {
+    do {
+      const key = this.key(T, typeof I == "function");
+      const value = this.hasOwnProperty(key) ? null : I;
+      if (value || this[key] !== I && !implicit)
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable,
+          value
+        });
+      T = Object.getPrototypeOf(T);
+    } while (T !== Model);
+  }
+  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;
+    }
+    this.put(T, I, implicit, writable);
+    return I;
+  }
+  push(inputs) {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      next.include(inputs);
+    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();
+  }
+};
+function reject(argument) {
+  throw new Error(`Context can only include Model or instance but got ${argument}.`);
+}
+
+// src/instruction/has.ts
+function has(type, argument) {
+  return add((key, subject, state) => {
+    if (typeof argument == "boolean") {
+      Context.request(type, subject, (model) => {
+        const remove = () => {
+          drop();
+          if (state[key] === model)
+            delete state[key];
+        };
+        subject.set(key, model);
+        const drop = model.get(null, remove);
+        return remove;
+      });
+      return { get: argument };
+    }
+    const children = /* @__PURE__ */ new Set();
+    Context.request(type, subject, (model) => {
+      if (children.has(model))
+        return;
+      const remove = typeof argument == "function" ? argument(model) : void 0;
+      if (remove === false)
+        return;
+      children.add(model);
+      subject.set(key);
+      const done = () => {
+        drop();
+        if (typeof remove == "function")
+          remove();
+        children.delete(model);
+        subject.set(key);
+      };
+      const drop = model.get(null, done);
+      return done;
+    });
+    return {
+      value: children
+    };
+  });
+}
 export {
   Context,
   Model,
   add,
   Model as default,
   get,
+  has,
   ref,
   set,
   use

package/package.json

@@ -28,6 +28,6 @@
     "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.37.0",
-  "gitHead": "aac8ff030e577922a5fceb87d9b0b5d44bed8f54"
+  "version": "0.39.0",
+  "gitHead": "40cda872145802a7e87964695840d7ee27053844"
 }