@refraction-ui/astro 0.4.0 → 0.4.4

package/dist/accordion/index.ts

@@ -0,0 +1 @@
+export {}

package/dist/ai/ai-manager.ts

@@ -0,0 +1,121 @@
+import type { AIProvider, AIConfig, AIAPI, GenerateOptions } from './types.js'
+
+/**
+ * createAI — creates an AI manager that routes requests to registered providers.
+ *
+ * Resolution order: explicit opts.provider -> router -> default -> first available
+ * Fallback: on error, try next in fallback chain
+ */
+export function createAI(config?: AIConfig): AIAPI {
+  const providers = new Map<string, AIProvider>()
+  /** Insertion-ordered list of provider names */
+  const providerOrder: string[] = []
+
+  const defaultProvider = config?.default
+  const fallbackChain = config?.fallback ?? []
+  const router = config?.router
+
+  function resolveProvider(opts?: GenerateOptions): AIProvider {
+    // 1. Explicit opts.provider
+    if (opts?.provider) {
+      const p = providers.get(opts.provider)
+      if (!p) {
+        throw new Error(`AI provider "${opts.provider}" not found. Registered providers: [${providerOrder.join(', ')}]`)
+      }
+      return p
+    }
+
+    // 2. Router
+    if (router) {
+      const chosen = router(opts ?? {}, {
+        providers: [...providerOrder],
+        default: defaultProvider ?? providerOrder[0] ?? '',
+      })
+      const p = providers.get(chosen)
+      if (p) return p
+    }
+
+    // 3. Default
+    if (defaultProvider) {
+      const p = providers.get(defaultProvider)
+      if (!p) {
+        throw new Error(`Default AI provider "${defaultProvider}" not registered. Registered providers: [${providerOrder.join(', ')}]`)
+      }
+      return p
+    }
+
+    // 4. First available
+    if (providerOrder.length === 0) {
+      throw new Error('No AI providers configured. Call addProvider() to register at least one provider.')
+    }
+
+    return providers.get(providerOrder[0])!
+  }
+
+  async function withFallback<T>(
+    primary: AIProvider,
+    fn: (provider: AIProvider) => Promise<T>,
+  ): Promise<T> {
+    try {
+      return await fn(primary)
+    } catch (error) {
+      // Try fallback chain
+      for (const name of fallbackChain) {
+        const fallback = providers.get(name)
+        if (!fallback || fallback === primary) continue
+        try {
+          return await fn(fallback)
+        } catch {
+          // continue to next fallback
+        }
+      }
+      // All fallbacks exhausted or no fallbacks — throw
+      // If there were fallbacks, throw the last error from the chain
+      if (fallbackChain.length > 0) {
+        // Try the last fallback one more time to get its error
+        const lastFallbackName = fallbackChain[fallbackChain.length - 1]
+        const lastFallback = providers.get(lastFallbackName)
+        if (lastFallback && lastFallback !== primary) {
+          return await fn(lastFallback)
+        }
+      }
+      throw error
+    }
+  }
+
+  const api: AIAPI = {
+    get providers() {
+      return [...providerOrder]
+    },
+
+    async generateText(prompt: string, opts?: GenerateOptions): Promise<string> {
+      const provider = resolveProvider(opts)
+      return withFallback(provider, (p) => p.generateText(prompt, opts))
+    },
+
+    async generateJSON<T = unknown>(prompt: string, opts?: GenerateOptions): Promise<T> {
+      const provider = resolveProvider(opts)
+      return withFallback(provider, (p) => p.generateJSON<T>(prompt, opts))
+    },
+
+    addProvider(name: string, provider: AIProvider): void {
+      if (providers.has(name)) {
+        // Replace, keep same position
+        providers.set(name, provider)
+      } else {
+        providers.set(name, provider)
+        providerOrder.push(name)
+      }
+    },
+
+    removeProvider(name: string): void {
+      if (providers.has(name)) {
+        providers.delete(name)
+        const idx = providerOrder.indexOf(name)
+        if (idx !== -1) providerOrder.splice(idx, 1)
+      }
+    },
+  }
+
+  return api
+}

package/dist/ai/index.ts

@@ -0,0 +1,23 @@
+// Types
+export type {
+  AIProvider,
+  GenerateOptions,
+  TTSProvider,
+  TTSOptions,
+  RouterFn,
+  AIConfig,
+  TTSConfig,
+  AIAPI,
+  TTSAPI,
+} from './types.js'
+
+// Managers
+export { createAI } from './ai-manager.js'
+export { createTTS } from './tts-manager.js'
+
+// Mock providers (for testing)
+export { createMockAIProvider, createMockTTSProvider } from './mock-providers.js'
+export type { MockAIResponses, MockTTSProviderExtended } from './mock-providers.js'
+
+// Utilities
+export { sanitizeForSpeech } from './sanitizer.js'

package/dist/ai/mock-providers.ts

@@ -0,0 +1,68 @@
+import type { AIProvider, GenerateOptions, TTSProvider, TTSOptions } from './types.js'
+
+export interface MockAIResponses {
+  text?: string[]
+  json?: unknown[]
+}
+
+export interface MockTTSProviderExtended extends TTSProvider {
+  speakCalls: Array<{ text: string; opts?: TTSOptions }>
+  stopCalls: number
+}
+
+/**
+ * createMockAIProvider — returns an AIProvider that returns canned responses.
+ * Used for testing without real API calls.
+ */
+export function createMockAIProvider(
+  name: string = 'mock',
+  responses?: MockAIResponses,
+): AIProvider {
+  let textIndex = 0
+  let jsonIndex = 0
+
+  const textResponses = responses?.text ?? ['Mock AI response']
+  const jsonResponses = responses?.json ?? [{ mock: true }]
+
+  return {
+    name,
+    supportsVision: false,
+
+    async generateText(_prompt: string, _opts?: GenerateOptions): Promise<string> {
+      const response = textResponses[Math.min(textIndex, textResponses.length - 1)]
+      textIndex++
+      return response
+    },
+
+    async generateJSON<T = unknown>(_prompt: string, _opts?: GenerateOptions): Promise<T> {
+      const response = jsonResponses[Math.min(jsonIndex, jsonResponses.length - 1)]
+      jsonIndex++
+      return response as T
+    },
+  }
+}
+
+/**
+ * createMockTTSProvider — returns a TTSProvider that tracks calls for assertion.
+ * Used for testing without real speech synthesis.
+ */
+export function createMockTTSProvider(
+  name: string = 'mock-tts',
+): MockTTSProviderExtended {
+  const provider: MockTTSProviderExtended = {
+    name,
+    isSupported: true,
+    speakCalls: [],
+    stopCalls: 0,
+
+    speak(text: string, opts?: TTSOptions): void {
+      provider.speakCalls.push({ text, opts })
+    },
+
+    stop(): void {
+      provider.stopCalls++
+    },
+  }
+
+  return provider
+}

package/dist/ai/sanitizer.ts

@@ -0,0 +1,174 @@
+/**
+ * sanitizeForSpeech — converts AI-generated text (with markdown, LaTeX, HTML)
+ * into clean, speakable plain text suitable for TTS engines.
+ *
+ * 30+ regex-based transformation rules applied in order.
+ */
+export function sanitizeForSpeech(text: string): string {
+  if (!text) return ''
+
+  let result = text
+
+  // === HTML ===
+
+  // 1. Strip HTML comments
+  result = result.replace(/<!--[\s\S]*?-->/g, '')
+
+  // 2. Strip HTML tags (including self-closing)
+  result = result.replace(/<[^>]+>/g, '')
+
+  // === Code blocks (before other markdown to avoid interference) ===
+
+  // 3. Strip fenced code blocks (``` with optional language)
+  result = result.replace(/```[\w]*\n?([\s\S]*?)```/g, '$1')
+
+  // 4. Strip inline code backticks
+  result = result.replace(/`([^`]+)`/g, '$1')
+
+  // === LaTeX (before markdown to handle $ delimiters) ===
+
+  // 5. Strip display math $$...$$
+  result = result.replace(/\$\$([\s\S]*?)\$\$/g, '$1')
+
+  // 6. Strip inline math $...$
+  result = result.replace(/\$([^$]+)\$/g, '$1')
+
+  // 7. Common fractions
+  result = result.replace(/\\frac\{1\}\{2\}/g, 'one half')
+  result = result.replace(/\\frac\{1\}\{3\}/g, 'one third')
+  result = result.replace(/\\frac\{1\}\{4\}/g, 'one quarter')
+  result = result.replace(/\\frac\{([^}]+)\}\{([^}]+)\}/g, '$1 over $2')
+
+  // 8. Square root
+  result = result.replace(/\\sqrt\{([^}]+)\}/g, 'square root of $1')
+
+  // 9. Superscripts (special cases)
+  result = result.replace(/\^\{2\}/g, ' squared')
+  result = result.replace(/\^\{3\}/g, ' cubed')
+  result = result.replace(/\^\{([^}]+)\}/g, ' to the power of $1')
+
+  // 10. Subscripts
+  result = result.replace(/_\{([^}]+)\}/g, ' sub $1')
+
+  // 11. Greek letters
+  result = result.replace(/\\alpha/g, 'alpha')
+  result = result.replace(/\\beta/g, 'beta')
+  result = result.replace(/\\gamma/g, 'gamma')
+  result = result.replace(/\\delta/g, 'delta')
+  result = result.replace(/\\theta/g, 'theta')
+  result = result.replace(/\\lambda/g, 'lambda')
+  result = result.replace(/\\mu/g, 'mu')
+  result = result.replace(/\\sigma/g, 'sigma')
+  result = result.replace(/\\omega/g, 'omega')
+  result = result.replace(/\\pi/g, 'pi')
+  result = result.replace(/\\phi/g, 'phi')
+
+  // 12. Operators
+  result = result.replace(/\\times/g, 'times')
+  result = result.replace(/\\div/g, 'divided by')
+  result = result.replace(/\\pm/g, 'plus or minus')
+  result = result.replace(/\\cdot/g, 'dot')
+
+  // 13. Relations
+  result = result.replace(/\\neq/g, 'not equal to')
+  result = result.replace(/\\leq/g, 'less than or equal to')
+  result = result.replace(/\\geq/g, 'greater than or equal to')
+  result = result.replace(/\\approx/g, 'approximately')
+  result = result.replace(/\\equiv/g, 'equivalent to')
+
+  // 14. Special symbols
+  result = result.replace(/\\infty/g, 'infinity')
+  result = result.replace(/\\partial/g, 'partial')
+
+  // 15. Summation and integrals
+  result = result.replace(/\\sum/g, 'sum')
+  result = result.replace(/\\prod/g, 'product')
+  result = result.replace(/\\int/g, 'integral')
+  result = result.replace(/\\lim/g, 'limit')
+
+  // 16. Trig functions
+  result = result.replace(/\\sin/g, 'sin')
+  result = result.replace(/\\cos/g, 'cos')
+  result = result.replace(/\\tan/g, 'tan')
+  result = result.replace(/\\log/g, 'log')
+  result = result.replace(/\\ln/g, 'ln')
+
+  // 17. Text commands (keep content)
+  result = result.replace(/\\text\{([^}]+)\}/g, '$1')
+  result = result.replace(/\\mathrm\{([^}]+)\}/g, '$1')
+  result = result.replace(/\\mathbf\{([^}]+)\}/g, '$1')
+  result = result.replace(/\\mathit\{([^}]+)\}/g, '$1')
+
+  // 18. Delimiters
+  result = result.replace(/\\left/g, '')
+  result = result.replace(/\\right/g, '')
+  result = result.replace(/\\big/g, '')
+  result = result.replace(/\\Big/g, '')
+
+  // 19. Strip remaining LaTeX commands (\word)
+  result = result.replace(/\\[a-zA-Z]+/g, '')
+
+  // 20. Strip LaTeX curly braces (but keep content)
+  result = result.replace(/\{([^}]*)\}/g, '$1')
+  // Handle any remaining stray braces
+  result = result.replace(/[{}]/g, '')
+
+  // === Markdown ===
+
+  // 21. Strip images ![alt](url)
+  result = result.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
+
+  // 22. Strip links [text](url) keeping text
+  result = result.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+
+  // 23. Strip bold **text** and __text__
+  result = result.replace(/\*\*([^*]+)\*\*/g, '$1')
+  result = result.replace(/__([^_]+)__/g, '$1')
+
+  // 24. Strip italic *text* and _text_
+  result = result.replace(/\*([^*]+)\*/g, '$1')
+  result = result.replace(/(?<!\w)_([^_]+)_(?!\w)/g, '$1')
+
+  // 25. Strip strikethrough ~~text~~
+  result = result.replace(/~~([^~]+)~~/g, '$1')
+
+  // 26. Strip headings (# to ######)
+  result = result.replace(/^#{1,6}\s+/gm, '')
+
+  // 27. Strip blockquotes
+  result = result.replace(/^>\s+/gm, '')
+
+  // 28. Strip unordered list markers (- or * at line start)
+  result = result.replace(/^[-*]\s+/gm, '')
+
+  // 29. Strip ordered list markers (1. 2. etc.)
+  result = result.replace(/^\d+\.\s+/gm, '')
+
+  // 30. Strip horizontal rules (---, ***, ___)
+  result = result.replace(/^[-*_]{3,}\s*$/gm, '')
+
+  // 31. Strip table separator lines (|---|---|)
+  result = result.replace(/^\|[-:\s|]+\|\s*$/gm, '')
+
+  // 32. Strip table pipes (keep cell content)
+  result = result.replace(/\|/g, ' ')
+
+  // === Whitespace normalization ===
+
+  // 33. Collapse multiple spaces to single space
+  result = result.replace(/ {2,}/g, ' ')
+
+  // 34. Normalize excessive newlines (3+ -> 2)
+  result = result.replace(/\n{3,}/g, '\n\n')
+
+  // 35. Trim each line
+  result = result
+    .split('\n')
+    .map((line) => line.trim())
+    .join('\n')
+
+  // 36. Remove empty lines at start/end
+  result = result.trim()
+
+  return result
+}

package/dist/ai/tts-manager.ts

@@ -0,0 +1,80 @@
+import type { TTSProvider, TTSConfig, TTSAPI, TTSOptions } from './types.js'
+
+/**
+ * createTTS — creates a TTS manager that routes requests to registered providers.
+ *
+ * Resolution order: explicit opts.provider -> router -> default -> first available
+ */
+export function createTTS(config?: TTSConfig): TTSAPI {
+  const providers = new Map<string, TTSProvider>()
+  const providerOrder: string[] = []
+
+  const defaultProvider = config?.default
+  const router = config?.router
+
+  function resolveProvider(opts?: TTSOptions): TTSProvider {
+    // 1. Explicit opts.provider
+    if (opts?.provider) {
+      const p = providers.get(opts.provider)
+      if (!p) {
+        throw new Error(`TTS provider "${opts.provider}" not found. Registered providers: [${providerOrder.join(', ')}]`)
+      }
+      return p
+    }
+
+    // 2. Router
+    if (router) {
+      const chosen = router(opts ?? {}, {
+        providers: [...providerOrder],
+        default: defaultProvider ?? providerOrder[0] ?? '',
+      })
+      const p = providers.get(chosen)
+      if (p) return p
+    }
+
+    // 3. Default
+    if (defaultProvider) {
+      const p = providers.get(defaultProvider)
+      if (!p) {
+        throw new Error(`Default TTS provider "${defaultProvider}" not registered. Registered providers: [${providerOrder.join(', ')}]`)
+      }
+      return p
+    }
+
+    // 4. First available
+    if (providerOrder.length === 0) {
+      throw new Error('No TTS providers configured. Call addProvider() to register at least one provider.')
+    }
+
+    return providers.get(providerOrder[0])!
+  }
+
+  const api: TTSAPI = {
+    get providers() {
+      return [...providerOrder]
+    },
+
+    speak(text: string, opts?: TTSOptions): void {
+      const provider = resolveProvider(opts)
+      provider.speak(text, opts)
+    },
+
+    stop(): void {
+      for (const name of providerOrder) {
+        const p = providers.get(name)
+        if (p) p.stop()
+      }
+    },
+
+    addProvider(name: string, provider: TTSProvider): void {
+      if (providers.has(name)) {
+        providers.set(name, provider)
+      } else {
+        providers.set(name, provider)
+        providerOrder.push(name)
+      }
+    },
+  }
+
+  return api
+}

package/dist/ai/types.ts

@@ -0,0 +1,72 @@
+/** AI provider interface — implemented by adapter packages (OpenAI, Anthropic, etc.) */
+export interface AIProvider {
+  name: string
+  generateText(prompt: string, opts?: GenerateOptions): Promise<string>
+  generateJSON<T = unknown>(prompt: string, opts?: GenerateOptions): Promise<T>
+  supportsVision: boolean
+}
+
+/** Options passed to generate calls */
+export interface GenerateOptions {
+  provider?: string
+  model?: string
+  intent?: string
+  image?: unknown
+  maxTokens?: number
+  temperature?: number
+  [key: string]: unknown
+}
+
+/** TTS provider interface — implemented by TTS adapter packages */
+export interface TTSProvider {
+  name: string
+  speak(text: string, opts?: TTSOptions): void
+  stop(): void
+  isSupported: boolean
+}
+
+/** Options passed to TTS calls */
+export interface TTSOptions {
+  provider?: string
+  voice?: string
+  language?: string
+  speed?: number
+  onEnd?: () => void
+  [key: string]: unknown
+}
+
+/** Router function — picks a provider name given a request and context */
+export type RouterFn<T> = (
+  request: T,
+  context: { providers: string[]; default: string },
+) => string
+
+/** Config for createAI */
+export interface AIConfig {
+  default?: string
+  fallback?: string[]
+  router?: RouterFn<GenerateOptions>
+}
+
+/** Config for createTTS */
+export interface TTSConfig {
+  default?: string
+  router?: RouterFn<TTSOptions>
+}
+
+/** Return type of createAI */
+export interface AIAPI {
+  providers: string[]
+  generateText(prompt: string, opts?: GenerateOptions): Promise<string>
+  generateJSON<T = unknown>(prompt: string, opts?: GenerateOptions): Promise<T>
+  addProvider(name: string, provider: AIProvider): void
+  removeProvider(name: string): void
+}
+
+/** Return type of createTTS */
+export interface TTSAPI {
+  providers: string[]
+  speak(text: string, opts?: TTSOptions): void
+  stop(): void
+  addProvider(name: string, provider: TTSProvider): void
+}

package/dist/animated-text/animated-text.styles.ts

@@ -0,0 +1,28 @@
+import { cva } from '../shared/index.ts'
+
+export const animatedTextVariants = cva({
+  base: 'inline-block transition-opacity',
+  variants: {
+    state: {
+      entering: 'opacity-100',
+      exiting: 'opacity-0',
+      idle: 'opacity-100',
+    },
+  },
+  defaultVariants: {
+    state: 'idle',
+  },
+})
+
+export const typewriterVariants = cva({
+  base: 'inline',
+  variants: {
+    cursor: {
+      blinking: 'after:inline-block after:w-[2px] after:h-[1em] after:bg-current after:ml-[1px] after:animate-blink after:align-text-bottom',
+      hidden: '',
+    },
+  },
+  defaultVariants: {
+    cursor: 'blinking',
+  },
+})

package/dist/animated-text/animated-text.ts

@@ -0,0 +1,83 @@
+export interface AnimatedTextProps {
+  words: string[]
+  interval?: number
+  transitionDuration?: number
+}
+
+export interface AnimatedTextState {
+  currentIndex: number
+}
+
+export interface AnimatedTextAPI {
+  /** Get the current word */
+  getCurrentWord: () => string
+  /** Get the next index (wraps around) */
+  getNextIndex: () => number
+  /** Current state */
+  state: AnimatedTextState
+}
+
+export interface TypewriterProps {
+  text: string
+  speed?: number
+  startDelay?: number
+}
+
+export interface TypewriterState {
+  currentIndex: number
+}
+
+export interface TypewriterAPI {
+  /** Get the currently visible portion of text */
+  getVisibleText: () => string
+  /** Whether the typewriter has finished */
+  isComplete: () => boolean
+  /** Current state */
+  state: TypewriterState
+}
+
+export function createAnimatedText(props: AnimatedTextProps): AnimatedTextAPI {
+  const { words } = props
+
+  const state: AnimatedTextState = {
+    currentIndex: 0,
+  }
+
+  function getCurrentWord(): string {
+    if (words.length === 0) return ''
+    return words[state.currentIndex]
+  }
+
+  function getNextIndex(): number {
+    if (words.length === 0) return 0
+    return (state.currentIndex + 1) % words.length
+  }
+
+  return {
+    getCurrentWord,
+    getNextIndex,
+    state,
+  }
+}
+
+export function createTypewriter(props: TypewriterProps): TypewriterAPI {
+  const { text } = props
+
+  const state: TypewriterState = {
+    currentIndex: 0,
+  }
+
+  function getVisibleText(): string {
+    return text.slice(0, state.currentIndex)
+  }
+
+  function isComplete(): boolean {
+    return state.currentIndex >= text.length
+  }
+
+  return {
+    getVisibleText,
+    isComplete,
+    state,
+  }
+}

package/dist/animated-text/index.ts

@@ -0,0 +1,15 @@
+export {
+  createAnimatedText,
+  createTypewriter,
+  type AnimatedTextProps,
+  type AnimatedTextState,
+  type AnimatedTextAPI,
+  type TypewriterProps,
+  type TypewriterState,
+  type TypewriterAPI,
+} from './animated-text.js'
+
+export {
+  animatedTextVariants,
+  typewriterVariants,
+} from './animated-text.styles.js'