@expressive/mvc 0.73.1 → 0.78.0

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+import { Fragment, JSX, jsxDEV } from "./jsx-runtime.js";
+export { Fragment, type JSX, jsxDEV };

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,3 @@
+import { Fragment, jsxDEV } from "./jsx-runtime.js";
+
+export { Fragment, jsxDEV };

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,90 @@
+import { Component } from "./component.js";
+
+//#region src/jsx-runtime.d.ts
+/**
+ * Per-adapter interpretation manifest. Each adapter augments this interface to
+ * declare how it renders; the first member is `node` - the element type produced
+ * by `Component.render` (surfaced as `Component.Node`) - alongside `intrinsics`,
+ * the host's tag map (surfaced as `JSX.IntrinsicElements`).
+ *
+ * ```ts
+ * declare module '@expressive/mvc/jsx-runtime' {
+ *   interface Host {
+ *     node: React.ReactNode;
+ *     intrinsics: React.JSX.IntrinsicElements;
+ *   }
+ * }
+ * ```
+ *
+ * Only one adapter is expected per compilation; two augmenting the same member
+ * with different types in the same build would conflict - by design.
+ */
+interface Host {}
+/**
+ * Host JSX runtime, registered by an adapter (e.g. `@expressive/react`) as an
+ * import side effect. One host per build - a second registration with a
+ * different runtime throws.
+ */
+interface HostRuntime {
+  childrenOf(children: unknown): Component.Node[];
+  isElement(node: unknown): boolean;
+  jsx(type: unknown, props: object, key?: unknown): Component.Node;
+  jsxDEV?(type: unknown, props: object, key?: unknown, isStatic?: boolean, source?: object, self?: unknown): Component.Node;
+  jsxs(type: unknown, props: object, key?: unknown): Component.Node;
+  propsOf(node: unknown): Record<string, unknown>;
+  typeOf(node: unknown): unknown;
+  Fragment: unknown;
+}
+declare namespace JSX {
+  type Element = Component.Node;
+  type ElementType = keyof IntrinsicElements | ((props: any) => Component.Node) | (abstract new (...args: any[]) => ElementClass);
+  /**
+   * Gates class element types on the `render` contract alone - requiring full
+   * `Component` assignability trips contravariance on `props` members (e.g.
+   * the `is` callback narrows per subclass), rejecting every subclass.
+   */
+  interface ElementClass {
+    render(props?: any): Component.Node;
+  }
+  interface ElementAttributesProperty {
+    props: {};
+  }
+  interface ElementChildrenAttribute {
+    children: {};
+  }
+  interface IntrinsicAttributes {
+    key?: string | number | null;
+  }
+  /**
+   * Host tag manifest, via the {@link Host} seam. Resolves to `{}` until an
+   * adapter augments `Host` with `intrinsics` - agnostic code is
+   * components-only by design, since it cannot know what tags a host renders.
+   */
+  type IntrinsicElements = Host extends {
+    intrinsics: infer T extends object;
+  } ? T : {};
+}
+/**
+ * Agnostic Fragment sentinel. The runtime entries translate it to the host's
+ * Fragment on element creation; `typeOf` translates back, so identity checks
+ * against this value hold for fragments from either pragma.
+ */
+declare const Fragment: unique symbol;
+/** Register the host JSX runtime. Idempotent for the same runtime. */
+declare function host(runtime: HostRuntime): void;
+declare function jsx(type: unknown, props: object, key?: unknown): Component.Node;
+declare function jsxs(type: unknown, props: object, key?: unknown): Component.Node;
+/** Dev-transpiled element creation. Falls back to the production runtime when
+ * the host registered no `jsxDEV` (prod-only host under a dev build). */
+declare function jsxDEV(type: unknown, props: object, key?: unknown, isStatic?: boolean, source?: object, self?: unknown): Component.Node;
+/** Flatten `children` to an array of nodes, per the host's semantics. */
+declare function childrenOf(children: unknown): Component.Node[];
+/** Is `node` a host element? */
+declare function isElement(node: unknown): boolean;
+/** Element type of `node`; host Fragments surface as the agnostic `Fragment`. */
+declare function typeOf(node: unknown): unknown;
+/** Props carried by element `node`. */
+declare function propsOf(node: unknown): Record<string, unknown>;
+//#endregion
+export { Fragment, Host, HostRuntime, JSX, childrenOf, host, isElement, jsx, jsxDEV, jsxs, propsOf, typeOf };
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist/jsx-runtime.js

@@ -0,0 +1,57 @@
+//#region src/jsx-runtime.ts
+/**
+* Agnostic Fragment sentinel. The runtime entries translate it to the host's
+* Fragment on element creation; `typeOf` translates back, so identity checks
+* against this value hold for fragments from either pragma.
+*/
+const Fragment = Symbol.for("@expressive/mvc.Fragment");
+let HOST;
+/** Register the host JSX runtime. Idempotent for the same runtime. */
+function host(runtime) {
+	if (HOST && HOST !== runtime) throw new Error("A different JSX host is already registered for @expressive/mvc. Only one host adapter may be active per build.");
+	HOST = runtime;
+}
+/** Current host runtime; throws a setup-pointing error when none registered. */
+function resolved() {
+	if (HOST) return HOST;
+	throw new Error("No JSX host is registered for @expressive/mvc. Import a host adapter (e.g. '@expressive/react') before anything renders - typically as the first import of your application entry module.");
+}
+/** Translate the agnostic Fragment sentinel to the host's Fragment. */
+function hostType(type) {
+	return type === Fragment ? resolved().Fragment : type;
+}
+function jsx(type, props, key) {
+	return resolved().jsx(hostType(type), props, key);
+}
+function jsxs(type, props, key) {
+	return resolved().jsxs(hostType(type), props, key);
+}
+/** Dev-transpiled element creation. Falls back to the production runtime when
+* the host registered no `jsxDEV` (prod-only host under a dev build). */
+function jsxDEV(type, props, key, isStatic, source, self) {
+	const runtime = resolved();
+	const resolvedType = hostType(type);
+	return runtime.jsxDEV ? runtime.jsxDEV(resolvedType, props, key, isStatic, source, self) : isStatic ? runtime.jsxs(resolvedType, props, key) : runtime.jsx(resolvedType, props, key);
+}
+/** Flatten `children` to an array of nodes, per the host's semantics. */
+function childrenOf(children) {
+	return resolved().childrenOf(children);
+}
+/** Is `node` a host element? */
+function isElement(node) {
+	return resolved().isElement(node);
+}
+/** Element type of `node`; host Fragments surface as the agnostic `Fragment`. */
+function typeOf(node) {
+	const { typeOf, Fragment: hosted } = resolved();
+	const type = typeOf(node);
+	return type === hosted ? Fragment : type;
+}
+/** Props carried by element `node`. */
+function propsOf(node) {
+	return resolved().propsOf(node);
+}
+
+//#endregion
+export { Fragment, childrenOf, host, isElement, jsx, jsxDEV, jsxs, propsOf, typeOf };
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.js","names":[],"sources":["../src/jsx-runtime.ts"],"sourcesContent":["import type { Component } from './component';\n\n/**\n * Per-adapter interpretation manifest. Each adapter augments this interface to\n * declare how it renders; the first member is `node` - the element type produced\n * by `Component.render` (surfaced as `Component.Node`) - alongside `intrinsics`,\n * the host's tag map (surfaced as `JSX.IntrinsicElements`).\n *\n * ```ts\n * declare module '@expressive/mvc/jsx-runtime' {\n *   interface Host {\n *     node: React.ReactNode;\n *     intrinsics: React.JSX.IntrinsicElements;\n *   }\n * }\n * ```\n *\n * Only one adapter is expected per compilation; two augmenting the same member\n * with different types in the same build would conflict - by design.\n */\nexport interface Host { }\n\n/**\n * Host JSX runtime, registered by an adapter (e.g. `@expressive/react`) as an\n * import side effect. One host per build - a second registration with a\n * different runtime throws.\n */\nexport interface HostRuntime {\n  childrenOf(children: unknown): Component.Node[];\n  isElement(node: unknown): boolean;\n  jsx(type: unknown, props: object, key?: unknown): Component.Node;\n  jsxDEV?(type: unknown, props: object, key?: unknown, isStatic?: boolean, source?: object, self?: unknown): Component.Node;\n  jsxs(type: unknown, props: object, key?: unknown): Component.Node;\n  propsOf(node: unknown): Record<string, unknown>;\n  typeOf(node: unknown): unknown;\n  Fragment: unknown;\n}\n\nexport declare namespace JSX {\n  type Element = Component.Node;\n  type ElementType =\n    | keyof IntrinsicElements\n    | ((props: any) => Component.Node)\n    | (abstract new (...args: any[]) => ElementClass);\n  /**\n   * Gates class element types on the `render` contract alone - requiring full\n   * `Component` assignability trips contravariance on `props` members (e.g.\n   * the `is` callback narrows per subclass), rejecting every subclass.\n   */\n  interface ElementClass { render(props?: any): Component.Node }\n  interface ElementAttributesProperty { props: {} }\n  interface ElementChildrenAttribute { children: {} }\n  interface IntrinsicAttributes { key?: string | number | null }\n  /**\n   * Host tag manifest, via the {@link Host} seam. Resolves to `{}` until an\n   * adapter augments `Host` with `intrinsics` - agnostic code is\n   * components-only by design, since it cannot know what tags a host renders.\n   */\n  type IntrinsicElements =\n    Host extends { intrinsics: infer T extends object } ? T : {};\n}\n\n\n/**\n * Agnostic Fragment sentinel. The runtime entries translate it to the host's\n * Fragment on element creation; `typeOf` translates back, so identity checks\n * against this value hold for fragments from either pragma.\n */\nexport const Fragment = Symbol.for('@expressive/mvc.Fragment');\n\nlet HOST: HostRuntime | undefined;\n\n/** Register the host JSX runtime. Idempotent for the same runtime. */\nexport function host(runtime: HostRuntime) {\n  if (HOST && HOST !== runtime)\n    throw new Error(\n      'A different JSX host is already registered for @expressive/mvc. ' +\n      'Only one host adapter may be active per build.'\n    );\n\n  HOST = runtime;\n}\n\n/** Current host runtime; throws a setup-pointing error when none registered. */\nfunction resolved(): HostRuntime {\n  if (HOST) return HOST;\n\n  throw new Error(\n    'No JSX host is registered for @expressive/mvc. ' +\n    \"Import a host adapter (e.g. '@expressive/react') before anything renders - \" +\n    'typically as the first import of your application entry module.'\n  );\n}\n\n/** Translate the agnostic Fragment sentinel to the host's Fragment. */\nfunction hostType(type: unknown): unknown {\n  return type === Fragment ? resolved().Fragment : type;\n}\n\nexport function jsx(type: unknown, props: object, key?: unknown): Component.Node {\n  return resolved().jsx(hostType(type), props, key);\n}\n\nexport function jsxs(type: unknown, props: object, key?: unknown): Component.Node {\n  return resolved().jsxs(hostType(type), props, key);\n}\n\n/** Dev-transpiled element creation. Falls back to the production runtime when\n * the host registered no `jsxDEV` (prod-only host under a dev build). */\nexport function jsxDEV(\n  type: unknown,\n  props: object,\n  key?: unknown,\n  isStatic?: boolean,\n  source?: object,\n  self?: unknown\n): Component.Node {\n  const runtime = resolved();\n  const resolvedType = hostType(type);\n\n  return runtime.jsxDEV\n    ? runtime.jsxDEV(resolvedType, props, key, isStatic, source, self)\n    : isStatic\n      ? runtime.jsxs(resolvedType, props, key)\n      : runtime.jsx(resolvedType, props, key);\n}\n\n/** Flatten `children` to an array of nodes, per the host's semantics. */\nexport function childrenOf(children: unknown): Component.Node[] {\n  return resolved().childrenOf(children);\n}\n\n/** Is `node` a host element? */\nexport function isElement(node: unknown): boolean {\n  return resolved().isElement(node);\n}\n\n/** Element type of `node`; host Fragments surface as the agnostic `Fragment`. */\nexport function typeOf(node: unknown): unknown {\n  const { typeOf, Fragment: hosted } = resolved();\n  const type = typeOf(node);\n  return type === hosted ? Fragment : type;\n}\n\n/** Props carried by element `node`. */\nexport function propsOf(node: unknown): Record<string, unknown> {\n  return resolved().propsOf(node);\n}"],"mappings":";;;;;;AAoEA,MAAa,WAAW,OAAO,IAAI,2BAA2B;AAE9D,IAAI;;AAGJ,SAAgB,KAAK,SAAsB;AACzC,KAAI,QAAQ,SAAS,QACnB,OAAM,IAAI,MACR,iHAED;AAEH,QAAO;;;AAIT,SAAS,WAAwB;AAC/B,KAAI,KAAM,QAAO;AAEjB,OAAM,IAAI,MACR,4LAGD;;;AAIH,SAAS,SAAS,MAAwB;AACxC,QAAO,SAAS,WAAW,UAAU,CAAC,WAAW;;AAGnD,SAAgB,IAAI,MAAe,OAAe,KAA+B;AAC/E,QAAO,UAAU,CAAC,IAAI,SAAS,KAAK,EAAE,OAAO,IAAI;;AAGnD,SAAgB,KAAK,MAAe,OAAe,KAA+B;AAChF,QAAO,UAAU,CAAC,KAAK,SAAS,KAAK,EAAE,OAAO,IAAI;;;;AAKpD,SAAgB,OACd,MACA,OACA,KACA,UACA,QACA,MACgB;CAChB,MAAM,UAAU,UAAU;CAC1B,MAAM,eAAe,SAAS,KAAK;AAEnC,QAAO,QAAQ,SACX,QAAQ,OAAO,cAAc,OAAO,KAAK,UAAU,QAAQ,KAAK,GAChE,WACE,QAAQ,KAAK,cAAc,OAAO,IAAI,GACtC,QAAQ,IAAI,cAAc,OAAO,IAAI;;;AAI7C,SAAgB,WAAW,UAAqC;AAC9D,QAAO,UAAU,CAAC,WAAW,SAAS;;;AAIxC,SAAgB,UAAU,MAAwB;AAChD,QAAO,UAAU,CAAC,UAAU,KAAK;;;AAInC,SAAgB,OAAO,MAAwB;CAC7C,MAAM,EAAE,QAAQ,UAAU,WAAW,UAAU;CAC/C,MAAM,OAAO,OAAO,KAAK;AACzB,QAAO,SAAS,SAAS,WAAW;;;AAItC,SAAgB,QAAQ,MAAwC;AAC9D,QAAO,UAAU,CAAC,QAAQ,KAAK"}

package/dist/observable.d.ts

@@ -0,0 +1,58 @@
+//#region src/observable.d.ts
+declare namespace Observer {
+  /**
+   * Update callback function.
+   *
+   * @param key -
+   *   - `string` - property which has updated.
+   *   - `false` - a normal update has completed.
+   *   - `true` - initial event; instance is ready.
+   *   - `null` - terminal event; instance is expired.
+   */
+  type Notify = (key: Signal) => (() => void) | null | void;
+  type EffectCleanup = (update: boolean | null) => void;
+  type Effect<T extends object> = (this: T, proxy: T, changed: readonly Event[]) => EffectCleanup | Promise<void> | null | void;
+  type Event = number | string | symbol;
+  type Signal = Event | true | false | null;
+  type Callback = () => void | null;
+}
+interface Observer {
+  /** Becomes `true` once the subject has emitted its initial event. */
+  ready?: true;
+  listeners: Map<Observer.Notify, Set<Observer.Signal> | undefined>;
+  /** Recursion guard for an in-progress emit pass. */
+  pending: Set<Observer.Signal>;
+  /** Accumulator drained by the next microtask. */
+  events: Set<Observer.Event>;
+}
+declare const Observer: unique symbol;
+/**
+ * Fetch the dispatch bundle attached to an object.
+ * - returns the bundle if active
+ * - returns `null` if the subject has been terminated
+ * - returns `undefined` if the subject was never observable
+ *
+ * With `create: true`, attaches a fresh bundle iff the slot is undefined.
+ * A terminated (null) slot is not resurrected.
+ */
+declare function observer(state: object, create: true): Observer;
+declare function observer(state: object, create?: boolean): Observer | undefined | null;
+declare function touch(from: object, key: any): void;
+declare function touch<T>(from: object, key: any, value?: T): T;
+declare function listener<T extends object>(subject: T, callback: Observer.Notify, select?: Observer.Signal | Set<Observer.Signal>): () => boolean;
+declare function pending<K extends Observer.Event>(state: object): K[] & PromiseLike<K[]>;
+declare function event(state: object, key?: Observer.Event | null, silent?: boolean): void;
+/**
+ * Create a side-effect which will update whenever values accessed change.
+ * Callback is called immediately and whenever values are stale.
+ *
+ * @param target - Instance of State to observe.
+ * @param callback - Function to invoke when values change.
+ * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
+ */
+declare function watch<T extends object>(target: T, callback: Observer.Effect<Required<T>>, requireValues: true): () => void;
+declare function watch<T extends object>(target: T, callback: Observer.Effect<T>, recursive?: boolean): () => void;
+declare function capture(scope: (release: (update?: boolean | null) => void) => void): void;
+//#endregion
+export { Observer, capture, event, listener, observer, pending, touch, watch };
+//# sourceMappingURL=observable.d.ts.map

package/dist/observable.js

@@ -0,0 +1,184 @@
+//#region src/observable.ts
+const Observer = Symbol("Observer");
+const Observing = Symbol("Observing");
+/** Central event dispatch. Bunches all updates to occur at same time. */
+const DISPATCH = /* @__PURE__ */ new Set();
+function observer(state, create) {
+	const o = state[Observer];
+	if (!o && create) {
+		if (o === null) throw new Error("Object is not observable (terminated).");
+		const value = {
+			listeners: /* @__PURE__ */ new Map(),
+			pending: /* @__PURE__ */ new Set(),
+			events: /* @__PURE__ */ new Set()
+		};
+		Object.defineProperty(state, Observer, {
+			value,
+			writable: true
+		});
+		return value;
+	}
+	return o;
+}
+function observe(object, callback, required) {
+	const watching = /* @__PURE__ */ new Set();
+	const release = listener(object, (key) => {
+		if (watching.has(key)) return callback();
+	});
+	if (EffectContext) EffectContext.add((update) => {
+		if (update !== true) release();
+	});
+	const proxy = Object.create(object);
+	return Object.defineProperty(proxy, Observing, { value: {
+		callback,
+		watching,
+		required
+	} });
+}
+function touch(from, key, value) {
+	const active = from[Observing];
+	if (active) {
+		if (value === void 0 && arguments.length === 3 && active.required) throw new Error(`${Object.getPrototypeOf(from)}.${String(key)} is required in this context.`);
+		active.watching.add(key);
+		if (value instanceof Object && observer(value)) return observe(value, active.callback, active.required);
+	}
+	return value;
+}
+function listener(subject, callback, select) {
+	const o = observer(subject, true);
+	if (select !== void 0 && !(select instanceof Set)) select = new Set([select]);
+	if (o.ready && !select) callback(true);
+	o.listeners.set(callback, select);
+	return () => o.listeners.delete(callback);
+}
+const EMPTY = Object.assign([], { then: Promise.prototype.then.bind(Promise.resolve([])) });
+function pending(state) {
+	const o = observer(state);
+	if (!o?.events.size) return EMPTY;
+	const current = o.events;
+	const promise = new Promise((res) => {
+		const callback = () => {
+			o.listeners.delete(callback);
+			return () => res([...current]);
+		};
+		o.listeners.set(callback, void 0);
+	});
+	return Object.assign([...current], { then: promise.then.bind(promise) });
+}
+function event(state, key, silent) {
+	const o = observer(state, key === void 0);
+	if (!o) return;
+	if (key === null) {
+		state[Observer] = null;
+		return emit(o, key);
+	}
+	if (key === void 0) return emit(o, true);
+	if (!o.events.size && !silent) enqueue(() => {
+		emit(o, false);
+		o.events = /* @__PURE__ */ new Set();
+	});
+	o.events.add(key);
+	if (!silent) emit(o, key);
+}
+function emit(o, key) {
+	const { listeners, pending, ready } = o;
+	if (key === ready) return;
+	if (pending.size) {
+		pending.add(key);
+		return;
+	}
+	if (!ready) pending.add(true);
+	pending.add(key);
+	for (const k of pending) for (const [callback, filter] of listeners) if (!filter || filter.has(k)) {
+		const after = callback(k);
+		if (after === null) listeners.delete(callback);
+		else if (after) enqueue(after);
+	}
+	if (key === null) listeners.clear();
+	else if (key === true) o.ready = true;
+	pending.clear();
+}
+function enqueue(eventHandler) {
+	if (!DISPATCH.size) queueMicrotask(() => {
+		DISPATCH.forEach((event) => {
+			try {
+				event();
+			} catch (err) {
+				console.error(err);
+			}
+		});
+		DISPATCH.clear();
+	});
+	DISPATCH.add(eventHandler);
+}
+function watch(target, callback, argument) {
+	const o = observer(target, true);
+	let events = [];
+	let unset;
+	let reset;
+	let previous;
+	function invoke() {
+		if (observer(target) === null) return;
+		let ignore = true;
+		function onUpdate() {
+			events = [...o.events];
+			if (reset === null) return null;
+			if (ignore) return;
+			ignore = true;
+			unset(true);
+			unset = void 0;
+			enqueue(invoke);
+		}
+		function run(release) {
+			const proxy = observe(target, onUpdate, argument === true);
+			const output = callback.call(proxy, proxy, events);
+			if (previous && argument === false) {
+				const { watching } = proxy[Observing];
+				if (!watching.size) previous[Observing].watching.forEach((k) => watching.add(k));
+			}
+			previous = proxy;
+			ignore = false;
+			reset = output === null ? null : invoke;
+			unset = (key) => {
+				if (typeof output == "function") output(key);
+				if (release) release(key);
+			};
+			events = [];
+		}
+		try {
+			if (argument !== false) capture(run);
+			else run();
+		} catch (err) {
+			if (err instanceof Promise) {
+				reset = void 0;
+				err.then(invoke);
+			} else throw err;
+		}
+	}
+	const unlisten = listener(target, (key) => {
+		if (key === true) invoke();
+		else if (!reset) return reset;
+		if (key === null && unset) unset(null);
+	});
+	function cleanup() {
+		if (unset) unset(false);
+		reset = null;
+		unlisten();
+	}
+	if (EffectContext && argument !== false) EffectContext.add(cleanup);
+	return cleanup;
+}
+let EffectContext;
+function capture(scope) {
+	const parent = EffectContext;
+	const context = EffectContext = /* @__PURE__ */ new Set();
+	try {
+		scope((update) => context.forEach((fn) => fn(update)));
+	} finally {
+		EffectContext = parent;
+	}
+}
+
+//#endregion
+export { Observer, capture, event, listener, observer, pending, touch, watch };
+//# sourceMappingURL=observable.js.map

package/dist/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","names":[],"sources":["../src/observable.ts"],"sourcesContent":["declare namespace Observer {\n  /**\n   * Update callback function.\n   *\n   * @param key -\n   *   - `string` - property which has updated.\n   *   - `false` - a normal update has completed.\n   *   - `true` - initial event; instance is ready.\n   *   - `null` - terminal event; instance is expired.\n   */\n  type Notify = (key: Signal) => (() => void) | null | void;\n\n  type EffectCleanup = (update: boolean | null) => void;\n\n  type Effect<T extends object> = (\n    this: T,\n    proxy: T,\n    changed: readonly Event[]\n  ) => EffectCleanup | Promise<void> | null | void;\n\n  type Event = number | string | symbol;\n\n  type Signal = Event | true | false | null;\n\n  type Callback = () => void | null;\n}\n\ninterface Observer {\n  /** Becomes `true` once the subject has emitted its initial event. */\n  ready?: true;\n  listeners: Map<Observer.Notify, Set<Observer.Signal> | undefined>;\n  /** Recursion guard for an in-progress emit pass. */\n  pending: Set<Observer.Signal>;\n  /** Accumulator drained by the next microtask. */\n  events: Set<Observer.Event>;\n}\n\ninterface Observing {\n  callback: Observer.Callback;\n  watching: Set<Observer.Signal>;\n  required?: boolean;\n}\n\nconst Observer: unique symbol = Symbol('Observer');\nconst Observing: unique symbol = Symbol('Observing');\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\ninterface Observable { [Observer]?: Observer | null }\ninterface Observed { [Observing]?: Observing }\n\n/**\n * Fetch the dispatch bundle attached to an object.\n * - returns the bundle if active\n * - returns `null` if the subject has been terminated\n * - returns `undefined` if the subject was never observable\n *\n * With `create: true`, attaches a fresh bundle iff the slot is undefined.\n * A terminated (null) slot is not resurrected.\n */\nfunction observer(state: object, create: true): Observer;\nfunction observer(state: object, create?: boolean): Observer | undefined | null;\nfunction observer(state: object, create?: boolean) {\n  const o = (state as Observable)[Observer];\n\n  if (!o && create) {\n    if (o === null)\n      throw new Error('Object is not observable (terminated).');\n\n    const value: Observer = {\n      listeners: new Map(),\n      pending: new Set(),\n      events: new Set()\n    };\n    Object.defineProperty(state, Observer, { value, writable: true });\n    return value;\n  }\n\n  return o;\n}\n\nfunction observe<T extends object>(\n  object: T,\n  callback: Observer.Callback,\n  required?: boolean\n): T {\n  const watching = new Set<Observer.Signal>();\n\n  const release = listener(object, (key) => {\n    if (watching.has(key)) return callback();\n  });\n\n  if (EffectContext)\n    EffectContext.add((update) => {\n      if (update !== true) release();\n    });\n\n  const proxy = Object.create(object) as T;\n\n  return Object.defineProperty(proxy, Observing, {\n    value: { callback, watching, required } as Observing\n  });\n}\n\nfunction touch(from: object, key: any): void;\nfunction touch<T>(from: object, key: any, value?: T): T;\nfunction touch(from: object, key: any, value?: any) {\n  const active = (from as Observed)[Observing];\n\n  if (active) {\n    if (value === undefined && arguments.length === 3 && active.required)\n      throw new Error(\n        `${Object.getPrototypeOf(from)}.${String(key)} is required in this context.`\n      );\n\n    active.watching.add(key);\n\n    if (value instanceof Object && observer(value))\n      return observe(value, active.callback, active.required);\n  }\n\n  return value;\n}\n\nfunction listener<T extends object>(\n  subject: T,\n  callback: Observer.Notify,\n  select?: Observer.Signal | Set<Observer.Signal>\n) {\n  const o = observer(subject, true);\n\n  if (select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if (o.ready && !select) callback(true);\n\n  o.listeners.set(callback, select);\n\n  return () => o.listeners.delete(callback);\n}\n\nconst EMPTY = Object.assign([], {\n  then: Promise.prototype.then.bind(Promise.resolve([]))\n} as PromiseLike<never[]>);\n\nfunction pending<K extends Observer.Event>(\n  state: object\n): K[] & PromiseLike<K[]> {\n  const o = observer(state);\n  if (!o?.events.size) return EMPTY;\n\n  const current = o.events as Set<K>;\n  const promise = new Promise<K[]>((res) => {\n    const callback: Observer.Notify = () => {\n      o.listeners.delete(callback);\n      return () => res([...current]);\n    };\n    o.listeners.set(callback, undefined);\n  });\n\n  return Object.assign([...current], {\n    then: promise.then.bind(promise)\n  });\n}\n\nfunction event(state: object, key?: Observer.Event | null, silent?: boolean) {\n  const o = observer(state, key === undefined);\n\n  if (!o) return;\n\n  if (key === null) {\n    (state as Observable)[Observer] = null;\n    return emit(o, key);\n  }\n\n  if (key === undefined) return emit(o, true);\n\n  if (!o.events.size && !silent)\n    enqueue(() => {\n      emit(o, false);\n      o.events = new Set();\n    });\n\n  o.events.add(key);\n\n  if (!silent) emit(o, key);\n}\n\nfunction emit(o: Observer, key: Observer.Signal): void {\n  const { listeners, pending, ready } = o;\n\n  if (key === ready) return;\n\n  if (pending.size) {\n    pending.add(key);\n    return;\n  }\n\n  if (!ready) pending.add(true);\n\n  pending.add(key);\n\n  for (const k of pending)\n    for (const [callback, filter] of listeners)\n      if (!filter || filter.has(k)) {\n        const after = callback(k);\n        if (after === null) listeners.delete(callback);\n        else if (after) enqueue(after);\n      }\n\n  if (key === null) listeners.clear();\n  else if (key === true) o.ready = true;\n\n  pending.clear();\n}\n\nfunction enqueue(eventHandler: () => void) {\n  if (!DISPATCH.size)\n    queueMicrotask(() => {\n      DISPATCH.forEach((event) => {\n        try {\n          event();\n        } catch (err) {\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    });\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n *\n * @param target - Instance of State to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction watch<T extends object>(\n  target: T,\n  callback: Observer.Effect<Required<T>>,\n  requireValues: true\n): () => void;\n\nfunction watch<T extends object>(\n  target: T,\n  callback: Observer.Effect<T>,\n  recursive?: boolean\n): () => void;\n\nfunction watch<T extends object>(\n  target: T,\n  callback: Observer.Effect<T>,\n  argument?: boolean\n) {\n  const o = observer(target, true);\n  let events: readonly Observer.Event[] = [];\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n  let previous: T | undefined;\n\n  function invoke() {\n    if (observer(target) === null) return;\n\n    let ignore: boolean = true;\n\n    function onUpdate() {\n      events = [...o.events];\n\n      if (reset === null) return null;\n      if (ignore) return;\n\n      ignore = true;\n\n      unset!(true);\n      unset = undefined;\n\n      enqueue(invoke);\n    }\n\n    function run(release?: (update?: boolean | null) => void) {\n      const proxy = observe(target, onUpdate, argument === true);\n      const output = callback.call(proxy, proxy, events);\n\n      if (previous && argument === false) {\n        const { watching } = (proxy as Observed)[Observing]!;\n        if (!watching.size)\n          (previous as Observed)[Observing]!.watching.forEach((k) => watching.add(k));\n      }\n      \n      previous = proxy;\n      ignore = false;\n      reset = output === null ? null : invoke;\n      unset = (key) => {\n        if (typeof output == 'function') output(key);\n        if (release) release(key);\n      };\n\n      events = [];\n    }\n\n    try {\n      if (argument !== false) capture(run);\n      else run();\n    } catch (err) {\n      if (err instanceof Promise) {\n        reset = undefined;\n        err.then(invoke);\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  const unlisten = listener(target, (key) => {\n    if (key === true) invoke();\n    else if (!reset) return reset;\n\n    if (key === null && unset) unset(null);\n  });\n\n  function cleanup() {\n    if (unset) unset(false);\n\n    reset = null;\n    unlisten();\n  }\n\n  if (EffectContext && argument !== false) EffectContext.add(cleanup);\n\n  return cleanup;\n}\n\nlet EffectContext: Set<(update?: boolean | null) => void> | undefined;\n\nfunction capture(scope: (release: (update?: boolean | null) => void) => void) {\n  const parent = EffectContext;\n  const context = (EffectContext = new Set());\n\n  try {\n    scope((update) => context.forEach((fn) => fn(update)));\n  } finally {\n    EffectContext = parent;\n  }\n}\n\nexport {\n  listener,\n  event,\n  Observer,\n  touch,\n  pending,\n  observer,\n  watch,\n  capture\n};\n"],"mappings":"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"}