@refraction-ui/astro 0.8.1 → 0.10.0

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)
+}

package/dist/conversation/types.ts

@@ -0,0 +1,232 @@
+/**
+ * @refraction-ui/conversation — headless chat store.
+ *
+ * Owns the *data format* and *behavior* of a multi-conversation chat with
+ * reply-threads, reactions, edit/delete, and streaming. It has NO UI opinion
+ * and NO backend opinion: the wire is supplied by a {@link ChatTransport}
+ * adapter, exactly as {@link AIProvider} is supplied to `@refraction-ui/ai`.
+ *
+ * Two threading modes (how replies relate to the main timeline):
+ * - `'inline'` (default): every message — replies included — appears in the
+ *   main timeline; a reply shows its parent quoted, and opening it reveals the
+ *   focused thread in a side panel.
+ * - `'panel'`: only root messages appear in the main timeline (each showing a
+ *   reply count); replies live solely in the thread panel (Slack-style).
+ */
+
+/** Author display info — structurally compatible with thread-view's MessageData. */
+export interface ChatAuthor {
+  id: string
+  name: string
+  avatarUrl?: string
+}
+
+/** Conversational role. Generic; the transport decides what each means. */
+export type ChatRole = 'user' | 'assistant' | 'system'
+
+/** Lifecycle of a single message. */
+export type MessageStatus = 'pending' | 'streaming' | 'sent' | 'error'
+
+/** How replies relate to the main timeline. */
+export type ThreadingMode = 'inline' | 'panel'
+
+/** An emoji reaction aggregate on a message. */
+export interface MessageReaction {
+  emoji: string
+  count: number
+  /** Whether the local user has reacted with this emoji */
+  userReacted: boolean
+}
+
+/** A file/media attachment (images, gifs, docs). */
+export interface MessageAttachment {
+  id: string
+  name: string
+  url: string
+  /** MIME type, e.g. 'image/gif', 'image/png', 'application/pdf' */
+  type: string
+  size?: number
+}
+
+/** A single message. */
+export interface ChatMessage {
+  /** Unique message ID */
+  id: string
+  /** Conversation this message belongs to */
+  conversationId: string
+  /** Who/what produced it */
+  role: ChatRole
+  /** Author display info */
+  author: ChatAuthor
+  /** Content (markdown — may contain code fences, images/gifs; grows while streaming) */
+  content: string
+  /** Creation time */
+  timestamp: Date
+  /** Lifecycle status */
+  status: MessageStatus
+  /** Failure reason when `status === 'error'` */
+  error?: string
+  /**
+   * Root message id of the reply-thread this message belongs to. Absent on
+   * root/main-timeline messages. Threads are one level deep — a reply to any
+   * message in a thread groups under the same originating root.
+   */
+  parentId?: string
+  /**
+   * The specific message this is "in reply to" (for the quote), which may be a
+   * mid-thread reply even though `parentId` is always the originating root.
+   */
+  replyToId?: string
+  /** Emoji reactions */
+  reactions?: MessageReaction[]
+  /** Attachments (images/gifs/files) */
+  attachments?: MessageAttachment[]
+  /** Whether this message was edited */
+  edited?: boolean
+  /** Arbitrary consumer metadata — never inspected by the store */
+  metadata?: Record<string, unknown>
+}
+
+/** A conversation/session (an entry in the conversation list). */
+export interface Conversation {
+  id: string
+  /** Display title (auto-derived from the first message unless set) */
+  title: string
+  createdAt: Date
+  /** Last-activity time (bumped on every message) */
+  updatedAt: Date
+  metadata?: Record<string, unknown>
+}
+
+/** Context handed to the transport for one send. */
+export interface SendContext {
+  /** Active conversation ID */
+  conversationId: string
+  /** The user message being sent */
+  message: ChatMessage
+  /** Prior messages in scope (the thread when replying, else the main timeline) */
+  history: ChatMessage[]
+  /** Root message id when this send is a reply within a thread */
+  parentId?: string
+  /** Aborted when the consumer calls `stop()` */
+  signal: AbortSignal
+}
+
+/** A streamed piece of an assistant reply. */
+export interface TransportChunk {
+  /** Token/delta to append to the assistant reply */
+  delta?: string
+  /** Replace the whole reply content (for non-streaming transports) */
+  content?: string
+  /** Arbitrary metadata merged onto the assistant message */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * The backend wire. Implemented by adapter code the consumer owns — never by
+ * this package. A non-streaming backend yields one chunk with `content` then
+ * returns; a streaming backend yields many `delta` chunks.
+ */
+export interface ChatTransport {
+  name: string
+  send(ctx: SendContext): AsyncIterable<TransportChunk>
+}
+
+/** Snapshot of the store. Returned by `getState()`; treat as immutable. */
+export interface ConversationState {
+  /** All conversations, most-recently-updated first */
+  conversations: Conversation[]
+  /** Active conversation ID, or null when none selected */
+  activeConversationId: string | null
+  /** Flat messages of the active conversation (roots + replies) */
+  messages: ChatMessage[]
+  /** Root id of the thread shown in the side panel, or null when closed */
+  openThreadRootId: string | null
+  /** The specific message a reply in the open thread will target (default: the root) */
+  replyTarget: string | null
+  /** Current threading mode */
+  threadingMode: ThreadingMode
+  /** Coarse store status */
+  status: 'idle' | 'sending' | 'streaming' | 'error'
+  /** Last error, if any */
+  error: string | null
+}
+
+/** Options for `createConversation`. */
+export interface ConversationConfig {
+  /** Backend wire. Without it the store is a local message log. */
+  transport?: ChatTransport
+  /** Seed conversations */
+  conversations?: Conversation[]
+  /** Seed messages keyed by conversationId */
+  messages?: Record<string, ChatMessage[]>
+  /** Initially active conversation */
+  activeConversationId?: string
+  /** The local user — author of outgoing messages */
+  currentUser?: ChatAuthor
+  /** Author of assistant replies (default: { id: 'assistant', name: 'Assistant' }) */
+  assistant?: ChatAuthor
+  /** Derive a conversation title from its first message (default: first ~48 chars) */
+  generateTitle?: (firstMessage: string) => string
+  /** Threading mode (default 'inline') */
+  threadingMode?: ThreadingMode
+}
+
+/** Options for a single `sendMessage`. */
+export interface SendOptions {
+  /** Send into a specific conversation instead of the active one */
+  conversationId?: string
+  /** Reply within the thread of this message id */
+  replyTo?: string
+  /** Attachments on the outgoing message */
+  attachments?: MessageAttachment[]
+  /** Metadata attached to the outgoing user message */
+  metadata?: Record<string, unknown>
+}
+
+/** The framework-agnostic store. React/Astro adapters wrap this. */
+export interface ConversationAPI {
+  /** Current immutable snapshot */
+  getState(): ConversationState
+  /** Subscribe to changes; returns an unsubscribe fn (suits useSyncExternalStore) */
+  subscribe(listener: () => void): () => void
+
+  // — conversation management —
+  /** Create a new conversation and make it active */
+  newConversation(opts?: { title?: string; metadata?: Record<string, unknown> }): Conversation
+  /** Make a conversation active */
+  selectConversation(conversationId: string): void
+  /** Delete a conversation and its messages */
+  deleteConversation(conversationId: string): void
+  /** Rename a conversation */
+  renameConversation(conversationId: string, title: string): void
+
+  // — messaging —
+  /** Optimistically append the user message, then stream the reply via transport */
+  sendMessage(content: string, opts?: SendOptions): Promise<void>
+  /** Append a message directly (no transport round-trip) */
+  appendMessage(message: ChatMessage): void
+  /** Edit a message's content (marks it edited) */
+  editMessage(messageId: string, content: string): void
+  /** Delete a message (and, for a thread root, its replies) */
+  deleteMessage(messageId: string): void
+  /** Toggle the local user's emoji reaction on a message */
+  react(messageId: string, emoji: string): void
+  /** Retry the last failed turn in the active conversation */
+  retryLast(): Promise<void>
+  /** Abort the in-flight stream, keeping any partial reply */
+  stop(): void
+
+  // — threads / view —
+  /** Open the side panel focused on a message's thread (reply target = root) */
+  openThread(rootId: string): void
+  /** Open the originating thread and target a specific message for the next reply */
+  replyTo(messageId: string): void
+  /** Close the thread side panel */
+  closeThread(): void
+  /** Switch threading mode */
+  setThreadingMode(mode: ThreadingMode): void
+
+  /** Swap the transport at runtime */
+  setTransport(transport: ChatTransport): void
+}

package/dist/cookie-consent/cookie-consent.ts

@@ -0,0 +1,132 @@
+import type {
+  CookieCategory,
+  CookieConsentAPI,
+  CookieConsentConfig,
+  CookieConsentState,
+  ConsentPreferences,
+} from './types.js'
+
+const DEFAULT_KEY = 'rfr-cookie-consent'
+
+/** Popular default GDPR-style categories. */
+export const DEFAULT_CATEGORIES: CookieCategory[] = [
+  { id: 'necessary', label: 'Strictly necessary', description: 'Required for the site to function. Always on.', required: true },
+  { id: 'preferences', label: 'Preferences', description: 'Remembers your settings and choices.' },
+  { id: 'analytics', label: 'Analytics', description: 'Helps us understand how the site is used.' },
+  { id: 'marketing', label: 'Marketing', description: 'Used to personalize ads and measure campaigns.' },
+]
+
+interface Persisted {
+  version?: string
+  preferences: ConsentPreferences
+}
+
+/** Preferences with only required categories granted. */
+function baseline(categories: CookieCategory[]): ConsentPreferences {
+  const p: ConsentPreferences = {}
+  for (const c of categories) p[c.id] = !!c.required
+  return p
+}
+
+/**
+ * createCookieConsent — headless consent store. Reads any persisted choice on
+ * init (re-prompting if the `version` changed), and exposes accept/reject/save
+ * plus banner visibility. Persistence is via the optional storage adapter.
+ */
+export function createCookieConsent(config: CookieConsentConfig = {}): CookieConsentAPI {
+  const categories = config.categories ?? DEFAULT_CATEGORIES
+  const storage = config.storage
+  const key = config.storageKey ?? DEFAULT_KEY
+  const version = config.version
+
+  let preferences = baseline(categories)
+  let consented = false
+
+  // Hydrate from storage.
+  const raw = storage?.get(key) ?? null
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw) as Persisted
+      if ((parsed.version ?? undefined) === version) {
+        preferences = { ...baseline(categories), ...parsed.preferences }
+        // required stay on regardless of stored value
+        for (const c of categories) if (c.required) preferences[c.id] = true
+        consented = true
+      }
+    } catch {
+      // ignore corrupt storage
+    }
+  }
+
+  let open = !consented
+
+  const listeners = new Set<() => void>()
+  let snapshot = build()
+
+  function build(): CookieConsentState {
+    return { consented, preferences: { ...preferences }, open, categories }
+  }
+  function emit(): void {
+    snapshot = build()
+    for (const l of listeners) l()
+  }
+
+  function persist(): void {
+    storage?.set(key, JSON.stringify({ version, preferences } satisfies Persisted))
+    config.onChange?.({ ...preferences })
+  }
+
+  function save(next: ConsentPreferences): void {
+    const merged = { ...baseline(categories), ...next }
+    for (const c of categories) if (c.required) merged[c.id] = true
+    preferences = merged
+    consented = true
+    open = false
+    persist()
+    emit()
+  }
+
+  return {
+    getState() {
+      return snapshot
+    },
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    acceptAll() {
+      const all: ConsentPreferences = {}
+      for (const c of categories) all[c.id] = true
+      save(all)
+    },
+    rejectAll() {
+      save(baseline(categories))
+    },
+    savePreferences(prefs) {
+      save(prefs)
+    },
+    setPreference(id, value) {
+      const cat = categories.find((c) => c.id === id)
+      if (!cat || cat.required) return
+      preferences = { ...preferences, [id]: value }
+      emit()
+    },
+    reset() {
+      storage?.remove(key)
+      preferences = baseline(categories)
+      consented = false
+      open = true
+      emit()
+    },
+    openSettings() {
+      if (open) return
+      open = true
+      emit()
+    },
+    close() {
+      if (!open) return
+      open = false
+      emit()
+    },
+  }
+}

package/dist/cookie-consent/index.ts

@@ -0,0 +1,10 @@
+export { createCookieConsent, DEFAULT_CATEGORIES } from './cookie-consent.js'
+
+export type {
+  CookieCategory,
+  ConsentPreferences,
+  CookieStorage,
+  CookieConsentConfig,
+  CookieConsentState,
+  CookieConsentAPI,
+} from './types.js'

package/dist/cookie-consent/types.ts

@@ -0,0 +1,72 @@
+/**
+ * @refraction-ui/cookie-consent — headless cookie-consent store.
+ *
+ * Owns consent categories + the user's per-category opt-in and banner state.
+ * Persistence is backend-agnostic via a {@link CookieStorage} adapter (the React
+ * adapter defaults to localStorage); no DOM/cookie access in the core.
+ */
+
+/** A consent category the user can opt into. */
+export interface CookieCategory {
+  id: string
+  label: string
+  description?: string
+  /** Required categories are always on and cannot be toggled off. */
+  required?: boolean
+}
+
+/** Per-category opt-in map (categoryId → granted). */
+export type ConsentPreferences = Record<string, boolean>
+
+/** Persistence adapter — implement over localStorage, cookies, a backend, etc. */
+export interface CookieStorage {
+  get(key: string): string | null
+  set(key: string, value: string): void
+  remove(key: string): void
+}
+
+/** Options for `createCookieConsent`. */
+export interface CookieConsentConfig {
+  /** Consent categories (default: necessary*, analytics, marketing, preferences) */
+  categories?: CookieCategory[]
+  /** Persistence adapter; omit for in-memory (non-persistent) */
+  storage?: CookieStorage
+  /** Storage key (default 'rfr-cookie-consent') */
+  storageKey?: string
+  /** Consent version — bump to re-prompt users after a policy change */
+  version?: string
+  /** Called whenever consent is saved, with the resolved preferences */
+  onChange?: (preferences: ConsentPreferences) => void
+}
+
+/** Immutable store snapshot. */
+export interface CookieConsentState {
+  /** Whether the user has made a choice (false → show the banner) */
+  consented: boolean
+  /** Per-category opt-in */
+  preferences: ConsentPreferences
+  /** Banner/dialog visibility */
+  open: boolean
+  /** The configured categories */
+  categories: CookieCategory[]
+}
+
+/** The framework-agnostic store. */
+export interface CookieConsentAPI {
+  getState(): CookieConsentState
+  subscribe(listener: () => void): () => void
+  /** Grant every category and persist */
+  acceptAll(): void
+  /** Grant only required categories and persist */
+  rejectAll(): void
+  /** Persist the given preferences (required categories are forced on) */
+  savePreferences(preferences: ConsentPreferences): void
+  /** Toggle a single (non-required) category in the working preferences */
+  setPreference(id: string, value: boolean): void
+  /** Clear stored consent and re-open the banner */
+  reset(): void
+  /** Open the banner/settings */
+  openSettings(): void
+  /** Close the banner without changing stored consent */
+  close(): void
+}

package/dist/index.ts

@@ -18,7 +18,9 @@ export * from './astro-checkbox/index.ts';
 export * from './astro-code-editor/index.ts';
 export * from './astro-collapsible/index.ts';
 export * from './astro-command/index.ts';
+export * from './astro-conversation/index.ts';
 export * from './astro-content-protection/index.ts';
+export * from './astro-cookie-consent/index.ts';
 export * from './astro-data-table/index.ts';
 export * from './astro-date-picker/index.ts';
 export * from './astro-device-frame/index.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@refraction-ui/astro",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "All Refraction UI Astro components in one package",
   "type": "module",
   "exports": {
@@ -38,7 +38,9 @@
     "@refraction-ui/astro-code-editor": "workspace:*",
     "@refraction-ui/astro-collapsible": "workspace:*",
     "@refraction-ui/astro-command": "workspace:*",
+    "@refraction-ui/astro-conversation": "workspace:*",
     "@refraction-ui/astro-content-protection": "workspace:*",
+    "@refraction-ui/astro-cookie-consent": "workspace:*",
     "@refraction-ui/astro-data-table": "workspace:*",
     "@refraction-ui/astro-date-picker": "workspace:*",
     "@refraction-ui/astro-device-frame": "workspace:*",