gorsee 0.2.3 → 0.2.5

package/src/reactive/live.ts

@@ -1,97 +0,0 @@
-import { createSignal, type SignalGetter } from "./signal.ts"
-
-export interface LiveOptions<T> {
-  url: string
-  initialValue: T
-  transform?: (data: unknown) => T
-  reconnect?: boolean
-  reconnectDelay?: number
-}
-
-export interface LiveSignal<T> {
-  readonly value: SignalGetter<T>
-  readonly connected: SignalGetter<boolean>
-  send: (data: unknown) => void
-  close: () => void
-}
-
-export function createLive<T>(options: LiveOptions<T>): LiveSignal<T> {
-  const {
-    url,
-    initialValue,
-    transform,
-    reconnect = true,
-    reconnectDelay = 1000,
-  } = options
-
-  const [value, setValue] = createSignal<T>(initialValue)
-  const [connected, setConnected] = createSignal(false)
-
-  let ws: WebSocket | null = null
-  let closed = false
-  let retryCount = 0
-
-  function handleMessage(event: MessageEvent): void {
-    try {
-      const parsed: unknown = JSON.parse(String(event.data))
-      const result = transform ? transform(parsed) : (parsed as T)
-      setValue(result)
-    } catch {
-      // ignore malformed messages
-    }
-  }
-
-  function handleOpen(): void {
-    retryCount = 0
-    setConnected(true)
-  }
-
-  function handleClose(): void {
-    setConnected(false)
-    ws = null
-    if (!closed && reconnect) {
-      scheduleReconnect()
-    }
-  }
-
-  function scheduleReconnect(): void {
-    const delay = Math.min(reconnectDelay * 2 ** retryCount, 30_000)
-    retryCount++
-    setTimeout(connect, delay)
-  }
-
-  function connect(): void {
-    if (closed) return
-    if (typeof globalThis.WebSocket === "undefined") return
-
-    ws = new WebSocket(url)
-    ws.addEventListener("open", handleOpen)
-    ws.addEventListener("message", handleMessage)
-    ws.addEventListener("close", handleClose)
-    ws.addEventListener("error", () => {
-      // error triggers close, handled there
-    })
-  }
-
-  function send(data: unknown): void {
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(data))
-    }
-  }
-
-  function close(): void {
-    closed = true
-    if (ws) {
-      ws.close()
-      ws = null
-    }
-    setConnected(false)
-  }
-
-  // Only connect in browser environment
-  if (typeof globalThis.WebSocket !== "undefined") {
-    connect()
-  }
-
-  return { value, connected, send, close }
-}

package/src/reactive/optimistic.ts

@@ -1,83 +0,0 @@
-// Optimistic mutations — update UI instantly, rollback on server error
-// Killer feature: no framework has this built-in at reactive level
-
-import { createSignal, type SignalGetter } from "./signal.ts"
-
-export interface MutationOptions<T, V> {
-  mutationFn: (variables: V) => Promise<T>
-  onSuccess?: (data: T, variables: V) => void
-  onError?: (error: Error, variables: V) => void
-  onSettled?: (data: T | undefined, error: Error | undefined) => void
-}
-
-export interface MutationState<T> {
-  readonly data: SignalGetter<T | undefined>
-  readonly error: SignalGetter<Error | undefined>
-  readonly isPending: SignalGetter<boolean>
-}
-
-export interface Mutation<T, V> extends MutationState<T> {
-  mutate: (variables: V) => Promise<T>
-  /** Optimistic: update signal immediately, rollback if server fails */
-  optimistic: <S>(
-    signal: SignalGetter<S>,
-    setter: (current: S) => void,
-    update: (current: S, variables: V) => S,
-    variables: V,
-  ) => Promise<T>
-  reset: () => void
-}
-
-export function createMutation<T, V = void>(
-  options: MutationOptions<T, V>,
-): Mutation<T, V> {
-  const [data, setData] = createSignal<T | undefined>(undefined)
-  const [error, setError] = createSignal<Error | undefined>(undefined)
-  const [isPending, setIsPending] = createSignal(false)
-
-  async function mutate(variables: V): Promise<T> {
-    setIsPending(true)
-    setError(undefined)
-    try {
-      const result = await options.mutationFn(variables)
-      setData(result)
-      options.onSuccess?.(result, variables)
-      options.onSettled?.(result, undefined)
-      return result
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err))
-      setError(e)
-      options.onError?.(e, variables)
-      options.onSettled?.(undefined, e)
-      throw e
-    } finally {
-      setIsPending(false)
-    }
-  }
-
-  async function optimistic<S>(
-    signal: SignalGetter<S>,
-    setter: (val: S) => void,
-    update: (current: S, variables: V) => S,
-    variables: V,
-  ): Promise<T> {
-    const previous = signal()
-    // Apply optimistic update immediately
-    setter(update(previous, variables))
-    try {
-      return await mutate(variables)
-    } catch (err) {
-      // Rollback on failure
-      setter(previous)
-      throw err
-    }
-  }
-
-  function reset(): void {
-    setData(undefined)
-    setError(undefined)
-    setIsPending(false)
-  }
-
-  return { data, error, isPending, mutate, optimistic, reset }
-}

package/src/reactive/resource.ts

@@ -1,138 +0,0 @@
-import { createSignal, type SignalGetter } from "./signal.ts"
-
-export interface ResourceOptions {
-  /** Initial data (skip first fetch) */
-  initialData?: unknown
-  /** Retry count on failure (default: 0) */
-  retry?: number
-  /** Retry delay in ms (default: 1000) */
-  retryDelay?: number
-  /** Cache key for deduplication */
-  key?: string
-  /** Stale time in ms — refetch after this period */
-  staleTime?: number
-}
-
-export interface ResourceState<T> {
-  loading: SignalGetter<boolean>
-  error: SignalGetter<Error | undefined>
-  refetch: () => void
-  mutate: (value: T | ((prev: T | undefined) => T)) => void
-}
-
-export type ResourceReturn<T> = [SignalGetter<T | undefined>, ResourceState<T>]
-
-// Simple in-memory cache for resource deduplication
-interface CacheEntry {
-  data: unknown
-  fetchedAt: number
-  promise?: Promise<unknown>
-}
-
-const resourceCache = new Map<string, CacheEntry>()
-
-export function invalidateResource(key: string): void {
-  resourceCache.delete(key)
-}
-
-export function invalidateAll(): void {
-  resourceCache.clear()
-}
-
-export function createResource<T>(
-  fetcher: () => Promise<T>,
-  options?: ResourceOptions,
-): ResourceReturn<T> {
-  const retryCount = options?.retry ?? 0
-  const retryDelay = options?.retryDelay ?? 1000
-  const cacheKey = options?.key
-  const staleTime = options?.staleTime
-
-  // Check cache
-  const cached = cacheKey ? resourceCache.get(cacheKey) : undefined
-  const hasValidCache = cached && staleTime && (Date.now() - cached.fetchedAt < staleTime)
-  const initialValue = hasValidCache ? cached.data as T : options?.initialData as T | undefined
-
-  const [data, setData] = createSignal<T | undefined>(initialValue)
-  const [loading, setLoading] = createSignal(!hasValidCache)
-  const [error, setError] = createSignal<Error | undefined>(undefined)
-
-  async function fetchWithRetry(attempt: number): Promise<T> {
-    try {
-      return await fetcher()
-    } catch (err) {
-      if (attempt < retryCount) {
-        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)))
-        return fetchWithRetry(attempt + 1)
-      }
-      throw err
-    }
-  }
-
-  const load = () => {
-    // Deduplicate: if another resource with same key is already fetching, reuse promise
-    if (cacheKey) {
-      const entry = resourceCache.get(cacheKey)
-      if (entry?.promise) {
-        entry.promise.then((result) => {
-          setData(() => result as T)
-          setLoading(false)
-        }).catch((err) => {
-          setError(err instanceof Error ? err : new Error(String(err)))
-          setLoading(false)
-        })
-        return
-      }
-    }
-
-    setLoading(true)
-    setError(undefined)
-
-    const promise = fetchWithRetry(0)
-
-    // Store promise in cache for dedup
-    if (cacheKey) {
-      const entry = resourceCache.get(cacheKey) ?? { data: undefined, fetchedAt: 0 }
-      entry.promise = promise
-      resourceCache.set(cacheKey, entry)
-    }
-
-    promise
-      .then((result) => {
-        setData(() => result)
-        setLoading(false)
-        if (cacheKey) {
-          resourceCache.set(cacheKey, { data: result, fetchedAt: Date.now() })
-        }
-      })
-      .catch((err) => {
-        setError(err instanceof Error ? err : new Error(String(err)))
-        setLoading(false)
-        if (cacheKey) {
-          const entry = resourceCache.get(cacheKey)
-          if (entry) entry.promise = undefined
-        }
-      })
-  }
-
-  // Don't fetch if we have valid cache
-  if (!hasValidCache) {
-    load()
-  }
-
-  return [
-    data,
-    {
-      loading,
-      error,
-      refetch: load,
-      mutate: (value) => {
-        if (typeof value === "function") {
-          setData(value as (prev: T | undefined) => T)
-        } else {
-          setData(() => value)
-        }
-      },
-    },
-  ]
-}

package/src/reactive/signal.ts

@@ -1,20 +0,0 @@
-import { signal as alienSignal } from "alien-signals"
-
-export type SignalGetter<T> = () => T
-export type SignalSetter<T> = (value: T | ((prev: T) => T)) => void
-
-export function createSignal<T>(initialValue: T): [SignalGetter<T>, SignalSetter<T>] {
-  const s = alienSignal(initialValue)
-
-  const getter: SignalGetter<T> = () => s()
-
-  const setter: SignalSetter<T> = (value) => {
-    if (typeof value === "function") {
-      s((value as (prev: T) => T)(s()))
-    } else {
-      s(value)
-    }
-  }
-
-  return [getter, setter]
-}

package/src/reactive/store.ts

@@ -1,36 +0,0 @@
-import { createSignal, type SignalGetter, type SignalSetter } from "./signal.ts"
-
-export type Store<T extends Record<string, unknown>> = {
-  readonly [K in keyof T]: SignalGetter<T[K]>
-}
-
-export type SetStore<T extends Record<string, unknown>> = <K extends keyof T>(
-  key: K,
-  value: T[K] | ((prev: T[K]) => T[K])
-) => void
-
-export function createStore<T extends Record<string, unknown>>(
-  initialValue: T
-): [Store<T>, SetStore<T>] {
-  const signals = new Map<keyof T, [SignalGetter<unknown>, SignalSetter<unknown>]>()
-
-  for (const key of Object.keys(initialValue) as (keyof T)[]) {
-    signals.set(key, createSignal<unknown>(initialValue[key]))
-  }
-
-  const store = new Proxy({} as Store<T>, {
-    get(_target, prop: string) {
-      const entry = signals.get(prop as keyof T)
-      if (!entry) return undefined
-      return entry[0]
-    },
-  })
-
-  const setStore: SetStore<T> = (key, value) => {
-    const entry = signals.get(key)
-    if (!entry) return
-    entry[1](value as unknown)
-  }
-
-  return [store, setStore]
-}

package/src/router/index.ts

@@ -1,2 +0,0 @@
-export { createRouter, type Route } from "./scanner.ts"
-export { matchRoute, buildStaticMap, type MatchResult } from "./matcher.ts"

package/src/router/matcher.ts

@@ -1,53 +0,0 @@
-import type { Route } from "./scanner.ts"
-
-export interface MatchResult {
-  route: Route
-  params: Record<string, string>
-}
-
-// Pre-build a lookup map for static routes (O(1) matching)
-export function buildStaticMap(routes: Route[]): Map<string, Route> {
-  const map = new Map<string, Route>()
-  for (const route of routes) {
-    if (!route.isDynamic) map.set(route.path, route)
-  }
-  return map
-}
-
-export function matchRoute(
-  routes: Route[],
-  pathname: string,
-  staticMap?: Map<string, Route>,
-): MatchResult | null {
-  // Normalize: remove trailing slash (except root)
-  const normalized = pathname === "/" ? "/" : pathname.replace(/\/+$/, "")
-
-  // Fast O(1) lookup for static routes
-  if (staticMap) {
-    const staticRoute = staticMap.get(normalized)
-    if (staticRoute) return { route: staticRoute, params: {} }
-  }
-
-  // Fallback to regex matching for dynamic routes
-  for (const route of routes) {
-    if (!route.isDynamic && staticMap) continue
-    const match = route.pattern.exec(normalized)
-    if (!match) continue
-
-    const params: Record<string, string> = {}
-    for (let i = 0; i < route.params.length; i++) {
-      const value = match[i + 1]
-      if (value !== undefined) {
-        try {
-          params[route.params[i]!] = decodeURIComponent(value)
-        } catch {
-          params[route.params[i]!] = value
-        }
-      }
-    }
-
-    return { route, params }
-  }
-
-  return null
-}

package/src/router/scanner.ts

@@ -1,206 +0,0 @@
-// Route scanner -- reads routes/ directory, builds route tree
-
-import { readdir, stat } from "node:fs/promises"
-import { join, extname, basename } from "node:path"
-
-export interface Route {
-  path: string
-  pattern: RegExp
-  filePath: string
-  isDynamic: boolean
-  params: string[]
-  layoutPath: string | null
-  layoutPaths: string[]
-  middlewarePath: string | null
-  middlewarePaths: string[]
-  errorPath: string | null
-  loadingPath: string | null
-}
-
-const ROUTE_EXTENSIONS = new Set([".tsx", ".ts"])
-const IGNORED_PREFIXES = ["_"]
-
-function fileToRoutePath(relativePath: string): string {
-  let route = relativePath
-    .replace(/\\/g, "/")
-    .replace(/\.(tsx?|jsx?)$/, "")
-
-  // index files -> parent path
-  if (route === "index" || route.endsWith("/index")) {
-    route = route.slice(0, -"index".length) || "/"
-  }
-
-  if (!route.startsWith("/")) route = "/" + route
-  // Remove trailing slash (except root)
-  if (route.length > 1 && route.endsWith("/")) route = route.slice(0, -1)
-  return route
-}
-
-function routeToPattern(routePath: string): { pattern: RegExp; params: string[] } {
-  const params: string[] = []
-
-  const regexStr = routePath
-    .split("/")
-    .map((segment) => {
-      if (!segment) return ""
-
-      // catch-all: [...path]
-      if (segment.startsWith("[...") && segment.endsWith("]")) {
-        const param = segment.slice(4, -1)
-        params.push(param)
-        return "(?:/(.+))?"
-      }
-
-      // dynamic: [id]
-      if (segment.startsWith("[") && segment.endsWith("]")) {
-        const param = segment.slice(1, -1)
-        params.push(param)
-        return "/([^/]+)"
-      }
-
-      return "/" + segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-    })
-    .join("")
-
-  const finalRegex = regexStr || "/"
-  return {
-    pattern: new RegExp(`^${finalRegex}$`),
-    params,
-  }
-}
-
-interface ScanMaps {
-  layouts: Map<string, string>
-  middlewares: Map<string, string>
-  errors: Map<string, string>
-  loadings: Map<string, string>
-}
-
-async function scanDirectory(
-  dir: string,
-  basePath: string,
-  routes: Route[],
-  parent?: ScanMaps,
-): Promise<ScanMaps> {
-  const layouts = new Map<string, string>(parent?.layouts)
-  const middlewares = new Map<string, string>(parent?.middlewares)
-
-  let entries: string[]
-  try {
-    entries = await readdir(dir)
-  } catch {
-    return { layouts, middlewares, errors: new Map(), loadings: new Map() }
-  }
-
-  // First pass: find layouts, middleware, error boundaries, and loading states
-  const errors = new Map<string, string>(parent?.errors)
-  const loadings = new Map<string, string>(parent?.loadings)
-  for (const entry of entries) {
-    const fullPath = join(dir, entry)
-    const name = basename(entry, extname(entry))
-
-    if (name === "_layout") {
-      layouts.set(basePath || "/", fullPath)
-    }
-    if (name === "_middleware") {
-      middlewares.set(basePath || "/", fullPath)
-    }
-    if (name === "_error") {
-      errors.set(basePath || "/", fullPath)
-    }
-    if (name === "_loading") {
-      loadings.set(basePath || "/", fullPath)
-    }
-  }
-
-  // Second pass: process routes and subdirectories
-  for (const entry of entries) {
-    const fullPath = join(dir, entry)
-    const entryStat = await stat(fullPath)
-    const name = basename(entry, extname(entry))
-
-    if (entryStat.isDirectory()) {
-      // Route groups: (group) directories don't add to URL path
-      const isGroup = entry.startsWith("(") && entry.endsWith(")")
-      const subPath = isGroup ? basePath : (basePath ? `${basePath}/${entry}` : entry)
-      const sub = await scanDirectory(fullPath, subPath, routes, { layouts, middlewares, errors, loadings })
-      for (const [k, v] of sub.layouts) layouts.set(k, v)
-      for (const [k, v] of sub.middlewares) middlewares.set(k, v)
-      for (const [k, v] of sub.errors) errors.set(k, v)
-      for (const [k, v] of sub.loadings) loadings.set(k, v)
-      continue
-    }
-
-    if (!ROUTE_EXTENSIONS.has(extname(entry))) continue
-    if (IGNORED_PREFIXES.some((p) => name.startsWith(p))) continue
-
-    const relPath = basePath ? `${basePath}/${entry}` : entry
-    const routePath = fileToRoutePath(relPath)
-    const { pattern, params } = routeToPattern(routePath)
-
-    // Build middleware chain: collect from root → current directory
-    const middlewarePaths: string[] = []
-    const segments = (basePath || "/").split("/").filter(Boolean)
-    const dirs = ["/"]
-    for (let i = 0; i < segments.length; i++) {
-      dirs.push(segments.slice(0, i + 1).join("/"))
-    }
-    for (const d of dirs) {
-      const mwPath = middlewares.get(d)
-      if (mwPath) middlewarePaths.push(mwPath)
-    }
-
-    // Build layout chain: collect from root → current directory
-    const layoutPaths: string[] = []
-    for (const d of dirs) {
-      const lPath = layouts.get(d)
-      if (lPath) layoutPaths.push(lPath)
-    }
-
-    // Find nearest loading component (walk up)
-    let loadingPath: string | null = null
-    for (let i = dirs.length - 1; i >= 0; i--) {
-      const lp = loadings.get(dirs[i]!)
-      if (lp) { loadingPath = lp; break }
-    }
-
-    // Find nearest error boundary (walk up)
-    let errorPath: string | null = null
-    for (let i = dirs.length - 1; i >= 0; i--) {
-      const ep = errors.get(dirs[i]!)
-      if (ep) { errorPath = ep; break }
-    }
-
-    routes.push({
-      path: routePath,
-      pattern,
-      filePath: fullPath,
-      isDynamic: params.length > 0,
-      params,
-      layoutPath: layoutPaths[layoutPaths.length - 1] ?? null,
-      layoutPaths,
-      middlewarePath: middlewarePaths[middlewarePaths.length - 1] ?? null,
-      middlewarePaths,
-      errorPath,
-      loadingPath,
-    })
-  }
-
-  return { layouts, middlewares, errors, loadings }
-}
-
-export async function createRouter(routesDir: string): Promise<Route[]> {
-  const routes: Route[] = []
-  await scanDirectory(routesDir, "", routes)
-
-  // Sort: static routes first, then dynamic, then catch-all
-  routes.sort((a, b) => {
-    if (a.isDynamic !== b.isDynamic) return a.isDynamic ? 1 : -1
-    const aCatchAll = a.path.includes("[...")
-    const bCatchAll = b.path.includes("[...")
-    if (aCatchAll !== bCatchAll) return aCatchAll ? 1 : -1
-    return a.path.localeCompare(b.path)
-  })
-
-  return routes
-}

package/src/runtime/client.ts

@@ -1,28 +0,0 @@
-// Client-side rendering and hydration
-
-import type { GorseeNode } from "./jsx-runtime.ts"
-import { enterHydration, exitHydration } from "./hydration.ts"
-import { replayEvents } from "./event-replay.ts"
-
-function insertResult(container: Element, result: GorseeNode): void {
-  if (result instanceof Node) {
-    container.appendChild(result)
-  } else if (Array.isArray(result)) {
-    for (const child of result) insertResult(container, child)
-  }
-}
-
-export function render(component: () => GorseeNode, container: Element): void {
-  container.replaceChildren()
-  insertResult(container, component())
-}
-
-export function hydrate(component: () => GorseeNode, container: Element): void {
-  // Cursor-based hydration: walks server-rendered DOM, attaches bindings
-  enterHydration(container)
-  component()
-  exitHydration()
-
-  // Replay events captured before hydration
-  replayEvents(container)
-}

package/src/runtime/error-boundary.ts

@@ -1,35 +0,0 @@
-// Client-side ErrorBoundary component
-// Catches errors during rendering and shows fallback UI
-
-import { createSignal } from "../reactive/signal.ts"
-
-export interface ErrorBoundaryProps {
-  fallback: unknown | ((error: Error) => unknown)
-  children: unknown
-}
-
-export function ErrorBoundary(props: ErrorBoundaryProps): unknown {
-  const [error, setError] = createSignal<Error | null>(null)
-
-  try {
-    // Try to evaluate children
-    const children = typeof props.children === "function"
-      ? (props.children as Function)()
-      : props.children
-    return () => {
-      const err = error()
-      if (err) {
-        return typeof props.fallback === "function"
-          ? (props.fallback as (e: Error) => unknown)(err)
-          : props.fallback
-      }
-      return children
-    }
-  } catch (err) {
-    const errObj = err instanceof Error ? err : new Error(String(err))
-    setError(errObj)
-    return typeof props.fallback === "function"
-      ? (props.fallback as (e: Error) => unknown)(errObj)
-      : props.fallback
-  }
-}