deepspace 0.6.2 → 0.8.0

package/features/search-bar/src/__tests__/search-model.test.ts

@@ -0,0 +1,40 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { readRecentSearches, rememberRecentItem, rememberRecentQuery } from '../search-model'
+
+const storageKey = 'search-history-test'
+let values: Map<string, string>
+
+beforeEach(() => {
+  values = new Map()
+  vi.stubGlobal('window', {
+    localStorage: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+    },
+  })
+})
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('recent search history', () => {
+  it('stores only the stable ID for a selected result', () => {
+    expect(rememberRecentItem(storageKey, 'post-1', 5)).toEqual([
+      { kind: 'item', itemId: 'post-1' },
+    ])
+    expect(JSON.parse(values.get(storageKey) ?? 'null')).toEqual([
+      { kind: 'item', itemId: 'post-1' },
+    ])
+  })
+
+  it('ignores legacy result snapshots instead of replaying incomplete objects', () => {
+    values.set(storageKey, JSON.stringify([{ id: 'post-1', title: 'Old title' }]))
+    expect(readRecentSearches(storageKey, 5)).toEqual([])
+  })
+
+  it('deduplicates submitted queries without changing their display casing', () => {
+    rememberRecentQuery(storageKey, 'Project Alpha', 5)
+    expect(rememberRecentQuery(storageKey, 'project alpha', 5)).toEqual([
+      { kind: 'query', query: 'project alpha' },
+    ])
+  })
+})

package/features/search-bar/src/search-model.ts

@@ -0,0 +1,223 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+
+export interface HighlightedPart {
+  text: string
+  match: boolean
+}
+
+export interface UseSearchIndexOptions<T> {
+  items: T[]
+  query: string
+  getText: (item: T) => Array<string | number | null | undefined>
+  limit?: number
+}
+
+export function useSearchIndex<T>({
+  items,
+  query,
+  getText,
+  limit = 20,
+}: UseSearchIndexOptions<T>): T[] {
+  return useMemo(() => {
+    const resultLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : items.length
+    const normalizedQuery = normalize(query)
+    if (!normalizedQuery) return items.slice(0, resultLimit)
+
+    return items
+      .map((item, index) => {
+        const haystack = getText(item)
+          .filter((value): value is string | number => value !== null && value !== undefined)
+          .map(String)
+          .join(' ')
+        return { item, index, score: scoreText(haystack, normalizedQuery) }
+      })
+      .filter((entry) => entry.score > 0)
+      .sort((left, right) => right.score - left.score || left.index - right.index)
+      .slice(0, resultLimit)
+      .map((entry) => entry.item)
+  }, [getText, items, limit, query])
+}
+
+export function getHighlightedParts(text: string, query: string): HighlightedPart[] {
+  const normalizedQuery = normalize(query)
+  if (!text || !normalizedQuery) return [{ text, match: false }]
+
+  const normalizedText = text.toLowerCase()
+  const parts: HighlightedPart[] = []
+  let cursor = 0
+  let index = normalizedText.indexOf(normalizedQuery)
+
+  while (index !== -1) {
+    if (index > cursor) parts.push({ text: text.slice(cursor, index), match: false })
+    parts.push({ text: text.slice(index, index + normalizedQuery.length), match: true })
+    cursor = index + normalizedQuery.length
+    index = normalizedText.indexOf(normalizedQuery, cursor)
+  }
+
+  if (cursor < text.length) parts.push({ text: text.slice(cursor), match: false })
+  return parts.length > 0 ? parts : [{ text, match: false }]
+}
+
+export interface UseAsyncSearchOptions<T> {
+  query: string
+  search: (query: string) => Promise<T[]>
+  minLength?: number
+  delayMs?: number
+}
+
+export function useAsyncSearch<T>({
+  query,
+  search,
+  minLength = 2,
+  delayMs = 250,
+}: UseAsyncSearchOptions<T>) {
+  const [items, setItems] = useState<T[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const requestId = useRef(0)
+
+  useEffect(() => {
+    const trimmed = query.trim()
+    const currentRequest = ++requestId.current
+    const requiredLength = Number.isFinite(minLength) ? Math.max(0, Math.floor(minLength)) : 2
+    const waitMs = Number.isFinite(delayMs)
+      ? Math.min(60_000, Math.max(0, Math.floor(delayMs)))
+      : 250
+
+    if (trimmed.length < requiredLength) {
+      setItems([])
+      setLoading(false)
+      setError(null)
+      return
+    }
+
+    setLoading(true)
+    setError(null)
+
+    const timer = window.setTimeout(() => {
+      void search(trimmed)
+        .then((results) => {
+          if (requestId.current !== currentRequest) return
+          setItems(results)
+          setError(null)
+        })
+        .catch((searchError) => {
+          if (requestId.current !== currentRequest) return
+          setItems([])
+          setError(searchError instanceof Error ? searchError.message : 'Search failed')
+        })
+        .finally(() => {
+          if (requestId.current === currentRequest) setLoading(false)
+        })
+    }, waitMs)
+
+    return () => {
+      window.clearTimeout(timer)
+      if (requestId.current === currentRequest) requestId.current += 1
+    }
+  }, [delayMs, minLength, query, search])
+
+  return { items, loading, error }
+}
+
+export type RecentSearchEntry = { kind: 'item'; itemId: string } | { kind: 'query'; query: string }
+
+export function createRecentStorageKey(
+  title: string,
+  placeholder: string,
+  triggerLabel: string,
+): string {
+  const scope =
+    [title, placeholder, triggerLabel].map((value) => value.trim().toLowerCase()).find(Boolean) ??
+    'search'
+  const normalizedScope = scope.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'search'
+  return `deepspace:search-bar:recent:${normalizedScope}`
+}
+
+export function readRecentSearches(storageKey: string, maxItems: number): RecentSearchEntry[] {
+  try {
+    const parsed: unknown = JSON.parse(window.localStorage.getItem(storageKey) ?? '[]')
+    if (!Array.isArray(parsed)) return []
+    return parsed.filter(isRecentSearchEntry).slice(0, normalizeLimit(maxItems))
+  } catch {
+    return []
+  }
+}
+
+export function rememberRecentItem(
+  storageKey: string,
+  itemId: string,
+  maxItems: number,
+): RecentSearchEntry[] {
+  if (!itemId) return readRecentSearches(storageKey, maxItems)
+  return rememberRecent(
+    storageKey,
+    { kind: 'item', itemId },
+    (entry) => entry.kind === 'item' && entry.itemId === itemId,
+    maxItems,
+  )
+}
+
+export function rememberRecentQuery(
+  storageKey: string,
+  rawQuery: string,
+  maxItems: number,
+): RecentSearchEntry[] {
+  const query = rawQuery.trim()
+  const normalizedQuery = normalize(query)
+  if (!normalizedQuery) return readRecentSearches(storageKey, maxItems)
+  return rememberRecent(
+    storageKey,
+    { kind: 'query', query },
+    (entry) => entry.kind === 'query' && normalize(entry.query) === normalizedQuery,
+    maxItems,
+  )
+}
+
+function rememberRecent(
+  storageKey: string,
+  recent: RecentSearchEntry,
+  matches: (entry: RecentSearchEntry) => boolean,
+  maxItems: number,
+): RecentSearchEntry[] {
+  const next = [
+    recent,
+    ...readRecentSearches(storageKey, maxItems).filter((entry) => !matches(entry)),
+  ].slice(0, normalizeLimit(maxItems))
+
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(next))
+  } catch {
+    // Persistence is optional; search continues with the in-memory result.
+  }
+  return next
+}
+
+function isRecentSearchEntry(value: unknown): value is RecentSearchEntry {
+  if (!value || typeof value !== 'object') return false
+  const candidate = value as Partial<RecentSearchEntry>
+  if (candidate.kind === 'item') return typeof candidate.itemId === 'string' && !!candidate.itemId
+  return (
+    candidate.kind === 'query' && typeof candidate.query === 'string' && !!candidate.query.trim()
+  )
+}
+
+function normalizeLimit(value: number): number {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0
+}
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function scoreText(value: string, query: string): number {
+  const text = normalize(value)
+  if (!text || !query) return 0
+  if (text === query) return 100
+  if (text.startsWith(query)) return 80
+  if (text.includes(` ${query}`)) return 60
+  if (text.includes(query)) return 40
+
+  const terms = query.split(/\s+/).filter(Boolean)
+  return terms.length > 1 && terms.every((term) => text.includes(term)) ? 20 : 0
+}

package/features/tasks/src/TasksPage.tsx

@@ -81,7 +81,7 @@ function CreateChallengeModal({ isOpen, onClose, onCreate }: CreateChallengeModa
 
   return (
     <Modal open={isOpen} onClose={onClose} size="md">
-      <Modal.Header onClose={onClose}>
+      <Modal.Header>
         <Modal.Title>Create Challenge</Modal.Title>
       </Modal.Header>
       <Modal.Body>
@@ -163,7 +163,7 @@ function SubmitModal({ isOpen, onClose, onSubmit, challenge }: SubmitModalProps)
 
   return (
     <Modal open={isOpen} onClose={onClose} size="md">
-      <Modal.Header onClose={onClose}>
+      <Modal.Header>
         <Modal.Title>Submit Challenge</Modal.Title>
       </Modal.Header>
       <Modal.Body>
@@ -228,7 +228,7 @@ function GradeModal({ isOpen, onClose, onGrade, challenge }: GradeModalProps) {
 
   return (
     <Modal open={isOpen} onClose={onClose} size="md">
-      <Modal.Header onClose={onClose}>
+      <Modal.Header>
         <Modal.Title>Grade Submission</Modal.Title>
       </Modal.Header>
       <Modal.Body>

package/features/topbar/src/Topbar.tsx

@@ -334,20 +334,3 @@ export default function Topbar({
     </header>
   )
 }
-
-// ============================================================================
-// Example Logo Component
-// ============================================================================
-
-export function ExampleLogo({ collapsed = false }: { collapsed?: boolean }) {
-  return (
-    <div className="flex items-center gap-2">
-      <div className="w-8 h-8 bg-primary/20 rounded-lg flex items-center justify-center">
-        <svg className="w-5 h-5 text-primary" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth="2">
-          <path strokeLinecap="round" strokeLinejoin="round" d="M13 10V3L4 14h7v7l9-11h-7z" />
-        </svg>
-      </div>
-      {!collapsed && <span className="text-lg font-semibold text-foreground">My App</span>}
-    </div>
-  )
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepspace",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "engines": {
     "node": ">=22.15.0"
   },
@@ -33,7 +33,6 @@
   "files": [
     "dist",
     "features",
-    "scripts",
     "CHANGELOG.md"
   ],
   "scripts": {

package/features/docs/src/docs-favorites.ts

@@ -1,18 +0,0 @@
-/**
- * Pin favorites — browser localStorage (same pattern as docs2).
- */
-
-const FAVORITES_KEY = 'deepspace-docs-favorites'
-
-export function getFavorites(): Set<string> {
-  try {
-    const stored = localStorage.getItem(FAVORITES_KEY)
-    return stored ? new Set(JSON.parse(stored) as string[]) : new Set()
-  } catch {
-    return new Set()
-  }
-}
-
-export function saveFavorites(favs: Set<string>): void {
-  localStorage.setItem(FAVORITES_KEY, JSON.stringify([...favs]))
-}

package/features/docs/src/use-yjs-room-with-awareness.ts

@@ -1,289 +0,0 @@
-/**
- * Matches {@link import('deepspace').useYjsRoom} (YjsRoom DO via /ws/yjs/:id) but wires
- * {@link Awareness} over the server's MSG_AWARENESS path. Published `useYjsRoom` builds may
- * omit awareness relay; collaborator avatars/presence otherwise never populate.
- */
-
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import * as Y from 'yjs'
-import {
-  Awareness,
-  createDecoder,
-  createEncoder,
-  encodeAwarenessMessage,
-  getAuthToken,
-  handleAwarenessMessage,
-  MSG_AWARENESS,
-  MSG_SYNC,
-  MSG_SYNC_STEP1,
-  MSG_SYNC_STEP2,
-  MSG_SYNC_UPDATE,
-  readVarUint,
-  readVarUint8Array,
-  toUint8Array,
-  writeVarUint,
-  writeVarUint8Array,
-} from 'deepspace'
-
-const UPDATE_BATCH_DELAY_MS = 16
-
-export interface UseYjsRoomWithAwarenessResult {
-  doc: Y.Doc
-  text: string
-  setText: (value: string) => void
-  synced: boolean
-  /** From the server's WebSocket `{ type:'auth', canWrite }`; false until confirmed. */
-  canWrite: boolean
-  /** Becomes true after the auth message is parsed (eliminates transient false before handshake). */
-  writeAuthResolved: boolean
-  awareness: Awareness
-}
-
-export function useYjsRoomWithAwareness(
-  docId: string,
-  fieldName: string,
-): UseYjsRoomWithAwarenessResult {
-  const [syncedDocId, setSyncedDocId] = useState<string | null>(null)
-  const [canWrite, setCanWrite] = useState(false)
-  const [writeAuthResolved, setWriteAuthResolved] = useState(false)
-  const [text, setTextState] = useState('')
-  const [, setUpdateCount] = useState(0)
-  const synced = syncedDocId === docId
-
-  const { doc, awareness } = useMemo(() => {
-    const nextDoc = new Y.Doc()
-    return { doc: nextDoc, awareness: new Awareness(nextDoc) }
-    // docId is a deliberate semantic dep (not textually used): switching rooms
-    // MUST mint a fresh Y.Doc/Awareness so state from the old room never leaks
-    // into the new one. Removing it would reuse a stale doc across docIds.
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- docId forces a fresh Y.Doc per room; removing it reuses a stale doc across rooms
-  }, [docId])
-
-  const wsRef = useRef<WebSocket | null>(null)
-  const isLocalRef = useRef(false)
-  const applyingRemoteAwarenessRef = useRef(false)
-  const pendingUpdatesRef = useRef<Uint8Array[]>([])
-  const updateBatchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-  const yText = useMemo(() => doc.getText(fieldName), [doc, fieldName])
-
-  useEffect(() => {
-    return () => {
-      awareness.setLocalState(null)
-      doc.destroy()
-    }
-  }, [awareness, doc])
-
-  useLayoutEffect(() => {
-    setSyncedDocId(null)
-    setCanWrite(false)
-    setWriteAuthResolved(false)
-    setTextState('')
-  }, [docId])
-
-  useEffect(() => {
-    const observer = () => {
-      if (isLocalRef.current) return
-      setTextState(yText.toString())
-    }
-    yText.observe(observer)
-    return () => yText.unobserve(observer)
-  }, [yText])
-
-  useEffect(() => {
-    let ws: WebSocket | null = null
-    let reconnectTimer: ReturnType<typeof setTimeout> | null = null
-    let alive = true
-
-    const connect = async (isReconnect: boolean) => {
-      if (!alive) return
-
-      if (!isReconnect) {
-        doc.transact(() => {
-          if (yText.length > 0) yText.delete(0, yText.length)
-        })
-        setTextState('')
-        try {
-          awareness.setLocalState(null)
-        } catch {
-          /* ignore */
-        }
-      }
-
-      const token = await getAuthToken()
-      if (!alive) return
-      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
-      const baseUrl = `${protocol}//${window.location.host}`
-      const url = new URL(`/ws/yjs/${encodeURIComponent(docId)}`, baseUrl)
-      if (token) url.searchParams.set('token', token)
-      ws = new WebSocket(url.toString())
-      ws.binaryType = 'arraybuffer'
-      wsRef.current = ws
-
-      ws.onopen = () => {
-        setSyncedDocId(null)
-      }
-
-      ws.onmessage = (event: MessageEvent<ArrayBuffer>) => {
-        if (typeof event.data === 'string') {
-          try {
-            const msg = JSON.parse(event.data) as { type?: string; canWrite?: boolean }
-            if (msg.type === 'auth') {
-              setWriteAuthResolved(true)
-              if (typeof msg.canWrite === 'boolean') setCanWrite(msg.canWrite)
-            }
-          } catch {
-            /* ignore */
-          }
-          return
-        }
-
-        const data = new Uint8Array(event.data)
-        const decoder = createDecoder(data)
-        const messageType = readVarUint(decoder)
-
-        if (messageType === MSG_SYNC) {
-          const syncType = readVarUint(decoder)
-          const payload = readVarUint8Array(decoder)
-          switch (syncType) {
-            case MSG_SYNC_STEP1: {
-              const diff = Y.encodeStateAsUpdate(doc, payload)
-              const enc = createEncoder()
-              writeVarUint(enc, MSG_SYNC)
-              writeVarUint(enc, MSG_SYNC_STEP2)
-              writeVarUint8Array(enc, diff)
-              ws?.send(toUint8Array(enc).buffer)
-              setSyncedDocId(docId)
-              break
-            }
-            case MSG_SYNC_STEP2: {
-              Y.applyUpdate(doc, payload, 'server')
-              setTextState(yText.toString())
-              setSyncedDocId(docId)
-              break
-            }
-            case MSG_SYNC_UPDATE: {
-              Y.applyUpdate(doc, payload, 'server')
-              setTextState(yText.toString())
-              setUpdateCount((c) => c + 1)
-              break
-            }
-          }
-        } else if (messageType === MSG_AWARENESS) {
-          applyingRemoteAwarenessRef.current = true
-          try {
-            handleAwarenessMessage(awareness, data)
-          } catch {
-            /* ignore malformed */
-          } finally {
-            applyingRemoteAwarenessRef.current = false
-          }
-        }
-      }
-
-      ws.onclose = () => {
-        wsRef.current = null
-        setSyncedDocId(null)
-        if (alive) reconnectTimer = setTimeout(() => void connect(true), 1000)
-      }
-
-      ws.onerror = () => ws?.close()
-    }
-
-    void connect(false)
-
-    return () => {
-      alive = false
-      if (reconnectTimer) clearTimeout(reconnectTimer)
-      if (ws) {
-        ws.onclose = null
-        ws.onmessage = null
-        ws.onerror = null
-        ws.close()
-      }
-      wsRef.current = null
-    }
-  }, [doc, docId, yText, awareness])
-
-  useEffect(() => {
-    /**
-     * Tiptap fires a Yjs `update` for every keystroke. Sending each as its
-     * own WS frame floods the socket and visibly drops typing latency under
-     * load. We coalesce into a single MSG_SYNC_UPDATE per ~16 ms via
-     * Y.mergeUpdates — same behaviour Tiptap collab examples ship with.
-     */
-    const flushPendingUpdates = () => {
-      updateBatchTimerRef.current = null
-      const updates = pendingUpdatesRef.current
-      pendingUpdatesRef.current = []
-      const socket = wsRef.current
-      if (!socket || socket.readyState !== WebSocket.OPEN || updates.length === 0) return
-
-      const enc = createEncoder()
-      writeVarUint(enc, MSG_SYNC)
-      writeVarUint(enc, MSG_SYNC_UPDATE)
-      writeVarUint8Array(enc, updates.length === 1 ? updates[0] : Y.mergeUpdates(updates))
-      socket.send(toUint8Array(enc).buffer)
-    }
-
-    const handler = (update: Uint8Array, origin: unknown) => {
-      if (origin === 'server') return
-      const socket = wsRef.current
-      if (!socket || socket.readyState !== WebSocket.OPEN) return
-      pendingUpdatesRef.current.push(update)
-      if (!updateBatchTimerRef.current) {
-        updateBatchTimerRef.current = setTimeout(flushPendingUpdates, UPDATE_BATCH_DELAY_MS)
-      }
-    }
-    doc.on('update', handler)
-    return () => {
-      doc.off('update', handler)
-      if (updateBatchTimerRef.current) {
-        clearTimeout(updateBatchTimerRef.current)
-        flushPendingUpdates()
-      }
-      pendingUpdatesRef.current = []
-    }
-  }, [doc])
-
-  useEffect(() => {
-    const handleAwarenessUpdate = ({
-      added,
-      updated,
-      removed,
-    }: {
-      added: number[]
-      updated: number[]
-      removed: number[]
-    }) => {
-      if (applyingRemoteAwarenessRef.current) return
-      const changedClients = [...added, ...updated, ...removed]
-      if (changedClients.length === 0) return
-      const socket = wsRef.current
-      if (!socket || socket.readyState !== WebSocket.OPEN) return
-      socket.send(encodeAwarenessMessage(awareness, changedClients).buffer)
-    }
-
-    awareness.on('update', handleAwarenessUpdate)
-    return () => {
-      awareness.off('update', handleAwarenessUpdate)
-      awareness.setLocalState(null)
-    }
-  }, [awareness])
-
-  const setText = useCallback(
-    (value: string) => {
-      setTextState(value)
-      if (!canWrite) return
-      isLocalRef.current = true
-      doc.transact(() => {
-        yText.delete(0, yText.length)
-        yText.insert(0, value)
-      })
-      isLocalRef.current = false
-    },
-    [doc, yText, canWrite],
-  )
-
-  return { doc, text, setText, synced, canWrite, writeAuthResolved, awareness }
-}

package/features/file-attachments/src/attachments-constants.ts

@@ -1,9 +0,0 @@
-/**
- * File Attachments Feature - Constants
- *
- * For file category detection, use getFileCategory from useMimeTypeDetection.ts.
- * For human-readable sizes, import `formatFileSize` from 'deepspace'.
- */
-
-/** Max upload size (50MB) */
-export const MAX_FILE_SIZE = 50 * 1024 * 1024

package/features/items/src/items-constants.ts

@@ -1,10 +0,0 @@
-/**
- * Items Feature - Constants
- */
-
-export const ITEM_STATUS = {
-  ACTIVE: 'active',
-  ARCHIVED: 'archived',
-} as const
-
-export type ItemStatus = typeof ITEM_STATUS[keyof typeof ITEM_STATUS]

package/features/leaderboard/src/leaderboard-constants.ts

@@ -1,21 +0,0 @@
-/**
- * Leaderboard Feature - Constants
- */
-
-import type { BadgeProps } from '@/components/ui'
-
-export type BadgeVariant = BadgeProps['variant']
-
-export const LEADERBOARD_CATEGORY = {
-  GENERAL: 'general',
-  SPEED: 'speed',
-  ACCURACY: 'accuracy',
-} as const
-
-export type LeaderboardCategory = typeof LEADERBOARD_CATEGORY[keyof typeof LEADERBOARD_CATEGORY]
-
-export const CATEGORY_CONFIG: Record<LeaderboardCategory, { title: string; color: BadgeVariant }> = {
-  [LEADERBOARD_CATEGORY.GENERAL]: { title: 'General', color: 'info' },
-  [LEADERBOARD_CATEGORY.SPEED]: { title: 'Speed', color: 'warning' },
-  [LEADERBOARD_CATEGORY.ACCURACY]: { title: 'Accuracy', color: 'success' },
-}

package/features/messaging/src/components/chat/ReactionPicker.tsx

@@ -1,2 +0,0 @@
-/** Shared emoji list used by the hover toolbar and mobile action sheet. */
-export const EMOJI_LIST = ['\u{1F44D}', '\u{1F44E}', '\u{1F604}', '\u{1F389}', '\u2764\uFE0F', '\u{1F680}', '\u{1F440}', '\u{1F525}', '\u{1F4AF}', '\u{1F914}', '\u{1F622}', '\u{1F64F}']