@refraction-ui/astro 0.8.0 → 0.9.0

package/dist/astro-skip-to-content/SkipToContent.stories.ts

@@ -0,0 +1,12 @@
+import Component from './SkipToContent.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/SkipToContent',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-slide-viewer/SlideViewer.stories.ts

@@ -0,0 +1,12 @@
+import Component from './SlideViewer.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/SlideViewer',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-status-indicator/StatusIndicator.stories.ts

@@ -0,0 +1,12 @@
+import Component from './StatusIndicator.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/StatusIndicator',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-steps/Steps.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Steps.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Steps',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-switch/Switch.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Switch.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Switch',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-table-of-contents/TableOfContents.stories.ts

@@ -0,0 +1,12 @@
+import Component from './TableOfContents.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/TableOfContents',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-tabs/Tabs.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Tabs.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Tabs',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-textarea/Textarea.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Textarea.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Textarea',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-theme/Theme.stories.ts

@@ -0,0 +1,12 @@
+import Component from './ThemeScript.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Theme',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-thread-view/ThreadView.stories.ts

@@ -0,0 +1,12 @@
+import Component from './ThreadView.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/ThreadView',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-toast/Toast.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Toast.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Toast',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-tooltip/Tooltip.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Tooltip.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Tooltip',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-version-selector/VersionSelector.stories.ts

@@ -0,0 +1,12 @@
+import Component from './VersionSelector.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/VersionSelector',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-video-player/VideoPlayer.stories.ts

@@ -0,0 +1,12 @@
+import Component from './VideoPlayer.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/VideoPlayer',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-voice-pill/VoicePill.stories.ts

@@ -0,0 +1,12 @@
+import Component from './VoicePill.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/VoicePill',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/astro-waveform/Waveform.stories.ts

@@ -0,0 +1,12 @@
+import Component from './Waveform.astro'
+
+// Auto-generated baseline story. Renders the component with empty args;
+// components that require props show a render error (enrich by hand as needed).
+const meta = {
+  title: 'Astro/Waveform',
+  component: Component,
+}
+
+export default meta
+
+export const Default = { args: {} }

package/dist/conversation/conversation.ts

@@ -0,0 +1,379 @@
+import { generateId } from '../shared/index.ts'
+import { rootIdOf, selectRoots, selectThreadMessages } from './selectors.js'
+import type {
+  ChatAuthor,
+  ChatMessage,
+  Conversation,
+  ConversationAPI,
+  ConversationConfig,
+  ConversationState,
+  SendOptions,
+  ThreadingMode,
+} from './types.js'
+
+const DEFAULT_ASSISTANT: ChatAuthor = { id: 'assistant', name: 'Assistant' }
+const DEFAULT_USER: ChatAuthor = { id: 'user', name: 'You' }
+const DEFAULT_TITLE = 'New conversation'
+
+/** Default title: first line, trimmed to ~48 chars. */
+function defaultGenerateTitle(firstMessage: string): string {
+  const firstLine = firstMessage.split('\n', 1)[0]!.trim()
+  if (firstLine.length <= 48) return firstLine || DEFAULT_TITLE
+  return `${firstLine.slice(0, 47).trimEnd()}…`
+}
+
+/**
+ * createConversation — headless multi-conversation chat store with reply-threads,
+ * reactions, edit/delete, and streaming. Backend-agnostic: provide a
+ * {@link ChatTransport} and `sendMessage` will optimistically append the user
+ * message, stream the reply, and expose retry/stop. Without a transport it is a
+ * pure local message log.
+ */
+export function createConversation(config: ConversationConfig = {}): ConversationAPI {
+  const assistant = config.assistant ?? DEFAULT_ASSISTANT
+  const currentUser = config.currentUser ?? DEFAULT_USER
+  const generateTitle = config.generateTitle ?? defaultGenerateTitle
+
+  let transport = config.transport
+  let threadingMode: ThreadingMode = config.threadingMode ?? 'inline'
+  const conversations = new Map<string, Conversation>()
+  const messagesByConv = new Map<string, ChatMessage[]>()
+  let activeConversationId: string | null = config.activeConversationId ?? null
+  let openThreadRootId: string | null = null
+  let status: ConversationState['status'] = 'idle'
+  let error: string | null = null
+  let abortController: AbortController | null = null
+
+  // Seed
+  for (const c of config.conversations ?? []) {
+    conversations.set(c.id, c)
+    messagesByConv.set(c.id, [])
+  }
+  for (const [conversationId, msgs] of Object.entries(config.messages ?? {})) {
+    messagesByConv.set(conversationId, [...msgs])
+  }
+  if (activeConversationId === null && config.conversations?.length) {
+    activeConversationId = config.conversations[0]!.id
+  }
+
+  // — subscription —
+  const listeners = new Set<() => void>()
+  let snapshot: ConversationState = buildSnapshot()
+
+  function buildSnapshot(): ConversationState {
+    return {
+      conversations: orderedConversations(),
+      activeConversationId,
+      messages: activeConversationId ? (messagesByConv.get(activeConversationId) ?? []) : [],
+      openThreadRootId,
+      threadingMode,
+      status,
+      error,
+    }
+  }
+
+  function emit(): void {
+    snapshot = buildSnapshot()
+    for (const l of listeners) l()
+  }
+
+  function orderedConversations(): Conversation[] {
+    return [...conversations.values()].sort(
+      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime(),
+    )
+  }
+
+  function touch(conversationId: string): void {
+    const c = conversations.get(conversationId)
+    if (c) conversations.set(conversationId, { ...c, updatedAt: new Date() })
+  }
+
+  function ensureActiveConversation(opts?: SendOptions): string {
+    if (opts?.conversationId) {
+      if (!conversations.has(opts.conversationId)) createConversationInternal({}, opts.conversationId)
+      return opts.conversationId
+    }
+    if (activeConversationId && conversations.has(activeConversationId)) return activeConversationId
+    return createConversationInternal({}).id
+  }
+
+  function createConversationInternal(
+    opts: { title?: string; metadata?: Record<string, unknown> },
+    id?: string,
+  ): Conversation {
+    const now = new Date()
+    const conversation: Conversation = {
+      id: id ?? generateId('rfr-conv'),
+      title: opts.title ?? DEFAULT_TITLE,
+      createdAt: now,
+      updatedAt: now,
+      metadata: opts.metadata,
+    }
+    conversations.set(conversation.id, conversation)
+    messagesByConv.set(conversation.id, [])
+    activeConversationId = conversation.id
+    return conversation
+  }
+
+  /** Run a transport stream into the given assistant message. */
+  async function streamReply(
+    conversationId: string,
+    assistantMsg: ChatMessage,
+    userMsg: ChatMessage,
+    history: ChatMessage[],
+  ): Promise<void> {
+    abortController = new AbortController()
+    status = 'streaming'
+    emit()
+
+    try {
+      const stream = transport!.send({
+        conversationId,
+        message: userMsg,
+        history,
+        parentId: assistantMsg.parentId,
+        signal: abortController.signal,
+      })
+      for await (const chunk of stream) {
+        // Apply the delivered chunk before honoring an abort, so a `stop()` mid
+        // stream keeps the partial reply rather than discarding the last token.
+        if (chunk.content !== undefined) assistantMsg.content = chunk.content
+        if (chunk.delta) assistantMsg.content += chunk.delta
+        if (chunk.metadata) {
+          assistantMsg.metadata = { ...assistantMsg.metadata, ...chunk.metadata }
+        }
+        emit()
+        if (abortController.signal.aborted) break
+      }
+      assistantMsg.status = 'sent'
+      status = 'idle'
+      error = null
+    } catch (err) {
+      if (abortController.signal.aborted) {
+        assistantMsg.status = 'sent'
+        status = 'idle'
+      } else {
+        const message = err instanceof Error ? err.message : String(err)
+        assistantMsg.status = 'error'
+        assistantMsg.error = message
+        status = 'error'
+        error = message
+      }
+    } finally {
+      abortController = null
+      touch(conversationId)
+      emit()
+    }
+  }
+
+  /** History the transport sees: the thread when replying, else the main timeline. */
+  function historyFor(list: ChatMessage[], parentId: string | undefined): ChatMessage[] {
+    const scope = parentId
+      ? selectThreadMessages(list, parentId)
+      : selectRoots(list)
+    return scope.filter((m) => m.status !== 'error')
+  }
+
+  const api: ConversationAPI = {
+    getState() {
+      return snapshot
+    },
+
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+
+    newConversation(opts) {
+      const conversation = createConversationInternal(opts ?? {})
+      openThreadRootId = null
+      emit()
+      return conversation
+    },
+
+    selectConversation(conversationId) {
+      if (!conversations.has(conversationId) || activeConversationId === conversationId) return
+      activeConversationId = conversationId
+      openThreadRootId = null
+      emit()
+    },
+
+    deleteConversation(conversationId) {
+      if (!conversations.has(conversationId)) return
+      conversations.delete(conversationId)
+      messagesByConv.delete(conversationId)
+      if (activeConversationId === conversationId) {
+        activeConversationId = orderedConversations()[0]?.id ?? null
+        openThreadRootId = null
+      }
+      emit()
+    },
+
+    renameConversation(conversationId, title) {
+      const c = conversations.get(conversationId)
+      if (!c) return
+      conversations.set(conversationId, { ...c, title })
+      emit()
+    },
+
+    appendMessage(message) {
+      const list = messagesByConv.get(message.conversationId)
+      if (!list) return
+      list.push(message)
+      touch(message.conversationId)
+      emit()
+    },
+
+    editMessage(messageId, content) {
+      if (!activeConversationId) return
+      const list = messagesByConv.get(activeConversationId)!
+      const msg = list.find((m) => m.id === messageId)
+      if (!msg) return
+      msg.content = content
+      msg.edited = true
+      emit()
+    },
+
+    deleteMessage(messageId) {
+      if (!activeConversationId) return
+      const list = messagesByConv.get(activeConversationId)!
+      const msg = list.find((m) => m.id === messageId)
+      if (!msg) return
+      const removeIds = new Set<string>([messageId])
+      // Deleting a thread root removes its replies too.
+      if (!msg.parentId) for (const r of list) if (r.parentId === messageId) removeIds.add(r.id)
+      const next = list.filter((m) => !removeIds.has(m.id))
+      messagesByConv.set(activeConversationId, next)
+      if (openThreadRootId && removeIds.has(openThreadRootId)) openThreadRootId = null
+      emit()
+    },
+
+    react(messageId, emoji) {
+      if (!activeConversationId) return
+      const list = messagesByConv.get(activeConversationId)!
+      const msg = list.find((m) => m.id === messageId)
+      if (!msg) return
+      const reactions = [...(msg.reactions ?? [])]
+      const idx = reactions.findIndex((r) => r.emoji === emoji)
+      if (idx === -1) {
+        reactions.push({ emoji, count: 1, userReacted: true })
+      } else {
+        const r = reactions[idx]!
+        if (r.userReacted) {
+          const count = r.count - 1
+          if (count <= 0) reactions.splice(idx, 1)
+          else reactions[idx] = { ...r, count, userReacted: false }
+        } else {
+          reactions[idx] = { ...r, count: r.count + 1, userReacted: true }
+        }
+      }
+      msg.reactions = reactions
+      emit()
+    },
+
+    async sendMessage(content, opts) {
+      const trimmed = content.trim()
+      if (!trimmed && !opts?.attachments?.length) return
+
+      const conversationId = ensureActiveConversation(opts)
+      const list = messagesByConv.get(conversationId)!
+      const parentId = opts?.replyTo ? rootIdOf(list, opts.replyTo) : undefined
+      const isFirstRoot = !parentId && selectRoots(list).length === 0
+
+      const userMsg: ChatMessage = {
+        id: generateId('rfr-msg'),
+        conversationId,
+        role: 'user',
+        author: currentUser,
+        content: trimmed,
+        timestamp: new Date(),
+        status: 'sent',
+        parentId,
+        attachments: opts?.attachments,
+        metadata: opts?.metadata,
+      }
+      list.push(userMsg)
+
+      const conversation = conversations.get(conversationId)!
+      if (isFirstRoot && conversation.title === DEFAULT_TITLE) {
+        conversations.set(conversationId, { ...conversation, title: generateTitle(trimmed) })
+      }
+      touch(conversationId)
+
+      if (!transport) {
+        status = 'idle'
+        emit()
+        return
+      }
+
+      // history excludes the just-pushed user message
+      const history = historyFor(list, parentId).filter((m) => m.id !== userMsg.id)
+      const assistantMsg: ChatMessage = {
+        id: generateId('rfr-msg'),
+        conversationId,
+        role: 'assistant',
+        author: assistant,
+        content: '',
+        timestamp: new Date(),
+        status: 'streaming',
+        parentId,
+      }
+      list.push(assistantMsg)
+      await streamReply(conversationId, assistantMsg, userMsg, history)
+    },
+
+    async retryLast() {
+      if (!activeConversationId || !transport) return
+      const list = messagesByConv.get(activeConversationId)!
+      const last = list[list.length - 1]
+      const parentId = last?.parentId
+      // Drop a trailing failed assistant message, if any.
+      if (last && last.role === 'assistant' && last.status === 'error') list.pop()
+
+      const scope = parentId ? selectThreadMessages(list, parentId) : selectRoots(list)
+      const lastUser = [...scope].reverse().find((m) => m.role === 'user')
+      if (!lastUser) return
+
+      const history = historyFor(list, parentId)
+      const assistantMsg: ChatMessage = {
+        id: generateId('rfr-msg'),
+        conversationId: activeConversationId,
+        role: 'assistant',
+        author: assistant,
+        content: '',
+        timestamp: new Date(),
+        status: 'streaming',
+        parentId,
+      }
+      list.push(assistantMsg)
+      await streamReply(activeConversationId, assistantMsg, lastUser, history)
+    },
+
+    stop() {
+      abortController?.abort()
+    },
+
+    openThread(rootId) {
+      openThreadRootId = rootId
+      emit()
+    },
+
+    closeThread() {
+      if (openThreadRootId === null) return
+      openThreadRootId = null
+      emit()
+    },
+
+    setThreadingMode(mode) {
+      if (threadingMode === mode) return
+      threadingMode = mode
+      emit()
+    },
+
+    setTransport(next) {
+      transport = next
+    },
+  }
+
+  return api
+}

package/dist/conversation/index.ts

@@ -0,0 +1,30 @@
+export { createConversation } from './conversation.js'
+
+export {
+  findMessage,
+  rootIdOf,
+  selectRoots,
+  selectReplies,
+  selectThreadMessages,
+  getReplyCount,
+  selectMainTimeline,
+  selectTimelineFromState,
+} from './selectors.js'
+
+export type {
+  ChatAuthor,
+  ChatRole,
+  MessageStatus,
+  ThreadingMode,
+  MessageReaction,
+  MessageAttachment,
+  ChatMessage,
+  Conversation,
+  SendContext,
+  TransportChunk,
+  ChatTransport,
+  ConversationState,
+  ConversationConfig,
+  SendOptions,
+  ConversationAPI,
+} from './types.js'

package/dist/conversation/selectors.ts

@@ -0,0 +1,58 @@
+import type { ChatMessage, ConversationState, ThreadingMode } from './types.js'
+
+/** Sort by timestamp ascending (oldest first). */
+function byTime(a: ChatMessage, b: ChatMessage): number {
+  return a.timestamp.getTime() - b.timestamp.getTime()
+}
+
+/** Find a message by id. */
+export function findMessage(messages: ChatMessage[], id: string): ChatMessage | undefined {
+  return messages.find((m) => m.id === id)
+}
+
+/** Resolve a message id to its thread root (itself if it's already a root). */
+export function rootIdOf(messages: ChatMessage[], id: string): string {
+  const m = findMessage(messages, id)
+  if (!m) return id
+  return m.parentId ?? m.id
+}
+
+/** Root (main-timeline) messages — those not belonging to a reply-thread. */
+export function selectRoots(messages: ChatMessage[]): ChatMessage[] {
+  return messages.filter((m) => !m.parentId).sort(byTime)
+}
+
+/** Replies belonging to a thread root, oldest first (excludes the root itself). */
+export function selectReplies(messages: ChatMessage[], rootId: string): ChatMessage[] {
+  return messages.filter((m) => m.parentId === rootId).sort(byTime)
+}
+
+/** A full thread: root message followed by its replies. */
+export function selectThreadMessages(messages: ChatMessage[], rootId: string): ChatMessage[] {
+  const root = findMessage(messages, rootId)
+  const replies = selectReplies(messages, rootId)
+  return root ? [root, ...replies] : replies
+}
+
+/** Number of replies in a thread. */
+export function getReplyCount(messages: ChatMessage[], rootId: string): number {
+  return messages.reduce((n, m) => (m.parentId === rootId ? n + 1 : n), 0)
+}
+
+/**
+ * The main timeline for the active conversation, honoring the threading mode:
+ * - `'inline'`: every message in chronological order (replies included).
+ * - `'panel'`: only root messages (replies hidden behind their thread).
+ */
+export function selectMainTimeline(
+  messages: ChatMessage[],
+  mode: ThreadingMode,
+): ChatMessage[] {
+  if (mode === 'panel') return selectRoots(messages)
+  return [...messages].sort(byTime)
+}
+
+/** Convenience: main timeline from a store snapshot. */
+export function selectTimelineFromState(state: ConversationState): ChatMessage[] {
+  return selectMainTimeline(state.messages, state.threadingMode)
+}