@vortexm/vjt 0.1.0

package/dist/lib/action-runtime.d.ts

@@ -0,0 +1,78 @@
+import type { ActionDefinition, ActionMap, DescriptionNode, WidgetEventName, WidgetState } from './types.js';
+export type ActionExecutionContext = {
+    currentValue: unknown;
+    responseValue?: unknown;
+    pointer?: {
+        x: number;
+        y: number;
+    } | null;
+};
+type ActionRuntimeOptions = {
+    actionsMap: ActionMap;
+    actionFunctions: Record<string, () => unknown>;
+    nodeById: Map<string, DescriptionNode>;
+    stateById: Map<string, WidgetState>;
+    rerenderRoot: () => Promise<void>;
+    dispatchWidgetEvent: (node: DescriptionNode, eventName: WidgetEventName, key: string, inputValue?: unknown, pointer?: {
+        x: number;
+        y: number;
+    } | null) => Promise<void>;
+    executeRequest: (requestName: string, currentValue: unknown) => Promise<unknown>;
+    resolveReference: (reference: string, currentValue: unknown, responseValue: unknown) => unknown;
+    assignReference: (reference: string, inputValue: unknown, currentValue: unknown) => void;
+    resolveMappedValue: (template: unknown, currentValue: unknown, responseValue: unknown) => unknown;
+    setWidgetEnabled: (widgetId: string, enabled: boolean) => void;
+    clearWidget: (widgetId: string) => void;
+    setUiReference: (widgetId: string, resourceRef: string) => void;
+    refreshWidgetTree: (widgetId: string) => Promise<void>;
+    renderWidgetTree: (widgetId: string) => Promise<void>;
+    getContextMenuPosition: (menuId: string, pointer?: {
+        x: number;
+        y: number;
+    } | null) => {
+        x: number;
+        y: number;
+    };
+    setActiveContextMenu: (menu: {
+        id: string;
+        x: number;
+        y: number;
+    } | null) => void;
+    setActiveModalId: (modalId: string | null) => void;
+    closeModal: (modalId?: string | null) => void;
+    getInlineActions: (node: DescriptionNode) => ActionDefinition[] | undefined;
+    isWidgetEnabled: (node: DescriptionNode, key: string) => boolean;
+};
+export declare class ActionRuntime {
+    private readonly actionsMap;
+    private readonly actionFunctions;
+    private readonly nodeById;
+    private readonly stateById;
+    private readonly rerenderRoot;
+    private readonly dispatchWidgetEventImpl;
+    private readonly executeRequest;
+    private readonly resolveReference;
+    private readonly assignReference;
+    private readonly resolveMappedValue;
+    private readonly setWidgetEnabled;
+    private readonly clearWidget;
+    private readonly setUiReference;
+    private readonly refreshWidgetTree;
+    private readonly renderWidgetTree;
+    private readonly getContextMenuPosition;
+    private readonly setActiveContextMenu;
+    private readonly setActiveModalId;
+    private readonly closeModal;
+    private readonly getInlineActions;
+    private readonly isWidgetEnabled;
+    constructor(options: ActionRuntimeOptions);
+    dispatchWidgetEvent(node: DescriptionNode, eventName: WidgetEventName, key: string, inputValue?: unknown, pointer?: {
+        x: number;
+        y: number;
+    } | null): Promise<void>;
+    runActions(actions: ActionDefinition[], inputValue: unknown, context: ActionExecutionContext): Promise<unknown>;
+    getInlineActionsForNode(node: DescriptionNode): ActionDefinition[] | undefined;
+    private runSingleAction;
+    private executeAction;
+}
+export {};

package/dist/lib/default-styles.d.ts

@@ -0,0 +1,2 @@
+import type { StyleMap } from './types.js';
+export declare const DEFAULT_STYLE_MAP: StyleMap;

package/dist/lib/dom-state.d.ts

@@ -0,0 +1,45 @@
+import type { DescriptionNode, ListElementContext, WidgetState } from './types.js';
+export type PreservedElementState = {
+    activeId: string | null;
+    values: Map<string, string>;
+    checked: Map<string, boolean>;
+    windowScroll: {
+        x: number;
+        y: number;
+    };
+    scrollPositions: Array<{
+        id?: string;
+        widgetKey?: string;
+        top: number;
+        left: number;
+    }>;
+};
+export declare function isElementInsidePendingResetModal(element: HTMLElement, pendingResetModalIds: Set<string>): boolean;
+export declare function captureElementState(root: HTMLElement, pendingResetModalIds: Set<string>, stateByKey: Map<string, WidgetState>): PreservedElementState;
+export declare function restoreElementState(root: HTMLElement, state: PreservedElementState): void;
+export declare function adjustContextMenuPosition(root: HTMLElement, activeContextMenu: {
+    id: string;
+    x: number;
+    y: number;
+} | null): {
+    id: string;
+    x: number;
+    y: number;
+} | null;
+export declare function updatePointerFromMouseEvent(event: MouseEvent): {
+    x: number;
+    y: number;
+};
+export declare function getListElementContextFromElement(element: HTMLElement, stateByKey: Map<string, WidgetState>): ListElementContext | null;
+export declare function getActionInputValueForElement(element: HTMLElement, node: DescriptionNode, stateByKey: Map<string, WidgetState>): unknown;
+export declare function getContextMenuPosition(menuId: string, pointer: {
+    x: number;
+    y: number;
+} | null, lastPointer: {
+    x: number;
+    y: number;
+}, nodeById: Map<string, DescriptionNode>): {
+    x: number;
+    y: number;
+};
+export declare function redispatchUnderlyingClick(root: HTMLElement | null, clientX: number, clientY: number): void;

package/dist/lib/layout.d.ts

@@ -0,0 +1,11 @@
+import type { WidgetState } from './types.js';
+import type { ConditionExpression } from './widgets/conditional-container.js';
+import type { CellConstraints, ContainerCell, ContainerLayoutNode } from './widgets/container-layout.js';
+export declare function resolveCellSpaces(children: ContainerCell[] | undefined): number[];
+export declare function getResolvedContainerSpaces(node: ContainerLayoutNode, state: WidgetState): number[];
+export declare function buildCellBoxStyle(cell: CellConstraints, axis: 'horizontal' | 'vertical' | 'grid', space?: number): string;
+export declare function buildSwellBoxStyle(maySwellHorizontally: unknown, maySwellVertically: unknown, normalizeBoolean: (value: unknown, fallback: boolean) => boolean, options?: {
+    horizontallyScrollable?: boolean;
+    verticallyScrollable?: boolean;
+}): string[];
+export declare function evaluateConditionExpression(expression: ConditionExpression, currentValue: unknown, resolveReference: (reference: string, currentValue: unknown, responseValue: unknown) => unknown): boolean;

package/dist/lib/logging.d.ts

@@ -0,0 +1 @@
+export declare function logRuntimeError(scope: string, error: unknown, details?: Record<string, unknown>): void;

package/dist/lib/network.d.ts

@@ -0,0 +1,29 @@
+import type { ActionDefinition, PrimitiveRequestType, RequestMap, RequestSchema, SseConfig } from './types.js';
+type ActionRunner = (actions: ActionDefinition[], inputValue: unknown, context: {
+    currentValue: unknown;
+    responseValue?: unknown;
+}) => Promise<unknown>;
+type NetworkRuntimeOptions = {
+    requestsMap: RequestMap;
+    sseConfigs: SseConfig[];
+    backendUrl?: string;
+    eventSources: EventSource[];
+    runActions: ActionRunner;
+    rerenderRoot: () => Promise<void>;
+};
+export declare class NetworkRuntime {
+    private readonly requestsMap;
+    private readonly sseConfigs;
+    private readonly backendUrl?;
+    private readonly eventSources;
+    private readonly runActions;
+    private readonly rerenderRoot;
+    constructor(options: NetworkRuntimeOptions);
+    connectSseStreams(): void;
+    executeRequest(requestName: string, currentValue: unknown): Promise<unknown>;
+    buildSchemaValue(schema: RequestSchema, currentValue: unknown, responseValue: unknown): Promise<unknown>;
+    private stringifyPrimitive;
+    coercePrimitiveSchemaValue(type: PrimitiveRequestType, value: unknown): unknown;
+    private handleSseEvent;
+}
+export {};

package/dist/lib/references.d.ts

@@ -0,0 +1,25 @@
+import type { DescriptionNode, GridViewNode, ListNode, ListElementContext, WidgetState } from './types.js';
+type ReferenceRuntimeHost = {
+    readonly stateById: Map<string, WidgetState>;
+    readonly stateByKey: Map<string, WidgetState>;
+    readonly nodeById: Map<string, DescriptionNode>;
+    readonly nodeByKey: Map<string, DescriptionNode>;
+    getAppValue: (name: string) => unknown;
+    setAppValue: (name: string, value: unknown) => void;
+    ensureWidgetState: (node: DescriptionNode, key: string) => WidgetState;
+    resolveItemNodeKey: (node: DescriptionNode, listKey: string, index: number, fallbackPath: string) => string;
+    indexListElementNodes: (listNode: ListNode | GridViewNode, element: DescriptionNode, index: number) => void;
+};
+export declare class ReferenceRuntime {
+    private readonly host;
+    constructor(host: ReferenceRuntimeHost);
+    resolveReference(reference: string, currentValue: unknown, responseValue: unknown): unknown;
+    resolveCurrentReference(reference: string, currentValue: unknown): unknown;
+    readWidgetField(state: WidgetState, field: string): unknown;
+    assignReference(reference: string, inputValue: unknown, _currentValue: unknown): void;
+    clearListElementState(listKey: string): void;
+    resolveMappedValue(template: unknown, currentValue: unknown, responseValue: unknown): unknown;
+    isListElementContext(value: unknown): value is ListElementContext;
+    findNamedWidget(node: DescriptionNode | undefined, name: string): DescriptionNode | null;
+}
+export {};

package/dist/lib/render.d.ts

@@ -0,0 +1,3 @@
+import type { DescriptionNode, MountJsonOptions, RenderJsonOptions } from './types.js';
+export declare function renderJson(description: DescriptionNode, options?: RenderJsonOptions): string;
+export declare function renderApp(root: HTMLElement, description: DescriptionNode, options?: MountJsonOptions): () => void;

package/dist/lib/resource-manager.d.ts

@@ -0,0 +1,25 @@
+import type { ActionMap, DescriptionNode, I18nMap, RequestMap, SseConfig, StyleMap } from './types.js';
+export type ResourceManagerInput = {
+    ui?: Record<string, DescriptionNode>;
+    actions?: ActionMap;
+    requests?: RequestMap;
+    sse?: Record<string, SseConfig>;
+    i18n?: I18nMap;
+    styles?: StyleMap;
+};
+export declare class ResourceManager {
+    private readonly ui;
+    private actions;
+    private requests;
+    private sse;
+    private i18n;
+    private styles;
+    constructor(input?: ResourceManagerInput);
+    getUi(name: string): DescriptionNode | null;
+    setUi(name: string, description: DescriptionNode): void;
+    getActionsMap(): ActionMap;
+    getRequestsMap(): RequestMap;
+    getSseConfigs(): SseConfig[];
+    getI18n(): I18nMap;
+    getStyleMap(): StyleMap;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,144 @@
+export type Theme = 'light' | 'dark';
+export type LayoutType = 'vertical' | 'horizontal' | 'grid';
+export type TextAlign = 'left' | 'center' | 'right';
+export type VerticalAlign = 'top' | 'center' | 'bottom';
+export type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export type WidgetEventName = 'onClick' | 'onUserValueChange' | 'onRefresh';
+export type PrimitiveRequestType = 'int' | 'float' | 'boolean' | 'string';
+export type ActionDefinition = {
+    action: string;
+    andThen?: ActionDefinition[];
+    args?: unknown;
+};
+export type RequestSchema = {
+    type: 'object';
+    name?: string;
+    source?: ActionDefinition[];
+    properties?: RequestSchema[];
+} | {
+    type: 'array';
+    name?: string;
+    source?: ActionDefinition[];
+    elements: RequestSchema;
+} | {
+    type: PrimitiveRequestType;
+    name?: string;
+    source?: ActionDefinition[];
+    maxLength?: number;
+    regexp?: string;
+};
+export type RequestDefinition = {
+    name: string;
+    url?: string;
+    request: RequestSchema;
+    response?: RequestSchema;
+    onResponse?: ActionDefinition[];
+};
+export type SseEventDefinition = {
+    name: string;
+    message?: RequestSchema;
+    onEvent?: ActionDefinition[];
+};
+export type SseConfig = {
+    url: string;
+    events?: SseEventDefinition[];
+};
+type WidgetEvents = Partial<Record<WidgetEventName, ActionDefinition[]>>;
+export type BaseNode = {
+    id?: string;
+    name?: string;
+    style?: string | string[];
+    css?: string;
+    enabled?: boolean | string;
+    events?: WidgetEvents;
+    [key: string]: unknown;
+};
+import type { AdaptiveLayoutNode } from './widgets/adaptive-layout.js';
+import type { ButtonNode } from './widgets/button.js';
+import type { CheckboxNode } from './widgets/checkbox.js';
+import type { ComboboxNode } from './widgets/combobox.js';
+import type { ConditionExpression, ConditionalContainerNode } from './widgets/conditional-container.js';
+import type { CellConstraints, ContainerCell, ContainerLayoutNode } from './widgets/container-layout.js';
+import type { ContextMenuNode } from './widgets/context-menu.js';
+import type { EditNode } from './widgets/edit.js';
+import type { GridViewNode } from './widgets/grid-view.js';
+import type { ImageNode } from './widgets/image.js';
+import type { LinkNode } from './widgets/link.js';
+import type { ListNode } from './widgets/list.js';
+import type { ListboxNode } from './widgets/listbox.js';
+import type { MdTextNode } from './widgets/md-text.js';
+import type { ModalWindowNode } from './widgets/modal-window.js';
+import type { OverlayContainerNode, OverlayLayer } from './widgets/overlay-container.js';
+import type { PanelNode } from './widgets/panel.js';
+import type { RadioGroupNode } from './widgets/radio-group.js';
+import type { SpoilerNode } from './widgets/spoiler.js';
+import type { SplitterNode } from './widgets/splitter.js';
+import type { StaticTextNode } from './widgets/static-text.js';
+import type { TabsNode } from './widgets/tabs.js';
+import type { TextareaNode } from './widgets/textarea.js';
+import type { UiReferenceNode } from './widgets/ui-reference.js';
+import type { ResourceManager } from './resource-manager.js';
+export type DescriptionNode = AdaptiveLayoutNode | ContainerLayoutNode | ConditionalContainerNode | ListNode | GridViewNode | ListboxNode | ComboboxNode | PanelNode | StaticTextNode | MdTextNode | EditNode | TextareaNode | ButtonNode | CheckboxNode | ImageNode | LinkNode | RadioGroupNode | SplitterNode | OverlayContainerNode | TabsNode | SpoilerNode | UiReferenceNode | ContextMenuNode | ModalWindowNode;
+export type StyleMap = Record<string, string>;
+export type I18nMap = Record<string, Record<string, string>>;
+export type ActionMap = Record<string, ActionDefinition[]>;
+export type RequestMap = Record<string, RequestDefinition>;
+export type SseConfigInput = SseConfig | SseConfig[];
+export type WidgetState = {
+    key: string;
+    widget: DescriptionNode['widget'];
+    id?: string;
+    name?: string;
+    currentRef?: string;
+    text?: string;
+    url?: string;
+    placeholder?: string;
+    enabled?: boolean;
+    editable?: boolean;
+    checked?: boolean;
+    condition?: boolean;
+    elements?: DescriptionNode[];
+    selected?: number;
+    borderVisible?: boolean;
+    rowSize?: number;
+    listboxElements?: Array<Record<string, unknown>>;
+    comboboxElements?: Array<Record<string, unknown>>;
+    layoutSpaces?: number[];
+    modalWidth?: number;
+    modalHeight?: number;
+    activeTab?: number;
+    isHidden?: boolean;
+};
+export type RuntimeSnapshot = {
+    stateByKey: Array<[string, WidgetState]>;
+    activeModalId: string | null;
+    activeContextMenu: {
+        id: string;
+        x: number;
+        y: number;
+    } | null;
+};
+export type ListElementContext = {
+    kind: 'list-element';
+    listId: string;
+    index: number;
+    descriptor: DescriptionNode;
+};
+export type RenderJsonOptions = {
+    styleMap?: StyleMap;
+    i18n?: I18nMap;
+    language?: string;
+    theme?: Theme;
+    actionsMap?: ActionMap;
+    requestsMap?: RequestMap;
+    sseConfigs?: SseConfigInput;
+    actionFunctions?: Record<string, () => unknown>;
+    backendUrl?: string;
+    resourceManager?: ResourceManager;
+    runtimeSnapshot?: RuntimeSnapshot;
+    onRuntimeSnapshot?: (snapshot: RuntimeSnapshot) => void;
+};
+export type MountJsonOptions = RenderJsonOptions & {
+    afterRender?: (root: HTMLElement) => void;
+};
+export type { AdaptiveLayoutNode, ButtonNode, CellConstraints, CheckboxNode, ComboboxNode, ConditionExpression, ConditionalContainerNode, ContainerCell, ContainerLayoutNode, ContextMenuNode, EditNode, GridViewNode, ImageNode, LinkNode, ListNode, ListboxNode, MdTextNode, ModalWindowNode, OverlayContainerNode, OverlayLayer, PanelNode, RadioGroupNode, SpoilerNode, SplitterNode, StaticTextNode, TabsNode, TextareaNode, UiReferenceNode };

package/dist/lib/widgets/adaptive-layout.d.ts

@@ -0,0 +1,10 @@
+import type { BaseNode, DescriptionNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type AdaptiveLayoutNode = BaseNode & {
+    widget: 'adaptive-layout';
+    maySwellHorizontally?: boolean | string;
+    maySwellVertically?: boolean | string;
+    desktop?: DescriptionNode;
+    mobile?: DescriptionNode;
+};
+export declare const renderAdaptiveLayout: WidgetRenderer<AdaptiveLayoutNode>;

package/dist/lib/widgets/bindings.d.ts

@@ -0,0 +1,33 @@
+import type { DescriptionNode, WidgetState } from '../types.js';
+type BindingEnvironment = {
+    nodeByKey: Map<string, DescriptionNode>;
+    stateByKey: Map<string, WidgetState>;
+    lastPointer: {
+        x: number;
+        y: number;
+    };
+    setLastPointer: (pointer: {
+        x: number;
+        y: number;
+    }) => void;
+    updatePointerFromEvent: (event: MouseEvent) => void;
+    updateOwningListElementDescriptor: (element: HTMLElement, mutate: (descriptor: DescriptionNode) => void) => void;
+    dispatchWidgetEvent: (node: DescriptionNode, eventName: 'onClick' | 'onUserValueChange', key: string, inputValue?: unknown, pointer?: {
+        x: number;
+        y: number;
+    } | null) => Promise<void>;
+    rerenderRoot: () => Promise<void>;
+    getInlineActions: (node: DescriptionNode) => Array<{
+        action: string;
+        andThen?: unknown[];
+        args?: unknown;
+    }> | undefined;
+    getActionInputValueForElement: (element: HTMLElement, node: DescriptionNode) => unknown;
+    createDateValidator: (format: string) => (value: string) => string;
+    getDefaultDateFormat: () => string;
+    parseSteppedValue: (input: HTMLInputElement) => number | null;
+    formatSteppedValue: (kind: string, value: number) => string;
+};
+export declare function bindWidgetInputBehavior(root: HTMLElement, env: BindingEnvironment): void;
+export declare function bindWidgetEvents(root: HTMLElement, env: BindingEnvironment): void;
+export {};

package/dist/lib/widgets/button.d.ts

@@ -0,0 +1,11 @@
+import type { ActionDefinition, BaseNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type ButtonNode = BaseNode & {
+    widget: 'button';
+    text?: string;
+    enabled?: boolean | string;
+    type?: 'button' | 'submit';
+    color?: 'bright' | 'regular';
+    actions?: ActionDefinition[];
+};
+export declare const renderButton: WidgetRenderer<ButtonNode>;

package/dist/lib/widgets/checkbox.d.ts

@@ -0,0 +1,11 @@
+import type { BaseNode, HeadingTag } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type CheckboxNode = BaseNode & {
+    widget: 'checkbox';
+    type?: 'switch' | 'check';
+    text?: string;
+    checked?: boolean | string;
+    enabled?: boolean | string;
+    heading?: HeadingTag;
+};
+export declare const renderCheckbox: WidgetRenderer<CheckboxNode>;

package/dist/lib/widgets/combobox.d.ts

@@ -0,0 +1,9 @@
+import type { BaseNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type ComboboxNode = BaseNode & {
+    widget: 'combobox';
+    size?: number;
+    selected?: number | string;
+    elements?: Array<Record<string, unknown>>;
+};
+export declare const renderCombobox: WidgetRenderer<ComboboxNode>;

package/dist/lib/widgets/conditional-container.d.ts

@@ -0,0 +1,21 @@
+import type { BaseNode, DescriptionNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type ConditionExpression = {
+    equals: {
+        left: unknown;
+        right: unknown;
+    };
+} | {
+    and: ConditionExpression[];
+} | {
+    or: ConditionExpression[];
+};
+export type ConditionalContainerNode = BaseNode & {
+    widget: 'conditional-container';
+    maySwellHorizontally?: boolean | string;
+    maySwellVertically?: boolean | string;
+    condition?: boolean | string | ConditionExpression;
+    default?: DescriptionNode;
+    alternative?: DescriptionNode;
+};
+export declare const renderConditionalContainer: WidgetRenderer<ConditionalContainerNode>;

package/dist/lib/widgets/container-layout.d.ts

@@ -0,0 +1,39 @@
+import type { BaseNode, DescriptionNode, LayoutType } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type CellConstraints = {
+    space?: number | string;
+    minWidthPx?: number | string;
+    maxWidthPx?: number | string;
+    minHeightPx?: number | string;
+    maxHeightPx?: number | string;
+    marginTopPx?: number | string;
+    marginRightPx?: number | string;
+    marginBottomPx?: number | string;
+    marginLeftPx?: number | string;
+};
+export type ContainerCell = CellConstraints & {
+    child?: DescriptionNode;
+};
+type GridColumn = {
+    child?: DescriptionNode;
+};
+type GridRow = {
+    space?: number | string;
+    columns?: GridColumn[];
+};
+export type ContainerLayoutNode = BaseNode & {
+    widget: 'container-layout';
+    type?: LayoutType;
+    cellsVisible?: boolean | string;
+    verticallyScrollable?: boolean | string;
+    horizontallyScrollable?: boolean | string;
+    maySwellHorizontally?: boolean | string;
+    maySwellVertically?: boolean | string;
+    children?: ContainerCell[];
+    grid?: {
+        columnWidth?: Array<number | string>;
+        rows?: GridRow[];
+    };
+};
+export declare const renderContainerLayout: WidgetRenderer<ContainerLayoutNode>;
+export {};

package/dist/lib/widgets/context-menu.d.ts

@@ -0,0 +1,14 @@
+import type { ActionDefinition, BaseNode } from '../types.js';
+import type { WidgetRenderEnvironment } from './context.js';
+export type ContextMenuNode = BaseNode & {
+    widget: 'context-menu';
+    items?: Array<{
+        name: string;
+        actions?: ActionDefinition[];
+    }>;
+};
+export declare function renderContextMenuOverlay(env: WidgetRenderEnvironment, menu: {
+    id: string;
+    x: number;
+    y: number;
+}): string;

package/dist/lib/widgets/context.d.ts

@@ -0,0 +1,58 @@
+import type { DescriptionNode, EditNode, ListElementContext, WidgetState } from '../types.js';
+import type { AdaptiveLayoutNode } from './adaptive-layout.js';
+import type { ButtonNode } from './button.js';
+import type { CheckboxNode } from './checkbox.js';
+import type { ComboboxNode } from './combobox.js';
+import type { ConditionalContainerNode } from './conditional-container.js';
+import type { ContainerCell, ContainerLayoutNode } from './container-layout.js';
+import type { ContextMenuNode } from './context-menu.js';
+import type { GridViewNode } from './grid-view.js';
+import type { ImageNode } from './image.js';
+import type { LinkNode } from './link.js';
+import type { ListNode } from './list.js';
+import type { ListboxNode } from './listbox.js';
+import type { MdTextNode } from './md-text.js';
+import type { ModalWindowNode } from './modal-window.js';
+import type { OverlayContainerNode } from './overlay-container.js';
+import type { PanelNode } from './panel.js';
+import type { RadioGroupNode } from './radio-group.js';
+import type { SpoilerNode } from './spoiler.js';
+import type { SplitterNode } from './splitter.js';
+import type { StaticTextNode } from './static-text.js';
+import type { TabsNode } from './tabs.js';
+import type { TextareaNode } from './textarea.js';
+import type { UiReferenceNode } from './ui-reference.js';
+export type WidgetRenderEnvironment = {
+    readonly activeContextMenu: {
+        id: string;
+        x: number;
+        y: number;
+    } | null;
+    readonly activeModalId: string | null;
+    readonly nodeById: Map<string, DescriptionNode>;
+    escapeHtml: (value: unknown) => string;
+    buildStyleString: (node: DescriptionNode) => string;
+    resolveI18nValue: (value: string | undefined) => string;
+    getUiResource: (ref: string) => DescriptionNode | null;
+    resolveReference: (reference: string, currentValue: unknown, responseValue: unknown) => unknown;
+    buildWidgetDataAttributes: (key: string, node: DescriptionNode) => string;
+    ensureWidgetState: (node: DescriptionNode, key: string) => WidgetState;
+    renderNode: (node: DescriptionNode | undefined, path: string, itemContext: ListElementContext | null) => string;
+    resolveItemNodeKey: (node: DescriptionNode, listKey: string, index: number, fallbackPath: string) => string;
+    resolveNodeKey: (node: DescriptionNode, fallbackPath: string) => string;
+    indexListElementNodes: (listNode: ListNode | GridViewNode, element: DescriptionNode, index: number) => void;
+    normalizeBoolean: (value: unknown, fallback: boolean) => boolean;
+    toFiniteNumber: (value: unknown) => number | null;
+    getDateFormat: (node: EditNode) => string;
+    isStepperEdit: (node: EditNode) => boolean;
+    getResolvedContainerSpaces: (node: ContainerLayoutNode, state: WidgetState) => number[];
+    buildCellBoxStyle: (cell: ContainerCell, axis: 'horizontal' | 'vertical' | 'grid', space?: number) => string;
+    buildSwellBoxStyle: (maySwellHorizontally: unknown, maySwellVertically: unknown, options?: {
+        horizontallyScrollable?: boolean;
+        verticallyScrollable?: boolean;
+    }) => string[];
+    evaluateConditionExpression: (expression: unknown, currentValue: unknown) => boolean;
+    isMobileViewport: () => boolean;
+};
+export type WidgetRenderer<T extends DescriptionNode> = (env: WidgetRenderEnvironment, node: T, state: WidgetState, key: string, path: string, itemContext: ListElementContext | null) => string;
+export type { AdaptiveLayoutNode, ButtonNode, CheckboxNode, ComboboxNode, ConditionalContainerNode, ContainerCell, ContainerLayoutNode, ContextMenuNode, DescriptionNode, EditNode, GridViewNode, ImageNode, LinkNode, ListElementContext, ListNode, ListboxNode, MdTextNode, ModalWindowNode, OverlayContainerNode, PanelNode, RadioGroupNode, SpoilerNode, SplitterNode, StaticTextNode, TabsNode, TextareaNode, UiReferenceNode, WidgetState };

package/dist/lib/widgets/delegation.d.ts

@@ -0,0 +1,30 @@
+import type { ActionDefinition, DescriptionNode, WidgetState } from '../types.js';
+type DelegationEnvironment = {
+    nodeById: Map<string, DescriptionNode>;
+    nodeByKey: Map<string, DescriptionNode>;
+    stateByKey: Map<string, WidgetState>;
+    getLastPointer: () => {
+        x: number;
+        y: number;
+    };
+    setActiveContextMenu: (menu: {
+        id: string;
+        x: number;
+        y: number;
+    } | null) => void;
+    isWidgetEnabled: (node: DescriptionNode, key: string) => boolean;
+    startSplitterDrag: (layoutKey: string, axis: 'horizontal' | 'vertical', splitterIndex: number, startPointer: number) => void;
+    getSplitterDragAxis: () => 'horizontal' | 'vertical' | null;
+    updateSplitterDrag: (clientPosition: number) => void;
+    stopSplitterDrag: () => void;
+    hasSplitterDrag: () => boolean;
+    closeModal: (modalId: string | null) => void;
+    rerenderRoot: () => Promise<void>;
+    redispatchUnderlyingClick: (clientX: number, clientY: number) => void;
+    runActions: (actions: ActionDefinition[], inputValue: unknown, context: {
+        currentValue: unknown;
+        responseValue?: unknown;
+    }) => Promise<unknown>;
+};
+export declare function bindDelegatedUi(root: HTMLElement, env: DelegationEnvironment): void;
+export {};

package/dist/lib/widgets/edit.d.ts

@@ -0,0 +1,12 @@
+import type { BaseNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type EditNode = BaseNode & {
+    widget: 'edit';
+    text?: string;
+    placeholder?: string;
+    enabled?: boolean | string;
+    editable?: boolean | string;
+    type?: 'string' | 'number' | 'float' | 'date' | 'password';
+    format?: 'yyyy-MM-dd' | 'dd.MM.yyyy';
+};
+export declare const renderEdit: WidgetRenderer<EditNode>;

package/dist/lib/widgets/grid-view.d.ts

@@ -0,0 +1,9 @@
+import type { BaseNode, DescriptionNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type GridViewNode = BaseNode & {
+    widget: 'grid-view';
+    rowSize?: number | string;
+    size?: number;
+    elements?: DescriptionNode[];
+};
+export declare const renderGridView: WidgetRenderer<GridViewNode>;

package/dist/lib/widgets/image.d.ts

@@ -0,0 +1,7 @@
+import type { BaseNode } from '../types.js';
+import type { WidgetRenderer } from './context.js';
+export type ImageNode = BaseNode & {
+    widget: 'image';
+    url?: string;
+};
+export declare const renderImage: WidgetRenderer<ImageNode>;