@absolutejs/voice 0.0.22-beta.501 → 0.0.22-beta.503

package/dist/client/htmxAttributes.d.ts

@@ -0,0 +1,28 @@
+export type VoiceHTMXPollingAttributes = {
+    /** Set true to emit hx-get/hx-trigger when refreshUrl is also provided. */
+    poll?: boolean;
+    /** Polling cadence. Default 5_000ms. Clamped to >= 1_000ms. */
+    pollIntervalMs?: number;
+    /** Extra HTMX attributes to splice in. Keys without the 'hx-' prefix have it added. */
+    pushAttributes?: Record<string, string>;
+    /** URL hx-get fires against. Without it, polling is skipped. */
+    refreshUrl?: string;
+    /** hx-swap value. Default 'outerHTML'. */
+    swap?: string;
+    /** Optional hx-target selector. */
+    target?: string;
+};
+export declare const buildVoiceHTMXAttributes: (attrs: VoiceHTMXPollingAttributes | undefined) => string;
+/**
+ * Injects HTMX polling attributes into the first opening tag of an HTML string.
+ * Returns the original HTML unchanged when attrs produce no attributes.
+ */
+export declare const wrapVoiceHTMLWithHTMXPolling: (html: string, attrs: VoiceHTMXPollingAttributes | undefined) => string;
+/**
+ * Wraps arbitrary HTML in a self-refreshing div that polls refreshUrl.
+ * Use this when the inner HTML doesn't have a stable root element to mutate.
+ */
+export declare const wrapVoiceHTMLInHTMXContainer: (html: string, attrs: VoiceHTMXPollingAttributes & {
+    className?: string;
+    elementTag?: string;
+}) => string;

package/dist/client/htmxDashboardRenderers.d.ts

@@ -0,0 +1,72 @@
+import type { StoredVoiceTraceEvent } from "../trace";
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type VoiceCostDashboardBucket, type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "./costDashboard";
+import { type LiveCallViewState, type LiveCallViewer } from "./liveCallViewer";
+import { type ReplayTimelineReport } from "./replayTimeline";
+import { type VoiceHTMXPollingAttributes } from "./htmxAttributes";
+export type VoiceDashboardHTMXAttributes = VoiceHTMXPollingAttributes;
+export type VoiceCostDashboardHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    currency?: string;
+    emptyMessage?: string;
+    report: VoiceCostDashboardReport;
+    title?: string;
+};
+export type VoiceCostDashboardRenderer = (input: VoiceCostDashboardHTMXInput) => string;
+export type VoiceCostDashboardCellRenderer = (bucket: VoiceCostDashboardBucket, currency: string, isTotal: boolean) => string;
+export type VoiceReplayTimelineHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    emptyMessage?: string;
+    report: ReplayTimelineReport;
+    title?: string;
+};
+export type VoiceReplayTimelineRenderer = (input: VoiceReplayTimelineHTMXInput) => string;
+export type VoiceLiveCallViewerHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    state: LiveCallViewState;
+    title?: string;
+};
+export type VoiceLiveCallViewerRenderer = (input: VoiceLiveCallViewerHTMXInput) => string;
+export type VoiceDashboardHTMXRendererConfig = {
+    costDashboard?: VoiceCostDashboardRenderer;
+    liveCallViewer?: VoiceLiveCallViewerRenderer;
+    replayTimeline?: VoiceReplayTimelineRenderer;
+};
+export type ResolvedVoiceDashboardRenderers = Required<VoiceDashboardHTMXRendererConfig>;
+export declare const resolveVoiceDashboardRenderers: (custom?: VoiceDashboardHTMXRendererConfig) => ResolvedVoiceDashboardRenderers;
+export declare const renderVoiceCostDashboardHTMX: (input: VoiceCostDashboardHTMXInput & {
+    custom?: VoiceCostDashboardRenderer;
+}) => string;
+export declare const renderVoiceReplayTimelineHTMX: (input: VoiceReplayTimelineHTMXInput & {
+    custom?: VoiceReplayTimelineRenderer;
+}) => string;
+export declare const renderVoiceLiveCallViewerHTMX: (input: VoiceLiveCallViewerHTMXInput & {
+    custom?: VoiceLiveCallViewerRenderer;
+}) => string;
+export declare const renderVoiceCostDashboardFromEvents: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    currency?: string;
+    events: ReadonlyArray<StoredVoiceTraceEvent>;
+    options?: Omit<VoiceCostDashboardOptions, "events">;
+    renderer?: VoiceCostDashboardRenderer;
+    title?: string;
+}) => string;
+export declare const renderVoiceReplayTimelineFromArtifact: (input: {
+    artifact: VoiceCallReviewArtifact;
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceReplayTimelineRenderer;
+    title?: string;
+}) => string;
+export declare const renderVoiceLiveCallViewerFromViewer: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceLiveCallViewerRenderer;
+    title?: string;
+    viewer: LiveCallViewer;
+}) => string;
+export declare const renderVoiceLiveCallViewerFromState: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceLiveCallViewerRenderer;
+    state: LiveCallViewState;
+    title?: string;
+}) => string;
+export declare const createLiveCallViewerFromOptions: (options: import("./liveCallViewer").CreateLiveCallViewerOptions) => LiveCallViewer;

package/dist/htmxDashboardRoutes.d.ts

@@ -0,0 +1,249 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { LiveCallViewer } from "./client/liveCallViewer";
+import { type VoiceDashboardHTMXRendererConfig } from "./client/htmxDashboardRenderers";
+import type { VoiceCostDashboardOptions } from "./client/costDashboard";
+export type VoiceHTMXDashboardRoutesShared = {
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+};
+export type VoiceHTMXCostDashboardRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    bucketBy?: VoiceCostDashboardOptions["bucketBy"];
+    currency?: string;
+    fromMs?: () => number | undefined;
+    path?: string;
+    pollIntervalMs?: number;
+    resolveEvents: () => Promise<ReadonlyArray<StoredVoiceTraceEvent>> | ReadonlyArray<StoredVoiceTraceEvent>;
+    title?: string;
+    toMs?: () => number | undefined;
+};
+export declare const createVoiceCostDashboardHTMXRoute: (options: VoiceHTMXCostDashboardRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXReplayTimelineRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** The HTML route mounts at `${path}/:artifactId`. */
+    path?: string;
+    resolveArtifact: (artifactId: string) => Promise<StoredVoiceCallReviewArtifact | undefined> | StoredVoiceCallReviewArtifact | undefined;
+    title?: string;
+};
+export declare const createVoiceReplayTimelineHTMXRoute: (options: VoiceHTMXReplayTimelineRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":artifactId": {
+            get: {
+                body: unknown;
+                params: {
+                    artifactId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXLiveCallViewerRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** Route mounts at `${path}/:sessionId`. */
+    path?: string;
+    pollIntervalMs?: number;
+    resolveViewer: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    title?: string;
+};
+export declare const createVoiceLiveCallViewerHTMXRoute: (options: VoiceHTMXLiveCallViewerRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":sessionId": {
+            get: {
+                body: unknown;
+                params: {
+                    sessionId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXDashboardRoutesOptions = {
+    cost?: Omit<VoiceHTMXCostDashboardRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    liveCall?: Omit<VoiceHTMXLiveCallViewerRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+    replay?: Omit<VoiceHTMXReplayTimelineRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+};
+export declare const createVoiceHTMXDashboardRoutes: (options: VoiceHTMXDashboardRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type CreateVoiceHTMXDashboardRoutesFromStoresOptions = {
+    liveViewerByCallId?: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    pollIntervalMs?: number;
+    render?: VoiceDashboardHTMXRendererConfig;
+    reviewStore?: VoiceCallReviewStore;
+    traceStore?: VoiceTraceEventStore;
+};
+export declare const createVoiceHTMXDashboardRoutesFromStores: (options: CreateVoiceHTMXDashboardRoutesFromStoresOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/index.d.ts

@@ -110,6 +110,12 @@ export { createInMemoryVoiceCallQuota } from "./callQuota";
 export type { CreateInMemoryVoiceCallQuotaOptions, VoiceCallQuota, VoiceCallQuotaRejection, VoiceCallQuotaResult, VoiceCallQuotaTier, VoiceCallReservation, } from "./callQuota";
 export { createVoiceBearerAuthVerifier, createVoiceHMACAuthVerifier, createVoiceRouteAuth, } from "./routeAuth";
 export type { VoiceRouteAuthDecision, VoiceRouteAuthInput, VoiceRouteAuthOptions, VoiceRouteAuthVerifier, } from "./routeAuth";
+export { buildVoiceHTMXAttributes, wrapVoiceHTMLInHTMXContainer, wrapVoiceHTMLWithHTMXPolling, } from "./client/htmxAttributes";
+export type { VoiceHTMXPollingAttributes } from "./client/htmxAttributes";
+export { createLiveCallViewerFromOptions, renderVoiceCostDashboardFromEvents, renderVoiceCostDashboardHTMX, renderVoiceLiveCallViewerFromState, renderVoiceLiveCallViewerFromViewer, renderVoiceLiveCallViewerHTMX, renderVoiceReplayTimelineFromArtifact, renderVoiceReplayTimelineHTMX, resolveVoiceDashboardRenderers, } from "./client/htmxDashboardRenderers";
+export type { ResolvedVoiceDashboardRenderers, VoiceCostDashboardHTMXInput, VoiceCostDashboardRenderer, VoiceDashboardHTMXAttributes, VoiceDashboardHTMXRendererConfig, VoiceLiveCallViewerHTMXInput, VoiceLiveCallViewerRenderer, VoiceReplayTimelineHTMXInput, VoiceReplayTimelineRenderer, } from "./client/htmxDashboardRenderers";
+export { createVoiceCostDashboardHTMXRoute, createVoiceHTMXDashboardRoutes, createVoiceHTMXDashboardRoutesFromStores, createVoiceLiveCallViewerHTMXRoute, createVoiceReplayTimelineHTMXRoute, } from "./htmxDashboardRoutes";
+export type { CreateVoiceHTMXDashboardRoutesFromStoresOptions, VoiceHTMXCostDashboardRoutesOptions, VoiceHTMXDashboardRoutesOptions, VoiceHTMXLiveCallViewerRoutesOptions, VoiceHTMXReplayTimelineRoutesOptions, } from "./htmxDashboardRoutes";
 export { buildVoiceCostDashboardReport } from "./client/costDashboard";
 export type { VoiceCostDashboardBucket, VoiceCostDashboardOptions, VoiceCostDashboardReport, } from "./client/costDashboard";
 export { createLiveCallViewer } from "./client/liveCallViewer";