@expressive/mvc 0.73.0 → 0.78.0

package/README.md

@@ -0,0 +1,137 @@
+<h1 align="center">@expressive/mvc</h1>
+
+<p align="center">
+  Class-based reactive state management - framework-agnostic core.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@expressive/mvc"><img alt="NPM" src="https://badge.fury.io/js/%40expressive%2Fmvc.svg"></a>
+  <img src="https://img.shields.io/badge/Coverage-100%25-brightgreen.svg">
+</p>
+
+---
+
+The core of [Expressive MVC](https://github.com/gabeklein/expressive-mvc): reactive primitives built around plain classes, with no framework dependency. Provides the `State` model, instructions, context, and the renderer-agnostic `Component` that adapters like [`@expressive/react`](https://www.npmjs.com/package/@expressive/react) build on.
+
+```bash
+npm install @expressive/mvc
+```
+
+## State
+
+A `State` is a class whose fields are reactive - read to subscribe, assign to update. Getters are cached computed values.
+
+```ts
+import { State } from '@expressive/mvc';
+
+class Counter extends State {
+  count = 0;
+  increment = () => this.count++;
+
+  get doubled() {
+    return this.count * 2;     // recomputes only when count changes
+  }
+}
+
+const counter = Counter.new();
+
+// effect runs now, then again whenever read values change
+counter.get(({ count }) => {
+  console.log(`count is ${count}`);
+});
+
+counter.increment();           // -> "count is 1"
+```
+
+Models run and test anywhere - no renderer required.
+
+## Instructions
+
+Field initializers that change how a property behaves:
+
+| | |
+|---|---|
+| `ref()` | a mutable reference (e.g. a DOM node) that's still reactive |
+| `set()` | computed values, smart setters, side-effects on assignment |
+| `get()` | dependency injection - pull another `State` from context |
+| `hot()` | a shallow-reactive array or object |
+
+```ts
+import { State, set, hot } from '@expressive/mvc';
+
+class Cart extends State {
+  items = hot<Item[]>([]);                  // reactive collection
+  coupon = set('', code => apply(code));    // side-effect on assignment
+}
+```
+
+## Lifecycle
+
+```ts
+class Timer extends State {
+  seconds = 0;
+
+  new() {                              // runs once on activation
+    const id = setInterval(() => this.seconds++, 1000);
+    return () => clearInterval(id);    // returned cleanup runs on destroy
+  }
+}
+
+const timer = Timer.new();   // construct + activate
+timer.set(null);             // destroy - runs cleanup, freezes state
+```
+
+## Context & composition
+
+States find each other through context, and compose by holding one another:
+
+```ts
+import { State, get } from '@expressive/mvc';
+
+class Session extends State {
+  user = 'guest';
+}
+
+class Profile extends State {
+  session = get(Session);    // injected from the nearest provider
+  address = new Address();   // nested state - its changes bubble up
+}
+```
+
+An adapter (e.g. [`@expressive/react`](https://www.npmjs.com/package/@expressive/react)) supplies the provider that places a `State` in a tree; `get()` pulls it back out.
+
+## Events
+
+Any property or arbitrary key can be dispatched and listened to:
+
+```ts
+const off = counter.set('refresh', () => reload());   // listen
+counter.set('refresh');                               // dispatch
+off();                                                // stop listening
+```
+
+## Framework-agnostic components
+
+`@expressive/mvc` ships its own JSX runtime, so you can author components - including reusable libraries - against the core and let any host render them:
+
+```jsonc
+// tsconfig.json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@expressive/mvc"
+  }
+}
+```
+
+`Component` - a `State` that renders - lives here as the agnostic base. For using it in an app (rendering, props, subcomponents, suspense), see **[`@expressive/react`](https://www.npmjs.com/package/@expressive/react)**.
+
+---
+
+To render state in a UI framework, add an adapter: [`@expressive/react`](https://www.npmjs.com/package/@expressive/react) or `@expressive/preact`.
+
+Full guide and API reference → **[github.com/gabeklein/expressive-mvc](https://github.com/gabeklein/expressive-mvc)**
+
+## License
+
+MIT

package/dist/component.d.ts

@@ -0,0 +1,87 @@
+import { State } from "./state.js";
+import { Host } from "./jsx-runtime.js";
+
+//#region src/component.d.ts
+type IfEquals<X, Y, A, B> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+/** Keys of T which are settable (excludes get-only accessors and `readonly`). */
+type Acceptable<T> = { [P in keyof T]-?: IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P, never> }[keyof T];
+declare namespace Component {
+  /**
+   * Host element type produced by `Component.render`. Delegates to the
+   * {@link Host} manifest on the jsx-runtime entry; resolves to `unknown`
+   * until an adapter augments it with `node`.
+   */
+  type Node = Host extends {
+    node: infer T;
+  } ? T : unknown;
+  interface BaseProps<T extends Component> {
+    /**
+     * Callback for newly created instance. Only called once.
+     *
+     * Runs after props apply but **before** the `new()` lifecycle hook - so it
+     * may configure state that `new()` then observes. To react to a fully
+     * initialized instance instead, use `watch` or an effect.
+     */
+    is?: (instance: T) => void;
+    /**
+     * Fallback to show when suspended or in error recovery.
+     * Pass `false` to opt out of the component's own suspense boundary,
+     * letting suspension bubble to an ancestor.
+     */
+    fallback?: Component.Node;
+  }
+  type StateProps<T extends State> = { [K in Exclude<keyof T, keyof Component> & Acceptable<T>]?: T[K] };
+  type RenderProps<T> = [T] extends [(props: infer P) => any] ? [keyof NonNullable<P>] extends [never] ? {
+    children?: Component.Node;
+  } : NonNullable<P> : {
+    children?: Component.Node;
+  };
+  type Props<T extends Component> = StateProps<T> & BaseProps<T> & RenderProps<T['render']>;
+}
+declare class Component extends State {
+  /**
+   * All JSX attributes passed to this component.
+   * Includes state-derived props, render props, and built-in props like `is` and `fallback`.
+   *
+   * Will incorperate extra props you declare as props parameter in `render` method.
+   */
+  readonly props: Component.Props<this>;
+  /**
+   * Content to display while this component or its children are suspended.
+   * Will cover suspense by pending properties in `this.render` as well.
+   * Can be set as a class property or overridden via the `fallback` JSX prop.
+   *
+   * Defaults to null - nothing will be rendered.
+   * Set `false` to opt out of having a boundary at all - suspension then
+   * bubbles to the nearest ancestor boundary.
+   */
+  fallback: Component.Node;
+  constructor(props?: any, ...rest: any[]);
+  /**
+   * Output for this component. Override to define custom JSX.
+   *
+   * Properties accessed via `this` are reactive and trigger a render when they
+   * change, in addition to props. Accepts an optional parameter to receive extra
+   * props from JSX, beyond those merged to state properties; declare its shape
+   * via `props = {} as { ... }`. Without a parameter (the default below),
+   * children pass through.
+   *
+   * The constructor installs a composed `render` per instance; the bootstrap
+   * `type` pass seals this and any override non-configurable, keeping it the
+   * content-render seam the chain reads.
+   */
+  render(props?: {}): Component.Node;
+  /**
+   * Called when a child component throws during render.
+   * While this is pending, `fallback` is displayed.
+   * When resolved, the error boundary resets and `render` is called again.
+   *
+   * Override to handle errors - set `this.fallback` for error-specific UI,
+   * await async recovery, or await user interaction before retrying. If you
+   * assign a fallback within catch, it will be reverted after resolved.
+   */
+  catch?(error: Error): Promise<void> | void;
+}
+//#endregion
+export { Component };
+//# sourceMappingURL=component.d.ts.map

package/dist/component.js

@@ -0,0 +1,111 @@
+import { State, unbind } from "./state.js";
+import { Context } from "./context.js";
+import { set } from "./field/set.js";
+
+//#region src/component.ts
+const PENDING = /* @__PURE__ */ new WeakMap();
+/** Per-class composed content render. */
+const CHAIN = /* @__PURE__ */ new WeakMap();
+var Component = class extends State {
+	constructor(props, ...rest) {
+		if (props == null) props = {};
+		const seen = {};
+		const copy = PENDING.get(props);
+		if (typeof props == "object") merge(props);
+		function merge(props) {
+			for (const k in props) seen[k] = void 0;
+			return {
+				...seen,
+				...props
+			};
+		}
+		super(copy ? [] : [
+			props,
+			rest.filter((x) => !(x instanceof Context)),
+			() => {
+				props.is?.(this);
+				Object.defineProperty(this, "props", { enumerable: false });
+				PENDING.delete(props);
+			}
+		]);
+		this.fallback = set(null);
+		if (copy) return copy;
+		PENDING.set(props, this);
+		this.props = props;
+		this.set("props", () => {
+			this.set(merge(this.props));
+		});
+		Object.defineProperty(this, "render", {
+			writable: true,
+			configurable: true,
+			value: render(this)
+		});
+	}
+	/**
+	* Output for this component. Override to define custom JSX.
+	*
+	* Properties accessed via `this` are reactive and trigger a render when they
+	* change, in addition to props. Accepts an optional parameter to receive extra
+	* props from JSX, beyond those merged to state properties; declare its shape
+	* via `props = {} as { ... }`. Without a parameter (the default below),
+	* children pass through.
+	*
+	* The constructor installs a composed `render` per instance; the bootstrap
+	* `type` pass seals this and any override non-configurable, keeping it the
+	* content-render seam the chain reads.
+	*/
+	render(props) {
+		const { children } = props || this.props;
+		return children || null;
+	}
+};
+/**
+* Seal each class's own `render` non-configurable at bootstrap so member
+* classification leaves it unbound - it stays the content-render seam the chain
+* reads (and which adapters like preact detect as the class-component marker).
+*/
+Component.on({ type(type) {
+	const desc = Object.getOwnPropertyDescriptor(type.prototype, "render");
+	if (desc && typeof desc.value == "function") Object.defineProperty(type.prototype, "render", {
+		...desc,
+		configurable: false
+	});
+} });
+/**
+* Build (or fetch the cached) composed content render for an instance's class.
+* Walks the prototype chain for content renders strictly below Component - the
+* default render on Component.prototype is excluded and serves as the fallback
+* when a class authors none.
+*/
+function render(target) {
+	const cached = CHAIN.get(target.constructor);
+	if (cached) return cached;
+	let render;
+	let proto = target;
+	while ((proto = Object.getPrototypeOf(proto)) !== Component.prototype) {
+		const desc = Object.getOwnPropertyDescriptor(proto, "render");
+		if (desc) {
+			const layer = unbind(desc.get || desc.value);
+			render = render ? compose(layer, render) : layer;
+		}
+	}
+	if (!render) render = Component.prototype.render;
+	CHAIN.set(target.constructor, render);
+	return render;
+}
+/** Wrap an outer render so it receives `inner` as a lazy `children` getter. */
+function compose(outer, inner) {
+	return function(props) {
+		const self = this;
+		return outer.call(self, {
+			...props,
+			get children() {
+				return inner.call(self, props);
+			}
+		});
+	};
+}
+
+//#endregion
+export { Component };
+//# sourceMappingURL=component.js.map

package/dist/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","names":[],"sources":["../src/component.ts"],"sourcesContent":["import { Context } from './context';\nimport { set } from './field/set';\nimport { State, unbind } from './state';\n\nimport type { Host } from './jsx-runtime';\n\nconst PENDING = new WeakMap<object, Component>();\n\n/** Per-class composed content render. */\nconst CHAIN = new WeakMap<Function, Function>();\n\ntype IfEquals<X, Y, A, B> =\n  (<T>() => T extends X ? 1 : 2) extends\n  (<T>() => T extends Y ? 1 : 2) ? A : B;\n\n/** Keys of T which are settable (excludes get-only accessors and `readonly`). */\ntype Acceptable<T> = {\n  [P in keyof T]-?: IfEquals<\n    { [Q in P]: T[P] },\n    { -readonly [Q in P]: T[P] },\n    P, never\n  >;\n}[keyof T];\n\ndeclare namespace Component {\n  /**\n   * Host element type produced by `Component.render`. Delegates to the\n   * {@link Host} manifest on the jsx-runtime entry; resolves to `unknown`\n   * until an adapter augments it with `node`.\n   */\n  type Node = Host extends { node: infer T } ? T : unknown;\n\n  interface BaseProps<T extends Component> {\n    /**\n     * Callback for newly created instance. Only called once.\n     *\n     * Runs after props apply but **before** the `new()` lifecycle hook - so it\n     * may configure state that `new()` then observes. To react to a fully\n     * initialized instance instead, use `watch` or an effect.\n     */\n    is?: (instance: T) => void;\n\n    /**\n     * Fallback to show when suspended or in error recovery.\n     * Pass `false` to opt out of the component's own suspense boundary,\n     * letting suspension bubble to an ancestor.\n     */\n    fallback?: Component.Node;\n  }\n\n  type StateProps<T extends State> = {\n    [K in Exclude<keyof T, keyof Component> & Acceptable<T>]?: T[K];\n  };\n\n  type RenderProps<T> = [T] extends [(props: infer P) => any]\n    ? [keyof NonNullable<P>] extends [never]\n    ? { children?: Component.Node }\n    : NonNullable<P>\n    : { children?: Component.Node };\n\n  type Props<T extends Component> =\n    & StateProps<T>\n    & BaseProps<T>\n    & RenderProps<T['render']>;\n}\n\nclass Component extends State {\n  /**\n   * All JSX attributes passed to this component.\n   * Includes state-derived props, render props, and built-in props like `is` and `fallback`.\n   *\n   * Will incorperate extra props you declare as props parameter in `render` method.\n   */\n  declare readonly props: Component.Props<this>;\n\n  /**\n   * Content to display while this component or its children are suspended.\n   * Will cover suspense by pending properties in `this.render` as well.\n   * Can be set as a class property or overridden via the `fallback` JSX prop.\n   *\n   * Defaults to null - nothing will be rendered.\n   * Set `false` to opt out of having a boundary at all - suspension then\n   * bubbles to the nearest ancestor boundary.\n   */\n  fallback: Component.Node = set(null);\n\n  constructor(props?: any, ...rest: any[]) {\n    if (props == null) props = {};\n\n    const seen = {} as Record<string, undefined>;\n    const copy = PENDING.get(props);\n\n    if (typeof props == 'object') merge(props);\n\n    function merge(props: {}) {\n      for (const k in props) seen[k] = undefined;\n      return { ...seen, ...props };\n    }\n\n    super(copy ? [] : [\n      props,\n      rest.filter((x) => !(x instanceof Context)),\n      () => {\n        props.is?.(this);\n        Object.defineProperty(this, 'props', { enumerable: false });\n        PENDING.delete(props);\n      }\n    ]);\n\n    if (copy) return copy;\n\n    PENDING.set(props, this);\n\n    this.props = props;\n    this.set('props', () => {\n      this.set(merge(this.props));\n    });\n\n    Object.defineProperty(this, 'render', {\n      writable: true,\n      configurable: true,\n      value: render(this)\n    });\n  }\n\n  /**\n   * Output for this component. Override to define custom JSX.\n   *\n   * Properties accessed via `this` are reactive and trigger a render when they\n   * change, in addition to props. Accepts an optional parameter to receive extra\n   * props from JSX, beyond those merged to state properties; declare its shape\n   * via `props = {} as { ... }`. Without a parameter (the default below),\n   * children pass through.\n   *\n   * The constructor installs a composed `render` per instance; the bootstrap\n   * `type` pass seals this and any override non-configurable, keeping it the\n   * content-render seam the chain reads.\n   */\n  render(props?: {}): Component.Node {\n    const { children } = (props || this.props) as { children?: Component.Node };\n    return children || null;\n  }\n\n  /**\n   * Called when a child component throws during render.\n   * While this is pending, `fallback` is displayed.\n   * When resolved, the error boundary resets and `render` is called again.\n   *\n   * Override to handle errors - set `this.fallback` for error-specific UI,\n   * await async recovery, or await user interaction before retrying. If you\n   * assign a fallback within catch, it will be reverted after resolved.\n   */\n  catch?(error: Error): Promise<void> | void;\n}\n\n/**\n * Seal each class's own `render` non-configurable at bootstrap so member\n * classification leaves it unbound - it stays the content-render seam the chain\n * reads (and which adapters like preact detect as the class-component marker).\n */\nComponent.on({\n  type(type) {\n    const desc = Object.getOwnPropertyDescriptor(type.prototype, 'render');\n\n    if (desc && typeof desc.value == 'function')\n      Object.defineProperty(type.prototype, 'render', {\n        ...desc,\n        configurable: false\n      });\n  }\n});\n\n/**\n * Build (or fetch the cached) composed content render for an instance's class.\n * Walks the prototype chain for content renders strictly below Component - the\n * default render on Component.prototype is excluded and serves as the fallback\n * when a class authors none.\n */\nfunction render(target: Component) {\n  const cached = CHAIN.get(target.constructor);\n\n  if (cached) return cached;\n\n  let render: Function | undefined;\n  let proto = target;\n\n  while ((proto = Object.getPrototypeOf(proto)) !== Component.prototype) {\n    const desc = Object.getOwnPropertyDescriptor(proto, 'render');\n\n    if (desc) {\n      const layer = unbind(desc.get || desc.value);\n      render = render ? compose(layer, render) : layer;\n    }\n  }\n\n  if (!render)\n    render = Component.prototype.render;\n\n  CHAIN.set(target.constructor, render);\n\n  return render;\n}\n\n/** Wrap an outer render so it receives `inner` as a lazy `children` getter. */\nfunction compose(outer: Function, inner: Function): Function {\n  return function (this: Component, props?: {}) {\n    const self = this;\n    return outer.call(self, {\n      ...props,\n      get children() {\n        return inner.call(self, props);\n      }\n    });\n  };\n}\n\nexport { Component };\n"],"mappings":";;;;;AAMA,MAAM,0BAAU,IAAI,SAA4B;;AAGhD,MAAM,wBAAQ,IAAI,SAA6B;AAyD/C,IAAM,YAAN,cAAwB,MAAM;CAoB5B,YAAY,OAAa,GAAG,MAAa;AACvC,MAAI,SAAS,KAAM,SAAQ,EAAE;EAE7B,MAAM,OAAO,EAAE;EACf,MAAM,OAAO,QAAQ,IAAI,MAAM;AAE/B,MAAI,OAAO,SAAS,SAAU,OAAM,MAAM;EAE1C,SAAS,MAAM,OAAW;AACxB,QAAK,MAAM,KAAK,MAAO,MAAK,KAAK;AACjC,UAAO;IAAE,GAAG;IAAM,GAAG;IAAO;;AAG9B,QAAM,OAAO,EAAE,GAAG;GAChB;GACA,KAAK,QAAQ,MAAM,EAAE,aAAa,SAAS;SACrC;AACJ,UAAM,KAAK,KAAK;AAChB,WAAO,eAAe,MAAM,SAAS,EAAE,YAAY,OAAO,CAAC;AAC3D,YAAQ,OAAO,MAAM;;GAExB,CAAC;kBAvBuB,IAAI,KAAK;AAyBlC,MAAI,KAAM,QAAO;AAEjB,UAAQ,IAAI,OAAO,KAAK;AAExB,OAAK,QAAQ;AACb,OAAK,IAAI,eAAe;AACtB,QAAK,IAAI,MAAM,KAAK,MAAM,CAAC;IAC3B;AAEF,SAAO,eAAe,MAAM,UAAU;GACpC,UAAU;GACV,cAAc;GACd,OAAO,OAAO,KAAK;GACpB,CAAC;;;;;;;;;;;;;;;CAgBJ,OAAO,OAA4B;EACjC,MAAM,EAAE,aAAc,SAAS,KAAK;AACpC,SAAO,YAAY;;;;;;;;AAoBvB,UAAU,GAAG,EACX,KAAK,MAAM;CACT,MAAM,OAAO,OAAO,yBAAyB,KAAK,WAAW,SAAS;AAEtE,KAAI,QAAQ,OAAO,KAAK,SAAS,WAC/B,QAAO,eAAe,KAAK,WAAW,UAAU;EAC9C,GAAG;EACH,cAAc;EACf,CAAC;GAEP,CAAC;;;;;;;AAQF,SAAS,OAAO,QAAmB;CACjC,MAAM,SAAS,MAAM,IAAI,OAAO,YAAY;AAE5C,KAAI,OAAQ,QAAO;CAEnB,IAAI;CACJ,IAAI,QAAQ;AAEZ,SAAQ,QAAQ,OAAO,eAAe,MAAM,MAAM,UAAU,WAAW;EACrE,MAAM,OAAO,OAAO,yBAAyB,OAAO,SAAS;AAE7D,MAAI,MAAM;GACR,MAAM,QAAQ,OAAO,KAAK,OAAO,KAAK,MAAM;AAC5C,YAAS,SAAS,QAAQ,OAAO,OAAO,GAAG;;;AAI/C,KAAI,CAAC,OACH,UAAS,UAAU,UAAU;AAE/B,OAAM,IAAI,OAAO,aAAa,OAAO;AAErC,QAAO;;;AAIT,SAAS,QAAQ,OAAiB,OAA2B;AAC3D,QAAO,SAA2B,OAAY;EAC5C,MAAM,OAAO;AACb,SAAO,MAAM,KAAK,MAAM;GACtB,GAAG;GACH,IAAI,WAAW;AACb,WAAO,MAAM,KAAK,MAAM,MAAM;;GAEjC,CAAC"}

package/dist/context.d.ts

@@ -0,0 +1,56 @@
+import { State } from "./state.js";
+
+//#region src/context.d.ts
+type Accept<T extends State = State> = T | State.Type<T> | Record<string | number, T | State.Type<T>>;
+type Expect<T extends State = State> = (state: T, downstream: boolean) => (() => void) | void;
+declare namespace Context {
+  export { Accept, Expect };
+}
+declare class Context {
+  static get root(): Context;
+  /** Get the context for a State. Adapters may override to provide framework context. */
+  static get(state?: State): Context;
+  id: string;
+  parent?: Context;
+  scope: Set<Context>;
+  consume: Map<State.Extends<State>, Set<[Expect<State>, boolean | undefined]> | null>;
+  provide: Map<State.Extends<State>, Set<[State, boolean]> | null>;
+  protected inputs: Record<string | number, State | State.Extends>;
+  private cleanup;
+  constructor(arg?: Context | Accept);
+  private traverse;
+  private register;
+  /** Find specified type upstream. Throws if not found. */
+  get<T extends State>(Type: State.Extends<T>, required?: true): T;
+  /** Find specified type upstream. Returns undefined if not found. */
+  get<T extends State>(Type: State.Extends<T>, required?: boolean): T | undefined;
+  /** Subscribe to a type becoming available in context. */
+  get<T extends State>(Type: State.Extends<T>, callback: Expect<T>, downstream?: boolean): () => void;
+  /** Lookup excluding a specific instance (used by State.prototype.get for upstream-of-self semantics). */
+  get<T extends State>(Type: State.Extends<T>, arg: boolean | Expect<T> | undefined, downstream: boolean | undefined, skip: State): T | undefined | (() => void);
+  /**
+   * 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.
+   */
+  set<T extends State>(inputs: Accept<T>, forEach?: (state: T) => (() => void) | void): this;
+  add(I: State, explicit?: boolean): () => 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?: Accept): Context;
+  /**
+   * Remove all States from this context.
+   *
+   * Will also run any cleanup callbacks registered when States were added.
+   */
+  pop(): void;
+}
+//#endregion
+export { Context };
+//# sourceMappingURL=context.d.ts.map

package/dist/context.js

@@ -0,0 +1,201 @@
+import { event, listener } from "./observable.js";
+import { State, uid } from "./state.js";
+
+//#region src/context.ts
+const LOOKUP = /* @__PURE__ */ new WeakMap();
+let ROOT;
+var Context = class Context {
+	static get root() {
+		return ROOT ??= new Context();
+	}
+	/** Get the context for a State. Adapters may override to provide framework context. */
+	static get(state) {
+		return state && LOOKUP.get(state.is) || Context.root;
+	}
+	constructor(arg) {
+		this.id = uid();
+		this.scope = /* @__PURE__ */ new Set();
+		this.consume = /* @__PURE__ */ new Map();
+		this.provide = /* @__PURE__ */ new Map();
+		this.inputs = {};
+		this.cleanup = /* @__PURE__ */ new Map();
+		if (arg instanceof Context) {
+			this.parent = arg;
+			arg.scope.add(this);
+		} else if (arg) this.set(arg);
+	}
+	traverse(accept) {
+		const queue = [...this.scope];
+		for (const ctx of queue) if (accept(ctx) !== false) for (const c of ctx.scope) queue.push(c);
+	}
+	register(type, value, asConsumer) {
+		const mode = asConsumer ? "consume" : "provide";
+		let set = this[mode].get(type);
+		if (!set) this[mode].set(type, set = /* @__PURE__ */ new Set());
+		set.add(value);
+		for (let ctx = this.parent; ctx; ctx = ctx.parent) {
+			if (ctx[mode].has(type)) break;
+			ctx[mode].set(type, null);
+		}
+		return () => set.delete(value);
+	}
+	get(Type, arg, downstream, skip) {
+		let found;
+		let priority = false;
+		for (let ctx = this; ctx; ctx = ctx.parent) {
+			const entries = ctx.provide.get(Type);
+			if (!entries) continue;
+			for (const [state, explicit] of entries) {
+				if (state === skip || found === state) continue;
+				if (!found || explicit && !priority) {
+					found = state;
+					priority = explicit;
+					continue;
+				}
+				if (!priority) {
+					found = null;
+					break;
+				}
+				if (explicit) throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+			}
+			if (found !== void 0) break;
+		}
+		if (typeof arg === "function") {
+			if (found && !downstream) arg(found, false);
+			if (downstream !== false) this.traverse((ctx) => {
+				const has = ctx.provide.get(Type);
+				if (has) {
+					for (const x of has) if (x[0] !== skip) arg(x[0], true);
+				}
+				return has !== void 0;
+			});
+			return this.register(Type, [arg, downstream], true);
+		}
+		if (found) return found;
+		if (found === null) return null;
+		if (arg !== false) throw new Error(`Could not find ${Type} in context.`);
+	}
+	/**
+	* 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.
+	*/
+	set(inputs, forEach) {
+		const init = /* @__PURE__ */ new Set();
+		const { cleanup } = this;
+		if (typeof inputs == "function" || inputs instanceof State) inputs = { [0]: inputs };
+		for (const K of Object.keys({
+			...this.inputs,
+			...inputs
+		})) {
+			const V = inputs[K];
+			const E = this.inputs[K];
+			if (E === V) continue;
+			if (E) {
+				cleanup.get(K)?.();
+				cleanup.delete(K);
+			}
+			if (!V) continue;
+			if (!(State.is(V) || V instanceof State)) {
+				const as = K == "0" || K == String(V) ? V : `${V} (as '${K}')`;
+				throw new Error(`Context can only include an instance or class of State but got ${as}.`);
+			}
+			const state = State.is(V) ? new V() : V.is;
+			const remove = this.add(state, true);
+			init.add(() => {
+				event(state);
+				const dispose = forEach && forEach(state);
+				cleanup.set(K, () => {
+					if (dispose) dispose();
+					remove();
+					if (state !== V) event(state, null);
+				});
+			});
+		}
+		for (const i of init) i();
+		this.inputs = inputs;
+		return this;
+	}
+	add(I, explicit = false) {
+		const { cleanup, provide } = this;
+		const root = this === Context.root;
+		const TT = [];
+		function conflict(T) {
+			const entries = provide.get(T);
+			if (entries) {
+				for (const entry of entries) if (!entry[1] && entry[0] !== I) return entries.delete(entry);
+			}
+		}
+		for (let T = I.constructor; T !== State; T = Object.getPrototypeOf(T)) if (explicit || !root || !conflict(T)) TT.push(T);
+		const expects = /* @__PURE__ */ new Map();
+		const onDone = /* @__PURE__ */ new Set();
+		for (const T of TT) onDone.add(this.register(T, [I, explicit]));
+		function queue(ctx, downstream) {
+			let found = false;
+			for (const T of TT) {
+				const list = ctx.consume.get(T);
+				if (list !== void 0) found = true;
+				if (list) {
+					for (const [cb, filter] of list) if (filter === downstream || filter == null) expects.set(cb, () => {
+						const r = cb(I, downstream);
+						if (r) onDone.add(r);
+					});
+				}
+			}
+			return found;
+		}
+		for (let ctx = this; ctx; ctx = ctx.parent) queue(ctx, true);
+		this.traverse((ctx) => queue(ctx, false));
+		if (!LOOKUP.has(I)) LOOKUP.set(I, this);
+		listener(I, () => {
+			expects.forEach((f) => f());
+			expects.clear();
+			return null;
+		});
+		function flush() {
+			onDone.forEach((r) => r());
+			onDone.clear();
+		}
+		function remove() {
+			cleanup.delete(remove);
+			flush();
+		}
+		cleanup.set(remove, remove);
+		return remove;
+	}
+	/**
+	* 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 = new Context(this);
+		if (inputs) next.set(inputs);
+		return next;
+	}
+	/**
+	* Remove all States from this context.
+	*
+	* Will also run any cleanup callbacks registered when States were added.
+	*/
+	pop() {
+		this.inputs = {};
+		this.scope.forEach((x) => x.pop());
+		this.scope.clear();
+		this.cleanup.forEach((cb) => cb());
+		this.cleanup.clear();
+		this.consume.clear();
+		this.provide.clear();
+		if (this.parent) this.parent.scope.delete(this);
+	}
+};
+Object.defineProperty(Context.prototype, "toString", { value() {
+	return `Context-${this.id}`;
+} });
+
+//#endregion
+export { Context };
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import { listener } from \"./observable\";\nimport { event, State, uid } from \"./state\";\n\nconst LOOKUP = new WeakMap<State, Context>();\nlet ROOT: Context;\n\ntype Accept<T extends State = State> =\n  | T\n  | State.Type<T>\n  | Record<string | number, T | State.Type<T>>;\n\ntype Expect<T extends State = State> = (\n  state: T,\n  downstream: boolean,\n) => (() => void) | void;\n\ndeclare namespace Context {\n  export { Accept, Expect };\n}\n\nclass Context {\n  static get root(): Context {\n    return ROOT ??= new Context();\n  }\n\n  /** Get the context for a State. Adapters may override to provide framework context. */\n  static get(state?: State): Context {\n    return state && LOOKUP.get(state.is) || Context.root;\n  }\n\n  public id = uid();\n  public parent?: Context;\n  public scope = new Set<Context>();\n  public consume = new Map<\n    State.Extends,\n    Set<[Expect, boolean | undefined]> | null\n  >();\n  public provide = new Map<State.Extends, Set<[State, boolean]> | null>();\n\n  protected inputs: Record<string | number, State | State.Extends> = {};\n\n  private cleanup = new Map<string | number | Function, () => void>();\n\n  constructor(arg?: Context | Accept) {\n    if (arg instanceof Context) {\n      this.parent = arg;\n      arg.scope.add(this);\n    } else if (arg) {\n      this.set(arg);\n    }\n  }\n\n  private traverse(accept: (ctx: Context) => boolean | void) {\n    const queue = [...this.scope];\n    for (const ctx of queue)\n      if (accept(ctx) !== false) for (const c of ctx.scope) queue.push(c);\n  }\n\n  private register<T extends State>(\n    type: State.Extends<T>,\n    value: [Expect<T>, boolean | undefined],\n    asConsumer: true,\n  ): () => void;\n\n  private register<T extends State>(\n    type: State.Extends<T>,\n    value: [T, boolean],\n    asConsumer?: false,\n  ): () => void;\n\n  private register(type: State.Extends, value: any, asConsumer?: boolean) {\n    const mode = asConsumer ? \"consume\" : \"provide\";\n    let set = this[mode].get(type) as Set<any>;\n    if (!set) this[mode].set(type, (set = new Set()));\n    set.add(value);\n\n    for (let ctx = this.parent; ctx; ctx = ctx.parent) {\n      if (ctx[mode].has(type)) break;\n      ctx[mode].set(type, null);\n    }\n\n    return () => set.delete(value);\n  }\n\n  /** Find specified type upstream. Throws if not found. */\n  public get<T extends State>(Type: State.Extends<T>, required?: true): T;\n\n  /** Find specified type upstream. Returns undefined if not found. */\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    required?: boolean,\n  ): T | undefined;\n\n  /** Subscribe to a type becoming available in context. */\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    callback: Expect<T>,\n    downstream?: boolean,\n  ): () => void;\n\n  /** Lookup excluding a specific instance (used by State.prototype.get for upstream-of-self semantics). */\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    arg: boolean | Expect<T> | undefined,\n    downstream: boolean | undefined,\n    skip: State,\n  ): T | undefined | (() => void);\n\n  public get<T extends State>(\n    Type: State.Extends<T>,\n    arg?: boolean | Expect<T>,\n    downstream?: boolean,\n    skip?: State,\n  ) {\n    let found: T | null | undefined;\n    let priority = false;\n\n    for (let ctx: Context | undefined = this; ctx; ctx = ctx.parent) {\n      const entries = ctx.provide.get(Type);\n      if (!entries) continue;\n\n      for (const [state, explicit] of entries) {\n        if (state === skip || found === state) continue;\n        if (!found || (explicit && !priority)) {\n          found = state as T;\n          priority = explicit;\n          continue;\n        }\n        if (!priority) {\n          found = null;\n          break;\n        }\n        if (explicit)\n          throw new Error(\n            `Did find ${Type} in context, but multiple were defined.`,\n          );\n      }\n      if (found !== undefined) break;\n    }\n\n    if (typeof arg === \"function\") {\n      if (found && !downstream) arg(found, false);\n\n      if (downstream !== false) {\n        this.traverse((ctx) => {\n          const has = ctx.provide.get(Type);\n          if (has) for (const x of has) if (x[0] !== skip) arg(x[0] as T, true);\n          return has !== undefined;\n        });\n      }\n\n      return this.register(Type, [arg as Expect, downstream], true);\n    }\n\n    if (found) return found;\n    if (found === null) return null;\n    if (arg !== false) throw new Error(`Could not find ${Type} in context.`);\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 set<T extends State>(\n    inputs: Accept<T>,\n    forEach?: (state: T) => (() => void) | void,\n  ) {\n    const init = new Set<() => void>();\n    const { cleanup } = this;\n\n    if (typeof inputs == \"function\" || inputs instanceof State)\n      inputs = { [0]: inputs };\n\n    for (const K of Object.keys({ ...this.inputs, ...inputs })) {\n      const V = inputs[K];\n      const E = this.inputs[K];\n\n      if (E === V) continue;\n\n      if (E) {\n        cleanup.get(K)?.();\n        cleanup.delete(K);\n      }\n\n      if (!V) continue;\n\n      if (!(State.is(V) || V instanceof State)) {\n        const as = K == \"0\" || K == String(V) ? V : `${V} (as '${K}')`;\n        throw new Error(\n          `Context can only include an instance or class of State but got ${as}.`,\n        );\n      }\n\n      const state = State.is(V) ? new (V as State.Type)() : V.is;\n      const remove = this.add(state, true);\n\n      init.add(() => {\n        event(state);\n        const dispose = forEach && forEach(state as T);\n        cleanup.set(K, () => {\n          if (dispose) dispose();\n          remove();\n          if (state !== V) event(state, null);\n        });\n      });\n    }\n\n    for (const i of init) i();\n\n    this.inputs = inputs;\n\n    return this;\n  }\n\n  add(I: State, explicit = false) {\n    const { cleanup, provide } = this;\n    const root = this === Context.root;\n    const TT: State.Extends[] = [];\n\n    function conflict(T: State.Extends) {\n      const entries = provide.get(T);\n      if (entries)\n        for (const entry of entries)\n          if (!entry[1] && entry[0] !== I)\n            return entries.delete(entry);\n    }\n\n    for (\n      let T = I.constructor as State.Extends;\n      T !== State;\n      T = Object.getPrototypeOf(T)\n    )\n      if (explicit || !root || !conflict(T)) TT.push(T);\n\n    const expects = new Map<Expect, () => void>();\n    const onDone = new Set<() => void>();\n\n    for (const T of TT) onDone.add(this.register(T, [I, explicit]));\n\n    function queue(ctx: Context, downstream: boolean) {\n      let found = false;\n      for (const T of TT) {\n        const list = ctx.consume.get(T);\n        if (list !== undefined) found = true;\n        if (list)\n          for (const [cb, filter] of list)\n            if (filter === downstream || filter == null)\n              expects.set(cb, () => {\n                const r = cb(I, downstream);\n                if (r) onDone.add(r);\n              });\n      }\n      return found;\n    }\n\n    for (let ctx: Context | undefined = this; ctx; ctx = ctx.parent) queue(ctx, true);\n    this.traverse((ctx) => queue(ctx, false));\n\n    if (!LOOKUP.has(I)) LOOKUP.set(I, this);\n\n    listener(I, () => {\n      expects.forEach((f) => f());\n      expects.clear();\n      return null;\n    });\n\n    function flush() {\n      onDone.forEach((r) => r());\n      onDone.clear();\n    }\n\n    function remove() {\n      cleanup.delete(remove);\n      flush();\n    }\n\n    cleanup.set(remove, remove);\n\n    return remove;\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?: Accept) {\n    const next = new Context(this);\n    if (inputs) next.set(inputs);\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    this.inputs = {};\n    this.scope.forEach((x) => x.pop());\n    this.scope.clear();\n    this.cleanup.forEach((cb) => cb());\n    this.cleanup.clear();\n    this.consume.clear();\n    this.provide.clear();\n    if (this.parent) {\n      this.parent.scope.delete(this);\n    }\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/field/def.d.ts

@@ -0,0 +1,17 @@
+import { State } from "../state.js";
+
+//#region src/field/def.d.ts
+declare namespace def {
+  /**
+   * Property initializer, will run upon instance creation.
+   * Optional returned callback will run when once upon first access.
+   */
+  type Factory<T = any, M extends State = any> = (this: M, key: Extract<State.Field<M>, string>, thisArg: M, state: State.Values<M>) => def.Config<T> | (() => void) | void;
+  interface Config<T = any> extends State.Apply<T> {
+    destroy?: () => void;
+  }
+}
+declare function def<T>(arg1: def.Factory<T>): T extends void ? unknown : T;
+//#endregion
+export { def };
+//# sourceMappingURL=def.d.ts.map