gesso-framework 0.1.0

package/dist/FunctionComponent-DAyf5HQ6.d.ts

@@ -0,0 +1,716 @@
+import { BehaviorSubject, Observable, Subject, Subscription } from "rxjs";
+import { LayoutBox, Reactive, UiChild, UiModifier } from "gesso-core";
+//#region src/Component.d.ts
+/**
+ * Base class for all Gesso framework components.
+ *
+ * Components are class-based. They declare reactive state with
+ * an `internalState()` cell, inputs with `@Input()`, and return a UiElement tree
+ * from `render()`. The framework calls `render()` once per mount;
+ * after that, observable emissions in the returned tree drive updates.
+ */
+declare abstract class Component {
+  /**
+   * Called once after the component's UiNode subtree has been created
+   * and all observable bindings are connected.
+   */
+  onMount?(): void;
+  /**
+   * Called once when the component is being removed from the graph.
+   */
+  onUnmount?(): void;
+  /**
+   * Returns the component's UI definition.
+   *
+   * Called exactly once per component instance. Dynamic content is
+   * expressed through Observable props and children, never by
+   * re-invoking render().
+   *
+   * Returning an Observable is allowed for structural changes that
+   * cannot be expressed as observable children (routing, for example).
+   * The framework reconciles the component's root on each emission.
+   */
+  abstract render(): UiChild;
+}
+//#endregion
+//#region src/InternalState.d.ts
+/**
+ * A component's own state: originated here, and never crossing the
+ * barrier.
+ *
+ * The writable counterpart to `InputCell`. The two are the same
+ * `BehaviorSubject` and differ by one accessor — this one has a
+ * `.value` setter — and that difference is the whole semantics:
+ *
+ *     internalState()   never crosses    I write it
+ *     input()           crosses inward   someone else writes it
+ *
+ * Named on that axis deliberately. It used to be `state()`, which
+ * described *what* a thing was while `input()` described *where it
+ * came from*; two names on two axes made neither of them tell you
+ * anything about the other. `internalState(products)` reads as a
+ * mistake at the call site in a way `state(products)` never did.
+ *
+ * For values that originate on this thread and die with the component:
+ * a tooltip's open flag, a caret, a scroll offset, the active tab.
+ * Anything that survives a reload, or that another screen cares about,
+ * is application state and belongs on a channel. Anything derived from
+ * other cells is a `computed`.
+ *
+ * It is not only for components. The thread that owns a channel's data
+ * writes cells too, and wrote them as a `BehaviorSubject` mirrored
+ * into an `asObservable()` because this was reachable only through the
+ * framework's main entry. `gesso-framework/worker` is the same cell
+ * with none of the renderer behind it, so an application worker holds
+ * one cell rather than a subject and a copy of it, and reads it with
+ * `.value` in a `computed` rather than listing it in a
+ * `combineLatest`. "Internal" still means what it says there: written
+ * here, and crossing the barrier only as the plain data a view key
+ * publishes.
+ */
+declare class InternalState<T> extends BehaviorSubject<T> {
+  /** What to call this cell in a warning or the inspector; optional. */
+  label: string | undefined;
+  constructor(initialValue: T);
+  get value(): T;
+  set value(next: T);
+}
+/**
+ * Creates a reactive state cell.
+ *
+ * Usage inside a component:
+ *
+ *   private readonly count = state(0);
+ *
+ *   increment() {
+ *     this.count.value++;
+ *   }
+ */
+declare function internalState<T>(initialValue: T, label?: string): InternalState<T>;
+//#endregion
+//#region src/Input.d.ts
+/**
+ * Reactive cell holding a component input.
+ *
+ * Inputs must be cells because render() runs exactly once. A component
+ * that read a plain input value during render would capture it for the
+ * life of the instance, so a parent supplying new props under a
+ * dynamic subtree would update the field while the rendered tree kept
+ * showing the original value.
+ *
+ * The cell is written by the component host only: it accepts whatever
+ * the parent passed, subscribing it first when the parent passed an
+ * Observable. `value` is deliberately read-only, so `this.label.value =
+ * x` inside a component is a compile error rather than a silent
+ * violation of the one-way data flow.
+ */
+declare class InputCell<T> extends BehaviorSubject<T> {
+  /**
+   * What to call this cell in a warning: `Component.prop`, or
+   * `channel.key`. Set by whoever creates it; a cell without one is
+   * reported as "a cell".
+   */
+  label: string | undefined;
+  /** The component whose body read `.value`, for the stale-read warning below. */
+  private snapshotBy;
+  private warnedStale;
+  /** Everything emitted through `emit`, created on the first `events` read. */
+  private emitted;
+  constructor(initialValue: T);
+  /**
+   * Fires the output this cell stands for.
+   *
+   * An output is a cell whose value is what the parent gave to be
+   * called: a function, or a target made by `into(subject)`. `emit`
+   * calls it with the arguments, and also pushes the first argument
+   * through `events`, so the component can fire from three places
+   * without passing the cell around and a parent that wants a stream
+   * can have one. A parent that passed nothing is fine: the call
+   * simply reaches nobody.
+   */
+  emit(...args: EmitArgs<T>): void;
+  /** What `emit` has fired, as a stream: the first argument of each call. */
+  get events(): Observable<EmitValue<T>>;
+  get value(): T;
+  /**
+   * The one place the run-once model goes quietly wrong is a body that
+   * reads `props.x.value`, uses the value to build the tree, and never
+   * hears that it changed. Nothing crashes; the screen is simply stale.
+   * So a cell remembers being read while a body ran, and if it later
+   * changes with nobody subscribed to it, it says so once. A cell that
+   * something is following is fine: the follower carries the change.
+   */
+  next(value: T): void;
+}
+/**
+ * Anything with a current value that can be followed: an input, an
+ * internal state, a channel view key, a computed. What `computed`
+ * collects as it runs.
+ */
+interface ReadableCell<T> extends Observable<T> {
+  readonly value: T;
+}
+/**
+ * Creates a component input cell.
+ *
+ * Inside a class component the argument is the default the cell holds
+ * until the parent supplies a value:
+ *
+ *   @Input() label = input('Count');
+ *
+ * Inside a functional component the props are already cells; the
+ * two-argument form derives a cell that replaces `undefined` with a
+ * fallback, which is how an optional prop gets its default:
+ *
+ *   function Counter(inputs: Inputs<{ label?: string }>) {
+ *     const label = input(inputs.label, 'Count');   // InputCell<string>
+ *     return Text({ text: label });
+ *   }
+ *
+ * The derived cell follows the source for the life of the component
+ * and completes when the source does, so it needs no teardown.
+ */
+declare function input<T>(initialValue: T): InputCell<T>;
+declare function input<T>(source: InputCell<T | undefined>, fallback: T): InputCell<T>;
+/** The arguments `emit` takes for a cell holding a handler of type `T`. */
+type EmitArgs<T> = NonNullable<T> extends ((...args: infer A) => void) ? A : never;
+/** What `events` carries for a cell holding a handler of type `T`: the handler's first argument. */
+type EmitValue<T> = NonNullable<T> extends ((first: infer V, ...rest: never[]) => void) ? V : void;
+/**
+ * A component's output: an input cell that holds whatever the parent
+ * gave to be called, fired through `emit`. Every function-typed member
+ * of a component's inputs is one, so on a component declared with
+ * `onOpen: (id: string) => void`, `inputs.onOpen.emit(id)` is how the
+ * component speaks, and a parent may pass a function or `into(subject)`.
+ * The name is for a class field: `@Output() changed = output<[number]>()`.
+ */
+type OutputCell<A extends unknown[]> = InputCell<((...args: A) => void) | undefined>;
+/**
+ * An output a class component declares as a field:
+ *
+ *   @Output() changed = output<[value: number]>();
+ *
+ * The host wires the parent's handler into it exactly as it wires an
+ * input, and `this.changed.emit(next)` fires it.
+ */
+declare function output<A extends unknown[]>(): OutputCell<A>;
+declare const OUTPUT_TARGET: unique symbol;
+/**
+ * A parent's way of receiving an output as a stream rather than a call:
+ *
+ *   const opened = new Subject<string>();
+ *   <Card onOpen={into(opened)} />
+ *
+ * Wrapped rather than passed bare, because a bare `Subject` is an
+ * Observable and would be read as an *input* the parent is feeding the
+ * child, which is the opposite direction.
+ */
+interface OutputTarget<V> {
+  readonly [OUTPUT_TARGET]: {
+    next(value: V): void;
+  };
+}
+declare function into<V>(target: {
+  next(value: V): void;
+}): OutputTarget<V>;
+declare function isOutputTarget(value: unknown): value is OutputTarget<unknown>;
+//#endregion
+//#region src/bounds.d.ts
+/**
+ * A node's box, as a cell.
+ *
+ * `ctx.bounds()` hands one out and the modifier on it fills it, so the
+ * arithmetic a pointer position needs starts from a value rather than
+ * from `new BehaviorSubject<LayoutBox>({ x: 0, y: 0, width: 0, height: 0 })`
+ * and a `measure(subject)` beside it. It is an ordinary cell: read it
+ * with `.value` in a handler, bind it, or derive from it.
+ *
+ *   const track = ctx.bounds();
+ *   <box modifiers={[track.modifier]} onPointerMove={e => at(e.x - track.value.x)} />
+ *
+ * **It reports a move, and only a move.** `measure` is built on
+ * `LayoutNotifier`, which fires for every layout fact a node's listeners
+ * could care about, and one of those is a scroll offset that changed
+ * while the box stayed exactly where it was. A
+ * cell that emitted for those would wake everything derived from it on
+ * every frame of every scroll, for a box that did not move, which is
+ * the defect this exists to avoid. So an equal box is dropped here,
+ * where the comparison is four numbers, rather than by a
+ * `distinctUntilChanged` at each of the places that read it.
+ *
+ * There is no `ctx.bounds(ref)`. A box is reported by a modifier, which
+ * is how a node is reached from outside the layout engine everywhere
+ * else in this framework, and a ref would be a second way of naming the
+ * same node with nothing else built on it.
+ */
+declare class BoundsCell extends InternalState<LayoutBox> {
+  /** Put this on the element whose box the cell should hold. */
+  readonly modifier: UiModifier<Subject<LayoutBox>>;
+  constructor();
+  /** Writes a box, unless it is the one already held. */
+  next(box: LayoutBox): void;
+}
+/**
+ * A bounds cell outside a component, for a class component or a test.
+ * Inside a function component `ctx.bounds()` is the same thing, and it
+ * completes with the component.
+ */
+declare function bounds(label?: string): BoundsCell;
+//#endregion
+//#region src/channel/ChannelToken.d.ts
+/**
+ * The barrier between the application and the view, declared once.
+ *
+ * A token is a name, a shape and an initial value — and no
+ * implementation at all. Both threads import it, which is the point:
+ * the module holding it has nothing in it to bundle, so an app's api
+ * client and domain logic never reach the render worker the way a
+ * shared `Store` class dragged them there.
+ *
+ * What the framework knows about a channel ends here. It diffs plain
+ * data and ships patches; where the observables came from — a single
+ * subject, or an api → repository → domain → view-model stack — is the
+ * application's business and the framework cannot tell the difference.
+ *
+ *   export interface CatalogView {
+ *     products: ProductRow[];
+ *     status: 'loading' | 'ready' | 'error';
+ *   }
+ *   export interface CatalogCommands {
+ *     addToCart(id: string): void;
+ *   }
+ *   export const Catalog = channel<CatalogView, CatalogCommands>('catalog', {
+ *     products: [],
+ *     status: 'loading'
+ *   });
+ */
+/**
+ * A command a component can send back across the barrier.
+ *
+ * The arguments are what cross: each is structured-cloned onto the
+ * owning thread, so they must be plain data. There may be as many as
+ * the command needs, which is why `move(from, to)` is written the way
+ * anyone would write it rather than as `move({ from, to })`; a command
+ * used to carry one payload and the second argument was dropped on the
+ * floor with a warning.
+ *
+ * Commands return nothing: the effect comes back as a patch, never as
+ * a return value, since there is no synchronous answer to be had
+ * across a thread.
+ */
+type Command = (...args: never[]) => void;
+/**
+ * The internal view of a command set: a bag of callables by name.
+ *
+ * Public signatures constrain to `object`, not to this. An application
+ * declares its commands as an ordinary interface —
+ * `interface CatalogCommands { addToCart(id: string): void }` — and an
+ * interface has no index signature, so it does not satisfy a
+ * `Record<string, …>` constraint however well it fits in spirit.
+ * Constraining to `object` accepts what people actually write; this
+ * alias is what the implementation casts to when it looks a command up
+ * by name.
+ */
+type CommandMap = Record<string, Command>;
+/** The declared barrier for one area of an application. */
+interface ChannelToken<View extends object, Commands extends object = Record<string, never>> {
+  readonly name: string;
+  /**
+   * What every view key holds before the first patch arrives.
+   *
+   * Required rather than optional, so the render thread never observes
+   * `undefined` for a declared key. A channel that is genuinely still
+   * loading says so in its own shape — a `status` field — rather than
+   * leaving the view to infer it from an absence.
+   */
+  readonly initial: View;
+  /** Phantom, carrying the command types to `send`. Never read. */
+  readonly commands?: Commands;
+}
+/**
+ * Declares a channel.
+ *
+ * The name identifies it across the thread boundary and must be
+ * stable; unlike a class name it survives minification, which is why
+ * it is written out rather than derived.
+ */
+declare function channel<View extends object, Commands extends object = Record<string, never>>(name: string, initial: View): ChannelToken<View, Commands>;
+/** A channel written as one object: the view with its values, and the commands. */
+interface ChannelSpec<View extends object, Commands extends object> {
+  /**
+   * Every view key with the value it holds before the first patch.
+   *
+   * The type of the channel's view is the type of this object, so the
+   * keys and their initial values are written once instead of in an
+   * interface and again in a literal that has to agree with it.
+   */
+  readonly view: View;
+  /**
+   * The commands, as a type rather than as implementations.
+   *
+   * Written `{} as { addToCart(id: string, quantity: number): void }`:
+   * the handlers live on the thread that owns the data and are passed
+   * to `provide`, so what belongs in the token is only their shape.
+   */
+  readonly commands?: Commands;
+}
+/**
+ * Declares a channel from one object.
+ *
+ *   export const Catalog = defineChannel('catalog', {
+ *     view: {
+ *       products: [] as readonly ProductRow[],
+ *       status: 'loading' as ShelfStatus
+ *     },
+ *     commands: {} as {
+ *       addToCart(id: string, quantity: number): void;
+ *       move(from: number, to: number): void;
+ *     }
+ *   });
+ *
+ *   export type CatalogView = ViewOf<typeof Catalog>;
+ *
+ * The same token `channel()` returns, declared once instead of three
+ * times. `channel<View, Commands>(name, initial)` wrote the view as an
+ * interface, then as an initial literal that had to agree with it, and
+ * a key added to one and forgotten in the other was a type error in a
+ * third file. Here the object is the type.
+ *
+ * A field whose initial value is narrower than the type it holds is
+ * given the type it holds: `[]` is `never[]` and `'loading'` is
+ * `string` unless it is said, which is what the `as` clauses above are
+ * for. `ViewOf` and `CommandsOf` name the resulting types wherever the
+ * application used to name its own interface.
+ *
+ * `channel()` is not deprecated and keeps working exactly as it did.
+ * An application with interfaces it wants to keep, because they are
+ * shared with something else or because the initial values are built
+ * elsewhere, has nothing to migrate.
+ */
+declare function defineChannel<View extends object, Commands extends object = Record<string, never>>(name: string, spec: ChannelSpec<View, Commands>): ChannelToken<View, Commands>;
+/** The view type of a channel token, for an application that wants to name it. */
+type ViewOf<T> = T extends ChannelToken<infer View, object> ? View : never;
+/** The command type of a channel token. */
+type CommandsOf<T> = T extends ChannelToken<object, infer Commands> ? Commands : never;
+/**
+ * The keys a channel publishes.
+ *
+ * Structural in its parameter rather than generic over the token, so
+ * it does not have to agree with any particular command type to read
+ * what is only ever the initial value's shape.
+ */
+declare function viewKeys(token: {
+  initial: object;
+}): string[];
+//#endregion
+//#region src/channel/StorePatch.d.ts
+type PatchPath = readonly (string | number)[];
+/**
+ * A change to one projection, as sent from a data worker to a replica.
+ *
+ * Paths are relative to the projection's root value, so a patch is
+ * self-contained: the replica never needs the previous value to apply
+ * one, only the value it already holds.
+ */
+type Patch = {
+  op: 'set';
+  projection: string;
+  path: PatchPath;
+  value: unknown;
+} | {
+  op: 'delete';
+  projection: string;
+  path: PatchPath;
+} | {
+  op: 'splice';
+  projection: string;
+  path: PatchPath;
+  index: number;
+  deleteCount: number;
+  items: readonly unknown[];
+};
+/**
+ * Describes how to turn `previous` into `current` for one projection.
+ *
+ * Returns an empty list when nothing changed, which is the common case
+ * and the reason this exists: the point of a projection is that most
+ * state changes do not alter it, and the ones that do usually alter a
+ * small part.
+ */
+declare function diffProjection(projection: string, previous: unknown, current: unknown): Patch[];
+/**
+ * Applies patches to a projection value, sharing structure with the
+ * original everywhere the patch did not reach.
+ *
+ * Nothing is mutated: bindings hold onto emitted values, so a replica
+ * that edited in place would change data a component already rendered.
+ */
+declare function applyPatches(root: unknown, patches: readonly Patch[]): unknown;
+declare function applyPatch(root: unknown, patch: Patch): unknown;
+//#endregion
+//#region src/channel/ChannelProtocol.d.ts
+/**
+ * A two-way channel endpoint. `MessagePort` satisfies it, as does a
+ * test double, so nothing in the channel layer depends on Worker.
+ */
+interface ChannelPort {
+  postMessage(message: unknown): void;
+  onmessage: ((event: {
+    data: unknown;
+  }) => void) | null;
+}
+/**
+ * Render thread → the thread that owns the channel.
+ *
+ * A command's first argument stayed `payload` when commands learned to
+ * take more than one, and the rest travel beside it. That is not
+ * tidiness: an older view talking to a newer application worker sends
+ * no `rest`, which reads as the one-argument call it is, and an older
+ * application worker ignores the field, which is exactly what it did
+ * before the field existed.
+ */
+type ChannelClientMessage = {
+  type: 'channel:sync';
+} | {
+  type: 'channel:command';
+  command: string;
+  payload: unknown;
+  rest?: unknown[];
+};
+/** The owning thread → render thread. */
+type ChannelHostMessage = {
+  type: 'channel:patch';
+  patches: Patch[];
+} | {
+  type: 'channel:error';
+  message: string;
+  stack?: string;
+};
+declare function isChannelClientMessage(value: unknown): value is ChannelClientMessage;
+declare function isChannelHostMessage(value: unknown): value is ChannelHostMessage;
+//#endregion
+//#region src/channel/ChannelReplica.d.ts
+/**
+ * The render thread's end of a channel.
+ *
+ * It runs none of the application's logic. It holds the latest value
+ * of each view key and forwards commands, and that asymmetry is the
+ * point — the work stays on the thread that owns the data.
+ *
+ * Every key is an `InputCell`: a component reads it, binds it, and
+ * cannot write it, which is the same contract a prop has. Whether a
+ * value arrived from a parent or from across the barrier makes no
+ * difference to the component that reads it, so it is not worth a
+ * second name.
+ */
+declare class ChannelReplica<View extends object, Commands extends object> {
+  private readonly token;
+  private readonly port;
+  private readonly cells;
+  private readonly commandProxy;
+  private errorListener;
+  private pending;
+  private scheduleFlush;
+  constructor(token: ChannelToken<View, Commands>, port: ChannelPort);
+  /** The view keys, each an `InputCell` to read or bind. */
+  get view(): { readonly [K in keyof View]: InputCell<View[K]>; };
+  /**
+   * The channel's commands, typed as declared.
+   *
+   * Fire and forget: the effect comes back as a patch, never a return
+   * value. There is no synchronous answer across a thread, and
+   * pretending otherwise would invite code that cannot work.
+   */
+  get send(): Commands;
+  private readonly viewProxy;
+  private createCommandProxy;
+  /** Receives errors reported by the thread that owns the channel. */
+  onError(listener: ((message: string, stack?: string) => void) | null): void;
+  private receive;
+  private report;
+  /**
+   * Defers patch application to the next frame.
+   *
+   * A chatty application thread can deliver many patches between two
+   * frames. Applied on arrival each one pushes a value through the
+   * bindings watching it, rebuilding a subtree once per patch when
+   * only the last state is ever drawn. Queued, a burst costs one pass.
+   */
+  deferPatches(scheduleFlush: () => void): void;
+  get hasPendingPatches(): boolean;
+  flush(): void;
+  /**
+   * Applies a batch, emitting once per affected key.
+   *
+   * Grouping matters: a batch touching one key three times must not
+   * push three values through the bindings watching it.
+   */
+  applyPatches(patches: readonly Patch[]): void;
+  private post;
+  dispose(): void;
+}
+//#endregion
+//#region src/FunctionComponent.d.ts
+/**
+ * What a functional component can ask of the framework while its body
+ * runs. It is the function's half of what `@Inject`, `onMount()` and
+ * `onUnmount()` give a class.
+ */
+interface ComponentContext {
+  /**
+   * The runtime service of this class: overlays, focus, find, the
+   * clipboard, media, animation.
+   *
+   * Services stay on this thread and are simply called. Application
+   * state comes through `channel` instead.
+   */
+  inject<S extends object>(ServiceClass: new () => S): S;
+  /**
+   * The channel declared by `token`: `view` keys to read or bind, and
+   * `send` to issue a command.
+   */
+  channel<V extends object, C extends object>(token: ChannelToken<V, C>): ChannelReplica<V, C>;
+  /**
+   * Runs once after the component's nodes exist and its bindings are
+   * connected. Must be called while the component function runs.
+   */
+  onMount(hook: () => void): void;
+  /**
+   * Runs once when the component leaves the tree, before its
+   * subscriptions are torn down. Must be called while the component
+   * function runs.
+   */
+  onUnmount(hook: () => void): void;
+  /**
+   * Follows a stream for as long as the component is in the tree.
+   *
+   * A component that has to *act* on a value rather than draw it,
+   * telling the audio element to load a track, asking a channel for the
+   * page a url names, writing a scroll offset somewhere, subscribes, and
+   * something has to unsubscribe. Every screen in both applications
+   * wrote that pair by hand, and one of them had grown a `Subscription`
+   * bag to hold four of them.
+   *
+   *   ctx.effect(queue.view.current, track => audio.load(track.stream));
+   *
+   * The subscription is the host's and is torn down with the component,
+   * after `onUnmount` has run, in the order the host tears down every
+   * subscription it opened on the component's behalf. It is handed back
+   * for the rare case that wants to stop early; nothing has to hold it.
+   *
+   * Unlike `onMount` and `onUnmount` this may be called after the body,
+   * from a callback the component registered, since what it registers
+   * is a teardown rather than a hook that has already been run past.
+   */
+  effect<T>(source: Observable<T>, run: (value: T) => void): Subscription;
+  /**
+   * A cell holding a node's box, with the modifier that fills it.
+   *
+   * Turning a pointer position into a fraction of a track, or a drag
+   * into a seek, starts with knowing where the element is, and until
+   * now that meant declaring `new BehaviorSubject<LayoutBox>` with a
+   * zero box in it and passing it to `measure`. This is that, named,
+   * and it drops a report of a box that has not moved.
+   *
+   *   const track = ctx.bounds();
+   *   <box modifiers={[track.modifier]} onPointerDown={e => seek(e.x - track.value.x)} />
+   */
+  bounds(label?: string): BoundsCell;
+}
+/**
+ * The inputs a functional component receives: one host-owned cell per
+ * declared member, and for a member typed as a function, an output.
+ *
+ * The parent supplies values or Observables; the host feeds them into
+ * these cells and keeps feeding them when the parent's values change,
+ * so the function can run exactly once, like a class `render()`, and
+ * still follow its parent. An output is fired with
+ * `inputs.onChange.emit(next)`, and a parent may pass a handler or
+ * `into(subject)` for it.
+ *
+ * Every declared input is a cell, whether or not the parent passed
+ * anything: the record hands one out on first access and the host keeps
+ * feeding it, so an optional input that was omitted is a live cell
+ * holding `undefined`, and it takes a value if the parent starts
+ * passing one. What it is *not* is a value, so binding it straight to a
+ * property writes `undefined` there and the property draws as though it
+ * had never been set. `input(inputs.name, fallback)` gives it a
+ * default, and `select(inputs.name, ...)` projects one.
+ * `Input.optional.spec.ts` is that case written down.
+ */
+type Inputs<P> = { readonly [K in keyof P]-?: InputCell<P[K]>; };
+/**
+ * A component written as a function.
+ *
+ *   function Counter(inputs: Inputs<{ label?: string }>, ctx: ComponentContext) {
+ *     const label = input(inputs.label, 'Count');
+ *     const count = state(0);
+ *     const store = ctx.inject(DemoStore);
+ *     return Row(Text({ text: label }), Button({ onClick: () => count.value++ }));
+ *   }
+ *
+ * The body is the component's `render()`: it runs once per instance,
+ * and everything dynamic in the returned tree is an Observable. Local
+ * state is `internalState()` cells created in the body.
+ */
+type FunctionComponent<P = {}> = (inputs: Inputs<P>, context: ComponentContext) => UiChild;
+type ClassComponent = new () => Component;
+/**
+ * Anything `createComponent` (and JSX) can mount. The function half is
+ * loose on purpose: a function's own `Inputs<P>` parameter is what
+ * `ComponentProps` reads its props from.
+ */
+type ComponentType = ClassComponent | ((inputs: any, context: ComponentContext) => UiChild);
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type CellValue<C> = C extends InputCell<infer T> ? T : never;
+/** The keys of a cell record whose value may be undefined; the parent may omit those. */
+type OptionalCellKeys<I> = { [K in keyof I]: undefined extends CellValue<I[K]> ? K : never; }[keyof I];
+/**
+ * The props a parent may pass for a record of input cells: each one a
+ * value or an Observable of it. A cell that admits `undefined` is
+ * optional; every other one is required.
+ */
+type PropsForCells<I> = [keyof I] extends [never] ? NoProps : { [K in OptionalCellKeys<I>]?: Passable<CellValue<I[K]>>; } & { [K in Exclude<keyof I, OptionalCellKeys<I>>]: Passable<CellValue<I[K]>>; };
+/**
+ * What a parent may pass for one cell: a value or an Observable of it,
+ * and for an output, the handler itself or an `into(subject)` target
+ * that receives what the child emits.
+ */
+type Passable<T> = NonNullable<T> extends ((first: infer V, ...rest: never[]) => void) ? Reactive<T> | OutputTarget<V> : Reactive<T>;
+/**
+ * A component that declares no props accepts none: `{}` passes, anything
+ * else is an excess property error. A bare `{}` type would accept
+ * anything, and an index signature would swallow JSX's `key`, so this
+ * is an object type with one optional phantom member that can never be
+ * set.
+ */
+type NoProps = {
+  readonly __noProps?: never;
+};
+/** The `input()` fields of a class component, as the props its parent may pass. */
+type InputFields<I> = { [K in keyof I as I[K] extends InputCell<any> ? K : never]: I[K]; };
+/**
+ * The props a parent passes to a component.
+ *
+ * For a class, its `@Input() x = input(default)` fields, all optional
+ * because each has a default. For a function, the cells of its first
+ * parameter. A misspelled prop is an excess property error; a prop
+ * whose cell holds a `string` rejects a `number` or an
+ * `Observable<number>`.
+ */
+type ComponentProps<C> = C extends ClassComponent ? Partial<PropsForCells<InputFields<InstanceType<C>>>> : C extends ((inputs: infer I, ...rest: any[]) => UiChild) ? IsAny<I> extends true ? Record<string, unknown> : unknown extends I ? NoProps : [I] extends [undefined] ? NoProps : PropsForCells<I> : never;
+type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K; }[keyof T];
+/**
+ * The trailing arguments of `createComponent`: props may be omitted
+ * only when the component requires none of them.
+ */
+type ComponentArgs<C> = RequiredKeys<ComponentProps<C>> extends never ? [inputs?: ComponentProps<C>, key?: string | number] : [inputs: ComponentProps<C>, key?: string | number];
+/**
+ * Whether a component is a class (extends Component) rather than a
+ * function. Arrow functions have no prototype; a plain function's
+ * prototype is not a Component.
+ */
+declare function isClassComponent(component: ComponentType): component is ClassComponent;
+//#endregion
+export { bounds as A, output as B, CommandMap as C, defineChannel as D, channel as E, OutputTarget as F, internalState as H, ReadableCell as I, input as L, EmitValue as M, InputCell as N, viewKeys as O, OutputCell as P, into as R, Command as S, ViewOf as T, Component as U, InternalState as V, applyPatch as _, ComponentType as a, ChannelSpec as b, isClassComponent as c, ChannelHostMessage as d, ChannelPort as f, PatchPath as g, Patch as h, ComponentProps as i, EmitArgs as j, BoundsCell as k, ChannelReplica as l, isChannelHostMessage as m, ComponentArgs as n, FunctionComponent as o, isChannelClientMessage as p, ComponentContext as r, Inputs as s, ClassComponent as t, ChannelClientMessage as u, applyPatches as v, CommandsOf as w, ChannelToken as x, diffProjection as y, isOutputTarget as z };
+//# sourceMappingURL=FunctionComponent-DAyf5HQ6.d.ts.map