@spinjs/components 0.1.0-preview.2 → 0.2.0-alpha.1

package/dist/runtime/aria.js

@@ -0,0 +1,193 @@
+// src/runtime/aria.ts
+/** The id an ARIA relation points at. */
+function targetId(scope, target) {
+	if (target === void 0) return void 0;
+	if ("id" in target) return target.id;
+	if ("parts" in target) {
+		const ids = target.parts.map((ref) => scope.id(ref.part, ref.slot));
+		return ids.length > 0 ? ids.join(" ") : void 0;
+	}
+	return scope.id(target.part, target.slot);
+}
+/**
+* A part the user cannot act on.
+*
+* The state is stated rather than implied: the part is still in the page,
+* and a reader has to hear that it is unavailable.
+*/
+function ariaDisabled(state) {
+	return { "aria-disabled": state };
+}
+/** A part that is not in the page for a reader. */
+function ariaHidden(state) {
+	return { "aria-hidden": state };
+}
+/** A part whose value is not valid. */
+function ariaInvalid(state) {
+	return { "aria-invalid": state };
+}
+/** A toggle that is held down. */
+function ariaPressed(state) {
+	return { "aria-pressed": state };
+}
+/** A part that is still working. */
+function ariaBusy(state) {
+	return { "aria-busy": state };
+}
+/** Where a part stands within a set. */
+function ariaCurrent(place) {
+	return { "aria-current": place };
+}
+/** The direction a region reads in. */
+function ariaOrientation(dir) {
+	return { "aria-orientation": dir };
+}
+/** The name a part gives itself beyond its role. */
+function ariaRoleDescription(text) {
+	return { "aria-roledescription": text };
+}
+/** A description of a part that no element owns. */
+function ariaDescription(text) {
+	return { "aria-description": text };
+}
+/** How a combobox completes what is typed into it. */
+function ariaAutocomplete(mode) {
+	return { "aria-autocomplete": mode };
+}
+/**
+* A prop's truth, as an ARIA state.
+*
+* The corpus states a boolean prop as its own truth: a prop that is absent
+* or false says nothing, so the attribute is not written at all, and a
+* prop that is true states the state.
+*/
+function ariaFlag(value) {
+	return value ? true : void 0;
+}
+/**
+* A prop's value, as an ARIA state.
+*
+* A boolean prop is the state it is: a prop that is false states "false",
+* and a prop that is absent states nothing at all.
+*/
+function ariaState(value) {
+	if (typeof value === "boolean") return value;
+	if (value === "true") return "true";
+	if (value === "false") return "false";
+}
+/** Whether a part must be filled in. */
+function ariaRequired(state) {
+	return { "aria-required": state };
+}
+/** Whether a part refuses edits. */
+function ariaReadOnly(state) {
+	return { "aria-readonly": state };
+}
+/** The element that describes a part. */
+function ariaDescribedBy(scope, target) {
+	return { "aria-describedby": targetId(scope, target) };
+}
+/** The element that names a part. */
+function ariaLabelledBy(scope, target) {
+	return { "aria-labelledby": targetId(scope, target) };
+}
+/** The region a part controls. */
+function ariaControls(scope, target) {
+	return { "aria-controls": targetId(scope, target) };
+}
+/** The elements a part owns. */
+function ariaOwns(scope, target) {
+	return { "aria-owns": targetId(scope, target) };
+}
+/**
+* A region that announces itself.
+*
+* The region says how loudly it speaks, whether it speaks as a whole, and
+* which of its changes are worth speaking of.
+*/
+function liveRegion(init) {
+	return {
+		..."live" in init ? { "aria-live": init.live } : {},
+		..."atomic" in init ? { "aria-atomic": init.atomic } : {},
+		..."relevant" in init ? { "aria-relevant": init.relevant } : {}
+	};
+}
+/**
+* A control that opens a region.
+*
+* The trigger says whether the region is open, what kind of popup it
+* opens, and which region that is. A trigger that opens no region states
+* no `aria-controls`, and a part that is not a trigger at all states
+* neither.
+*/
+function disclosureTrigger(scope, init) {
+	return {
+		..."expanded" in init ? { "aria-expanded": init.expanded } : {},
+		..."hasPopup" in init ? { "aria-haspopup": init.hasPopup } : {},
+		..."controls" in init ? { "aria-controls": targetId(scope, init.controls) } : {}
+	};
+}
+/**
+* A surface that holds rows.
+*
+* The surface says what names it, which row is the active descendant, and
+* the selection states it carries.
+*/
+function listSurface(scope, init) {
+	return {
+		..."labelledBy" in init ? { "aria-labelledby": targetId(scope, init.labelledBy) } : {},
+		..."activeDescendant" in init ? { "aria-activedescendant": targetId(scope, init.activeDescendant) } : {},
+		..."multiSelectable" in init ? { "aria-multiselectable": init.multiSelectable } : {},
+		..."required" in init ? { "aria-required": init.required } : {},
+		..."readOnly" in init ? { "aria-readonly": init.readOnly } : {}
+	};
+}
+/**
+* A field that completes what is typed into it.
+*
+* The field says how it completes, which region it controls, whether that
+* region is open, and which row it is on.
+*/
+function comboboxInput(scope, init) {
+	return {
+		..."autocomplete" in init ? ariaAutocomplete(init.autocomplete) : {},
+		..."controls" in init ? { "aria-controls": targetId(scope, init.controls) } : {},
+		..."expanded" in init ? { "aria-expanded": init.expanded } : {},
+		..."activeDescendant" in init ? { "aria-activedescendant": targetId(scope, init.activeDescendant) } : {}
+	};
+}
+/**
+* A handle that rides a range.
+*
+* The thumb says the range it rides and where it sits in it; `text` is
+* what a reader hears, which the number alone does not say.
+*/
+function sliderThumb(init) {
+	return {
+		..."min" in init ? { "aria-valuemin": init.min } : {},
+		..."max" in init ? { "aria-valuemax": init.max } : {},
+		..."now" in init ? { "aria-valuenow": init.now } : {},
+		..."text" in init ? { "aria-valuetext": init.text } : {}
+	};
+}
+/**
+* A row inside a set.
+*
+* A row is either selected or checked, never both: `selected` says the
+* row is the chosen one, `checked` says the row carries a state of its
+* own. `posInSet` and `setSize` place the row in the set it belongs to,
+* and `level` places it in the hierarchy it belongs to.
+*/
+function optionRow(init) {
+	return {
+		..."selected" in init ? { "aria-selected": init.selected } : {},
+		..."checked" in init ? { "aria-checked": init.checked } : {},
+		..."posInSet" in init ? { "aria-posinset": init.posInSet } : {},
+		..."setSize" in init ? { "aria-setsize": init.setSize } : {},
+		..."level" in init ? { "aria-level": init.level } : {},
+		..."disabled" in init ? ariaDisabled(init.disabled) : {}
+	};
+}
+export { ariaAutocomplete, ariaBusy, ariaControls, ariaCurrent, ariaDescribedBy, ariaDescription, ariaDisabled, ariaFlag, ariaHidden, ariaInvalid, ariaLabelledBy, ariaOrientation, ariaOwns, ariaPressed, ariaReadOnly, ariaRequired, ariaRoleDescription, ariaState, comboboxInput, disclosureTrigger, listSurface, liveRegion, optionRow, sliderThumb };
+
+//# sourceMappingURL=aria.js.map

package/dist/runtime/component/define.d.ts

@@ -0,0 +1,242 @@
+/** The component definition: everything a component author writes besides
+ * the machine and the markup.
+ *
+ * The machine owns state. The markup owns structure. This file owns the
+ * narrow seam between them: which props exist and how they parse, which
+ * parts exist and which attributes each carries as a function of live
+ * state, which node reflexes report back in as events, which authored
+ * channels stay controlled, and which transitions report out.
+ *
+ * Nothing here is logic over state — every function reads, none decides.
+ * The framework synthesizes the bridge and the connect from this; no
+ * hand-written `getXProps()` exists for any component. */
+import { EventMap, EventUnion, Machine } from "@spinjs/components/fsm";
+export interface ParseHost {
+  /** The element root: behavioral host props (sanitize, validate,
+   * translations) live as element properties, not scope props. */
+  readonly root: () => Element;
+}
+export type PropParser = (raw: unknown, host?: ParseHost) => unknown;
+/** What a part bag reads. All live — the framework calls this per tick
+ * and memoizes on the returned signature. */
+export type AnyEvent = {
+  readonly type: string;
+} & Record<string, unknown>;
+export interface PartView<R = unknown, C extends object = Record<string, unknown>, P = Record<string, unknown>, Ev = AnyEvent, S extends string = string> {
+  readonly props: P;
+  readonly context: C;
+  readonly state: S;
+  readonly root: () => Element;
+  readonly id: (part: string, slot?: unknown) => string;
+  readonly measure: (part: string, slot?: unknown) => DOMRect | null;
+  send(event: Ev): void;
+  readonly attr: (value: boolean) => string | undefined;
+  readonly slot: R;
+}
+export type ViewFor<C extends object, E extends EventMap = Record<string, Record<string, unknown>>, S extends string = string, P = Record<string, unknown>> = PartView<unknown, C, P, EventUnion<E>, S>;
+export interface PartDef<R = unknown, C extends object = Record<string, unknown>, P = Record<string, unknown>, Ev = AnyEvent, S extends string = string> {
+  /** The id segment when it differs from the part key (`value-text` for
+   * the `valueText` method family). Default: the key. */
+  readonly id?: string;
+  /** The bag: attributes, aria, node reflexes (`onLoad`, `use:observe`).
+   * Keys are bag entries; values may read the scope. Receives the recipe's
+   * argument when the part takes one (`getTriggerProps({ focusable })`).
+   *
+   * The bag rebuilds when the scope's fields it read move: the reads are
+   * recorded, so a dependency is never named by hand. Optional when the
+   * part carries only its auto-stamped `id`, `data-scope`, and `data-part`. */
+  attrs?(view: PartView<R, C, P, Ev, S>, arg?: unknown): Record<string, unknown>;
+}
+/** What a slotted bag reads: the part view plus the slot. Slots are
+ * stable identities (a thumb index, a row key). */
+export interface SlotView<R = unknown, C extends object = Record<string, unknown>, P = Record<string, unknown>, Ev = AnyEvent, S extends string = string> extends PartView<R, C, P, Ev, S> {}
+export type SlotViewFor<R, C extends object, E extends EventMap = Record<string, Record<string, unknown>>, S extends string = string, P = Record<string, unknown>> = SlotView<R, C, P, EventUnion<E>, S>;
+export interface SlotDef<R = unknown, C extends object = Record<string, unknown>, P = Record<string, unknown>, Ev = AnyEvent, S extends string = string> {
+  /** The id segment when it differs from the slot key. Default: the key. */
+  readonly id?: string;
+  /** Whether the framework stamps `id`, `data-scope`, and `data-part` onto
+   * the slot's bag before `attrs(scope)`. Default `true`; set `false` for
+   * form controls like hidden inputs that omit scope/part attributes. */
+  readonly stamp?: boolean;
+  /** The slot identities, for the recipe's iteration: rows, blocks, thumb
+   * indexes. Receives parsed props: the collection lives there. */
+  readonly indexes: (context: C, props: Record<string, unknown>) => readonly unknown[];
+  attrs(view: SlotView<R, C, P, Ev, S>, arg?: unknown): Record<string, unknown>;
+}
+export interface ReaderDef<C extends object = Record<string, unknown>, R = unknown, S extends string = string> {
+  /** A state projection: live context + state + parsed props (the
+   * collection lives in props, rows never enter the machine) + the root
+   * (a fieldset's disabled state disables the control, and only the root
+   * knows its ancestors). */
+  read(context: C, state: S, props: Record<string, unknown>, root?: () => Element): R;
+}
+/**
+ * The machine a component consumes: a factory over the machine's OWN
+ * arguments.
+ */
+export type MachineFactory<C extends object, E extends EventMap, A = unknown, S extends string = string> = (args: A, authored: (name: string) => boolean) => Machine<C, E, S>;
+export interface MethodDef<C extends object = Record<string, unknown>, R = unknown, A extends readonly unknown[] = readonly unknown[], S extends string = string> {
+  /** An indexed read (`getThumbValue(index)`): live context + state + args
+   * + parsed props + part ids. */
+  call(context: C, state: S, args: A, props: Record<string, unknown>, id: (part: string, slot?: unknown) => string): R;
+}
+export type CommandDef<A extends readonly unknown[] = readonly unknown[], C extends object = Record<string, unknown>, E extends EventMap = Record<string, object>> = {
+  /** A sending command: name + event from args, live context, and part
+   * ids. */
+  event(args: A, context: C, id: (part: string, slot?: unknown) => string): EventUnion<E>;
+  readonly view?: undefined;
+} | {
+  /** A view-only command (node focus with no machine move): the api
+   * method runs this with the part ids instead of sending. */
+  readonly event?: undefined;
+  view(args: {
+    readonly args: A;
+    readonly id: (part: string, slot?: unknown) => string;
+    readonly focus: (part: string, slot?: unknown) => void;
+    readonly measure: (part: string, slot?: unknown) => DOMRect | null;
+    readonly root: () => Element;
+  }): void;
+};
+export interface EventDef<W extends readonly unknown[] = readonly unknown[], C extends object = Record<string, unknown>, S extends string = string> {
+  /** The callback prop name on the props surface (the def maps it to a CustomEvent). */
+  readonly prop: string;
+  /** Values the framework snapshots per notify; a change fires the event. */
+  watch(context: C, state: S): readonly unknown[];
+  /** Maps the changed values to the event detail. Receives the triggering
+   * lives in props, so row-resolving details read it here), and the live
+   * context — the watch carries ONLY the fire condition; current values for
+   * the payload come from here, so an unrelated move never reports. */
+  detail(watched: W, event?: {
+    readonly type: string;
+  }, props?: Record<string, unknown>, context?: C): Record<string, unknown>;
+  /** Which sends fire this event: every move, or commits (release +
+   * keyboard commit) only. Default `"move"`. */
+  readonly on?: "move" | "commit";
+  /** Event-gated reports (the `invokeOnSelect` rule): evaluated per send with
+   * the before/after contexts; a null return reports nothing (a guard the
+   * machine refused). When present, `watch` still advances the cursor. */
+  readonly select?: (event: {
+    readonly type: string;
+  } & Record<string, unknown>, before: C, after: C, states?: {
+    readonly was: string;
+    readonly is: string;
+  }, source?: string) => Record<string, unknown> | readonly Record<string, unknown>[] | null;
+}
+export interface ComponentDef<C extends object, E extends EventMap, P = Record<string, unknown>, A = unknown, S extends string = string, Methods = Record<string, MethodDef<C, unknown, readonly unknown[], S>>, Readers = Record<string, ReaderDef<C, unknown, S>>> {
+  readonly name: string;
+  /** The start state, or its computation from parsed props. */
+  readonly start?: S | ((props: Record<string, unknown>, authored: (name: string) => boolean) => S);
+  /** Events sent once after start. */
+  readonly establish?: (props: Record<string, unknown>, authored: (name: string) => boolean) => readonly ({
+    type: string;
+  } & Record<string, unknown>)[];
+  /** Derived context sync inside the owned effect. Runs as `refresh` → `applyContract` → `reconcile` → `settled`: live functions that must stay fresh sync through `scalarsOf`, and post-mount unauthored prop writes never reach context (author config at mount). */
+  readonly reconcile?: (args: {
+    readonly context: C;
+    readonly state: S;
+    readonly parsed: Record<string, unknown>;
+    readonly authored: (name: string) => boolean;
+    readonly send: (event: {
+      type: string;
+    } & Record<string, unknown>) => void;
+  }) => boolean;
+  /** Event enrichment pre-send. */
+  readonly dispatch?: (event: {
+    type: string;
+  } & Record<string, unknown>, props: Record<string, unknown>) => {
+    type: string;
+  } & Record<string, unknown>;
+  /** Once, after the first connect build: entry focus and mount reflexes. Receives props only, so mount-time gates like pin-input autoFocus stay props reads intentionally. */
+  readonly mounted?: (args: {
+    readonly props: Record<string, unknown>;
+    readonly root: () => Element;
+    readonly id: (part: string, slot?: unknown) => string;
+    readonly focus: (part: string, slot?: unknown) => void;
+    readonly measure: (part: string, slot?: unknown) => DOMRect | null;
+  }) => void;
+  /** Post-send view reflexes: the `settled` step of the refresh → applyContract → reconcile → settled pipeline. */
+  readonly settled?: (args: {
+    readonly event: AnyEvent;
+    readonly before: {
+      readonly context: C;
+      readonly state: S;
+    };
+    readonly after: {
+      readonly context: C;
+      readonly state: S;
+    };
+    readonly props: Record<string, unknown>;
+    readonly root: () => Element;
+    readonly id: (part: string, slot?: unknown) => string;
+    readonly focus: (part: string, slot?: unknown) => void;
+    readonly measure: (part: string, slot?: unknown) => DOMRect | null;
+    readonly send: (event: AnyEvent) => void;
+  }) => void;
+  /** Static scalar field names: host writes to these merge into context without an event. */
+  readonly scalars?: readonly string[];
+  /** Live scalar values: functions that must stay fresh (async-list load/sortFn) sync through here every effect run. */
+  readonly scalarsOf?: (parsed: Record<string, unknown>, authored: (name: string) => boolean) => Record<string, unknown>;
+  /** Names the commit-kind sends: those report `commit` events, all others report `move`. */
+  readonly commitEvents?: readonly (EventUnion<E>["type"] | (string & {}))[];
+  readonly machine?: MachineFactory<C, E, A, S>;
+  readonly args?: (props: P) => A;
+  readonly parts: Record<string, PartDef<unknown, C, P, EventUnion<E>, S>>;
+  readonly slots?: Record<string, SlotDef<never, C, P, EventUnion<E>, S>>;
+  readonly commands: Record<string, CommandDef<readonly unknown[], C, E>>;
+  readonly methods?: Methods;
+  readonly readers?: Readers;
+  readonly events: Record<string, EventDef<readonly unknown[], C, S>>;
+}
+/** A reader entry's value type, or never when the entry is not a reader. */
+export type ReaderValue<T> = T extends {
+  read(...args: never[]): infer R;
+} ? R : never;
+/** A method entry's api surface: infers tuple parameters from `call`'s
+ * `args` parameter when declared, or `() => R` for 0-arg methods. */
+export type MethodValue<T> = T extends {
+  call: (context: never, state?: never) => infer R;
+} ? () => R : T extends {
+  call: (context: never, state: never, args: infer A extends readonly unknown[], ...rest: never[]) => infer R;
+} ? (...args: A) => R : never;
+/** A command entry's callable surface: infers tuple parameters from
+ * `event(args: A, ...)` when declared, or `() => void` for 0-arg commands. */
+export type CommandFn<T> = T extends {
+  event: () => unknown;
+} | {
+  view: () => unknown;
+} ? () => void : T extends {
+  event: (args: infer A extends readonly unknown[], ...rest: never[]) => unknown;
+} ? (...args: A) => void : T extends {
+  view: (args: infer V) => unknown;
+} ? V extends {
+  readonly args: infer A extends readonly unknown[];
+} ? (...args: A) => void : () => void : never;
+/** A slot entry's `getXProps` surface: infers the slot parameter type `R`. */
+export type SlotPropsFn<T> = T extends {
+  attrs: (view: SlotView<infer R, never, never, never, never>, ...args: never[]) => unknown;
+} ? (slot: R) => Record<string, unknown> : (slot: unknown) => Record<string, unknown>;
+/** The state union a component's machine declares, or `string` when untyped. */
+export type StateOf<D> = D extends {
+  readonly machine?: (...args: never[]) => {
+    readonly initialState: {
+      readonly value: infer S extends string;
+    };
+  };
+} ? S : string;
+/** The api a component's def implies. */
+export type ApiOf<D extends {
+  readonly readers?: Record<string, unknown>;
+  readonly methods?: Record<string, unknown>;
+  readonly commands?: Record<string, unknown>;
+  readonly parts?: Record<string, unknown>;
+  readonly slots?: Record<string, unknown>;
+}> = { readonly [K in keyof D["readers"] & string as D["readers"] extends Record<K, unknown> ? K : never]: D["readers"] extends Record<K, infer T> ? ReaderValue<T> : never; } & { readonly [K in keyof D["methods"] & string as D["methods"] extends Record<K, unknown> ? K : never]: D["methods"] extends Record<K, infer T> ? MethodValue<T> : never; } & { readonly [K in keyof D["commands"] & string]: D["commands"] extends Record<K, infer T> ? CommandFn<T> : never; } & { readonly [K in keyof NonNullable<D["parts"]> & string as `get${Capitalize<K>}Props`]: (slot?: unknown) => Record<string, unknown>; } & { readonly [K in keyof NonNullable<D["slots"]> & string as `get${Capitalize<K>}Indexes`]: NonNullable<D["slots"]> extends Record<K, infer T> ? T extends {
+  indexes(...args: never[]): readonly (infer E)[];
+} ? () => readonly E[] : () => readonly unknown[] : () => readonly unknown[]; } & { readonly [K in keyof NonNullable<D["slots"]> & string as `get${Capitalize<K>}Props`]: NonNullable<D["slots"]> extends Record<K, infer T> ? SlotPropsFn<T> : (slot: unknown) => Record<string, unknown>; } & {
+  /** The machine's mode, live: the framework's own reader. */
+  readonly state: StateOf<D>;
+};
+/** Present (`""`) when the condition holds and absent (`undefined`) otherwise. */
+export declare function dataAttr(value: boolean): string | undefined;
+/** True when a keystroke is part of an active IME composition session. */
+export declare function isComposing(event: KeyboardEvent): boolean;

package/dist/runtime/component/define.js

@@ -0,0 +1,12 @@
+// src/runtime/component/define.ts
+/** Present (`""`) when the condition holds and absent (`undefined`) otherwise. */
+function dataAttr(value) {
+	return value ? "" : void 0;
+}
+/** True when a keystroke is part of an active IME composition session. */
+function isComposing(event) {
+	return event.isComposing === true || event.keyCode === 229;
+}
+export { dataAttr, isComposing };
+
+//# sourceMappingURL=define.js.map

package/dist/runtime/component/ids.d.ts

@@ -0,0 +1,14 @@
+/** Namespaced element ids: `<name>:<element-id>:<part>[:<slot>]`.
+ *
+ * One factory per connect replaces the hand-written id template strings.
+ * Ids are stable per element instance; slot ids take the slot index. */
+export type IdFn = (part: string, slot?: unknown) => string;
+/** Focus a part by id: a missing node is a no-op, never a throw (the
+ * element may not be in the document). */
+export declare function focuser(id: IdFn): (part: string, slot?: unknown) => void;
+/** Measure a part by id: a missing node reports null, never a throw (the
+ * element may not be in the document yet). Framework-core owned, so defs and
+ * bags read geometry through this instead of touching `document` directly;
+ * the node resolves through the same identity path `focuser` uses. */
+export declare function measurer(id: IdFn): (part: string, slot?: unknown) => DOMRect | null;
+export declare function ids(name: string, id: string): IdFn;

package/dist/runtime/component/ids.js

@@ -0,0 +1,35 @@
+// src/runtime/component/ids.ts
+/** Focus a part by id: a missing node is a no-op, never a throw (the
+* element may not be in the document). */
+function focuser(id) {
+	return (part, slot) => {
+		if (typeof document === "undefined") return;
+		document.getElementById(id(part, slot))?.focus({ preventScroll: true });
+	};
+}
+/** Measure a part by id: a missing node reports null, never a throw (the
+* element may not be in the document yet). Framework-core owned, so defs and
+* bags read geometry through this instead of touching `document` directly;
+* the node resolves through the same identity path `focuser` uses. */
+function measurer(id) {
+	return (part, slot) => {
+		if (typeof document === "undefined") return null;
+		const node = document.getElementById(id(part, slot));
+		if (!(node instanceof Element)) return null;
+		try {
+			return node.getBoundingClientRect();
+		} catch {
+			return null;
+		}
+	};
+}
+function ids(name, id) {
+	const root = id.startsWith(`${name}:`) ? id : `${name}:${id}`;
+	return (part, slot) => {
+		if (part === "") return root;
+		return slot === void 0 || slot === null ? `${root}:${part}` : `${root}:${part}:${String(slot)}`;
+	};
+}
+export { focuser, ids, measurer };
+
+//# sourceMappingURL=ids.js.map

package/dist/runtime/component/synthesize.d.ts

@@ -0,0 +1,32 @@
+import { EventMap } from "../machine/fsm/machine.js";
+import { ApiOf, ComponentDef } from "./define.js";
+import { MachineDef } from "../index.js";
+/**
+ * The props the host actually wrote, as a predicate.
+ * Controlled components live on the authored/written split: a host that
+ * writes `value` owns it, and the element marks the write so the bridge can
+ * tell a live prop from a coerced default.
+ */
+export declare function authoredProps(props: () => Record<string, unknown>): (name: string) => boolean;
+/** A callback prop, when the host wrote a function for it. */
+export declare function pickCallback<T>(props: Record<string, unknown>, name: string): T | undefined;
+/** A text prop, or empty when the host wrote anything else. */
+export declare function textProp(raw: unknown): string;
+export type DefinedComponent<Api extends object, A = unknown> = ((args?: A) => Api) & Omit<MachineDef, "createBridge"> & {
+  readonly name: string;
+  readonly fields: readonly string[];
+  readonly createBridge: (props: () => Record<string, unknown>, root: () => Element, id: string) => {
+    readonly api: Api;
+    dispose(): void;
+  };
+  readonly manifest: {
+    readonly parts: readonly string[];
+    readonly slots: readonly string[];
+    readonly readers: readonly string[];
+    readonly methods: readonly string[];
+    readonly commands: readonly string[];
+    readonly events: readonly string[];
+  };
+};
+export declare function defineComponent<const D extends ComponentDef<never, never, never, never, never, never, never>>(def: D): D extends ComponentDef<infer _C, infer _E, infer _P, infer A, infer _S, never, never> ? DefinedComponent<ApiOf<D>, A> : never;
+export declare function defineComponent<C extends object, E extends EventMap, Api extends object, A = unknown, S extends string = string>(def: ComponentDef<C, E, Record<string, unknown>, A, S>): DefinedComponent<Api, A>;