@vortexm/vjt 0.1.4 → 0.1.6

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

@@ -6,6 +6,8 @@ export type ActionExecutionContext = {
         x: number;
         y: number;
     } | null;
+    currentList?: unknown[];
+    currentIndex?: number;
 };
 type ActionRuntimeOptions = {
     debugLogging: boolean;
@@ -13,6 +15,7 @@ type ActionRuntimeOptions = {
     actionFunctions: Record<string, () => unknown>;
     nodeById: Map<string, DescriptionNode>;
     stateById: Map<string, WidgetState>;
+    stateByKey: Map<string, WidgetState>;
     rerenderRoot: () => Promise<void>;
     dispatchWidgetEvent: (node: DescriptionNode, eventName: WidgetEventName, key: string, inputValue?: unknown, pointer?: {
         x: number;
@@ -27,6 +30,17 @@ type ActionRuntimeOptions = {
     resolveMappedValue: (template: unknown, currentValue: unknown, responseValue: unknown) => unknown;
     setWidgetEnabled: (widgetId: string, enabled: boolean) => void;
     clearWidget: (widgetId: string) => void;
+    clearListElementState: (listKey: string) => void;
+    focusWidget: (reference: string) => void;
+    playAudio: (value: unknown) => Promise<void>;
+    stopPlaying: () => Promise<void>;
+    copyToClipboard: (value: unknown) => Promise<void>;
+    selectFile: (options: unknown) => Promise<unknown>;
+    confirmModal: (options: unknown, inputValue: unknown) => Promise<boolean>;
+    startRecording: () => Promise<void>;
+    stopRecording: () => Promise<void>;
+    startListening: () => Promise<void>;
+    stopListening: () => Promise<void>;
     setUiReference: (widgetId: string, resourceRef: string) => void;
     refreshWidgetTree: (widgetId: string) => Promise<void>;
     renderWidgetTree: (widgetId: string) => Promise<void>;
@@ -42,6 +56,8 @@ type ActionRuntimeOptions = {
         id: string;
         x: number;
         y: number;
+        currentValue?: unknown;
+        openPath?: number[];
     } | null) => void;
     setActiveModalId: (modalId: string | null) => void;
     closeModal: (modalId?: string | null) => void;
@@ -54,6 +70,7 @@ export declare class ActionRuntime {
     private readonly actionFunctions;
     private readonly nodeById;
     private readonly stateById;
+    private readonly stateByKey;
     private readonly rerenderRoot;
     private readonly dispatchWidgetEventImpl;
     private readonly executeRequest;
@@ -63,6 +80,17 @@ export declare class ActionRuntime {
     private readonly resolveMappedValue;
     private readonly setWidgetEnabled;
     private readonly clearWidget;
+    private readonly clearListElementState;
+    private readonly focusWidget;
+    private readonly playAudio;
+    private readonly stopPlaying;
+    private readonly copyToClipboard;
+    private readonly selectFile;
+    private readonly confirmModal;
+    private readonly startRecording;
+    private readonly stopRecording;
+    private readonly startListening;
+    private readonly stopListening;
     private readonly setUiReference;
     private readonly refreshWidgetTree;
     private readonly renderWidgetTree;
@@ -82,5 +110,10 @@ export declare class ActionRuntime {
     getInlineActionsForNode(node: DescriptionNode): ActionDefinition[] | undefined;
     private runSingleAction;
     private executeAction;
+    private unwrapListValue;
+    private getCurrentListState;
+    private cloneValue;
+    private stringifyValue;
+    private isCurrentScopedReference;
 }
 export {};

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

@@ -15,16 +15,20 @@ export type PreservedElementState = {
     }>;
 };
 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 captureElementState(root: HTMLElement, pendingResetModalIds: Set<string>): PreservedElementState;
+export declare function restoreElementState(root: HTMLElement, state: PreservedElementState, stateByKey: Map<string, WidgetState>): void;
 export declare function adjustContextMenuPosition(root: HTMLElement, activeContextMenu: {
     id: string;
     x: number;
     y: number;
+    currentValue?: unknown;
+    openPath?: number[];
 } | null): {
     id: string;
     x: number;
     y: number;
+    currentValue?: unknown;
+    openPath?: number[];
 } | null;
 export declare function updatePointerFromMouseEvent(event: MouseEvent): {
     x: number;

package/dist/lib/network.d.ts

@@ -25,6 +25,8 @@ export declare class NetworkRuntime {
     executeRequest(requestName: string, currentValue: unknown): Promise<unknown>;
     buildSchemaValue(schema: RequestSchema, currentValue: unknown, responseValue: unknown): Promise<unknown>;
     private stringifyPrimitive;
+    private createRequestError;
+    private toRequestErrorPayload;
     coercePrimitiveSchemaValue(type: PrimitiveRequestType, value: unknown): unknown;
     private handleSseEvent;
 }

package/dist/lib/references.d.ts

@@ -6,6 +6,8 @@ type ReferenceRuntimeHost = {
     readonly nodeByKey: Map<string, DescriptionNode>;
     getAppValue: (name: string) => unknown;
     setAppValue: (name: string, value: unknown) => void;
+    getVarValue: (name: string) => unknown;
+    setVarValue: (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;

package/dist/lib/types.d.ts

@@ -4,7 +4,7 @@ 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' | 'onEnter' | 'onShiftEnter' | 'onControlEnter';
-export type SystemEventName = 'onBeforeRender' | 'onAfterRender' | 'onBeforeNavigate' | 'onAfterNavigate';
+export type SystemEventName = 'onBeforeRender' | 'onAfterRender' | 'onBeforeNavigate' | 'onAfterNavigate' | 'onSpeechDetected' | 'onRecordingStarted' | 'onRecordingStopped' | 'onRecordingError' | 'onListeningError' | 'onListeringError' | 'onPlayFinished' | 'onPlayingStopped';
 export type PrimitiveRequestType = 'int' | 'float' | 'boolean' | 'string';
 export type ActionDefinition = {
     action: string;
@@ -34,6 +34,7 @@ export type RequestDefinition = {
     request: RequestSchema;
     response?: RequestSchema;
     onResponse?: ActionDefinition[];
+    onError?: ActionDefinition[];
 };
 export type SseEventDefinition = {
     name: string;
@@ -114,6 +115,7 @@ export type WidgetState = {
 };
 export type RuntimeSnapshot = {
     stateByKey: Array<[string, WidgetState]>;
+    vars: Array<[string, unknown]>;
     activeModalId: string | null;
     activeContextMenu: {
         id: string;

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

@@ -0,0 +1,48 @@
+import type { SystemEventName } from './types.js';
+type VoiceRuntimeOptions = {
+    debugLogging: boolean;
+    triggerSystemEvent: (eventName: SystemEventName, inputValue: unknown) => Promise<void>;
+};
+export declare class VoiceRuntime {
+    private readonly debugLogging;
+    private readonly triggerSystemEvent;
+    private readonly activePlayers;
+    private mediaStream;
+    private mediaRecorder;
+    private recordingChunks;
+    private recordingTimeoutId;
+    private listening;
+    private listenContext;
+    private listenAnalyser;
+    private listenSource;
+    private listenFrameId;
+    private lastSpeechAt;
+    private listeningStartedAt;
+    private recordingStartedFromListening;
+    private speechEventTriggered;
+    private readonly visibilityHandler;
+    private readonly pageHideHandler;
+    constructor(options: VoiceRuntimeOptions);
+    play(value: unknown): Promise<void>;
+    stopPlaying(): Promise<void>;
+    startRecording(): Promise<void>;
+    stopRecording(): void;
+    startListening(): Promise<void>;
+    stopListening(): Promise<void>;
+    dispose(): void;
+    private startRecordingInternal;
+    private handleRecorderStop;
+    private handleRecordingError;
+    private handleListeningError;
+    private normalizePlayablePayload;
+    private getPreferredRecordingMimeType;
+    private ensureInputStream;
+    private clearRecordingTimeout;
+    private releaseInputStreamIfIdle;
+    private stopStreamTracks;
+    private normalizeErrorMessage;
+    private detachPlayer;
+    private finishPlayback;
+    private handlePageDeactivation;
+}
+export {};

package/dist/lib/widgets/confirm-modal.d.ts

@@ -0,0 +1,7 @@
+import type { WidgetRenderEnvironment } from './context.js';
+export type ConfirmModalState = {
+    caption: string;
+    yes: string;
+    no: string;
+};
+export declare function renderConfirmModalOverlay(env: WidgetRenderEnvironment, modal: ConfirmModalState): string;

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

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

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

@@ -5,7 +5,7 @@ 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 { ActiveContextMenuState, ContextMenuNode } from './context-menu.js';
 import type { GridViewNode } from './grid-view.js';
 import type { ImageNode } from './image.js';
 import type { LinkNode } from './link.js';
@@ -23,11 +23,7 @@ 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 activeContextMenu: ActiveContextMenuState | null;
     readonly activeModalId: string | null;
     readonly nodeById: Map<string, DescriptionNode>;
     escapeHtml: (value: unknown) => string;

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

@@ -7,10 +7,19 @@ type DelegationEnvironment = {
         x: number;
         y: number;
     };
+    getActiveContextMenu: () => {
+        id: string;
+        x: number;
+        y: number;
+        currentValue?: unknown;
+        openPath?: number[];
+    } | null;
     setActiveContextMenu: (menu: {
         id: string;
         x: number;
         y: number;
+        currentValue?: unknown;
+        openPath?: number[];
     } | null) => void;
     isWidgetEnabled: (node: DescriptionNode, key: string) => boolean;
     startSplitterDrag: (layoutKey: string, axis: 'horizontal' | 'vertical', splitterIndex: number, startPointer: number) => void;
@@ -18,6 +27,7 @@ type DelegationEnvironment = {
     updateSplitterDrag: (clientPosition: number) => void;
     stopSplitterDrag: () => void;
     hasSplitterDrag: () => boolean;
+    resolveConfirmModal: (confirmed: boolean) => void;
     closeModal: (modalId: string | null) => void;
     rerenderRoot: () => Promise<void>;
     redispatchUnderlyingClick: (clientX: number, clientY: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vortexm/vjt",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/vjt-styles.css

@@ -685,12 +685,21 @@ body {
 }
 
 .vjt-modal-backdrop,
-.vjt-context-menu-backdrop {
+.vjt-context-menu-backdrop,
+.vjt-confirm-backdrop {
   position: fixed;
   inset: 0;
+}
+
+.vjt-modal-backdrop,
+.vjt-context-menu-backdrop {
   z-index: 1000;
 }
 
+.vjt-confirm-backdrop {
+  z-index: 1100;
+}
+
 .vjt-modal-backdrop {
   display: flex;
   align-items: center;
@@ -759,16 +768,20 @@ body {
 }
 
 .vjt-context-menu {
-  position: fixed;
-  min-width: 180px;
-  padding: 8px;
-  border-radius: 14px;
+    position: fixed;
+    box-sizing: border-box;
+    width: 220px;
+    padding: 8px;
+    border-radius: 14px;
   border: 1px solid var(--vjt-border);
   background: var(--vjt-surface);
   box-shadow: var(--vjt-shadow);
 }
 
 .vjt-context-menu-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
   width: 100%;
   padding: 10px 12px;
   text-align: left;
@@ -781,3 +794,48 @@ body {
 .vjt-context-menu-item:hover {
   background: color-mix(in srgb, var(--vjt-accent) 14%, transparent);
 }
+
+.vjt-context-menu-item--parent {
+  font-weight: 500;
+}
+
+.vjt-context-menu-chevron {
+  margin-left: 16px;
+  opacity: 0.7;
+}
+
+.vjt-confirm-backdrop {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(7, 10, 15, 0.42);
+  padding: 24px;
+}
+
+.vjt-confirm-window {
+  width: min(420px, calc(100vw - 32px));
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+  padding: 22px;
+  border-radius: 18px;
+  border: 1px solid var(--vjt-border);
+  background: var(--vjt-modal-surface);
+  color: var(--vjt-text);
+  box-shadow: var(--vjt-shadow);
+}
+
+.vjt-confirm-caption {
+  line-height: 1.45;
+  white-space: pre-wrap;
+}
+
+.vjt-confirm-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+.vjt-confirm-actions .vjt-button {
+  min-width: 120px;
+}