@barefootjs/hono 0.30.6 → 0.31.0

package/src/build.ts

@@ -1,230 +0,0 @@
-// Hono build config factory for barefoot.config.ts
-
-import type { BuildOptions } from '@barefootjs/jsx'
-import { HonoAdapter } from './adapter/index.ts'
-import type { HonoAdapterOptions } from './adapter/index.ts'
-
-export interface HonoBuildOptions extends BuildOptions {
-  /** Inject Hono script collection wrapper (default: true) */
-  scriptCollection?: boolean
-  /** Base path for client JS script URLs (default: '/static/components/') */
-  scriptBasePath?: string
-  /** Adapter-specific options passed to HonoAdapter */
-  adapterOptions?: HonoAdapterOptions
-}
-
-/**
- * Create a BarefootBuildConfig for Hono projects.
- *
- * Uses structural typing — does not import BarefootBuildConfig to avoid
- * circular dependency between @barefootjs/hono and @barefootjs/cli.
- */
-export function createConfig(options: HonoBuildOptions = {}) {
-  const useScriptCollection = options.scriptCollection ?? true
-
-  return {
-    adapter: new HonoAdapter(options.adapterOptions),
-    paths: options.paths,
-    components: options.components,
-    outDir: options.outDir,
-    minify: options.minify,
-    contentHash: options.contentHash,
-    externals: options.externals,
-    externalsBasePath: options.externalsBasePath,
-    bundleEntries: options.bundleEntries,
-    localImportPrefixes: options.localImportPrefixes,
-    transformMarkedTemplate: useScriptCollection
-      ? (content: string, componentId: string, clientJsPath: string) =>
-          addScriptCollection(content, componentId, clientJsPath, options.scriptBasePath)
-      : undefined,
-  }
-}
-
-/**
- * Add Hono script collection wrapper to an SSR marked template.
- * Injects imports, a helper function, and script collector into each
- * exported component function.
- */
-export function addScriptCollection(content: string, componentId: string, clientJsPath: string, scriptBasePath: string = '/static/components/'): string {
-  const basePath = scriptBasePath.endsWith('/') ? scriptBasePath : scriptBasePath + '/'
-  const importStatement = "import { useRequestContext } from 'hono/jsx-renderer'\nimport { Fragment } from 'hono/jsx'\n"
-
-  // Find the last import statement and add our import after it
-  const importMatch = content.match(/^([\s\S]*?)((?:import[^\n]+\n)*)/m)
-  if (!importMatch) {
-    return content
-  }
-
-  const beforeImports = importMatch[1]
-  const existingImports = importMatch[2]
-  const restOfFile = content.slice(importMatch[0].length)
-
-  // Helper function to wrap JSX with inline script tags (for Suspense streaming)
-  const helperFn = `
-function __bfWrap(jsx: any, scripts: string[]) {
-  if (scripts.length === 0) return jsx
-  return <Fragment>{jsx}{scripts.map(s => <script type="module" src={s} />)}</Fragment>
-}
-`
-
-  // Script collection code to insert at the start of each component function.
-  // When BfScripts has already rendered (e.g., inside Suspense boundaries),
-  // scripts are output inline instead of being collected.
-  const scriptCollector = `
-  let __bfInlineScripts: string[] = []
-  // Script collection for client JS hydration
-  try {
-    const __c = useRequestContext()
-    const __scripts: { src: string }[] = __c.get('bfCollectedScripts') || []
-    const __outputScripts: Set<string> = __c.get('bfOutputScripts') || new Set()
-    const __bfRendered = __c.get('bfScriptsRendered')
-    if (!__outputScripts.has('__barefoot__')) {
-      __outputScripts.add('__barefoot__')
-      if (__bfRendered) __bfInlineScripts.push('${basePath}barefoot.js')
-      else __scripts.push({ src: '${basePath}barefoot.js' })
-    }
-    if (!__outputScripts.has('${componentId}')) {
-      __outputScripts.add('${componentId}')
-      if (__bfRendered) __bfInlineScripts.push('${basePath}${clientJsPath}')
-      else __scripts.push({ src: '${basePath}${clientJsPath}' })
-    }
-    __c.set('bfCollectedScripts', __scripts)
-    __c.set('bfOutputScripts', __outputScripts)
-  } catch {}
-`
-
-  // Insert script collector at the start of each component function body.
-  // Matches both exported and non-exported PascalCase components (#786).
-  // Uses paren counting instead of regex to correctly handle nested
-  // delimiters in destructured params (e.g. `onInput = () => {}`).
-  //
-  // The regex matches against a comment-masked copy so a docstring
-  // example like `function MyNode(this: HTMLElement, props)` is NOT
-  // misread as a real function declaration (#1236). The paren counter
-  // still walks the ORIGINAL `restOfFile` and keeps the quote-skip
-  // logic — TS parameter type annotations contain balanced strings
-  // (e.g. `"data-key"?: string`) that the skip handles correctly.
-  let modifiedRest = restOfFile
-  const maskedRest = maskComments(restOfFile)
-  const exportFuncPattern = /(?:export )?function ([A-Z]\w*)\s*\(/g
-  const insertions: Array<{ index: number; text: string }> = []
-  let efMatch: RegExpExecArray | null
-  while ((efMatch = exportFuncPattern.exec(maskedRest)) !== null) {
-    const openParenPos = efMatch.index + efMatch[0].length - 1
-    // Count parens to find matching ')'
-    let depth = 1
-    let i = openParenPos + 1
-    while (i < restOfFile.length && depth > 0) {
-      const ch = restOfFile[i]
-      if (ch === "'" || ch === '"' || ch === '`') {
-        i++
-        while (i < restOfFile.length) {
-          if (restOfFile[i] === '\\') { i += 2; continue }
-          if (restOfFile[i] === ch) { i++; break }
-          i++
-        }
-        continue
-      }
-      if (ch === '(') depth++
-      else if (ch === ')') depth--
-      i++
-    }
-    // i is now right after matching ')'; find the next '{' for function body
-    while (i < restOfFile.length && restOfFile[i] !== '{') i++
-    if (i < restOfFile.length) {
-      insertions.push({ index: i + 1, text: scriptCollector })
-    }
-  }
-  // Apply insertions from back to front to preserve indices
-  for (let ii = insertions.length - 1; ii >= 0; ii--) {
-    const ins = insertions[ii]
-    modifiedRest = modifiedRest.slice(0, ins.index) + ins.text + modifiedRest.slice(ins.index)
-  }
-
-  // Wrap each return (...) with __bfWrap((...), __bfInlineScripts).
-  //
-  // Intentionally NO comment/string masking here. JSX bodies routinely
-  // contain unbalanced apostrophes in text content (`Hey! How's it
-  // going`) which a string-aware scanner misreads as an open quote and
-  // ends up blanking everything until the next stray `'`, breaking
-  // paren counting. Plain `(` / `)` counting works for JSX returns
-  // because JSX text cannot contain literal parens — those only appear
-  // inside `{expr}` slots, which are balanced JS.
-  const returnPattern = /return\s*\(/g
-  const returnMatches: Array<{ index: number; length: number }> = []
-  let m: RegExpExecArray | null
-  while ((m = returnPattern.exec(modifiedRest)) !== null) {
-    returnMatches.push({ index: m.index, length: m[0].length })
-  }
-  // Process from last to first to keep earlier offsets valid
-  for (let ri = returnMatches.length - 1; ri >= 0; ri--) {
-    const rm = returnMatches[ri]
-    const afterOpen = rm.index + rm.length // position after 'return ('
-    let depth = 1
-    let ci = afterOpen
-    while (ci < modifiedRest.length && depth > 0) {
-      if (modifiedRest[ci] === '(') depth++
-      else if (modifiedRest[ci] === ')') depth--
-      ci++
-    }
-    // ci is right after the matching ')'; insert wrap closing there
-    modifiedRest = modifiedRest.slice(0, ci) + ', __bfInlineScripts)' + modifiedRest.slice(ci)
-    // Replace 'return (' with 'return __bfWrap(('
-    modifiedRest = modifiedRest.slice(0, rm.index) + 'return __bfWrap((' + modifiedRest.slice(rm.index + rm.length)
-  }
-
-  return beforeImports + existingImports + importStatement + helperFn + modifiedRest
-}
-
-/**
- * Replace comment contents with spaces (preserving length and newlines
- * so indices computed against the masked text are valid in the
- * original). Used by `addScriptCollection` so its `function Foo(`
- * regex ignores JSDoc / inline comments — a docstring example like
- * `function MyNode(this: HTMLElement, props)` previously masqueraded
- * as a real function declaration (#1236).
- *
- * Handles `//` line comments and `/* ... *\/` block comments (incl.
- * JSDoc). String literals are intentionally NOT masked: JSX text
- * content routinely contains unbalanced apostrophes (`How's`) that a
- * string-aware masker would misread as an open quote, blanking the
- * rest of the file and hiding later function declarations.
- *
- * Strings inside comments are handled implicitly: the whole comment
- * (including any quotes it contains) is blanked.
- *
- * **Known limitation**: this function does NOT track string
- * boundaries, so a `//` or `/*` appearing INSIDE a string literal is
- * still treated as a comment delimiter. Example: in
- * `const u = "https://x.y" ; export function Foo() {}` the `//` in
- * `https://` is misread as a line comment and the rest of the line is
- * blanked — a `function Foo()` on that same line would be hidden from
- * the regex. SSR template output (the only caller) does not embed
- * such cases in practice. If a future caller can produce them, swap
- * in a real lexer rather than extending this helper.
- */
-export function maskComments(s: string): string {
-  let out = ''
-  let i = 0
-  while (i < s.length) {
-    const ch = s[i]
-    const next = s[i + 1]
-    if (ch === '/' && next === '*') {
-      const end = s.indexOf('*/', i + 2)
-      const stop = end === -1 ? s.length : end + 2
-      for (let j = i; j < stop; j++) out += s[j] === '\n' ? '\n' : ' '
-      i = stop
-      continue
-    }
-    if (ch === '/' && next === '/') {
-      const end = s.indexOf('\n', i + 2)
-      const stop = end === -1 ? s.length : end
-      for (let j = i; j < stop; j++) out += ' '
-      i = stop
-      continue
-    }
-    out += ch
-    i++
-  }
-  return out
-}

package/src/dev.tsx

@@ -1,154 +0,0 @@
-/**
- * BarefootJS Dev Reloader (Hono, Node-side)
- *
- * `createDevReloader` turns `bf build --watch`'s sentinel file
- * (`<distDir>/.dev/build-id`) into an SSE stream:
- *
- *   [bf build --watch] → writes `<distDir>/.dev/build-id` after each successful build
- *   [createDevReloader]      → watches that file, streams SSE `event: reload`
- *
- * Mount it on a Hono route in the generated app; the matching browser-
- * side subscriber (`<DevReload />`) lives in the project itself (see
- * the hono-node scaffold's `dev-reload.tsx`) so its endpoint URL and
- * reconnect behavior are an in-tree edit.
- *
- * ```ts
- * // factory.ts
- * import { createDevReloader } from '@barefootjs/hono/dev'
- * app.get('/_bf/reload', createDevReloader({ distDir: './dist' }))
- * ```
- *
- * Disabled (404) when `NODE_ENV === 'production'` unless `enabled: true`
- * is passed explicitly.
- */
-
-import type { Context } from 'hono'
-import { mkdir, readFile, watch } from 'node:fs/promises'
-import { resolve } from 'node:path'
-
-export interface CreateDevReloaderOptions {
-  /** Directory that `bf build` writes output into (contains `.dev/build-id`). */
-  distDir: string
-  /** Override the dev gate. Defaults to `process.env.NODE_ENV !== 'production'`. */
-  enabled?: boolean
-}
-
-// Sentinel path contract with `@barefootjs/cli`. These values must match
-// `DEV_SENTINEL_SUBDIR` / `DEV_SENTINEL_FILENAME` in `packages/cli/src/lib/build.ts`
-// — duplicated intentionally to avoid a runtime dep on the CLI.
-const DEV_SUBDIR = '.dev'
-const BUILD_ID_FILE = 'build-id'
-/**
- * Heartbeat interval for idle keepalive. Must stay comfortably under Bun's
- * default 10s idleTimeout — otherwise the server would close a quiet SSE
- * stream and the browser would EventSource-reconnect every cycle, which can
- * lose a rebuild event emitted in the gap between close and reconnect.
- */
-const HEARTBEAT_MS = 5000
-
-function isDevDefault(): boolean {
-  return process.env.NODE_ENV !== 'production'
-}
-
-/**
- * Hono route handler that streams Server-Sent Events and emits `reload` every
- * time `<distDir>/.dev/build-id` is written. Disabled (404) in production.
- */
-export function createDevReloader(
-  options: CreateDevReloaderOptions,
-): (c: Context) => Response | Promise<Response> {
-  const { distDir, enabled = isDevDefault() } = options
-
-  return async (c: Context) => {
-    if (!enabled) return c.notFound()
-
-    const devDir = resolve(distDir, DEV_SUBDIR)
-    // Ensure the directory exists so fs.watch doesn't ENOENT before the first build.
-    await mkdir(devDir, { recursive: true })
-
-    const buildIdPath = resolve(devDir, BUILD_ID_FILE)
-    const signal = c.req.raw.signal
-    // If the client reconnects with Last-Event-ID (the build-id it last saw)
-    // and the current build-id is newer, a rebuild happened while it was
-    // disconnected — recover by firing `reload` immediately instead of `hello`.
-    const lastEventId = (c.req.header('Last-Event-ID') ?? '').trim()
-
-    const readBuildId = async (): Promise<string> => {
-      try {
-        // `readFile(path, 'utf8')` is the obvious call, but Deno's
-        // `node:fs/promises` types resolve that positional-encoding
-        // overload to `NonSharedBuffer` rather than `string`, so `.trim()`
-        // is missing and `deno check` fails (TS2769 + TS2339). Read raw
-        // bytes and decode with `TextDecoder` instead: it defaults to
-        // UTF-8 (same result as before), sidesteps the broken overload
-        // entirely, and is portable across Node/Deno/Workers — matching
-        // the `TextEncoder` used just below.
-        return new TextDecoder().decode(await readFile(buildIdPath)).trim()
-      } catch {
-        return ''
-      }
-    }
-
-    const stream = new ReadableStream<Uint8Array>({
-      async start(controller) {
-        const encoder = new TextEncoder()
-        const send = (chunk: string) => {
-          try {
-            controller.enqueue(encoder.encode(chunk))
-          } catch {
-            // Stream already closed (client disconnected).
-          }
-        }
-
-        send(`retry: 1000\n\n`)
-        let lastSentId = ''
-        const initialId = await readBuildId()
-        if (initialId) {
-          lastSentId = initialId
-          const event = lastEventId && lastEventId !== initialId ? 'reload' : 'hello'
-          send(`event: ${event}\nid: ${initialId}\ndata: ${initialId}\n\n`)
-        }
-
-        // Heartbeat keeps the connection under Bun's idleTimeout so that a
-        // silent period between builds doesn't close the socket (which would
-        // otherwise race with in-flight rebuilds and drop `reload` events).
-        const heartbeat = setInterval(() => send(`: hb\n\n`), HEARTBEAT_MS)
-
-        try {
-          // Watch the parent directory: the build-id file may not exist yet,
-          // and `fs.watch` on a missing path throws.
-          const iter = watch(devDir, { signal })
-          for await (const event of iter) {
-            if (event.filename !== BUILD_ID_FILE) continue
-            const id = await readBuildId()
-            if (!id || id === lastSentId) continue
-            lastSentId = id
-            send(`event: reload\nid: ${id}\ndata: ${id}\n\n`)
-          }
-        } catch (err) {
-          const name = (err as { name?: string } | undefined)?.name
-          if (name !== 'AbortError') {
-            const message = (err as Error).message ?? 'watch error'
-            send(`event: error\ndata: ${JSON.stringify(message)}\n\n`)
-          }
-        } finally {
-          clearInterval(heartbeat)
-          try { controller.close() } catch { /* already closed */ }
-        }
-      },
-      cancel() {
-        // Client disconnected; fs.watch will unwind via `signal`.
-      },
-    })
-
-    return new Response(stream, {
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache, no-transform',
-        'Connection': 'keep-alive',
-        'X-Accel-Buffering': 'no',
-      },
-    })
-  }
-}
-