@expressive/mvc 0.72.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,170 +1,158 @@
-import { addListener } from "./control";
-import { event, State, PARENT, uid } from "./state";
+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) {
-    K = Symbol(typeof T == "symbol" ? "get " + T.description : String(T));
-    KEYS.set(T, K);
-  }
-  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));
-    from = Object.getPrototypeOf(from);
-  } while (from !== State);
-  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.id = uid();
-    this.inputs = {};
-    this.cleanup = /* @__PURE__ */ new Set();
-    if (inputs) this.use(inputs);
-  }
-  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]);
-  }
-  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, (event2) => {
-          if (event2 === 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 = /* @__PURE__ */ 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 key2 of Object.getOwnPropertySymbols(this)) delete this[key2];
-    this.cleanup.forEach((cb) => cb());
-    this.cleanup.clear();
-    this.inputs = {};
-  }
-}
-Object.defineProperty(Context.prototype, "toString", {
-  value() {
-    return `Context-${this.id}`;
-  }
-});
-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, 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.Class<T> | T;\n  };\n\n  type Accept<T extends State = State> = T | State.Class<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>(\n    input: T | State.Class<T>,\n    implicit?: boolean\n  ) {\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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",
  "names": ["keys", "event", "key"]
}

+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":";;;;AAGA,MAAM,yBAAS,IAAI,SAAsD;AACzE,MAAM,uBAAO,IAAI,KAAqC;AAEtD,SAAS,IAAI,GAA2B,UAA4B;CAClE,IAAI,IAAI,KAAK,IAAI,EAAE;AAEnB,KAAI,CAAC,GAAG;AACN,MAAI,OAAO,OAAO,KAAK,WAAW,SAAS,EAAE,cAAc,OAAO,EAAE,CAAC;AACrE,OAAK,IAAI,GAAG,EAAE;;AAGhB,QAAO,WAAW,IAAI,EAAE,GAAG;;AAG7B,SAAS,KAAK,MAAqB,UAAoB;CACrD,MAAM,uBAAO,IAAI,KAAa;AAE9B,IAAG;AACD,OAAK,IAAI,IAAI,MAAM,SAAS,CAAC;AAC7B,SAAO,OAAO,eAAe,KAAK;UAC3B,SAAS;AAElB,QAAO;;AAiBT,IAAM,UAAN,MAAM,QAAQ;CAeZ,OAAO,IAAI,EAAE,MAAa,UAAmC;EAC3D,MAAM,UAAU,OAAO,IAAI,GAAG;AAE9B,MAAI,mBAAmB,SAAS;AAC9B,OAAI,SAAU,UAAS,QAAQ;AAC/B,UAAO;;AAGT,MAAI,SACF,KAAI,QAAS,SAAQ,KAAK,SAAS;MAC9B,QAAO,IAAI,IAAI,CAAC,SAAS,CAAC;;CAQnC,YAAY,QAAyB;YALzB,KAAK;gBAEE,EAAE;iCACD,IAAI,KAAiB;AAGvC,MAAI,OAAQ,MAAK,IAAI,OAAO;;CAkB9B,AAAO,IACL,MACA,MACA;AACA,MAAI,OAAO,QAAQ,YAAY;GAC7B,MAAM,IAAI,IAAI,MAAM,KAAK;AACzB,UAAO,eAAe,MAAM,GAAG;IAC7B,OAAO;IACP,cAAc;IACf,CAAC;AACF,gBAAa;AACX,WAAO,KAAK;;;EAIhB,MAAM,SAAS,KAAK,IAAI,KAAK;AAE7B,MAAI,WAAW,KACb,OAAM,IAAI,MACR,YAAY,KAAK,yCAClB;AAEH,MAAI,OAAQ,QAAO;AAEnB,MAAI,KAAM,OAAM,IAAI,MAAM,kBAAkB,KAAK,cAAc;;;;;CAMjE,AAAU,IAAqB,OAA0B,UAAoB;EAC3E,MAAM,0BAAU,IAAI,KAAiB;EACrC,IAAI;EACJ,IAAI;AAEJ,MAAI,OAAO,SAAS,YAAY;AAC9B,OAAI;AACJ,OAAI,IAAI,OAAO;SACV;AACL,OAAI,MAAM;AACV,OAAI;;AAGN,OAAK,GAAG,KAAK,CAAC,SAAS,MAAM;GAC3B,MAAM,UAAU,KAAK;AAErB,OAAI,QACF,aAAY,IAAI,UAAU;AACxB,QAAI,UAAU,MAAM;KAClB,MAAM,KAAK,QAAQ,EAAE;AACrB,SAAI,GAAI,SAAQ,IAAI,GAAG;;AAGzB,WAAO;KACP;IACJ;AAEF,OAAK,EAAE,CAAC,SAAS,MAAM;GACrB,MAAM,QAAQ,KAAK,eAAe,EAAE,GAAG,OAAO;AAE9C,OAAI,SAAU,KAAK,OAAO,KAAK,CAAC,SAC9B,QAAO,eAAe,MAAM,GAAG;IAC7B,cAAc;IACd;IACD,CAAC;IACJ;AAEF,OAAK,QAAQ,UAAU;AACrB,WAAQ,SAAS,OAAO,IAAI,CAAC;AAC7B,OAAI,MAAM,MAAO,OAAM,GAAG,KAAK;IAC/B;EAEF,MAAM,UAAU,OAAO,IAAI,EAAE;AAE7B,MAAI,mBAAmB,MAAO,SAAQ,SAAS,OAAO,GAAG,KAAK,CAAC;AAE/D,SAAO,IAAI,GAAG,KAAK;AAEnB,SAAO;;;;;;;;;;CAWT,AAAO,IACL,QACA,SACA;EACA,MAAM,uBAAO,IAAI,KAAqB;AAEtC,MAAI,OAAO,UAAU,cAAc,kBAAkB,MACnD,UAAS,GAAG,IAAI,QAAQ;AAE1B,OAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,OAAO,EAAE;AAC3C,OAAI,EAAE,MAAM,GAAG,EAAE,IAAI,aAAa,OAChC,OAAM,IAAI,MACR,wEACE,KAAK,OAAO,KAAK,OAAO,EAAE,GAAG,IAAI,GAAG,EAAE,QAAQ,EAAE,IACjD,GACF;GAEH,MAAM,SAAS,KAAK,OAAO;AAE3B,OAAI,CAAC,OACH,MAAK,IAAI,KAAK,IAAI,EAAE,EAAE,KAAK;YAIpB,WAAW,GAAG;AACrB,SAAK,KAAK;AACV,SAAK,IAAI,OAAO;AAChB,SAAK,KAAK,KAAK;AACf;;;AAIJ,OAAK,MAAM,CAAC,OAAO,aAAa,MAAM;AACpC,SAAM,KAAK;AAEX,OAAI,YAAY,QAAS,SAAQ,MAAW;AAE5C,QAAK,MAAM,CAAC,MAAM,UAAU,MAC1B,KAAI,OAAO,IAAI,MAAe,KAAK,OAAO;AACxC,SAAK,IAAI,OAAgB,KAAK;AAC9B,SAAK,IAAI,OAAgB,MAAM;;;AAIrC,OAAK,SAAS;;;;;;;CAQhB,AAAO,KAAK,QAAyB;EACnC,MAAM,OAAO,OAAO,OAAO,KAAK;AAEhC,OAAK,UAAU,IAAI,IAAI,OAAO,KAAK,KAAK,EAAE,GAAG,KAAK,QAAQ,CAAC;AAE3D,OAAK,SAAS,EAAE;AAChB,OAAK,0BAAU,IAAI,KAAK;AAExB,MAAI,OAAQ,MAAK,IAAI,OAAO;AAE5B,SAAO;;;;;;;CAQT,AAAO,MAAM;AACX,OAAK,MAAM,OAAO,OAAO,sBAAsB,KAAK,CAAE,QAAO,KAAK;AAElE,OAAK,QAAQ,SAAS,OAAO,IAAI,CAAC;AAClC,OAAK,QAAQ,OAAO;AACpB,OAAK,SAAS,EAAE;;;AAIpB,OAAO,eAAe,QAAQ,WAAW,YAAY,EACnD,QAAQ;AACN,QAAO,WAAW,KAAK;GAE1B,CAAC"}

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,23 +1,9 @@
-import { use, Instruction } from "./instruction/use";
-import { get } from "./instruction/get";
-import { set } from "./instruction/set";
-import { ref } from "./instruction/ref";
-import { State, State as State2, METHOD } from "./state";
-import { watch, addListener, event, Observable } from "./control";
-import { Context } from "./context";
-export {
-  Context,
-  Instruction,
-  METHOD,
-  Observable,
-  State,
-  addListener,
-  State2 as default,
-  event,
-  get,
-  ref,
-  set,
-  use,
-  watch
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyB1c2UsIEluc3RydWN0aW9uIH0gZnJvbSAnLi9pbnN0cnVjdGlvbi91c2UnO1xuZXhwb3J0IHsgZ2V0IH0gZnJvbSAnLi9pbnN0cnVjdGlvbi9nZXQnO1xuZXhwb3J0IHsgc2V0IH0gZnJvbSAnLi9pbnN0cnVjdGlvbi9zZXQnO1xuZXhwb3J0IHsgcmVmIH0gZnJvbSAnLi9pbnN0cnVjdGlvbi9yZWYnO1xuXG5leHBvcnQgeyBTdGF0ZSwgU3RhdGUgYXMgZGVmYXVsdCwgTUVUSE9EIH0gZnJvbSAnLi9zdGF0ZSc7XG5leHBvcnQgeyB3YXRjaCwgYWRkTGlzdGVuZXIsIGV2ZW50LCBPYnNlcnZhYmxlIH0gZnJvbSAnLi9jb250cm9sJztcbmV4cG9ydCB7IENvbnRleHQgfSBmcm9tICcuL2NvbnRleHQnO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsU0FBUyxLQUFLLG1CQUFtQjtBQUNqQyxTQUFTLFdBQVc7QUFDcEIsU0FBUyxXQUFXO0FBQ3BCLFNBQVMsV0FBVztBQUVwQixTQUFTLE9BQWdCLFNBQVRBLFFBQWtCLGNBQWM7QUFDaEQsU0FBUyxPQUFPLGFBQWEsT0FBTyxrQkFBa0I7QUFDdEQsU0FBUyxlQUFlOyIsCiAgIm5hbWVzIjogWyJTdGF0ZSJdCn0K
+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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