@flamingo-stack/openframe-frontend-core 0.0.429-snapshot.20260715222543 → 0.0.429

package/dist/components/chat/hooks/use-scripted-stream.d.ts

@@ -1,3 +0,0 @@
-import type { StreamFrame } from '../utils/scripted-stream';
-export declare function useScriptedStream(frames: StreamFrame[], resetKey: unknown, enabled?: boolean): StreamFrame;
-//# sourceMappingURL=use-scripted-stream.d.ts.map

package/dist/components/chat/hooks/use-scripted-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-scripted-stream.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/hooks/use-scripted-stream.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAQ3D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,WAAW,CAwCvG"}

package/dist/components/chat/utils/scripted-stream.d.ts

@@ -1,38 +0,0 @@
-/**
- * Scripted-conversation replay — turn a stored `HistoricalMessage[]` into ordered
- * "mock SSE" playback frames that animate a chat surface exactly like the live
- * NATS/SSE stream (a `thinking` pause → assistant text token-by-token → tool /
- * approval segments popping in → `idle`), just replayed from a script instead of
- * a network stream.
- *
- * Lives in the lib (not a host) so any consumer — marketing hero demos, docs,
- * onboarding tours — can drive a `previewMode` `EmbeddableChat` or a
- * `ChatMessageList` from a canned conversation without re-implementing the
- * streaming cadence. Pair with {@link useScriptedStream} (the playback clock).
- */
-import type { HistoricalMessage, MessageData, StreamingPhase } from '../types';
-/** Normalize the single-or-array `messageData` to an array (empty when absent). */
-export declare function normalizeHistoricalMessageData(md: HistoricalMessage['messageData']): MessageData[];
-/** A message the user authored carries an `owner`; assistant turns have none —
- *  drives whether a turn streams (assistant) or lands at once (user). */
-export declare function isHistoricalUserTurn(m: HistoricalMessage): boolean;
-/** One rendered step of the mocked stream. */
-export interface StreamFrame {
-    /** The partial message list to show at this step. */
-    messages: HistoricalMessage[];
-    phase: StreamingPhase;
-    /** The chat "typing" indicator (up during the `thinking` pause). */
-    typing: boolean;
-    /** Hold time (ms) before advancing to the next frame. */
-    delayMs: number;
-}
-/**
- * Expand a message list into ordered playback frames reproducing the live
- * stream: each user turn lands whole; each assistant turn first shows a
- * `thinking` indicator, then streams its text token-by-token, then pops any
- * tool / approval segments. Frame COUNT for a given prefix is deterministic, so
- * a host that appends a continuation (e.g. after an Approve) resumes seamlessly
- * from where it paused — the shared prefix's frames are unchanged.
- */
-export declare function buildStreamFrames(messages: HistoricalMessage[]): StreamFrame[];
-//# sourceMappingURL=scripted-stream.d.ts.map

package/dist/components/chat/utils/scripted-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scripted-stream.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/utils/scripted-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9E,mFAAmF;AACnF,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,iBAAiB,CAAC,aAAa,CAAC,GAAG,WAAW,EAAE,CAElG;AAED;yEACyE;AACzE,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAElE;AAKD,8CAA8C;AAC9C,MAAM,WAAW,WAAW;IAC1B,qDAAqD;IACrD,QAAQ,EAAE,iBAAiB,EAAE,CAAA;IAC7B,KAAK,EAAE,cAAc,CAAA;IACrB,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAA;IACf,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAA;CAChB;AAgBD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,WAAW,EAAE,CAgD9E"}

package/src/components/chat/hooks/use-scripted-stream.ts

@@ -1,69 +0,0 @@
-'use client'
-
-/**
- * Playback clock for {@link buildStreamFrames}: advance through pre-built
- * scripted frames like a live chat stream — each frame holds for its own
- * `delayMs`, then the next reveals, parking on the last. Surface-agnostic: the
- * caller maps `frame.messages` to its own chat shape and reads `frame.phase` /
- * `frame.typing`.
- *
- * `resetKey` restarts playback from the top when a NEW conversation is selected
- * (identity change) — NOT when the SAME conversation grows (e.g. an Approve
- * appends its continuation), which must resume from where it paused. Because the
- * frame list's shared prefix is deterministic, keeping the index across a grow
- * resumes seamlessly into the appended frames.
- *
- * `prefers-reduced-motion` (or `enabled === false`) jumps straight to the final
- * frame (everything revealed, idle).
- */
-
-import { useEffect, useState } from 'react'
-import type { StreamFrame } from '../utils/scripted-stream'
-
-const EMPTY_FRAME: StreamFrame = { messages: [], phase: 'idle', typing: false, delayMs: 0 }
-
-function prefersReducedMotion(): boolean {
-  return typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches === true
-}
-
-export function useScriptedStream(frames: StreamFrame[], resetKey: unknown, enabled = true): StreamFrame {
-  const [index, setIndex] = useState(0)
-  const [reducedMotion, setReducedMotion] = useState(false)
-
-  // Restart from the top on a new conversation, synchronously during render
-  // (React's "adjust state on prop change" pattern) so the previous stream's
-  // last frame never flashes before the reset effect runs.
-  const [prevKey, setPrevKey] = useState(resetKey)
-  if (resetKey !== prevKey) {
-    setPrevKey(resetKey)
-    setIndex(0)
-  }
-
-  useEffect(() => {
-    setReducedMotion(prefersReducedMotion())
-    const mq = window.matchMedia?.('(prefers-reduced-motion: reduce)')
-    if (!mq) return
-    const onChange = () => setReducedMotion(mq.matches)
-    mq.addEventListener('change', onChange)
-    return () => mq.removeEventListener('change', onChange)
-  }, [])
-
-  const playing = enabled && !reducedMotion && frames.length > 0
-  const lastIndex = Math.max(0, frames.length - 1)
-
-  // Advance one frame after the current frame's hold. When `frames` grows (an
-  // Approve appends more), this effect re-runs and, if we were parked on the old
-  // last frame, schedules the next — resuming the stream. `frames[index]` is
-  // clamped because a shrink (a shorter new conversation before the reset lands)
-  // could momentarily leave `index` past the end.
-  useEffect(() => {
-    if (!playing || index >= lastIndex) return
-    const current = frames[Math.min(index, lastIndex)] ?? EMPTY_FRAME
-    const t = setTimeout(() => setIndex((i) => Math.min(i + 1, lastIndex)), current.delayMs)
-    return () => clearTimeout(t)
-  }, [index, frames, playing, lastIndex])
-
-  if (frames.length === 0) return EMPTY_FRAME
-  if (!playing) return frames[lastIndex]
-  return frames[Math.min(index, lastIndex)] ?? EMPTY_FRAME
-}

package/src/components/chat/utils/scripted-stream.ts

@@ -1,111 +0,0 @@
-/**
- * Scripted-conversation replay — turn a stored `HistoricalMessage[]` into ordered
- * "mock SSE" playback frames that animate a chat surface exactly like the live
- * NATS/SSE stream (a `thinking` pause → assistant text token-by-token → tool /
- * approval segments popping in → `idle`), just replayed from a script instead of
- * a network stream.
- *
- * Lives in the lib (not a host) so any consumer — marketing hero demos, docs,
- * onboarding tours — can drive a `previewMode` `EmbeddableChat` or a
- * `ChatMessageList` from a canned conversation without re-implementing the
- * streaming cadence. Pair with {@link useScriptedStream} (the playback clock).
- */
-
-import type { HistoricalMessage, MessageData, StreamingPhase } from '../types'
-
-/** Normalize the single-or-array `messageData` to an array (empty when absent). */
-export function normalizeHistoricalMessageData(md: HistoricalMessage['messageData']): MessageData[] {
-  return Array.isArray(md) ? md : md ? [md] : []
-}
-
-/** A message the user authored carries an `owner`; assistant turns have none —
- *  drives whether a turn streams (assistant) or lands at once (user). */
-export function isHistoricalUserTurn(m: HistoricalMessage): boolean {
-  return !!m.owner
-}
-
-const isTextSegment = (d: MessageData): d is MessageData & { type: 'TEXT'; text: string } =>
-  (d as { type?: string })?.type === 'TEXT' && typeof (d as { text?: unknown }).text === 'string'
-
-/** One rendered step of the mocked stream. */
-export interface StreamFrame {
-  /** The partial message list to show at this step. */
-  messages: HistoricalMessage[]
-  phase: StreamingPhase
-  /** The chat "typing" indicator (up during the `thinking` pause). */
-  typing: boolean
-  /** Hold time (ms) before advancing to the next frame. */
-  delayMs: number
-}
-
-// Playback cadence. Assistant turns "think" then stream token-by-token; user
-// turns land at once. Tuned to read like a real chat without dragging.
-const THINK_MS = 550
-const TOKEN_MS = 55 // per word revealed while streaming text
-const USER_MS = 480 // dwell on a user turn before the reply starts thinking
-const SEGMENT_MS = 340 // a tool / approval card pops in
-const POST_MS = 240 // dwell after a completed assistant turn
-
-/** Split text into tokens that KEEP surrounding whitespace, so re-joining a
- *  prefix reproduces the original spacing exactly (`"a b"` → `["a ", "b"]`). */
-function tokenize(text: string): string[] {
-  return text.match(/\s*\S+\s*/g) ?? (text ? [text] : [])
-}
-
-/**
- * Expand a message list into ordered playback frames reproducing the live
- * stream: each user turn lands whole; each assistant turn first shows a
- * `thinking` indicator, then streams its text token-by-token, then pops any
- * tool / approval segments. Frame COUNT for a given prefix is deterministic, so
- * a host that appends a continuation (e.g. after an Approve) resumes seamlessly
- * from where it paused — the shared prefix's frames are unchanged.
- */
-export function buildStreamFrames(messages: HistoricalMessage[]): StreamFrame[] {
-  const frames: StreamFrame[] = []
-  const revealed: HistoricalMessage[] = []
-  const push = (msgs: HistoricalMessage[], phase: StreamingPhase, typing: boolean, delayMs: number) =>
-    frames.push({ messages: msgs.slice(), phase, typing, delayMs })
-
-  messages.forEach((msg) => {
-    if (isHistoricalUserTurn(msg)) {
-      revealed.push(msg)
-      push(revealed, 'idle', false, USER_MS)
-      return
-    }
-
-    // Assistant turn: a `thinking` pause, then stream this turn's segments in
-    // order. The pause is emitted ONLY when there is already content to show
-    // (`revealed.length > 0`) — an empty first frame would hand the surface a
-    // zero-message list, flashing its empty state before the opening line.
-    if (revealed.length > 0) push(revealed, 'thinking', true, THINK_MS)
-
-    const segs = normalizeHistoricalMessageData(msg.messageData)
-    const built: MessageData[] = []
-    const emit = () => push([...revealed, { ...msg, messageData: [...built] }], 'streaming', false, 0)
-
-    segs.forEach((seg) => {
-      if (isTextSegment(seg)) {
-        const tokens = tokenize(seg.text)
-        let acc = ''
-        built.push({ ...seg, text: '' })
-        tokens.forEach((tok) => {
-          acc += tok
-          built[built.length - 1] = { ...seg, text: acc }
-          push([...revealed, { ...msg, messageData: [...built] }], 'streaming', false, TOKEN_MS)
-        })
-        built[built.length - 1] = { ...seg }
-      } else {
-        // Tool / approval segment: pops in fully.
-        built.push(seg)
-        emit()
-        frames[frames.length - 1].delayMs = SEGMENT_MS
-      }
-    })
-
-    revealed.push(msg)
-    push(revealed, 'idle', false, POST_MS)
-  })
-
-  if (frames.length === 0) push(revealed, 'idle', false, 0)
-  return frames
-}