@opencx/widget-react 4.0.62 → 5.0.0-beta.1

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

@@ -0,0 +1,22 @@
+import { Spec } from '@json-render/core';
+/**
+ * Recover List rows the model parked behind a `repeat`.
+ *
+ * The slim widget prompt documents no `repeat` directive, but models that know
+ * the full json-render contract sometimes invent one anyway (bind a container's
+ * children to a `/state` array) and apply it to a `List` — a leaf that renders
+ * `props.items` and ignores `children` — producing
+ * `{ type: 'List', props: { items: [] }, repeat: { statePath } }` with the real
+ * rows sitting in `state`. That renders an invisible empty list.
+ *
+ * This detects a `List` with empty `items` + a `repeat`, resolves the state
+ * array, inlines it into `props.items`, and drops the `repeat`. Scoped to `List`
+ * on purpose: List items are 1:1 with state objects (lossless to inline). Table
+ * rows are positional `string[]` (can't inline) and an empty Table already shows
+ * a visible empty state, so it's not a silent failure there.
+ *
+ * Returns the SAME spec reference when nothing changed, to keep React identity
+ * stable across streaming re-renders.
+ */
+export declare function inlineRepeatLeaves(spec: Spec): Spec;
+//# sourceMappingURL=normalize-spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-spec.d.ts","sourceRoot":"","sources":["../../../src/json-render/normalize-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,IAAI,EAAkB,MAAM,mBAAmB,CAAC;AAGzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAanD"}

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

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+/**
+ * Runtime prop schemas for every json-render component the widget agent can
+ * emit, plus a defensive parser. These are the single source of truth: the
+ * catalog (`catalog.ts`) feeds them to the model prompt, and the registry
+ * (`registry.tsx`) parses streamed props through them before rendering.
+ *
+ * Optional props use `.nullish()` (null OR absent) rather than `.optional()` so
+ * a prop the model omits — or hasn't finished streaming — never fails the parse.
+ * Required props that ARE malformed fall back to a typed default (see
+ * `parseProps`), so a bad prop degrades one component to a safe empty state
+ * instead of throwing and tearing down the whole spec.
+ */
+export declare const cardPropsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const stackPropsSchema: z.ZodObject<{
+    direction: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        row: "row";
+        column: "column";
+    }>>>;
+    gap: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+    }>>>;
+    align: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        center: "center";
+        start: "start";
+        end: "end";
+        stretch: "stretch";
+    }>>>;
+    justify: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        center: "center";
+        start: "start";
+        end: "end";
+        between: "between";
+    }>>>;
+}, z.core.$strip>;
+export declare const gridPropsSchema: z.ZodObject<{
+    columns: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>>;
+    gap: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+    }>>>;
+}, z.core.$strip>;
+export declare const headingPropsSchema: z.ZodObject<{
+    text: z.ZodString;
+    level: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>>;
+}, z.core.$strip>;
+export declare const textPropsSchema: z.ZodObject<{
+    text: z.ZodString;
+    variant: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        body: "body";
+        caption: "caption";
+        code: "code";
+        muted: "muted";
+    }>>>;
+}, z.core.$strip>;
+export declare const badgePropsSchema: z.ZodObject<{
+    text: z.ZodString;
+    variant: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        success: "success";
+        default: "default";
+        secondary: "secondary";
+        warning: "warning";
+        destructive: "destructive";
+    }>>>;
+}, z.core.$strip>;
+export declare const listItemSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodString;
+    secondary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    badge: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        success: "success";
+        warning: "warning";
+        error: "error";
+        info: "info";
+        neutral: "neutral";
+    }>>>;
+    href: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+}, z.core.$strip>;
+export declare const listPropsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodString;
+        secondary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        badge: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            success: "success";
+            warning: "warning";
+            error: "error";
+            info: "info";
+            neutral: "neutral";
+        }>>>;
+        href: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    }, z.core.$strip>>;
+    maxVisible: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * The List schema the CATALOG (and so the generated model prompt) sees. The
+ * `href` transform above is opaque to json-render's prompt printer, which
+ * renders it as a required `href: unknown` — so the prompt declares the plain
+ * `string?` shape the model should write, and the registry keeps parsing with
+ * the sanitizing schema.
+ */
+export declare const listPropsPromptSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodString;
+        secondary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        badge: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            success: "success";
+            warning: "warning";
+            error: "error";
+            info: "info";
+            neutral: "neutral";
+        }>>>;
+        href: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    maxVisible: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const tablePropsSchema: z.ZodObject<{
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+    caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** Period-over-period change on a Metric (KPI delta). */
+export declare const metricDeltaSchema: z.ZodObject<{
+    value: z.ZodString;
+    direction: z.ZodEnum<{
+        flat: "flat";
+        up: "up";
+        down: "down";
+    }>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const metricPropsSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    trend: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        neutral: "neutral";
+        up: "up";
+        down: "down";
+    }>>>;
+    delta: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        value: z.ZodString;
+        direction: z.ZodEnum<{
+            flat: "flat";
+            up: "up";
+            down: "down";
+        }>;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const calloutPropsSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        warning: "warning";
+        info: "info";
+        tip: "tip";
+        important: "important";
+    }>>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const chartPropsSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        line: "line";
+        bar: "bar";
+        pie: "pie";
+    }>;
+    data: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    centerLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * A phone agent the OpenCX companion just created or re-presented. The model
+ * never authors this itself — the `present_phone_agent` tool returns the whole
+ * spec, which the reply carries verbatim.
+ */
+export declare const phoneAgentCardPropsSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    agentName: z.ZodString;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ListItem = z.infer<typeof listItemSchema>;
+export type MetricDelta = z.infer<typeof metricDeltaSchema>;
+export type ChartProps = z.infer<typeof chartPropsSchema>;
+/**
+ * Parse streamed props against a schema, returning a typed `fallback` on
+ * failure instead of throwing. Failures are EXPECTED during streaming (a prop
+ * arrives half-formed, then completes on the next patch) and on the occasional
+ * model mistake — neither is an error worth surfacing, so we degrade quietly to
+ * the fallback and let the next patch re-render. This is the widget's first line
+ * of defense: one bad prop can never crash the whole spec render.
+ */
+export declare function parseProps<Schema extends z.ZodType>(schema: Schema, raw: unknown, fallback: z.output<Schema>): z.output<Schema>;
+//# sourceMappingURL=props.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/json-render/props.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;GAWG;AAIH,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAK3B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;iBAK1B,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;iBAK7B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;iBAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;iBAK3B,CAAC;AAoCH,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAOzB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;iBAI1B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;iBAI3B,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAM5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;iBAI7B,CAAC;AAOH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;iBAO3B,CAAC;AAIH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,SAAS,CAAC,CAAC,OAAO,EACjD,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GACzB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAGlB"}

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

@@ -0,0 +1,5 @@
+import { ComponentRenderer } from '@json-render/react';
+export declare const registry: import('@json-render/react').ComponentRegistry;
+/** Rendered for any element whose `type` isn't in the registry. */
+export declare const JsonRenderFallback: ComponentRenderer;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/json-render/registry.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAkE5E,eAAO,MAAQ,QAAQ,gDAsOrB,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,EAAE,iBAOhC,CAAC"}

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

@@ -0,0 +1,25 @@
+import { Spec } from '@json-render/core';
+export type ContentSegment = {
+    type: 'markdown';
+    content: string;
+} | {
+    type: 'ui';
+    spec: Spec;
+};
+/**
+ * Segment persisted AI output into markdown prose and compiled UI specs.
+ *
+ * The agent chat stream transforms ` ```spec ` fences into `data-spec` parts
+ * ONLY on the client-facing SSE — the persisted assistant text keeps the raw
+ * fence (persist raw, transform on serve). So the history path re-derives the
+ * spec from the stored text here.
+ *
+ * There is exactly ONE spec format: JSONL patch lines inside a ` ```spec `
+ * fence — what the prompt instructs the model to emit and what every tool
+ * that hands back a card emits. Everything else is markdown. A fence is consumed only after its patches compile to nonempty UI;
+ * malformed, unsupported, empty, and incomplete-only fences remain visible as
+ * their original fenced markdown. An unclosed fence (turn cut mid-stream)
+ * still compiles when enough valid patches arrived.
+ */
+export declare function segmentContent(text: string): ContentSegment[];
+//# sourceMappingURL=segment-content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment-content.d.ts","sourceRoot":"","sources":["../../../src/json-render/segment-content.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EACV,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAmF7D"}

package/dist/src/json-render/ui-prompt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The inline-mode UI prompt for the widget catalog. The agent chat model needs
+ * this server-side so it emits ` ```spec ` JSONL the stream can transform; the
+ * catalog lives in this package because the renderer that consumes the spec is
+ * the widget's React registry. To avoid duplicating the catalog server-side,
+ * the resolved prompt is materialized into the opencx backend as a frozen
+ * string — run `pnpm -F @opencx/widget-react gen:ui-prompt` after changing the
+ * catalog and commit the regenerated
+ * `backend/src/agent-engine/ui-prompt.generated.ts`.
+ *
+ * DELIBERATELY SLIM — display-only contract, all data inline in props.
+ * The full `catalog.prompt({ mode: 'inline' })` output (~19KB: state model,
+ * repeat, events, watchers, visibility, dynamic props) made the chat model
+ * reason for 85s+ before its first token, blowing through the 180s agent chat
+ * turn ceiling (`ai_decided_to_not_reply`). None of that machinery applies to
+ * the widget's static components, so the prompt documents only: the patch
+ * format, the component catalog (extracted from the generated prompt so props
+ * and descriptions never drift), and the usage rules. Measured: ~2x faster
+ * turns, identical spec quality.
+ */
+export declare const widgetUiPrompt: string;
+//# sourceMappingURL=ui-prompt.d.ts.map

package/dist/src/json-render/ui-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-prompt.d.ts","sourceRoot":"","sources":["../../../src/json-render/ui-prompt.ts"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,EAAE,MAmBU,CAAC"}

package/dist/src/motion.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The widget's motion tokens (see MOTION.md) and the companion's shadow
+ * materials. Surfaces are theme tokens (palette / primaryColor via cssVars
+ * on the host shell) so embedder customizations apply to companion chrome
+ * exactly like popover; only the shadows live here. There is no frosted
+ * glass — a filter inside the iframe can only sample the iframe's own
+ * document, never the host page.
+ *
+ * Rings and rim highlights stay whisper-faint: bright white edges read as
+ * "weird white borders" on dark host pages.
+ */
+/** Strong ease-out for entering/exiting chrome (fades, veils, headers). */
+export declare const EASE_OUT: readonly [0.23, 1, 0.32, 1];
+/** The default enter: a 200ms fade on `EASE_OUT`. */
+export declare const FADE_TRANSITION: {
+    readonly duration: 0.2;
+    readonly ease: readonly [0.23, 1, 0.32, 1];
+};
+/**
+ * The 150ms micro-feedback tween: exits (50ms snappier than the enter, a
+ * sanctioned asymmetry), reduced-motion stand-ins for the morph spring, and
+ * the pill settling after a drag.
+ */
+export declare const QUICK_TWEEN: {
+    readonly duration: 0.15;
+    readonly ease: readonly [0.23, 1, 0.32, 1];
+};
+/**
+ * The shared morph spring: near-critically damped (ratio ≈ 1.0 at stiffness
+ * 500 / mass 1), so the morph stays snappy but never overshoots. An
+ * underdamped spring (damping 40 → ratio 0.89) made the companion input bar's
+ * height bounce every time it settled — reads as jitter on a text composer,
+ * which should feel crisp, not springy. The popover open/close rides the same
+ * curve so both shells share one motion signature.
+ */
+export declare const MORPH_SPRING: {
+    readonly type: "spring";
+    readonly stiffness: 500;
+    readonly damping: 45;
+    readonly mass: 1;
+};
+export declare const APP_FRAME_EASE_CSS: string;
+/**
+ * The shell spring-interpolates between these shadows during the morph, and
+ * complex values only interpolate when their structure matches — a mismatched
+ * shadow count or length count makes the whole shadow snap mid-morph instead.
+ * So every constant fills the same four slots (large soft, small soft, ring,
+ * inset top highlight), all with explicit spread, padding unused slots with
+ * transparent zero-size entries (same trick as app-frame's transparent ring).
+ */
+export declare const PILL_SHADOW = "0 2px 12px 0 rgba(0,0,0,0.18), 0 1px 4px 0 rgba(0,0,0,0), 0 0 0 1px rgba(255,255,255,0.08), inset 0 1px 0 0 rgba(255,255,255,0)";
+export declare const DOCK_SHADOW = "0 8px 28px 0 rgba(0,0,0,0.10), 0 1px 4px 0 rgba(0,0,0,0), 0 0 0 1px rgba(0,0,0,0.05), inset 0 1px 0 0 rgba(255,255,255,0.5)";
+export declare const INPUT_SHADOW = "0 12px 40px 0 rgba(0,0,0,0.12), 0 2px 8px 0 rgba(0,0,0,0.04), 0 0 0 1px rgba(0,0,0,0.05), inset 0 1px 0 0 rgba(255,255,255,0.5)";
+export declare const CHAT_SHADOW = "0 24px 48px -16px rgba(0,0,0,0.18), 0 4px 16px 0 rgba(0,0,0,0.05), 0 0 0 1px rgba(0,0,0,0.05), inset 0 1px 0 0 rgba(255,255,255,0.5)";
+//# sourceMappingURL=motion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,6BAA8B,CAAC;AAEpD,qDAAqD;AACrD,eAAO,MAAM,eAAe;;;CAA6C,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;CAA8C,CAAC;AAEvE;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAUX,eAAO,MAAM,kBAAkB,QAA+C,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,oIAC2G,CAAC;AAEpI,eAAO,MAAM,WAAW,gIACuG,CAAC;AAEhI,eAAO,MAAM,YAAY,oIAC0G,CAAC;AAEpI,eAAO,MAAM,WAAW,yIACgH,CAAC"}

package/dist/src/page-context/PageContextPill.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { PageEntity } from './usePageEntity';
+/**
+ * The composer's page-context pill: the one thing on the host page the
+ * visitor is looking at (Linear-style), so they can see what "this" will
+ * mean to the agent before they send. Removable for a message that is not
+ * about it.
+ *
+ * Flat, with no surface of its own: it sits in the composer's attached-context
+ * tray, and the tray is already a surface. Marks are not here — they are
+ * pictures, so they preview with the files.
+ */
+export declare function PageContextPill({ entity, onRemove, }: {
+    entity: PageEntity;
+    onRemove: () => void;
+}): React.JSX.Element;
+//# sourceMappingURL=PageContextPill.d.ts.map

package/dist/src/page-context/PageContextPill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageContextPill.d.ts","sourceRoot":"","sources":["../../../src/page-context/PageContextPill.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,qBAwBA"}

package/dist/src/page-context/usePageEntity.d.ts

@@ -0,0 +1,15 @@
+import { WidgetPageContext } from '@opencx/widget-core';
+export type PageEntity = NonNullable<WidgetPageContext['entity']>;
+/**
+ * The entity the host says the visitor is looking at, read the same way the
+ * send reads it (`resolveConfigContext`, so a function-form `context` is
+ * live). Null when the host set none or set something malformed — the pill
+ * simply does not show, and the send still carries whatever the host sent.
+ * Also null when page context is off for this embed (org feature narrowed
+ * by `config.features.pageContext`): the agent will not read the page, so
+ * the pill must not promise it. Re-read when the host navigates, so a
+ * function-form `context` that follows the route is reflected in the pill
+ * without a reload.
+ */
+export declare function usePageEntity(): PageEntity | null;
+//# sourceMappingURL=usePageEntity.d.ts.map

package/dist/src/page-context/usePageEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePageEntity.d.ts","sourceRoot":"","sources":["../../../src/page-context/usePageEntity.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAe7B,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CASjD"}

package/dist/src/page-marks/MarkThumbnail.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+/**
+ * The region's actual pixels with the visitor's note captioned over them —
+ * the one presentation a page mark has. Two shapes: a `tile` is the same
+ * 48px square a file preview gets, for the composer's attachments row; a
+ * `strip` keeps the region's own proportions, for the sent bubble where
+ * there is room to read it. Children (the pill's remove button) overlay the
+ * picture.
+ */
+export declare function MarkThumbnail({ src, alt, title, note, shape, className, children, ...rest }: {
+    src: string;
+    alt: string;
+    title: string;
+    note?: string | undefined;
+    shape?: 'tile' | 'strip';
+    className?: string;
+    children?: React.ReactNode;
+} & Record<`data-${string}`, string>): React.JSX.Element;
+//# sourceMappingURL=MarkThumbnail.d.ts.map

package/dist/src/page-marks/MarkThumbnail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkThumbnail.d.ts","sourceRoot":"","sources":["../../../src/page-marks/MarkThumbnail.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAC5B,GAAG,EACH,GAAG,EACH,KAAK,EACL,IAAI,EACJ,KAAe,EACf,SAAS,EACT,QAAQ,EACR,GAAG,IAAI,EACR,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B,GAAG,MAAM,CAAC,QAAQ,MAAM,EAAE,EAAE,MAAM,CAAC,qBAmCnC"}

package/dist/src/page-marks/PageMarkOverlay.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { MarkShape } from './page-mark';
+import { MarkDraft, MarkHover } from './usePageMarking';
+/**
+ * Mark-mode visuals, rendered on the HOST page: a hint bar while armed, a
+ * hover frame over the element under the cursor, and — once a mark is placed
+ * — its editor: corner handles showing where to grab, plus one card carrying
+ * the shape palette and the note. The mark itself is notation ink anchored in
+ * page coordinates, so it scrolls with the content.
+ *
+ * Everything here is pointer-inert except the editor card: the gestures live
+ * on the host document (see `usePageMarking`), and an overlay that swallowed
+ * pointer events would blind them.
+ */
+export declare function PageMarkOverlay({ isActive, draft, hover, onShapeChange, onAttach, onDiscard, }: {
+    isActive: boolean;
+    draft: MarkDraft | null;
+    hover: MarkHover | null;
+    onShapeChange: (shape: MarkShape) => void;
+    onAttach: (note: string) => void;
+    onDiscard: () => void;
+}): React.ReactPortal | null;
+//# sourceMappingURL=PageMarkOverlay.d.ts.map

package/dist/src/page-marks/PageMarkOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageMarkOverlay.d.ts","sourceRoot":"","sources":["../../../src/page-marks/PageMarkOverlay.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAK3D,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,KAAK,EACL,KAAK,EACL,aAAa,EACb,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,4BA+IA"}

package/dist/src/page-marks/PageMarkPill.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { PageMark } from './page-mark';
+/**
+ * One page mark previewed in the composer's attachment row — the same square
+ * tile a file gets, because a mark IS a picture the message carries. Shows
+ * the region's actual pixels (the focus element's snapshot, rasterized at
+ * commit) the moment it lands, with the visitor's note captioned over them;
+ * until then — and whenever a snapshot isn't possible — the pen glyph stands
+ * in, with the label captioned the same way so the tile still says what it
+ * is. Removing it un-draws the mark from the host page.
+ */
+export declare function PageMarkPill({ mark, onRemove, }: {
+    mark: PageMark;
+    onRemove: () => void;
+}): React.JSX.Element;
+//# sourceMappingURL=PageMarkPill.d.ts.map

package/dist/src/page-marks/PageMarkPill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageMarkPill.d.ts","sourceRoot":"","sources":["../../../src/page-marks/PageMarkPill.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAI5C;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,qBA0EA"}

package/dist/src/page-marks/PageMarksProvider.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { MarkInk, PageMark } from './page-mark';
+type PageMarksContextValue = {
+    marks: readonly PageMark[];
+    isArmed: boolean;
+    setArmed(armed: boolean): void;
+    attach(mark: PageMark, ink: MarkInk): void;
+    detach(mark: PageMark): void;
+    detachAll(): void;
+};
+/**
+ * One page-mark owner per Widget. It sits above shell/composer swaps so marks
+ * survive those swaps, but below WidgetProvider so separate Widget instances
+ * never share marks or armed state.
+ */
+export declare function PageMarksProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function usePageMarks(): PageMarksContextValue;
+export {};
+//# sourceMappingURL=PageMarksProvider.d.ts.map

package/dist/src/page-marks/PageMarksProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageMarksProvider.d.ts","sourceRoot":"","sources":["../../../src/page-marks/PageMarksProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAErD,KAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3C,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC7B,SAAS,IAAI,IAAI,CAAC;CACnB,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,qBAkD5E;AAED,wBAAgB,YAAY,IAAI,qBAAqB,CAMpD"}

package/dist/src/page-marks/SentMarkChip.d.ts

@@ -0,0 +1,15 @@
+import { MarkedElementRef } from '@opencx/widget-core';
+import { default as React } from 'react';
+/**
+ * A page mark on the SENT user bubble — the composer pill's presentation
+ * without its remove affordance: the region's actual pixels, the note
+ * captioned over them, and the element name only as the fallback when no
+ * snapshot exists. The message carries the mark object itself, so the
+ * thumbnail taken in the composer survives the send instead of collapsing
+ * back into a bare tag name; after a reload the uploaded snapshot's URL takes
+ * its place.
+ */
+export declare function SentMarkChip({ element }: {
+    element: MarkedElementRef;
+}): React.JSX.Element;
+//# sourceMappingURL=SentMarkChip.d.ts.map

package/dist/src/page-marks/SentMarkChip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SentMarkChip.d.ts","sourceRoot":"","sources":["../../../src/page-marks/SentMarkChip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAE,qBA+BtE"}

package/dist/src/page-marks/__tests__/agent-mark.spec.d.ts

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

package/dist/src/page-marks/__tests__/agent-mark.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-mark.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/agent-mark.spec.ts"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/mark-snapshot-upload.spec.d.ts

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

package/dist/src/page-marks/__tests__/mark-snapshot-upload.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-snapshot-upload.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/mark-snapshot-upload.spec.ts"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/page-element-name.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-element-name.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-element-name.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/page-element-name.spec.ts"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/page-element.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-element.spec.d.ts.map

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

package/dist/src/page-marks/__tests__/page-mark-pill.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-mark-pill.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-mark-pill.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/page-mark-pill.spec.tsx"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/page-mark-theme.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-mark-theme.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-mark-theme.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/page-mark-theme.spec.ts"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/page-mark-tile.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-mark-tile.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-mark-tile.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/page-mark-tile.spec.tsx"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/page-marks-provider.spec.d.ts

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

package/dist/src/page-marks/__tests__/page-marks-provider.spec.d.ts.map

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

package/dist/src/page-marks/__tests__/picked-elements.spec.d.ts

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

package/dist/src/page-marks/__tests__/picked-elements.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picked-elements.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/picked-elements.spec.ts"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/sent-mark-chip.spec.d.ts

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

package/dist/src/page-marks/__tests__/sent-mark-chip.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sent-mark-chip.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/sent-mark-chip.spec.tsx"],"names":[],"mappings":""}

package/dist/src/page-marks/__tests__/use-page-marking.spec.d.ts

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

package/dist/src/page-marks/__tests__/use-page-marking.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-page-marking.spec.d.ts","sourceRoot":"","sources":["../../../../src/page-marks/__tests__/use-page-marking.spec.tsx"],"names":[],"mappings":""}