@expressive/mvc 0.71.0 → 0.73.0

package/dist/esm/context.d.ts

@@ -0,0 +1,62 @@
+import { State } from "./state.js";
+
+//#region src/context.d.ts
+declare namespace Context {
+  type Multiple<T extends State> = {
+    [key: string | number]: State.Type<T> | T;
+  };
+  type Accept<T extends State = State> = T | State.Type<T> | Multiple<T>;
+  type Expect<T extends State = State> = (state: T) => (() => void) | void;
+}
+interface Context {
+  [key: symbol]: State | Context.Expect | null | undefined;
+}
+declare class Context {
+  /**
+   * Get the context for a specified State. If a callback is provided, it will be run when
+   * the context becomes available.
+   */
+  static get<T extends State>(on: State, callback: (got: Context) => void): void;
+  /**
+   * Get the context for a specified State. Returns undefined if none are found.
+   */
+  static get<T extends State>(on: State): Context | undefined;
+  id: string;
+  protected inputs: Record<string | number, State | State.Extends>;
+  protected cleanup: Set<() => void>;
+  constructor(inputs?: Context.Accept);
+  /** Find specified type registered to a parent context. Throws if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require: true): T;
+  /** Find specified type registered to a parent context. Returns undefined if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require?: boolean): T | undefined;
+  /** Run callback when a specified type is registered in context downstream. */
+  get<T extends State>(Type: State.Extends<T>, callback: (state: T) => void): () => void;
+  /**
+   * Adds a State to this context.
+   */
+  protected add<T extends State>(input: T | State.Type<T>, implicit?: boolean): T;
+  /**
+   * Register one or more States to this context.
+   *
+   * Context will add or remove States as needed to keep with provided input.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   * @param forEach Optional callback to run for each State registered.
+   */
+  use<T extends State>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
+  /**
+   * Create a child context, optionally registering one or more States to it.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   */
+  push(inputs?: Context.Accept): this;
+  /**
+   * Remove all States from this context.
+   *
+   * Will also run any cleanup callbacks registered when States were added.
+   */
+  pop(): void;
+}
+//#endregion
+export { Context };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/context.js

@@ -1,149 +1,158 @@
-import { addListener } from "./control";
-import { event, Model, PARENT, uid } from "./model";
+import { addListener, event } from "./observable.js";
+import { PARENT, State, uid } from "./state.js";
+
+//#region src/context.ts
 const LOOKUP = /* @__PURE__ */ new WeakMap();
 const KEYS = /* @__PURE__ */ new Map();
 function key(T, upstream) {
-  let K = KEYS.get(T);
-  if (!K)
-    KEYS.set(T, K = Symbol(
-      typeof T == "symbol" ? "get " + T.description : String(T)
-    ));
-  return upstream ? key(K) : K;
+	let K = KEYS.get(T);
+	if (!K) {
+		K = Symbol(typeof T == "symbol" ? "get " + T.description : String(T));
+		KEYS.set(T, K);
+	}
+	return upstream ? key(K) : K;
 }
 function keys(from, upstream) {
-  const keys2 = /* @__PURE__ */ new Set();
-  do {
-    keys2.add(key(from, upstream));
-  } while ((from = Object.getPrototypeOf(from)) !== Model);
-  return keys2;
+	const keys = /* @__PURE__ */ new Set();
+	do {
+		keys.add(key(from, upstream));
+		from = Object.getPrototypeOf(from);
+	} while (from !== State);
+	return keys;
 }
-class Context {
-  constructor(inputs) {
-    this.layer = /* @__PURE__ */ new Map();
-    this.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get({ is }, callback) {
-    const waiting = LOOKUP.get(is);
-    if (waiting instanceof Context) {
-      if (callback)
-        callback(waiting);
-      return waiting;
-    }
-    if (callback)
-      if (waiting)
-        waiting.push(callback);
-      else
-        LOOKUP.set(is, [callback]);
-  }
-  /** Run callback when a specified type is registered to a **child** context. */
-  has(Type, callback) {
-    Object.defineProperty(this, key(Type, true), { value: callback, configurable: true });
-  }
-  get(Type, require2) {
-    const result = this[key(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    if (result)
-      return result;
-    if (require2)
-      throw new Error(`Could not find ${Type} in context.`);
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    this.cleanup = /* @__PURE__ */ new Set([() => next.pop(), ...this.cleanup]);
-    next.layer = /* @__PURE__ */ new Map();
-    next.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      next.include(inputs);
-    return next;
-  }
-  pop() {
-    for (const key2 of Object.getOwnPropertySymbols(this))
-      delete this[key2];
-    this.cleanup.forEach((cb) => cb());
-    this.cleanup.clear();
-    this.layer.clear();
-  }
-  include(inputs, forEach) {
-    const init = /* @__PURE__ */ new Map();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [forEach ? 0 : this.layer.size]: inputs };
-    for (const [K, V] of Object.entries(inputs)) {
-      if (Model.is(V) || V instanceof Model) {
-        const exists = this.layer.get(K);
-        if (!exists) {
-          const instance = this.add(V);
-          this.layer.set(K, V);
-          init.set(instance, true);
-        } else if (exists !== V) {
-          this.pop();
-          this.id = uid();
-          this.include(inputs);
-        }
-        continue;
-      }
-      throw new Error(
-        `Context may only include instance or class \`extends Model\` but got ${K == "0" || K == String(V) ? V : `${V} (as '${K}')`}.`
-      );
-    }
-    for (const [model, explicit] of init) {
-      model.set();
-      if (explicit && forEach)
-        forEach(model);
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init.set(value, false);
-        }
-    }
-  }
-  add(input, implicit) {
-    const cleanup = /* @__PURE__ */ new Set();
-    let T;
-    let I;
-    if (typeof input == "function") {
-      T = input;
-      I = new input();
-    } else {
-      T = input.constructor;
-      I = input;
-    }
-    keys(T, true).forEach((K) => {
-      const expects = this[K];
-      if (!expects)
-        return;
-      addListener(I, (event2) => {
-        if (event2 === true) {
-          const callback = expects(I);
-          if (callback)
-            cleanup.add(callback);
-        }
-        return null;
-      });
-    });
-    keys(T).forEach((K) => {
-      const value = this.hasOwnProperty(K) ? null : I;
-      if (value || this[K] !== I && !implicit)
-        Object.defineProperty(this, K, {
-          configurable: true,
-          value
-        });
-    });
-    this.cleanup.add(() => {
-      cleanup.forEach((cb) => cb());
-      if (I !== input)
-        event(I, null);
-    });
-    const waiting = LOOKUP.get(I);
-    if (waiting instanceof Array)
-      waiting.forEach((cb) => cb(this));
-    LOOKUP.set(I, this);
-    return I;
-  }
-}
-export {
-  Context
+var Context = class Context {
+	static get({ is }, callback) {
+		const context = LOOKUP.get(is);
+		if (context instanceof Context) {
+			if (callback) callback(context);
+			return context;
+		}
+		if (callback) if (context) context.push(callback);
+		else LOOKUP.set(is, [callback]);
+	}
+	constructor(inputs) {
+		this.id = uid();
+		this.inputs = {};
+		this.cleanup = /* @__PURE__ */ new Set();
+		if (inputs) this.use(inputs);
+	}
+	get(Type, arg2) {
+		if (typeof arg2 == "function") {
+			const k = key(Type, true);
+			Object.defineProperty(this, k, {
+				value: arg2,
+				configurable: true
+			});
+			return () => {
+				delete this[k];
+			};
+		}
+		const result = this[key(Type)];
+		if (result === null) throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+		if (result) return result;
+		if (arg2) throw new Error(`Could not find ${Type} in context.`);
+	}
+	/**
+	* Adds a State to this context.
+	*/
+	add(input, implicit) {
+		const cleanup = /* @__PURE__ */ new Set();
+		let T;
+		let I;
+		if (typeof input == "function") {
+			T = input;
+			I = new input();
+		} else {
+			T = input.constructor;
+			I = input;
+		}
+		keys(T, true).forEach((K) => {
+			const expects = this[K];
+			if (expects) addListener(I, (event) => {
+				if (event === true) {
+					const cb = expects(I);
+					if (cb) cleanup.add(cb);
+				}
+				return null;
+			});
+		});
+		keys(T).forEach((K) => {
+			const value = this.hasOwnProperty(K) ? null : I;
+			if (value || this[K] !== I && !implicit) Object.defineProperty(this, K, {
+				configurable: true,
+				value
+			});
+		});
+		this.cleanup.add(() => {
+			cleanup.forEach((cb) => cb());
+			if (I !== input) event(I, null);
+		});
+		const waiting = LOOKUP.get(I);
+		if (waiting instanceof Array) waiting.forEach((cb) => cb(this));
+		LOOKUP.set(I, this);
+		return I;
+	}
+	/**
+	* Register one or more States to this context.
+	*
+	* Context will add or remove States as needed to keep with provided input.
+	*
+	* @param inputs State, State class, or map of States / State classes to register.
+	* @param forEach Optional callback to run for each State registered.
+	*/
+	use(inputs, forEach) {
+		const init = /* @__PURE__ */ new Map();
+		if (typeof inputs == "function" || inputs instanceof State) inputs = { [0]: inputs };
+		for (const [K, V] of Object.entries(inputs)) {
+			if (!(State.is(V) || V instanceof State)) throw new Error(`Context may only include instance or class \`extends State\` but got ${K == "0" || K == String(V) ? V : `${V} (as '${K}')`}.`);
+			const exists = this.inputs[K];
+			if (!exists) init.set(this.add(V), true);
+			else if (exists !== V) {
+				this.pop();
+				this.use(inputs);
+				this.id = uid();
+				return;
+			}
+		}
+		for (const [state, explicit] of init) {
+			state.set();
+			if (explicit && forEach) forEach(state);
+			for (const [_key, value] of state) if (PARENT.get(value) === state) {
+				this.add(value, true);
+				init.set(value, false);
+			}
+		}
+		this.inputs = inputs;
+	}
+	/**
+	* Create a child context, optionally registering one or more States to it.
+	*
+	* @param inputs State, State class, or map of States / State classes to register.
+	*/
+	push(inputs) {
+		const next = Object.create(this);
+		this.cleanup = new Set([() => next.pop(), ...this.cleanup]);
+		next.inputs = {};
+		next.cleanup = /* @__PURE__ */ new Set();
+		if (inputs) next.use(inputs);
+		return next;
+	}
+	/**
+	* Remove all States from this context.
+	*
+	* Will also run any cleanup callbacks registered when States were added.
+	*/
+	pop() {
+		for (const key of Object.getOwnPropertySymbols(this)) delete this[key];
+		this.cleanup.forEach((cb) => cb());
+		this.cleanup.clear();
+		this.inputs = {};
+	}
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/context.ts"],
  "sourcesContent": ["import { addListener } from './control';\nimport { event, Model, PARENT, uid } from './model';\n\nconst LOOKUP = new WeakMap<Model, Context | ((got: Context) => void)[]>();\nconst KEYS = new Map<symbol | Model.Type, symbol>();\n\nfunction key(T: Model.Type | symbol, upstream?: boolean): symbol {\n  let K = KEYS.get(T);\n\n  if(!K)\n    KEYS.set(T, K = Symbol(\n      typeof T == \"symbol\" ? \"get \" + T.description : String(T)\n    ));\n  \n  return upstream ? key(K) : K;\n}\n\nfunction keys(from: Model.Type, upstream?: boolean){\n  const keys = new Set<symbol>();\n\n  do {\n    keys.add(key(from, upstream));\n  }\n  while((from = Object.getPrototypeOf(from)) !== Model);\n\n  return keys;\n}\n\ndeclare namespace Context {\n  type Multiple<T extends Model> = {\n    [key: string | number]: Model.Init<T> | T;\n  };\n\n  type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;\n\n  type Expect<T extends Model = Model> = (model: T) => (() => void) | void;\n}\n\ninterface Context {\n  [key: symbol]: Model | Context.Expect | null | undefined;\n}\n\nclass Context {\n  static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;\n  static get<T extends Model>(on: Model): Context | undefined;\n  static get({ is }: Model, callback?: (got: Context) => void){\n    const waiting = LOOKUP.get(is);\n\n    if(waiting instanceof Context){\n      if(callback)\n        callback(waiting);\n\n      return waiting;\n    }\n\n    if(callback)\n      if(waiting) \n        waiting.push(callback);\n      else \n        LOOKUP.set(is, [callback]);\n  }\n\n  public id!: string;\n\n  protected layer = new Map<string | number, Model | Model.Type>();\n  protected cleanup = new Set<() => void>();\n\n  constructor(inputs?: Context.Accept){\n    if(inputs)\n      this.include(inputs);\n  }\n\n  /** Run callback when a specified type is registered to a **child** context. */\n  public has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void){\n    Object.defineProperty(this, key(Type, true), { value: callback, configurable: true });\n  }\n\n  /** Find specified type registered to a parent context. Returns undefined if none are found. */\n  public get<T extends Model>(Type: Model.Type<T>, require: true): T;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean): T | undefined;\n  public get<T extends Model>(Type: Model.Type<T>, require?: boolean){\n    const result = this[key(Type)];\n\n    if(result === null)\n      throw new Error(`Did find ${Type} in context, but multiple were defined.`);\n\n    if(result)\n      return result as T;\n\n    if(require)\n      throw new Error(`Could not find ${Type} in context.`);\n  }\n\n  public push(inputs?: Context.Accept){\n    const next = Object.create(this) as this;\n\n    this.cleanup = new Set([() => next.pop(), ...this.cleanup]);\n\n    next.layer = new Map();\n    next.cleanup = new Set();\n\n    if(inputs)\n      next.include(inputs);\n\n    return next;\n  }\n\n  public pop(){\n    for(const key of Object.getOwnPropertySymbols(this))\n      delete (this as any)[key];\n\n    this.cleanup.forEach(cb => cb());\n    this.cleanup.clear();\n    this.layer.clear();\n  }\n\n  public include<T extends Model>(\n    inputs: Context.Accept<T>,\n    forEach?: Context.Expect<T>\n  ){\n    const init = new Map<Model, boolean>();\n\n    if(typeof inputs == \"function\" || inputs instanceof Model)\n      inputs = { [forEach ? 0 : this.layer.size]: inputs };\n    \n    for(const [K, V] of Object.entries(inputs)){\n      if(Model.is(V) || V instanceof Model){\n        const exists = this.layer.get(K);\n  \n        if(!exists){\n          const instance = this.add(V);\n  \n          this.layer.set(K, V);\n          init.set(instance, true);\n        }\n        // Context must force-reset because inputs are no longer safe.\n        else if(exists !== V){    \n          this.pop();\n          this.id = uid();\n          this.include(inputs);\n        }\n\n        continue;\n      }\n\n      throw new Error(\n        `Context may only include instance or class \\`extends Model\\` but got ${\n          K == '0' || K == String(V) ? V : `${V} (as '${K}')`\n        }.`\n      );\n    }\n\n    for(const [model, explicit] of init){\n      model.set();\n\n      if(explicit && forEach)\n        forEach(model as T);\n\n      for(const [_key, value] of model)\n        if(PARENT.get(value as Model) === model){\n          this.add(value as Model, true);\n          init.set(value as Model, false);\n        }\n    }\n  }\n\n  protected add<T extends Model>(\n    input: T | Model.Init<T>,\n    implicit?: boolean){\n\n    const cleanup = new Set<() => void>();\n    let T: Model.Type<T>;\n    let I: T;\n\n    if(typeof input == \"function\"){\n      T = input;\n      I = new input() as T;\n    }\n    else {\n      T = input.constructor as Model.Type<T>;\n      I = input;\n    }\n\n    keys(T, true).forEach(K => {\n      const expects = this[K] as Context.Expect | undefined;\n  \n      if(!expects)\n        return;\n  \n      addListener(I, event => {\n        if(event === true){\n          const callback = expects(I);\n            \n          if(callback)\n            cleanup.add(callback);\n        }\n\n        return null;\n      })  \n    });\n\n    keys(T).forEach(K => {\n      const value = this.hasOwnProperty(K) ? null : I;\n\n      if(value || this[K] !== I && !implicit)\n        Object.defineProperty(this, K, {\n          configurable: true,\n          value\n        });\n    });\n\n    this.cleanup.add(() => {\n      cleanup.forEach(cb => cb());\n\n      if(I !== input)\n        event(I, null);\n    })\n\n    const waiting = LOOKUP.get(I);\n  \n    if(waiting instanceof Array)\n      waiting.forEach(cb => cb(this));\n\n    LOOKUP.set(I, this);\n\n    return I;\n  }\n}\n\nexport { Context }"],
  "mappings": "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",
  "names": ["keys", "require", "key", "event"]
}

+Object.defineProperty(Context.prototype, "toString", { value() {
+	return `Context-${this.id}`;
+} });
+
+//#endregion
+export { Context };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"context.js","names":[],"sources":["../../src/context.ts"],"sourcesContent":["import { addListener } from './observable';\nimport { event, State, PARENT, uid } from './state';\n\nconst LOOKUP = new WeakMap<State, Context | ((got: Context) => void)[]>();\nconst KEYS = new Map<symbol | State.Extends, symbol>();\n\nfunction key(T: State.Extends | symbol, upstream?: boolean): symbol {\n  let K = KEYS.get(T);\n\n  if (!K) {\n    K = Symbol(typeof T == 'symbol' ? 'get ' + T.description : String(T));\n    KEYS.set(T, K);\n  }\n\n  return upstream ? key(K) : K;\n}\n\nfunction keys(from: State.Extends, upstream?: boolean) {\n  const keys = new Set<symbol>();\n\n  do {\n    keys.add(key(from, upstream));\n    from = Object.getPrototypeOf(from);\n  } while (from !== State);\n\n  return keys;\n}\n\ndeclare namespace Context {\n  type Multiple<T extends State> = {\n    [key: string | number]: State.Type<T> | T;\n  };\n\n  type Accept<T extends State = State> = T | State.Type<T> | Multiple<T>;\n\n  type Expect<T extends State = State> = (state: T) => (() => void) | void;\n}\n\ninterface Context {\n  [key: symbol]: State | Context.Expect | null | undefined;\n}\n\nclass Context {\n  /**\n   * Get the context for a specified State. If a callback is provided, it will be run when\n   * the context becomes available.\n   */\n  static get<T extends State>(\n    on: State,\n    callback: (got: Context) => void\n  ): void;\n\n  /**\n   * Get the context for a specified State. Returns undefined if none are found.\n   */\n  static get<T extends State>(on: State): Context | undefined;\n\n  static get({ is }: State, callback?: (got: Context) => void) {\n    const context = LOOKUP.get(is);\n\n    if (context instanceof Context) {\n      if (callback) callback(context);\n      return context;\n    }\n\n    if (callback)\n      if (context) context.push(callback);\n      else LOOKUP.set(is, [callback]);\n  }\n\n  public id = uid();\n\n  protected inputs = {} as Record<string | number, State | State.Extends>;\n  protected cleanup = new Set<() => void>();\n\n  constructor(inputs?: Context.Accept) {\n    if (inputs) this.use(inputs);\n  }\n\n  /** Find specified type registered to a parent context. Throws if none are found. */\n  public get<T extends State>(Type: State.Extends<T>, require: true): T;\n\n  /** Find specified type registered to a parent context. Returns undefined if none are found. */\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    require?: boolean\n  ): T | undefined;\n\n  /** Run callback when a specified type is registered in context downstream. */\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    callback: (state: T) => void\n  ): () => void;\n\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    arg2?: boolean | ((state: T) => void)\n  ) {\n    if (typeof arg2 == 'function') {\n      const k = key(Type, true);\n      Object.defineProperty(this, k, {\n        value: arg2,\n        configurable: true\n      });\n      return () => {\n        delete this[k];\n      };\n    }\n\n    const result = this[key(Type)];\n\n    if (result === null)\n      throw new Error(\n        `Did find ${Type} in context, but multiple were defined.`\n      );\n\n    if (result) return result as T;\n\n    if (arg2) throw new Error(`Could not find ${Type} in context.`);\n  }\n\n  /**\n   * Adds a State to this context.\n   */\n  protected add<T extends State>(input: T | State.Type<T>, implicit?: boolean) {\n    const cleanup = new Set<() => void>();\n    let T: State.Extends<T>;\n    let I: T;\n\n    if (typeof input == 'function') {\n      T = input;\n      I = new input() as T;\n    } else {\n      T = input.constructor as State.Extends<T>;\n      I = input;\n    }\n\n    keys(T, true).forEach((K) => {\n      const expects = this[K] as Context.Expect | undefined;\n\n      if (expects)\n        addListener(I, (event) => {\n          if (event === true) {\n            const cb = expects(I);\n            if (cb) cleanup.add(cb);\n          }\n\n          return null;\n        });\n    });\n\n    keys(T).forEach((K) => {\n      const value = this.hasOwnProperty(K) ? null : I;\n\n      if (value || (this[K] !== I && !implicit))\n        Object.defineProperty(this, K, {\n          configurable: true,\n          value\n        });\n    });\n\n    this.cleanup.add(() => {\n      cleanup.forEach((cb) => cb());\n      if (I !== input) event(I, null);\n    });\n\n    const waiting = LOOKUP.get(I);\n\n    if (waiting instanceof Array) waiting.forEach((cb) => cb(this));\n\n    LOOKUP.set(I, this);\n\n    return I;\n  }\n\n  /**\n   * Register one or more States to this context.\n   *\n   * Context will add or remove States as needed to keep with provided input.\n   *\n   * @param inputs State, State class, or map of States / State classes to register.\n   * @param forEach Optional callback to run for each State registered.\n   */\n  public use<T extends State>(\n    inputs: Context.Accept<T>,\n    forEach?: Context.Expect<T>\n  ) {\n    const init = new Map<State, boolean>();\n\n    if (typeof inputs == 'function' || inputs instanceof State)\n      inputs = { [0]: inputs };\n\n    for (const [K, V] of Object.entries(inputs)) {\n      if (!(State.is(V) || V instanceof State))\n        throw new Error(\n          `Context may only include instance or class \\`extends State\\` but got ${\n            K == '0' || K == String(V) ? V : `${V} (as '${K}')`\n          }.`\n        );\n\n      const exists = this.inputs[K];\n\n      if (!exists) {\n        init.set(this.add(V), true);\n      }\n      // Context must force-reset because inputs are no longer safe,\n      // however probably should do that on a per-state basis.\n      else if (exists !== V) {\n        this.pop();\n        this.use(inputs);\n        this.id = uid();\n        return;\n      }\n    }\n\n    for (const [state, explicit] of init) {\n      state.set();\n\n      if (explicit && forEach) forEach(state as T);\n\n      for (const [_key, value] of state)\n        if (PARENT.get(value as State) === state) {\n          this.add(value as State, true);\n          init.set(value as State, false);\n        }\n    }\n\n    this.inputs = inputs;\n  }\n\n  /**\n   * Create a child context, optionally registering one or more States to it.\n   *\n   * @param inputs State, State class, or map of States / State classes to register.\n   */\n  public push(inputs?: Context.Accept) {\n    const next = Object.create(this) as this;\n\n    this.cleanup = new Set([() => next.pop(), ...this.cleanup]);\n\n    next.inputs = {};\n    next.cleanup = new Set();\n\n    if (inputs) next.use(inputs);\n\n    return next;\n  }\n\n  /**\n   * Remove all States from this context.\n   *\n   * Will also run any cleanup callbacks registered when States were added.\n   */\n  public pop() {\n    for (const key of Object.getOwnPropertySymbols(this)) delete this[key];\n\n    this.cleanup.forEach((cb) => cb());\n    this.cleanup.clear();\n    this.inputs = {};\n  }\n}\n\nObject.defineProperty(Context.prototype, 'toString', {\n  value() {\n    return `Context-${this.id}`;\n  }\n});\n\nexport { Context };\n"],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+import { Observable, addListener, event, watch } from "./observable.js";
+import { METHOD, State } from "./state.js";
+import { Context } from "./context.js";
+import { Instruction, use } from "./instruction/use.js";
+import { get } from "./instruction/get.js";
+import { set } from "./instruction/set.js";
+import { ref } from "./instruction/ref.js";
+export { Context, type Instruction, METHOD, Observable, State, addListener, State as default, event, get, ref, set, use, watch };

package/dist/esm/index.js

@@ -1,24 +1,9 @@
-import { get } from "./instruction/get";
-import { ref } from "./instruction/ref";
-import { set } from "./instruction/set";
-import { use } from "./instruction/use";
-import { has } from "./instruction/has";
-import { Model, Model as Model2, METHOD } from "./model";
-import { createEffect, addListener, event, Observable } from "./control";
-import { Context } from "./context";
-export {
-  Context,
-  METHOD,
-  Model,
-  Observable,
-  addListener,
-  createEffect,
-  Model2 as default,
-  event,
-  get,
-  has,
-  ref,
-  set,
-  use
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBnZXQgfSBmcm9tICcuL2luc3RydWN0aW9uL2dldCc7XG5leHBvcnQgeyByZWYgfSBmcm9tICcuL2luc3RydWN0aW9uL3JlZic7XG5leHBvcnQgeyBzZXQgfSBmcm9tICcuL2luc3RydWN0aW9uL3NldCc7XG5leHBvcnQgeyB1c2UgfSBmcm9tICcuL2luc3RydWN0aW9uL3VzZSc7XG5leHBvcnQgeyBoYXMgfSBmcm9tICcuL2luc3RydWN0aW9uL2hhcyc7XG5cbmV4cG9ydCB7IE1vZGVsLCBNb2RlbCBhcyBkZWZhdWx0LCBNRVRIT0QgfSBmcm9tICcuL21vZGVsJztcbmV4cG9ydCB7IGNyZWF0ZUVmZmVjdCwgYWRkTGlzdGVuZXIsIGV2ZW50LCBPYnNlcnZhYmxlIH0gZnJvbSAnLi9jb250cm9sJztcbmV4cG9ydCB7IENvbnRleHQgfSBmcm9tICcuL2NvbnRleHQnOyJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFNBQVMsV0FBVztBQUNwQixTQUFTLFdBQVc7QUFDcEIsU0FBUyxXQUFXO0FBQ3BCLFNBQVMsV0FBVztBQUNwQixTQUFTLFdBQVc7QUFFcEIsU0FBUyxPQUFnQixTQUFUQSxRQUFrQixjQUFjO0FBQ2hELFNBQVMsY0FBYyxhQUFhLE9BQU8sa0JBQWtCO0FBQzdELFNBQVMsZUFBZTsiLAogICJuYW1lcyI6IFsiTW9kZWwiXQp9Cg==
+import { Observable, addListener, event, watch } from "./observable.js";
+import { METHOD, State } from "./state.js";
+import { Context } from "./context.js";
+import { use } from "./instruction/use.js";
+import { get } from "./instruction/get.js";
+import { set } from "./instruction/set.js";
+import { ref } from "./instruction/ref.js";
+
+export { Context, METHOD, Observable, State, addListener, State as default, event, get, ref, set, use, watch };

package/dist/esm/instruction/get.d.ts

@@ -0,0 +1,36 @@
+import { State } from "../state.js";
+
+//#region src/instruction/get.d.ts
+declare namespace get {
+  type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
+}
+/**
+ * Fetches upstream State from context with optional lifecycle callback.
+ * Callback runs on mount and can return cleanup function for unmount.
+ *
+ * @param Type - Type of State to fetch.
+ * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, callback?: get.Callback<T>): T;
+/**
+ * Fetches and assigns the controller which spawned this host.
+ * When parent assigns an instance via `use()` directive, it
+ * will be made available to child upon this request.
+ *
+ * @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 State>(Type: State.Extends<T>, required: false): T | undefined;
+/**
+ * Collects downstream States, this will accumulate all instances of specified type for which this is an ancestor.
+ * Returns a frozen array that updates as States are added or removed.
+ * Callback runs on each State registration and can return cleanup or false to prevent registration.
+ *
+ * @param Type - Type of State to collect.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, callback?: get.Callback<T>): readonly T[];
+//#endregion
+export { get };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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