@opencx/widget-react 4.0.61 → 5.0.0-beta.0

package/dist/src/components/lib/tooltip.d.ts

@@ -1,11 +1,27 @@
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
 import * as React from 'react';
 declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
-declare function Tooltippy({ children, content, side, align, }: {
+/**
+ * Silences every tooltip rendered inside. Companion's quick-ask bar wraps the
+ * composer in it: the shell clips that composer to a thin strip, so a
+ * `side="top"` tooltip bleeds above the bar as a dark sliver. Stated once for
+ * the whole subtree, so no control inside has to be told individually.
+ */
+declare function SuppressTooltips({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+declare function Tooltippy({ children, content, side, align, shortcut, }: {
     children: React.ReactNode;
     content: React.ReactNode;
     side?: TooltipPrimitive.TooltipContentProps['side'];
     align?: TooltipPrimitive.TooltipContentProps['align'];
+    /**
+     * Display form of the action's keyboard shortcut (e.g. "⌘⇧F", "Esc"),
+     * rendered as a fainter chip after the label. Always produce it with
+     * `formatBinding(WIDGET_KEYBINDINGS[action])` so the hint can never drift
+     * from the binding the handler actually matches.
+     */
+    shortcut?: string;
 }): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
-export { TooltipProvider, Tooltippy };
+export { TooltipProvider, Tooltippy, SuppressTooltips };
 //# sourceMappingURL=tooltip.d.ts.map

package/dist/src/components/lib/tooltip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/components/lib/tooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,gBAAgB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,QAAA,MAAM,eAAe,iDAA4B,CAAC;AAuBlD,iBAAS,SAAS,CAAC,EACjB,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,IAAI,CAAC,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IACpD,KAAK,CAAC,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;CACvD,mSAgBA;AAED,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/components/lib/tooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,gBAAgB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,QAAA,MAAM,eAAe,iDAA4B,CAAC;AAyBlD;;;;;GAKG;AACH,iBAAS,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,qBAIpE;AAED,iBAAS,SAAS,CAAC,EACjB,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,KAAK,EACL,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,IAAI,CAAC,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IACpD,KAAK,CAAC,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,mSAsBA;AAED,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/src/hooks/useCanHover.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether the visitor's primary input can hover. Hover-driven motion (pill
+ * label reveal, submenu on hover) is gated off coarse pointers, where a tap
+ * fires the hover events first and reads as a phantom wiggle before every
+ * open. Detected once: an input modality does not change mid-session.
+ */
+export declare function useCanHover(): boolean;
+//# sourceMappingURL=useCanHover.d.ts.map

package/dist/src/hooks/useCanHover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanHover.d.ts","sourceRoot":"","sources":["../../../src/hooks/useCanHover.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAOrC"}

package/dist/src/hooks/useTheme.d.ts

@@ -1,4 +1,3 @@
-import { CSSProperties } from 'react';
 /**
  * @returns The widget config theme with fallback default value
  */
@@ -60,6 +59,22 @@ export declare function useTheme(): {
         minHeight: string;
         minWidth: string;
     };
-    cssVars: CSSProperties;
+    cssVars: {
+        '--opencx-primary': string;
+        '--opencx-primary-foreground': string;
+        '--opencx-background': string;
+        '--opencx-foreground': string;
+        '--opencx-destructive': string;
+        '--opencx-destructive-foreground': string;
+        '--opencx-accent': string;
+        '--opencx-accent-foreground': string;
+        '--opencx-secondary': string;
+        '--opencx-secondary-foreground': string;
+        '--opencx-muted': string;
+        '--opencx-muted-foreground': string;
+        '--opencx-input': string;
+        '--opencx-border': string;
+        '--opencx-ring': string;
+    };
 };
 //# sourceMappingURL=useTheme.d.ts.map

package/dist/src/hooks/useTheme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTheme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAiB3C;;GAEG;AACH,wBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqKvB"}
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTheme.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,wBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqKvB"}

package/dist/src/hooks/useTranslation.d.ts

@@ -1,7 +1,8 @@
 import { TranslationKeyU } from '@opencx/widget-core';
+export type Translate = (key: TranslationKeyU, params?: Record<string, string | number>) => string;
 export declare function useTranslation(): {
-    t: (key: TranslationKeyU) => string;
-    language: "hr" | "th" | "tr" | "is" | "fr" | "no" | "ar" | "bn" | "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fil" | "hi" | "hu" | "it" | "ja" | "ko" | "lb" | "lt" | "lv" | "mt" | "nb" | "nl" | "pl" | "pt" | "ro" | "ru" | "sk" | "sv" | "ur" | "vi" | "zh-cn";
+    t: Translate;
+    language: "ar" | "bn" | "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fil" | "fr" | "hi" | "hr" | "hu" | "is" | "it" | "ja" | "ko" | "lb" | "lt" | "lv" | "mt" | "nb" | "nl" | "no" | "pl" | "pt" | "ro" | "ru" | "sk" | "sv" | "th" | "tr" | "ur" | "vi" | "zh-cn";
     dir: string;
     hostDocumentDir: import('@opencx/widget-core').StringOrLiteral<"ltr" | "rtl">;
 };

package/dist/src/hooks/useTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTranslation.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTranslation.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,cAAc;aASf,eAAe;;;;EAM7B"}
+{"version":3,"file":"useTranslation.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTranslation.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,SAAS,GAAG,CACtB,GAAG,EAAE,eAAe,EACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KACrC,MAAM,CAAC;AAEZ,wBAAgB,cAAc;;;;;EAe7B"}

package/dist/src/hooks/useTriggerLabel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Accessible label for the widget launcher — the popover trigger button and
+ * the companion resting pill share this one default.
+ */
+export declare function useTriggerLabel(): string;
+//# sourceMappingURL=useTriggerLabel.d.ts.map

package/dist/src/hooks/useTriggerLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTriggerLabel.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTriggerLabel.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAGxC"}

package/dist/src/index.d.ts

@@ -1,12 +1,23 @@
 import { default as React } from 'react';
 import { WidgetConfig } from '@opencx/widget-core';
 import { WidgetComponentType } from '@opencx/widget-react-headless';
+import { StreamingSpecComponentProps } from './components/StreamingTurn';
+import { StreamingStepsComponentProps } from './components/StepsGroup';
+import { ClarificationQuestionsProps } from './components/ClarificationQuestions';
 import { WidgetRef } from './WidgetImperativeHandler';
 declare const Widget: React.ForwardRefExoticComponent<{
     options: WidgetConfig;
     components?: WidgetComponentType[];
     loadingComponent?: React.ReactNode;
+    errorComponent?: (error: Error) => React.ReactNode;
 } & React.RefAttributes<WidgetRef>>;
 export { Widget };
-export type { WidgetRef };
+/**
+ * The agent's inline UI, for a host page that shows widget transcripts
+ * outside the widget (the OpenCX inbox): the same catalog, renderer, and
+ * fence parser the widget uses, so what the agent reads is what the customer
+ * saw.
+ */
+export { HostedSpecRenderer, segmentContent, type ContentSegment, } from './json-render';
+export type { ClarificationQuestionsProps, StreamingSpecComponentProps, StreamingStepsComponentProps, WidgetRef, };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAGV,YAAY,EACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAOvC,OAAO,EAEL,KAAK,SAAS,EACf,MAAM,2BAA2B,CAAC;AA6CnC,QAAA,MAAM,MAAM;aAGC,YAAY;iBACR,mBAAmB,EAAE;uBACf,KAAK,CAAC,SAAS;mCAoBpC,CAAC;AAGH,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAGV,YAAY,EACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAUvC,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEL,KAAK,SAAS,EACf,MAAM,2BAA2B,CAAC;AA6EnC,QAAA,MAAM,MAAM;aAGC,YAAY;iBACR,mBAAmB,EAAE;uBACf,KAAK,CAAC,SAAS;qBACjB,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAAC,SAAS;mCA8BpD,CAAC;AAGH,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB;;;;;GAKG;AACH,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,SAAS,GACV,CAAC"}

package/dist/src/json-render/Chart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from './props';
+export declare function Chart(props: ChartProps): React.JSX.Element;
+//# sourceMappingURL=Chart.d.ts.map

package/dist/src/json-render/Chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chart.d.ts","sourceRoot":"","sources":["../../../src/json-render/Chart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAgB1C,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,qBAOtC"}

package/dist/src/json-render/Chart.impl.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from './props';
+export default function ChartImpl({ type, data, height, centerLabel, }: ChartProps): React.JSX.Element;
+//# sourceMappingURL=Chart.impl.d.ts.map

package/dist/src/json-render/Chart.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chart.impl.d.ts","sourceRoot":"","sources":["../../../src/json-render/Chart.impl.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAgB1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAuD1C,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,EAChC,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,WAAW,GACZ,EAAE,UAAU,qBAsGZ"}

package/dist/src/json-render/JsonRenderErrorBoundary.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+/**
+ * Last-resort guard around a rendered spec. json-render validates props at the
+ * registry boundary (`parseProps`), but a genuinely broken tree (e.g. a cyclic
+ * `children` ref) could still throw during render — this keeps that from taking
+ * down the whole chat transcript. On error we render nothing (the prose in the
+ * same message still shows) and log once for diagnosis.
+ */
+export declare class JsonRenderErrorBoundary extends React.Component<{
+    children: React.ReactNode;
+    resetKey: unknown;
+}, {
+    hasError: boolean;
+}> {
+    state: {
+        hasError: boolean;
+    };
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: unknown): void;
+    componentDidUpdate(prevProps: Readonly<{
+        resetKey: unknown;
+    }>): void;
+    render(): React.ReactNode;
+}
+//# sourceMappingURL=JsonRenderErrorBoundary.d.ts.map

package/dist/src/json-render/JsonRenderErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRenderErrorBoundary.d.ts","sourceRoot":"","sources":["../../../src/json-render/JsonRenderErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,KAAK,CAAC,SAAS,CAC1D;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,EAChD;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CACtB;IACU,KAAK;;MAAuB;IAErC,MAAM,CAAC,wBAAwB;;;IAItB,iBAAiB,CAAC,KAAK,EAAE,OAAO;IAMhC,kBAAkB,CAAC,SAAS,EAAE,QAAQ,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAS7D,MAAM;CAIhB"}

package/dist/src/json-render/SpecRenderer.d.ts

@@ -0,0 +1,28 @@
+import { Spec } from '@json-render/core';
+import { WidgetUiAction } from '@opencx/widget-core';
+import { default as React } from 'react';
+/**
+ * The single seam every json-render spec funnels through — both the live
+ * streamed turn and persisted (fence-parsed) history go through here, so both
+ * get the same recovery + defenses.
+ *
+ * Applies leaf-`repeat` recovery, guards empty/partial specs, and renders under
+ * a per-spec state provider (so `{ "$state": "/path" }` refs resolve against
+ * THIS spec's own state) wrapped in an error boundary.
+ */
+export declare function SpecRenderer({ spec }: {
+    spec: Spec | null;
+}): React.JSX.Element;
+/**
+ * The same renderer for a page that is not the widget but shows what the
+ * widget showed — the OpenCX inbox. The host supplies what the widget would
+ * have read from its config; nothing else about rendering differs, so a
+ * customer and the agent reading their session see one and the same card.
+ */
+export declare function HostedSpecRenderer({ spec, language, onUiAction, anchorTarget, }: {
+    spec: Spec | null;
+    language?: string;
+    onUiAction?: (action: WidgetUiAction) => void;
+    anchorTarget?: string;
+}): React.JSX.Element;
+//# sourceMappingURL=SpecRenderer.d.ts.map

package/dist/src/json-render/SpecRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecRenderer.d.ts","sourceRoot":"","sources":["../../../src/json-render/SpecRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAkB,MAAM,OAAO,CAAC;AAWvC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAAE,qBAQ3D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,YAAY,GACb,EAAE;IACD,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,qBAGA"}

package/dist/src/json-render/__tests__/catalog.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=catalog.spec.d.ts.map

package/dist/src/json-render/__tests__/catalog.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/catalog.spec.ts"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/chart.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=chart.spec.d.ts.map

package/dist/src/json-render/__tests__/chart.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/chart.spec.tsx"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/json-render-error-boundary.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json-render-error-boundary.spec.d.ts.map

package/dist/src/json-render/__tests__/json-render-error-boundary.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-render-error-boundary.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/json-render-error-boundary.spec.tsx"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/normalize-spec.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=normalize-spec.spec.d.ts.map

package/dist/src/json-render/__tests__/normalize-spec.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-spec.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/normalize-spec.spec.ts"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/phone-agent-card.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=phone-agent-card.spec.d.ts.map

package/dist/src/json-render/__tests__/phone-agent-card.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phone-agent-card.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/phone-agent-card.spec.tsx"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/props.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=props.spec.d.ts.map

package/dist/src/json-render/__tests__/props.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/props.spec.ts"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/segment-content.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=segment-content.spec.d.ts.map

package/dist/src/json-render/__tests__/segment-content.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-content.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/segment-content.spec.ts"],"names":[],"mappings":""}

package/dist/src/json-render/__tests__/spec-renderer.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spec-renderer.spec.d.ts.map

package/dist/src/json-render/__tests__/spec-renderer.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-renderer.spec.d.ts","sourceRoot":"","sources":["../../../../src/json-render/__tests__/spec-renderer.spec.tsx"],"names":[],"mappings":""}

package/dist/src/json-render/catalog.d.ts

@@ -0,0 +1,260 @@
+/**
+ * The widget's json-render catalog — the closed set of components the agent may
+ * emit. It is the single source of truth in two directions: `registry.tsx`
+ * binds each name to a React renderer, and the backend prompt is generated from
+ * this same catalog (see `ui-prompt.ts`, codegen-only — never imported by the
+ * shipped widget), so the model can never emit a component the widget can't
+ * render.
+ *
+ * Kept deliberately small and embed-light (no per-org customization in v1):
+ * layout primitives + list / table / metric / callout / chart. `description`
+ * and `example` are the model's only guidance — they steer generation, so keep
+ * them tight.
+ */
+export declare const widgetCatalog: import('@json-render/core').Catalog<{
+    spec: import('@json-render/core').SchemaType<"object", {
+        root: import('@json-render/core').SchemaType<"string", unknown>;
+        elements: import('@json-render/core').SchemaType<"record", import('@json-render/core').SchemaType<"object", {
+            type: import('@json-render/core').SchemaType<"ref", string>;
+            props: import('@json-render/core').SchemaType<"propsOf", string>;
+            children: import('@json-render/core').SchemaType<"array", import('@json-render/core').SchemaType<"string", unknown>>;
+            visible: import('@json-render/core').SchemaType<"any", unknown>;
+        }>>;
+    }>;
+    catalog: import('@json-render/core').SchemaType<"object", {
+        components: import('@json-render/core').SchemaType<"map", {
+            props: import('@json-render/core').SchemaType<"zod", unknown>;
+            slots: import('@json-render/core').SchemaType<"array", import('@json-render/core').SchemaType<"string", unknown>>;
+            description: import('@json-render/core').SchemaType<"string", unknown>;
+            example: import('@json-render/core').SchemaType<"any", unknown>;
+        }>;
+        actions: import('@json-render/core').SchemaType<"map", {
+            params: import('@json-render/core').SchemaType<"zod", unknown>;
+            description: import('@json-render/core').SchemaType<"string", unknown>;
+        }>;
+    }>;
+}, {
+    components: {
+        Card: {
+            props: import('zod').ZodObject<{
+                title: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                description: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+            }, import('zod/v4/core').$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                title: string;
+                description: string;
+            };
+        };
+        Stack: {
+            props: import('zod').ZodObject<{
+                direction: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    row: "row";
+                    column: "column";
+                }>>>;
+                gap: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>>;
+                align: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    center: "center";
+                    start: "start";
+                    end: "end";
+                    stretch: "stretch";
+                }>>>;
+                justify: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    center: "center";
+                    start: "start";
+                    end: "end";
+                    between: "between";
+                }>>>;
+            }, import('zod/v4/core').$strip>;
+            slots: string[];
+            description: string;
+        };
+        Grid: {
+            props: import('zod').ZodObject<{
+                columns: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodUnion<readonly [import('zod').ZodLiteral<1>, import('zod').ZodLiteral<2>, import('zod').ZodLiteral<3>]>>>;
+                gap: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>>;
+            }, import('zod/v4/core').$strip>;
+            slots: string[];
+            description: string;
+        };
+        Heading: {
+            props: import('zod').ZodObject<{
+                text: import('zod').ZodString;
+                level: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodUnion<readonly [import('zod').ZodLiteral<1>, import('zod').ZodLiteral<2>, import('zod').ZodLiteral<3>, import('zod').ZodLiteral<4>]>>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                text: string;
+                level: number;
+            };
+        };
+        Text: {
+            props: import('zod').ZodObject<{
+                text: import('zod').ZodString;
+                variant: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    body: "body";
+                    caption: "caption";
+                    code: "code";
+                    muted: "muted";
+                }>>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+        };
+        Badge: {
+            props: import('zod').ZodObject<{
+                text: import('zod').ZodString;
+                variant: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    success: "success";
+                    default: "default";
+                    secondary: "secondary";
+                    warning: "warning";
+                    destructive: "destructive";
+                }>>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                text: string;
+                variant: string;
+            };
+        };
+        List: {
+            props: import('zod').ZodObject<{
+                items: import('zod').ZodArray<import('zod').ZodObject<{
+                    id: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                    label: import('zod').ZodString;
+                    secondary: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                    badge: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                    status: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                        success: "success";
+                        warning: "warning";
+                        error: "error";
+                        info: "info";
+                        neutral: "neutral";
+                    }>>>;
+                    href: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                }, import('zod/v4/core').$strip>>;
+                maxVisible: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodNumber>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                items: {
+                    label: string;
+                    secondary: string;
+                    status: string;
+                }[];
+            };
+        };
+        Table: {
+            props: import('zod').ZodObject<{
+                columns: import('zod').ZodArray<import('zod').ZodString>;
+                rows: import('zod').ZodArray<import('zod').ZodArray<import('zod').ZodString>>;
+                caption: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                columns: string[];
+                rows: string[][];
+            };
+        };
+        Metric: {
+            props: import('zod').ZodObject<{
+                label: import('zod').ZodString;
+                value: import('zod').ZodString;
+                description: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                trend: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    neutral: "neutral";
+                    up: "up";
+                    down: "down";
+                }>>>;
+                delta: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodObject<{
+                    value: import('zod').ZodString;
+                    direction: import('zod').ZodEnum<{
+                        flat: "flat";
+                        up: "up";
+                        down: "down";
+                    }>;
+                    label: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                }, import('zod/v4/core').$strip>>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                label: string;
+                value: string;
+                description: string;
+                trend: string;
+                delta: {
+                    value: string;
+                    direction: string;
+                    label: string;
+                };
+            };
+        };
+        Callout: {
+            props: import('zod').ZodObject<{
+                type: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodEnum<{
+                    warning: "warning";
+                    info: "info";
+                    tip: "tip";
+                    important: "important";
+                }>>>;
+                title: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                content: import('zod').ZodString;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                type: string;
+                title: string;
+                content: string;
+            };
+        };
+        PhoneAgentCard: {
+            props: import('zod').ZodObject<{
+                agentId: import('zod').ZodString;
+                agentName: import('zod').ZodString;
+                model: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                agentId: string;
+                agentName: string;
+                model: string;
+            };
+        };
+        Chart: {
+            props: import('zod').ZodObject<{
+                type: import('zod').ZodEnum<{
+                    line: "line";
+                    bar: "bar";
+                    pie: "pie";
+                }>;
+                data: import('zod').ZodArray<import('zod').ZodObject<{
+                    label: import('zod').ZodString;
+                    value: import('zod').ZodNumber;
+                }, import('zod/v4/core').$strip>>;
+                title: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+                height: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodNumber>>;
+                centerLabel: import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>;
+            }, import('zod/v4/core').$strip>;
+            description: string;
+            example: {
+                type: string;
+                title: string;
+                data: {
+                    label: string;
+                    value: number;
+                }[];
+            };
+        };
+    };
+    actions: {};
+}>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/src/json-render/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/json-render/catalog.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2GxB,CAAC"}

package/dist/src/json-render/host.d.ts

@@ -0,0 +1,27 @@
+import { TranslationKeyU, WidgetUiAction } from '@opencx/widget-core';
+import { default as React } from 'react';
+/**
+ * What the json-render registry needs from whoever mounts it. Inside the
+ * widget that is the widget config; on a host page that shows the same
+ * transcripts (the OpenCX inbox) it is a few props. One renderer, one
+ * catalog, two hosts — the registry never reaches for widget context itself.
+ */
+export type JsonRenderHost = {
+    t: (key: TranslationKeyU, params?: Record<string, string | number>) => string;
+    /** Where List links open — the embed's configured anchor target. */
+    anchorTarget: string;
+    /** Completes card actions the renderer cannot (e.g. test a phone agent). */
+    onUiAction?: (action: WidgetUiAction) => void;
+};
+export declare function JsonRenderHostProvider({ host, children, }: {
+    host: JsonRenderHost;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useJsonRenderHost(): JsonRenderHost;
+/** A host built from plain props — memoized so the tree does not re-render per keystroke. */
+export declare function useHostFromProps({ language, onUiAction, anchorTarget, }: {
+    language?: string;
+    onUiAction?: (action: WidgetUiAction) => void;
+    anchorTarget?: string;
+}): JsonRenderHost;
+//# sourceMappingURL=host.d.ts.map

package/dist/src/json-render/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/json-render/host.tsx"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAA6C,MAAM,OAAO,CAAC;AAElE;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,MAAM,CAAC;IAC9E,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;CAC/C,CAAC;AAeF,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,qBAMA;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,UAAU,EACV,YAAuB,GACxB,EAAE;IACD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,cAAc,CAKjB"}

package/dist/src/json-render/index.d.ts

@@ -0,0 +1,12 @@
+import { Spec } from '@json-render/core';
+import { DataPart } from '@json-render/react';
+export { HostedSpecRenderer, SpecRenderer } from './SpecRenderer';
+export { segmentContent, type ContentSegment } from './segment-content';
+/**
+ * Assemble the accumulated element-tree spec from a message's `data-spec` parts
+ * (the json-render patches `pipeJsonRender` emitted server-side). Returns `null`
+ * when the message carries no spec parts. Thin wrapper over `buildSpecFromParts`
+ * so the stream-mapping layer depends on this module, not the library directly.
+ */
+export declare function buildSpec(parts: DataPart[]): Spec | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/json-render/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/json-render/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEvE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,IAAI,CAExD"}