@exponential-at/ui-solid 0.0.0-stage → 0.1.0

package/dist/types/context.d.ts

@@ -0,0 +1,74 @@
+import { type Accessor } from "solid-js";
+import type { ExtensionDef, Formatter, ModeName, ResolvedTheme, ScrollAlign, TemplateBudget, UiNode } from "@exponential-at/ui";
+import type { ClientFunction, CompiledTheme, DataModel, ResolveContext } from "@exponential-at/ui/web";
+import type { HostPlugin } from "./host.js";
+import type { SolidExtension } from "./extensions.js";
+export interface SurfaceContextValue {
+    readonly surfaceId: string;
+    readonly compiled: CompiledTheme;
+    /** The theme the surface runs with (density + contrast applied). */
+    readonly theme: ResolvedTheme;
+    /** The RESOLVED mode (`system` already followed). */
+    readonly mode: ModeName;
+    readonly host: HostPlugin;
+    readonly extensions: readonly SolidExtension[];
+    readonly extensionDefs: readonly ExtensionDef[];
+    readonly data: DataModel;
+    readonly setData: (pointer: string, value: unknown) => void;
+    /** A template component id → its node (the reducer's LIFTED `templates`). */
+    readonly templateNode: (componentId: string) => UiNode | undefined;
+    /** VAPP-152: node `id`'s current node, a signal of its own (undefined =
+     *  not in the surface's tree). */
+    readonly nodeCell?: (id: string) => (() => UiNode | undefined) | undefined;
+    /** VAPP-103: the template items counted against `maxTemplateItems`. */
+    readonly templateBudget?: TemplateBudget;
+    /** Interaction states forced on every node (the recipe sheet). */
+    readonly states: readonly string[];
+    /** Geometry mode: every leaf becomes a fixed box of this size. */
+    readonly measure?: (node: UiNode) => {
+        w: number;
+        h: number;
+    } | null;
+    /** Where overlays portal: the overlay LAYER inside the `xui` container. */
+    readonly portal: HTMLElement | null;
+    /** The toast layer (above dialogs). */
+    readonly toastLayer: HTMLElement | null;
+    /** The direction of the node being painted (round 2 §2). */
+    readonly direction: `ltr` | `rtl`;
+    readonly functions: Record<string, ClientFunction>;
+    readonly openUrl: (url: string) => void;
+    readonly locale: string;
+    readonly formatter: Formatter;
+    /** The surface clock; ticks once a minute while the tree uses it. */
+    readonly now: () => number;
+    readonly registerScroller: (id: string, scroll: (index: number, align?: ScrollAlign) => void) => () => void;
+    readonly paintFailures?: Map<string, string>;
+    readonly strings: Readonly<Record<string, string>>;
+    readonly t: (id: string, params?: Record<string, unknown>) => string;
+    /** `activeBreakpoint(surface width, theme.tokens.breakpoint)`; null = base. */
+    readonly breakpoint: string | null;
+    /** The matching JS-evaluated conditions (`data-xq` tokens). */
+    readonly xq?: string;
+    readonly reducedMotion: boolean;
+    readonly hover: boolean;
+    readonly announce: (text: string, live?: `polite` | `assertive`) => void;
+}
+export declare const SurfaceContext: import("solid-js").Context<SurfaceContextValue | undefined>;
+export declare function useSurfaceContext(): SurfaceContextValue;
+/** A copy of `ctx` with some fields re-pointed (each override = a getter
+ *  body), every other field still following the original. */
+export declare function deriveContext(ctx: SurfaceContextValue, overrides: {
+    [K in keyof SurfaceContextValue]?: () => SurfaceContextValue[K];
+}): SurfaceContextValue;
+/** The data scope of a template item (relative paths resolve here): an
+ *  ACCESSOR, since a keyed item's index (and so its path) moves. */
+export declare const ScopeContext: import("solid-js").Context<Accessor<string>>;
+/** The INSTANCE suffix of a template item (`.0`, `.alice`): appended to the
+ *  ids of the nodes it renders (`data-xui-id`) while their CSS class stays
+ *  the template node's own. */
+export declare const InstanceContext: import("solid-js").Context<Accessor<string>>;
+export declare const useScope: () => Accessor<string>;
+export declare const useInstance: () => Accessor<string>;
+/** The resolve context of one evaluation (bindings + calls + `$string`):
+ *  getters over the surface's, read (and tracked) where they are used. */
+export declare function resolveContextOf(ctx: SurfaceContextValue, scope: string): ResolveContext;

package/dist/types/create-surface.d.ts

@@ -0,0 +1,58 @@
+import type { ExtensionDef, FlatComponent, NestedNode, ReduceIssue, ResolvedTheme, UiNode } from "@exponential-at/ui";
+import type { DataModel } from "@exponential-at/ui/web";
+export interface A2uiMessage {
+    version?: string;
+    createSurface?: {
+        surfaceId: string;
+        catalogId: string;
+        theme?: unknown;
+        sendDataModel?: boolean;
+    };
+    updateComponents?: {
+        surfaceId: string;
+        components: FlatComponent[];
+    };
+    updateDataModel?: {
+        surfaceId: string;
+        path?: string;
+        value?: unknown;
+    };
+    deleteSurface?: {
+        surfaceId: string;
+    };
+}
+export interface CreateSurfaceOptions {
+    /** The surface id messages must carry; default `main`. */
+    surfaceId?: string;
+    catalogId?: string;
+    extensions?: readonly ExtensionDef[];
+    /** A nested tree to start from (fixtures, static screens). */
+    initial?: NestedNode;
+    /** The initial data model. */
+    data?: DataModel;
+}
+/** React's name for the options. */
+export type UseSurfaceOptions = CreateSurfaceOptions;
+/** The surface state (every field a live getter on the object
+ *  `createSurface` returns; never destructure it). */
+export interface SurfaceState {
+    readonly surfaceId: string;
+    readonly catalogId: string;
+    readonly root: UiNode | null;
+    readonly issues: ReduceIssue[];
+    /** Round 2: the nodes a data `template` renders per item, by component id. */
+    readonly templates?: Readonly<Record<string, UiNode>>;
+    /** The server's `createSurface.theme`, resolved (a host surface). */
+    readonly theme?: ResolvedTheme;
+    readonly data: DataModel;
+    /** True after `deleteSurface`. */
+    readonly deleted: boolean;
+    readonly components: readonly FlatComponent[];
+    readonly extensions: readonly ExtensionDef[];
+    apply: (message: A2uiMessage) => void;
+    setData: (pointer: string, value: unknown) => void;
+    /** Replace the tree with a nested authoring tree. */
+    setNested: (tree: NestedNode) => void;
+    reset: () => void;
+}
+export declare function createSurface(options?: CreateSurfaceOptions): SurfaceState;

package/dist/types/extensions.d.ts

@@ -0,0 +1,25 @@
+import { type Component } from "solid-js";
+import type { ExtensionDef } from "@exponential-at/ui";
+import type { ExtensionComponentProps } from "./host.js";
+export type ExtensionComponent = Component<ExtensionComponentProps>;
+export interface SolidExtension {
+    /** The extension catalog (validated). `null` for a pure painter override. */
+    catalog: ExtensionDef | null;
+    components: Record<string, ExtensionComponent>;
+}
+export interface RegisterExtensionOptions {
+    catalog?: ExtensionDef;
+    components?: Record<string, ExtensionComponent>;
+}
+/** Register an extension for every surface on the page (last wins).
+ *  Returns an unregister function. */
+export declare function registerExtension(options: RegisterExtensionOptions): () => void;
+/** A per-surface extension (the `extensions` prop), validated once. */
+export declare function defineSolidExtension(options: RegisterExtensionOptions): SolidExtension;
+/** The registered extensions (a reactive read). */
+export declare function registeredExtensions(): readonly SolidExtension[];
+export declare function subscribeExtensions(listener: () => void): () => void;
+/** The catalog defs of a list of extensions (for the reducer). */
+export declare function extensionCatalogs(extensions: readonly SolidExtension[]): ExtensionDef[];
+export declare function extensionMacroNames(extensions: readonly SolidExtension[]): Set<string>;
+export declare function extensionComponent(extensions: readonly SolidExtension[], component: string): ExtensionComponent | undefined;

package/dist/types/form.d.ts

@@ -0,0 +1,63 @@
+import { type Accessor, type JSX } from "solid-js";
+import { joinIds } from "@exponential-at/ui/web";
+import type { UiNode } from "@exponential-at/ui";
+import type { NativeProps } from "./node-view.js";
+import { type PartFn } from "./natives/shared.js";
+export interface FieldHandle {
+    name: string;
+    domId: string;
+    value: () => unknown;
+    errors: () => string[];
+    focus: () => void;
+    element: () => HTMLElement | null;
+}
+/** The nearest Form (live getters for its state). */
+export interface FormContextValue {
+    register: (field: FieldHandle) => () => void;
+    /** Run the checks and fire `submit` or `invalid`. */
+    submit: () => void;
+    /** A field's value changed (Form `change {name, value}`). */
+    changed: (name: string, value: unknown) => void;
+    readonly disabled: boolean;
+    readonly busy: boolean;
+    /** Bumps on every refused submit: every field shows its errors. */
+    readonly attempts: number;
+}
+export declare const FormContext: import("solid-js").Context<FormContextValue | null>;
+/** Round 4 (`submitClosesOverlay`): the NEAREST overlay around a Form
+ *  decides; a dismissible Dialog or Drawer provides its close, every other
+ *  overlay provides null. */
+export declare const CloseOnSubmitContext: import("solid-js").Context<(() => void) | null>;
+export declare function useForm(): FormContextValue | null;
+export declare function FormNative(props: NativeProps): JSX.Element;
+export interface FieldOptions {
+    node: Accessor<UiNode>;
+    domId: Accessor<string>;
+    props: Accessor<Record<string, unknown>>;
+    /** The field's current (local) value. */
+    value: Accessor<unknown>;
+    /** The element focus moves to when the field is the first invalid one. */
+    focusEl: () => HTMLElement | null | undefined;
+}
+/** A field's validation state (live getters). */
+export interface FieldState {
+    /** The messages to SHOW now. */
+    readonly errors: string[];
+    readonly invalid: boolean;
+    /** `<field id>.error` — put it in the control's aria-describedby. */
+    readonly errorId: string;
+    readonly describedBy: string | undefined;
+    touch: () => void;
+    change: (value: unknown) => void;
+    submit: () => void;
+    readonly form: FormContextValue | null;
+}
+/** React's `useField`: a named control's validation + its registration
+ *  with the nearest Form. */
+export declare function createField(options: FieldOptions): FieldState;
+/** Every failing message under a field, linked by `errorId`. */
+export declare function FieldErrors(props: {
+    part: PartFn;
+    field: FieldState;
+}): JSX.Element;
+export { joinIds };

package/dist/types/host-surface.d.ts

@@ -0,0 +1,33 @@
+import { type Accessor, type JSX } from "solid-js";
+import type { ExponentialHost, TransportStatus } from "@exponential-at/ui";
+import type { HostPlugin } from "./host.js";
+import type { SurfaceState } from "./create-surface.js";
+import { type ExponentialSurfaceProps } from "./surface.js";
+/** The renderer callbacks that route through the host (React's
+ *  `hostPlugin`, identical). */
+export declare function hostPlugin(host: ExponentialHost, base?: HostPlugin): HostPlugin;
+/** The ids of the host's surfaces, live (React's `useHostSurfaceIds`). */
+export declare function createHostSurfaceIds(host: ExponentialHost): Accessor<string[]>;
+/** The host's transport state and the catalog it could not render, as live
+ *  getters (React's `useHostStatus`). */
+export declare function createHostStatus(host: ExponentialHost): {
+    readonly status: TransportStatus;
+    readonly detail?: string;
+    readonly unsupportedCatalog?: string;
+};
+/** React's name. */
+export declare const useHostStatus: typeof createHostStatus;
+/** One host surface as the `SurfaceState` `<ExponentialSurface>` paints
+ *  (React's `useHostSurface`); null while the host has none. */
+export declare function createHostSurface(host: ExponentialHost, surfaceId: string): Accessor<SurfaceState | null>;
+export interface HostSurfaceProps extends Omit<ExponentialSurfaceProps, `surface` | `root` | `data` | `host`> {
+    host: ExponentialHost;
+    surfaceId: string;
+    /** Icons, markdown, input observers… (actions, functions, urls and media
+     *  route through the host). */
+    plugin?: HostPlugin;
+    /** Shown while the host has no surface with this id. */
+    fallback?: JSX.Element;
+}
+/** A surface the host's transport feeds. */
+export declare function HostSurface(props: HostSurfaceProps): JSX.Element;

package/dist/types/host.d.ts

@@ -0,0 +1,37 @@
+import type { Component, JSX } from "solid-js";
+import type { LucideProps } from "lucide-solid";
+import type { UiNode, ResolvedTheme, ModeName } from "@exponential-at/ui";
+import type { HostPlugin as WebHostPlugin, IconMap as WebIconMap } from "@exponential-at/ui/web";
+export type { SurfaceActionEvent, SurfaceInputEvent, PaintError, SourceOption } from "@exponential-at/ui/web";
+/** An icon component the host maps a registry name to (`lucide-solid`'s
+ *  icon shape). */
+export type IconComponent = (props: LucideProps) => JSX.Element;
+export type IconMap = WebIconMap<IconComponent>;
+/** The host plugin on Solid: icons are Solid components, `Markdown` a Solid
+ *  component taking `{text, class}`. */
+export type HostPlugin = WebHostPlugin<IconComponent, Component<{
+    text: string;
+    class?: string;
+}>>;
+/** What an extension component receives (React's `ExtensionComponentProps`
+ *  as a Solid props object: every field is a live getter, never destructure
+ *  it): the node, its props resolved, the theme and mode, the rendered
+ *  children, and an emitter for its events. */
+export interface ExtensionComponentProps {
+    readonly node: UiNode;
+    readonly props: Record<string, unknown>;
+    readonly theme: ResolvedTheme;
+    readonly mode: ModeName;
+    readonly tokens: ResolvedTheme[`tokens`];
+    /** The node's children: read ONCE (each read paints them again). */
+    readonly children?: JSX.Element;
+    /** Rendered slots by name: read each ONCE. */
+    readonly slots: Record<string, JSX.Element>;
+    /** Fire one of the node's `on` handlers. `own` = what the component just
+     *  WROTE, by prop (round 4 own write). */
+    readonly emit: (event: string, payload?: Record<string, unknown>, own?: Record<string, unknown>) => Promise<void> | void;
+    /** The element attributes the renderer wants on the root (`class`,
+     *  `data-xui-id`, `data-xui-c`, recipe `data-r-*`/`data-m-*`, `data-xs`,
+     *  aria, `dir`, `style` in Solid's kebab-case form). */
+    readonly rootProps: Record<string, unknown>;
+}

package/dist/types/icons.d.ts

@@ -0,0 +1,56 @@
+import { type JSX } from "solid-js";
+import type { IconComponent, IconMap } from "./host.js";
+/** The renderer's own chrome glyphs that are NOT catalog part glyphs. */
+export declare const CHROME: {
+    readonly check: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly chevronDown: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly chevronUp: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly chevronLeft: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly chevronRight: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly close: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly search: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly calendar: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly send: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly stop: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly play: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly attach: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly spinner: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+    readonly placeholder: (props: import("lucide-solid").LucideProps) => import("solid-js").JSX.Element;
+};
+/** icons.json concept / registry names → the Lucide glyph icons.json gives
+ *  them, for every name the catalog's `builtinIcons` and the core macros
+ *  draw (React's table, name for name). */
+export declare const FALLBACK_ICONS: Record<string, IconComponent>;
+export declare function resolveIcon(icons: IconMap | undefined, name: string): IconComponent | undefined;
+/** A probed Lucide glyph: its class tokens (lucide-react's: `lucide-<name>`
+ *  twice, deduplicated) and its children. */
+interface LucideShape {
+    classes: string[];
+    nodes: [string, Record<string, string>][];
+}
+export type LucideSvgProps = JSX.SvgSVGAttributes<SVGSVGElement> & {
+    shape: LucideShape;
+    size?: number | string;
+    class?: string;
+    "data-icon"?: string;
+    "data-icon-missing"?: string;
+    "data-slot"?: string;
+};
+/** One icon as lucide-react paints it (a Lucide glyph through `LucideSvg`,
+ *  any other host component as it is). */
+export declare function PaintIcon(props: {
+    icon: IconComponent;
+} & JSX.SvgSVGAttributes<SVGSVGElement> & {
+    size?: number | string;
+    class?: string;
+    [data: `data-${string}`]: string | undefined;
+}): JSX.Element;
+export declare function IconGlyph(props: {
+    icons?: IconMap;
+    name: string;
+    size?: number;
+    class?: string;
+} & JSX.SvgSVGAttributes<SVGSVGElement> & {
+    [data: `data-${string}`]: string | undefined;
+}): JSX.Element;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,39 @@
+export { ExponentialSurface, resolveThemeInput, surfaceTheme } from "./surface.js";
+export type { ExponentialSurfaceProps, ThemeInput, SurfaceHandle } from "./surface.js";
+export { createSurface } from "./create-surface.js";
+export type { A2uiMessage, SurfaceState, CreateSurfaceOptions, UseSurfaceOptions } from "./create-surface.js";
+export { registerExtension, defineSolidExtension, registeredExtensions, extensionCatalogs, extensionComponent } from "./extensions.js";
+export type { SolidExtension, ExtensionComponent, RegisterExtensionOptions } from "./extensions.js";
+export type { HostPlugin, IconComponent, IconMap, PaintError, SurfaceActionEvent, SurfaceInputEvent, ExtensionComponentProps, SourceOption } from "./host.js";
+export { compileTheme, compiledTheme, themeScope, partClass, propAttribute, tokenVar, tokenVarName, cssValue, declarations, ruleSelectors, STATE_SELECTORS, LAYERS } from "@exponential-at/ui/web";
+export type { CompiledTheme } from "@exponential-at/ui/web";
+export { nodeSheet, compileNodeSheet, dynamicStyleEntries, queryToken, nodeClass, surfaceClass, walkNodes } from "@exponential-at/ui/web";
+export type { NodeSheet, DynamicStyleEntry } from "@exponential-at/ui/web";
+export { BASE_CSS } from "@exponential-at/ui/web";
+export { getPointer, setPointer, absolutePath, resolveValue, resolveProps, resolveNodeProps, resolveVisible, bindTree, boundPath, isBinding, isCall, hasDynamic, memoFormatter, CLIENT_FUNCTIONS } from "@exponential-at/ui/web";
+export type { DataModel, DataBinding, FunctionCall, ClientFunction, ResolveContext } from "@exponential-at/ui/web";
+export { createHostOwnedValue, DEBOUNCE_MS } from "./inputs.js";
+export type { HostOwnedOptions, HostOwnedValue } from "./inputs.js";
+export { WindowedList } from "./list.js";
+export type { WindowedListProps, WindowedListHandle } from "./list.js";
+export { NodeView, NodeList, TemplateItems, TemplateItemView, createRootProps, createEmitter, runNodeAction, templateItems, itemInstance, mergeStyle, withClass, forced } from "./node-view.js";
+export type { NativeProps, TemplateItem } from "./node-view.js";
+export { NATIVES, NATIVE_NAMES } from "./natives/index.js";
+export { useSurfaceContext, deriveContext, SurfaceContext, ScopeContext, InstanceContext, useScope, useInstance } from "./context.js";
+export type { SurfaceContextValue } from "./context.js";
+export { IconGlyph, PaintIcon, resolveIcon, FALLBACK_ICONS, CHROME } from "./icons.js";
+export { BuiltinMarkdown, renderMarkdown } from "./markdown.js";
+export { parts, useParts, str, num, bool, arr, BuiltinIcon, builtinIconName, failingChecks, TextPart } from "./natives/shared.js";
+export type { PartFn, Attrs } from "./natives/shared.js";
+export { createBoundState } from "./natives/bound.js";
+export { css, px } from "./style.js";
+export type { StyleInput, SolidStyle } from "./style.js";
+export { FormContext, CloseOnSubmitContext, useForm, createField, FieldErrors } from "./form.js";
+export type { FieldHandle, FormContextValue, FieldState, FieldOptions } from "./form.js";
+export { createMediaQuery, createElementSize } from "./platform.js";
+export type { BoxSize } from "./platform.js";
+export { sortRows, parseLocaleNumber, acceptsFile, monthGrid } from "@exponential-at/ui/web";
+export { HostSurface, hostPlugin, createHostSurface, createHostSurfaceIds, createHostStatus, useHostStatus } from "./host-surface.js";
+export type { HostSurfaceProps } from "./host-surface.js";
+export { createMediaSource, createMediaSrc, clearMediaCache, mediaCacheStats, fetchLimited, MEDIA_CACHE_IDLE_MAX } from "./media.js";
+export { linkHref, mediaRequestOf, urlPolicyOf } from "@exponential-at/ui/web";

package/dist/types/inputs.d.ts

@@ -0,0 +1,27 @@
+import { type Accessor } from "solid-js";
+import { DEBOUNCE_MS } from "@exponential-at/ui/web";
+export { DEBOUNCE_MS };
+export interface HostOwnedOptions<T> {
+    /** The value the host currently holds (resolved prop or data model). */
+    external: Accessor<T>;
+    /** Sends an edit; a returned promise acknowledges the revision on settle.
+     *  Read at call time (a getter on the options object is followed). */
+    send: (value: T, revision: number, kind: `change` | `commit`) => void | Promise<void>;
+    /** Optional local write-through (the bound data model path). */
+    writeLocal?: (value: T) => void;
+    debounceMs?: number;
+}
+export interface HostOwnedValue<T> {
+    readonly value: T;
+    readonly revision: number;
+    /** True while a revision the host has not acknowledged exists. */
+    readonly pending: boolean;
+    readonly focused: boolean;
+    onFocus: () => void;
+    onBlur: () => void;
+    /** A local edit. */
+    edit: (next: T) => void;
+    /** Flush the debounce and send a `commit`. */
+    commit: () => void;
+}
+export declare function createHostOwnedValue<T>(options: HostOwnedOptions<T>): HostOwnedValue<T>;

package/dist/types/list.d.ts

@@ -0,0 +1,33 @@
+import { type Accessor, type JSX } from "solid-js";
+import { type ScrollAlign } from "@exponential-at/ui";
+import { scrollParent, type ListAxis } from "@exponential-at/ui/web";
+export type { ListAxis };
+export { scrollParent };
+export interface WindowedListProps {
+    count: number;
+    itemKey: (index: number) => string;
+    /** The row's content; `index` follows the row (keyed by `itemKey`). */
+    renderItem: (index: Accessor<number>) => JSX.Element;
+    /** The extent (px on the axis) of a row before it is measured. */
+    estimatedItemHeight?: number | ((index: number) => number);
+    overscan?: number;
+    class?: string;
+    axis?: ListAxis;
+    direction?: `ltr` | `rtl`;
+    /** Space between rows on the axis (px). */
+    gap?: number;
+    /** A divider drawn centred in the gap BEFORE row `index` (null = none). */
+    divider?: (index: number) => JSX.Element | null;
+    /** Flat indices of the header rows that pin (ascending). */
+    stickyRows?: readonly number[];
+    /** Extra attributes of row `index`'s wrapper (role, aria-setsize…). */
+    itemProps?: (index: number) => Record<string, unknown>;
+    /** Receives the list's handle (React's forwarded ref). */
+    ref?: (handle: WindowedListHandle) => void;
+}
+export interface WindowedListHandle {
+    /** Scroll row `index` into view (default nearest), the pinned header's
+     *  extent subtracted. */
+    scrollToIndex: (index: number, align?: ScrollAlign) => void;
+}
+export declare function WindowedList(props: WindowedListProps): JSX.Element;

package/dist/types/markdown.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+import type { HostPlugin } from "./host.js";
+export { MAX_LINK_NESTING, MAX_LINK_DEST, MAX_BLOCK_NESTING, linkAt, wholeImage, parseList } from "@exponential-at/ui/web";
+/** The markdown tree of `text` as Solid elements. */
+export declare function renderMarkdown(text: string, host?: HostPlugin): JSX.Element[];
+export declare function BuiltinMarkdown(props: {
+    text: string;
+    class?: string;
+    host?: HostPlugin;
+}): JSX.Element;

package/dist/types/media.d.ts

@@ -0,0 +1,16 @@
+import { type Accessor } from "solid-js";
+import { type MediaKind } from "@exponential-at/ui/web";
+import type { HostPlugin } from "./host.js";
+export { clearMediaCache, fetchLimited, fetchStream, mediaCacheStats, MEDIA_CACHE_IDLE_MAX } from "@exponential-at/ui/web";
+export type { MediaKind } from "@exponential-at/ui/web";
+export interface MediaSourceState {
+    url: string | undefined;
+    error: boolean;
+}
+/** A media source's state, live: the url to use (undefined while a fetched
+ *  one loads or after it failed) and whether the fetch failed. A src the
+ *  media policy denies has no url and `error`. */
+export declare function createMediaSource(host: Accessor<HostPlugin>, src: Accessor<string>, kind?: MediaKind): Accessor<MediaSourceState>;
+/** The src an element should use, or undefined while a fetched one loads
+ *  (or after it failed). */
+export declare function createMediaSrc(host: Accessor<HostPlugin>, src: Accessor<string>, kind?: MediaKind): Accessor<string | undefined>;

package/dist/types/natives/actions.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor, type Component, type JSX } from "solid-js";
+import type { NativeProps } from "../node-view.js";
+/** React's `usePending`: `pending` while the last tracked promise runs. */
+export declare function createPending(): {
+    pending: Accessor<boolean>;
+    track: (result: void | Promise<void>) => void;
+};
+/** `loading` held for `PENDING_DELAY_MS` (false again at once when it ends). */
+export declare function createPendingShown(loading: Accessor<boolean>): Accessor<boolean>;
+export declare function ButtonNative(props: NativeProps): JSX.Element;
+export declare function LinkNative(props: NativeProps): JSX.Element;
+export declare function ToggleNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_ACTIONS: Record<string, Component<NativeProps>>;

package/dist/types/natives/bound.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from "solid-js";
+import type { UiNode } from "@exponential-at/ui";
+export declare function createBoundState<T>(node: Accessor<UiNode>, scope: Accessor<string>, prop: string, external: Accessor<T>, key?: (v: T) => string): [Accessor<T>, (next: T, written?: unknown) => void, Accessor<string | undefined>];

package/dist/types/natives/chart.d.ts

@@ -0,0 +1,4 @@
+import { type Component, type JSX } from "solid-js";
+import { type NativeProps } from "../node-view.js";
+export declare function ChartNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_CHART: Record<string, Component<NativeProps>>;

package/dist/types/natives/chips.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type JSX } from "solid-js";
+import { acceptsFile } from "@exponential-at/ui/web";
+import type { NativeProps } from "../node-view.js";
+export { acceptsFile };
+export declare function ChipInputNative(props: NativeProps): JSX.Element;
+export declare function FileUploadNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_CHIPS: Record<string, Component<NativeProps>>;

package/dist/types/natives/choice-tiles.d.ts

@@ -0,0 +1,4 @@
+import { type Component, type JSX } from "solid-js";
+import type { NativeProps } from "../node-view.js";
+export declare function ChoiceTilesNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_CHOICE_TILES: Record<string, Component<NativeProps>>;

package/dist/types/natives/code.d.ts

@@ -0,0 +1,4 @@
+import { type Component, type JSX } from "solid-js";
+import type { NativeProps } from "../node-view.js";
+export declare function CodeBlockNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_CODE: Record<string, Component<NativeProps>>;

package/dist/types/natives/dates.d.ts

@@ -0,0 +1,30 @@
+import { type Component, type JSX } from "solid-js";
+import type { Formatter } from "@exponential-at/ui";
+import { calendarStop, isoDate, monthGrid, parseIsoDate } from "@exponential-at/ui/web";
+import type { NativeProps } from "../node-view.js";
+import { type PartFn } from "./shared.js";
+export { calendarStop, isoDate, monthGrid, parseIsoDate };
+interface CalendarProps {
+    part: PartFn;
+    dayPart: `day`;
+    locale: string;
+    /** The surface Formatter: month and weekday names, day labels. */
+    formatter: Formatter;
+    firstDay: number;
+    min: Date | null;
+    max: Date | null;
+    /** Days drawn selected. */
+    isSelected: (d: Date) => boolean;
+    /** Days drawn inside a range (DateRangePicker). */
+    inRange?: (d: Date) => boolean;
+    initial: Date;
+    onPick: (d: Date) => void;
+    t: (id: string) => string;
+    /** The SURFACE direction: ArrowLeft/Right mirror in RTL. */
+    direction?: `ltr` | `rtl`;
+}
+export declare function CalendarGrid(props: CalendarProps): JSX.Element;
+export declare function DatePickerNative(props: NativeProps): JSX.Element;
+export declare function DateRangePickerNative(props: NativeProps): JSX.Element;
+export declare function TimePickerNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_DATES: Record<string, Component<NativeProps>>;

package/dist/types/natives/feedback.d.ts

@@ -0,0 +1,19 @@
+import { type JSX } from "solid-js";
+import type { Component } from "solid-js";
+import { type NativeProps } from "../node-view.js";
+export declare function RingNative(props: NativeProps): JSX.Element;
+export declare function SpinnerNative(props: NativeProps): JSX.Element;
+/** Skeleton: one pulsing block, or (EXP-1259, feedback-states.json
+ *  `placeholder`) `rows` placeholder rows in the row geometry: each a `dot`
+ *  (unless `dot: false`) and two `bar`s, hairline-divided; the root paints
+ *  nothing itself, the pieces pulse (base CSS). */
+export declare function SkeletonNative(props: NativeProps): JSX.Element;
+/** TreeGuides (round 3, a Row's `guides` part the CORE fills: `elbowAt`,
+ *  `tee`, `passThrough` arrive computed): `depth` columns of
+ *  `TREE_GUIDE_COLUMN` (14) px; column i's line sits at its centre. The
+ *  elbow = ONE element whose left + bottom borders are the vertical and the
+ *  stub, the corner rounded by `TREE_GUIDE_RADIUS`; `tee` and pass-through
+ *  columns = full-height verticals from the same bridge. Stroke width +
+ *  colour = the `TreeGuides/line` recipe. Physical x (never mirrored). */
+export declare function TreeGuidesNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_FEEDBACK: Record<string, Component<NativeProps>>;

package/dist/types/natives/index.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from "solid-js";
+import type { NativeProps } from "../node-view.js";
+export declare const NATIVES: Record<string, Component<NativeProps>>;
+export declare const NATIVE_NAMES: readonly string[];
+/** The natives still painted by `Pending` (empty once the fan-out landed). */
+export declare const PENDING_NATIVES: readonly string[];

package/dist/types/natives/inputs.d.ts

@@ -0,0 +1,20 @@
+import { type JSX } from "solid-js";
+import type { NativeProps } from "../node-view.js";
+/** React's `useInputSender`: the host `onInput` sender of a host-owned
+ *  field and its local write-through (the bound data path). */
+export declare function createInputSender(props: NativeProps, prop: string): {
+    send: (value: unknown, revision: number, kind: `change` | `commit`) => void | Promise<void> | undefined;
+    writeLocal: (value: unknown) => void;
+    path: import("solid-js").Accessor<string | undefined>;
+    name: () => string;
+};
+export declare function InputNative(p: NativeProps): JSX.Element;
+export declare function TextareaNative(p: NativeProps): JSX.Element;
+export declare function NumberFieldNative(props: NativeProps): JSX.Element;
+export declare function CheckboxNative(props: NativeProps): JSX.Element;
+export declare function SwitchNative(props: NativeProps): JSX.Element;
+export declare function RadioNative(props: NativeProps): JSX.Element;
+/** Radix's single-thumb horizontal Slider. */
+export declare function SliderNative(props: NativeProps): JSX.Element;
+export declare function ComposerNative(props: NativeProps): JSX.Element;
+export declare const NATIVES_INPUTS: Record<string, (props: NativeProps) => JSX.Element>;

package/dist/types/natives/layout.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+import { type NativeProps } from "../node-view.js";
+export declare function BoxNative(props: NativeProps): JSX.Element;
+/** Past this many items a List windows. The catalog's number. */
+export declare const WINDOW_THRESHOLD: number;
+/** List (round 2 §5): children then the data template's items; `sectionBy`
+ *  groups consecutive template items under a `section` header; past
+ *  `WINDOW_THRESHOLD` items, or with `stickyHeaders`, the list WINDOWS.
+ *  Every item is a listitem with its position in the whole list;
+ *  `scrollToIndex` (the host command) takes the data index. */
+export declare function ListNative(props: NativeProps): JSX.Element;
+export declare function UnknownNative(props: NativeProps): JSX.Element;