@bakery-framework/core 1.0.0

package/src/client/utils.ts

@@ -0,0 +1,315 @@
+/** biome-ignore-all lint/complexity/noExcessiveCognitiveComplexity: '*/
+
+/**
+ * Browser runtime: binds the shared utilities onto `globalThis` and adds the
+ * DOM-dependent pieces ($fmt, speculation rules, live navigation) on top.
+ *
+ * The utilities themselves live in `utils/isomorphic/` and are imported rather
+ * than redefined here. This file used to carry its own copy of each one, which
+ * is how the $fmt replacer-arity bug and the match() prototype-chain bug each
+ * had to be fixed twice.
+ */
+import type { MapOf } from '../types'
+import { Case } from '../utils/isomorphic/case'
+import { escapeHtml as escapeHTML } from '../utils/isomorphic/escape'
+import { is } from '../utils/isomorphic/is'
+import { match, matchDefault } from '../utils/isomorphic/match'
+import { Math2 } from '../utils/isomorphic/math'
+import { any, assert, repeat, throws } from '../utils/isomorphic/misc'
+import { circularReplacer } from '../utils/isomorphic/stringify'
+import { Try, tryCatch } from '../utils/isomorphic/try'
+
+export { escapeHTML }
+
+function processGetBody(
+  body: FormData | MapOf<any> | URLSearchParams | string,
+) {
+  if (body instanceof URLSearchParams) {
+    return body.toString()
+  }
+
+  if (body instanceof FormData || (is.object(body) && body !== null)) {
+    const urlSearchParams = new URLSearchParams()
+    const entries =
+      body instanceof FormData ? body.entries() : Object.entries(body)
+
+    for (const [key, value] of entries) {
+      urlSearchParams.append(key, (value as any).toString())
+    }
+    return urlSearchParams.toString()
+  }
+
+  return String(body)
+}
+
+// `randomId` and `request` are exported purely so `client/globals.d.ts` can
+// declare the globals as `typeof import('./utils').randomId` / `.request`
+// instead of restating their signatures — which is how both had drifted from
+// this file. Nothing imports them; the bundle entry's exports are inert.
+export function randomId(length = 8) {
+  const arr = new Uint8Array(Math.ceil(length / 2))
+  crypto.getRandomValues(arr)
+  return Array.from(arr, dec => dec.toString(16).padStart(2, '0'))
+    .join('')
+    .slice(0, length)
+}
+
+type RequestJson = RequestInit & { body?: any }
+
+export async function request(
+  url: string,
+  init: RequestJson | string = {},
+  bodyData?: any,
+): Promise<JsonResponse> {
+  let options: RequestJson = {}
+  if (typeof init === 'string') {
+    options = { method: init, body: bodyData }
+  } else {
+    options = init || {}
+  }
+
+  const method = (options.method || 'GET').toUpperCase()
+  const body = options.body || {}
+
+  if (method === 'GET' && body && Object.keys(body).length > 0) {
+    const query = processGetBody(body)
+    if (query) {
+      url = `${url}${url.includes('?') ? '&' : '?'}${query}`
+    }
+  }
+
+  const isFormData = body instanceof FormData
+
+  const response = await fetch(url, {
+    ...options,
+    method,
+    body:
+      method === 'GET' ? undefined : isFormData ? body : JSON.stringify(body),
+    headers: {
+      ...(isFormData ? {} : { 'Content-Type': 'application/json' }),
+      ...(options.headers || {}),
+    },
+  })
+
+  const [err, data] = await tryCatch(response.json.bind(response))
+
+  if (err) {
+    throws(`Request failed: ${err.message || 'Unknown error'}`)
+  }
+
+  if (
+    data &&
+    typeof data === 'object' &&
+    'status' in data &&
+    'message' in data
+  ) {
+    const status = (data as any).status
+    if (status >= 200 && status < 300) {
+      return data as JsonResponse
+    }
+    throws((data as any).message)
+  }
+
+  return data
+}
+
+export function formatHTML(html: string, indentWidth: number = 2): string {
+  if (!html) return ''
+
+  const cleanHtml = html
+    .replace(/\n/g, '')
+    .replace(/[\s]{2,}/g, ' ')
+    .replace(/>\s*</g, '><')
+    .trim()
+
+  const tokens = cleanHtml.match(/<[^>]+>|[^<]+/g) || []
+  let indentLevel = 0
+
+  return tokens.reduce((formattedString, token) => {
+    const isClosing = /^<\//.test(token)
+    const isSelfClosing =
+      /^<(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)[^>]*>/i.test(
+        token,
+      ) || /<[^>]+\/>/.test(token)
+    const isOpening = /^<[^/!?]/.test(token) && !isSelfClosing
+
+    indentLevel = isClosing ? Math.max(0, indentLevel - 1) : indentLevel
+
+    const indent = ' '.repeat(indentLevel * indentWidth)
+    const appendedToken =
+      formattedString === '' ? token : `\n${indent}${token.trim()}`
+
+    indentLevel = isOpening ? indentLevel + 1 : indentLevel
+
+    return formattedString + appendedToken
+  }, '')
+}
+
+Object.assign(globalThis, {
+  match,
+  matchDefault,
+  Try,
+  tryCatch,
+  is,
+  Case,
+  Math2,
+  throws,
+  assert,
+  any,
+  escapeHTML,
+  repeat,
+  request,
+  randomId,
+  Bakery: {
+    version: import.meta.env.BAKERY_VERSION,
+    async virtual(path: string) {
+      const response = await fetch(path)
+      if (!response.ok) {
+        return null
+      }
+
+      const contentType = response.headers.get('Content-Type') || ''
+      if (contentType.includes('application/json')) {
+        return response.json()
+      } else {
+        const text = await response.text()
+
+        if (path.endsWith('.css')) {
+          const style = document.createElement('style')
+          style.textContent = text
+          document.head.appendChild(style)
+          return null
+        }
+
+        // The body was already consumed above; re-reading it throws.
+        return text
+      }
+    },
+
+    params<T = MapOf<any>>(): T {
+      return any(window).__PAGE_PARAMS__ as T
+    },
+  },
+  $fmt(data: any): string {
+    if (data == null) return ''
+    if (is.string(data)) return data
+    if (is.bigint(data)) return `${data}n`
+    if (is.symbol(data)) return data.toString()
+
+    if (data instanceof Element) return `\n${formatHTML(data.outerHTML)}`
+    if (data instanceof Error) return data.stack || data.message || String(data)
+    if (data instanceof Date) return data.toISOString()
+    if (data instanceof RegExp) return data.toString()
+
+    if (is.function(data)) {
+      return data.name ? `[Function: ${data.name}]` : '[Function]'
+    }
+
+    if (data instanceof Set) {
+      const fmt = (globalThis as any).$fmt
+      return `Set(${data.size}) { ${Array.from(data)
+        .map(v => fmt(v))
+        .join(', ')} }`
+    }
+    if (data instanceof Map) {
+      const fmt = (globalThis as any).$fmt
+      return `Map(${data.size}) { ${Array.from(data.entries())
+        .map(([k, v]) => `${fmt(k)} => ${fmt(v)}`)
+        .join(', ')} }`
+    }
+
+    if (
+      Array.isArray(data) ||
+      typeof data?.toJSON === 'function' ||
+      (typeof data === 'object' &&
+        Object.prototype.toString.call(data) === '[object Object]')
+    ) {
+      try {
+        // Cycle handling comes from circularReplacer; this adds only the
+        // display rules for values JSON has no representation for.
+        return JSON.stringify(
+          data,
+          circularReplacer((_key, value) => {
+            if (is.bigint(value)) return `${value}n`
+            if (is.function(value))
+              return value.name ? `[Function: ${value.name}]` : '[Function]'
+            if (value instanceof RegExp) return String(value)
+            return value
+          }),
+          2,
+        )
+      } catch {
+        return String(data)
+      }
+    }
+
+    return String(data)
+  },
+})
+
+if (typeof document !== 'undefined') {
+  let debounceTimer: any
+
+  const updateSpeculationRules = () => {
+    const urls = new Set<string>()
+    const elements = document.querySelectorAll(
+      '[href]:not(link, base, use, image)',
+    )
+
+    const ignorePattern = /([?&](utm_|fbclid)|\.(pdf|zip)$)/i
+    for (const el of elements) {
+      const prefetchAttr = el.getAttribute('prefetch')
+      if (prefetchAttr === 'false') continue
+
+      const url = el.getAttribute('href')?.trim()
+
+      if (
+        !url ||
+        url.startsWith('#') ||
+        url.includes(':') ||
+        ignorePattern.test(url) ||
+        url.toLowerCase().includes('logout')
+      )
+        continue
+
+      urls.add(url)
+    }
+
+    if (urls.size === 0) return
+
+    document.querySelector('script[type="speculationrules"]')?.remove()
+
+    const specScript = document.createElement('script')
+    specScript.type = 'speculationrules'
+
+    // Prerender the same filtered list as prefetch, not every link on the page.
+    // A `source: 'document'` rule with href_matches '/*' and eager eagerness
+    // ignored the exclusions above and fully loaded — and ran the JS of — every
+    // same-origin link, including things like /logout or a destructive GET.
+    const urlList = Array.from(urls)
+    specScript.textContent = JSON.stringify({
+      prefetch: [{ source: 'list', urls: urlList }],
+      prerender: [{ source: 'list', urls: urlList, eagerness: 'moderate' }],
+    })
+
+    document.head.appendChild(specScript)
+  }
+
+  const observer = new MutationObserver(() => {
+    clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(updateSpeculationRules, 1000)
+  })
+
+  const initObserver = () => {
+    updateSpeculationRules()
+    if (document.body) {
+      observer.observe(document.body, { childList: true, subtree: true })
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initObserver)
+  } else {
+    initObserver()
+  }
+}

package/src/compiler/compiler.ts

@@ -0,0 +1,263 @@
+import { Strings } from '../cache/string'
+import { Bakery } from '../core/bakery'
+import { PluginHooks } from '../core/plugins'
+import {
+  compLog,
+  errorMsg,
+  errorWithPosition,
+  handlerLog,
+} from '../logger/serve-log'
+import type { MapOf } from '../types'
+import { is, Try } from '../utils/common'
+import { FileSystem as fs } from '../utils/fs'
+
+const RX_IMPORT =
+  /import\s+(?:(?:\*\s+as\s+)?([a-zA-Z_$\d\s{},/*]+?)\s+from\s+)?['"]([^'"]+?\.([a-zA-Z0-9]+))['"](?:\s+(?:with|assert)\s*\{[^}]+\})?\s*;?/gm
+
+/**
+ * The build-time `define` table, resolved on first use rather than at module
+ * evaluation.
+ *
+ * This used to be a top-level `await` reading `<cwd>/package.json`, which put a
+ * filesystem read on the boot path of every process that loads this module —
+ * and `handlers/assets/ts.ts` imports it, so that is every worker and every dev
+ * restart. The value it produces is needed only when something actually
+ * compiles; a production process serving out of a warm compile cache never
+ * needs it at all.
+ *
+ * Memoised as a promise, not a value, so two concurrent first compiles share
+ * one read instead of racing to do it twice.
+ */
+let definesPromise: Promise<MapOf<string>> | null = null
+
+async function buildDefines(): Promise<MapOf<string>> {
+  let bakeryVersion = '1.0.0'
+  try {
+    const file = await Bun.file(`${process.cwd()}/package.json`).json()
+    if (file?.version) bakeryVersion = file.version
+  } catch {
+    // No package.json in cwd, or it is unreadable. The version is cosmetic —
+    // it lands in a banner and a build define — so the default above stands.
+  }
+
+  return {
+    'import.meta.env.DEV': JSON.stringify(!!import.meta.env.DEV),
+    'import.meta.env.PROD': JSON.stringify(!import.meta.env.DEV),
+    'import.meta.env.WORKER': JSON.stringify(!!import.meta.env.WORKER),
+    'import.meta.env.MODE': JSON.stringify(
+      import.meta.env.MODE || 'production',
+    ),
+    'import.meta.env.BAKERY_VERSION': JSON.stringify(bakeryVersion),
+  }
+}
+
+function getDefines(): Promise<MapOf<string>> {
+  definesPromise ??= buildDefines()
+  return definesPromise
+}
+
+let transpilerPromise: Promise<Bun.Transpiler> | null = null
+function getTranspiler(): Promise<Bun.Transpiler> {
+  transpilerPromise ??= getDefines().then(
+    define =>
+      new Bun.Transpiler({
+        loader: 'ts',
+        inline: true,
+        trimUnusedImports: false,
+        minifyWhitespace: true,
+        target: 'browser',
+        deadCodeElimination: false,
+        define,
+      }),
+  )
+  return transpilerPromise
+}
+
+let virtualIdCounter = 0
+function nextVirtualId(): string {
+  return (++virtualIdCounter).toString(36)
+}
+
+function preprocessImports(source: string, filePath: fs.AbsolutePath): string {
+  const fileDir = fs.resolve(filePath)
+
+  const matches = [...source.matchAll(RX_IMPORT)]
+
+  for (const [string, varName, importPath, ext] of matches) {
+    if (ext !== 'css' && ext !== 'json') continue
+
+    const assetPath = fs.resolve(fileDir, importPath)
+
+    // The key is the bare id, never the `/_virtual/` URL. Storing the full URL
+    // meant getKey() returned an already-prefixed value that got prefixed again
+    // on the next compile — which both threw a StringCache collision and left
+    // VirtualAssetHandler (which looks up by bare id) unable to resolve it.
+    const id =
+      Strings.getKey(assetPath) || `${Date.now()}_${nextVirtualId()}.${ext}`
+
+    const quotedUrl = JSON.stringify(`/_virtual/${id}`)
+
+    const replacement = varName
+      ? `const ${varName} = await Bakery.virtual(${quotedUrl});`
+      : `await Bakery.virtual(${quotedUrl});`
+
+    source = source.replace(string, () => replacement)
+    Strings.set(id, assetPath)
+  }
+
+  return source
+}
+
+/**
+ * Compile `source`, naming `path` so a failure can say where it happened.
+ *
+ * The two branches are not symmetric on purpose. Without a path there is no
+ * file to name and no caller that can render a 500 — the Vue plugin compiles
+ * fragments of an SFC it has already parsed — so a failure logs and hands the
+ * source back. With a path the failure is a served request, and the answer is
+ * `null`: `TSHandler` turns that into the 500 it has always had a branch for.
+ *
+ * It used to be neither. The transpiler was wrapped only on the pathless
+ * branch, so a syntax error in a `.ts` asset threw straight past `compile()`,
+ * past `TSHandler` — leaving its `'Compilation Failed'` arm permanently
+ * unreachable — and into the worker's catch-all, which printed
+ * `Unhandled Server Error: <message>` with no file and no line while the client
+ * got `An unexpected error occurred.` A total blackout for a one-character typo.
+ */
+export function compileText(source: string): Promise<string>
+export function compileText(
+  source: string,
+  path: fs.AbsolutePath,
+): Promise<string | null>
+export async function compileText(source: string, path?: fs.AbsolutePath) {
+  if (!path) {
+    try {
+      const content = await (await getTranspiler()).transform(source)
+      return content
+    } catch (err) {
+      compLog.COMPILE_SOURCE_FAIL({ error: errorMsg(err) })
+      return source
+    }
+  }
+
+  source = preprocessImports(source, path)
+
+  const [failed, transformed] = await Try.catch(
+    (await getTranspiler()).transform(source),
+  )
+
+  if (failed) {
+    // `errorWithPosition`, not `errorMsg`: the thrown `BuildMessage` has no
+    // stack, so `errorMsg` degrades to the bare message and the line number —
+    // the only thing that makes this actionable — is dropped. The file comes
+    // from `{file}`; the diagnostic's own `position.file` is `input.ts`,
+    // because `transform()` was handed a string.
+    compLog.COMPILE_FAIL({ file: path, error: errorWithPosition(failed) })
+    return null
+  }
+
+  const content = transformed!
+  const importRegex = /\b(from|import)(\s*\(?\s*)(["'])([^"']+)\3(\)?)/g
+  const matches = [...content.matchAll(importRegex)]
+
+  if (!matches.length) return content
+
+  const { dir } = fs.parse(path)
+  const serveRoot = Bakery.serveRoot
+  const importMap = Bakery.config.importMap
+  const mapKeys = Object.keys(importMap)
+
+  const replacements = await Promise.all(
+    matches.map(
+      async ([fullMatch, keyword, spacing, quote, importPath, closing]) => {
+        const hasExtension = (importPath.split('/').pop() || '').includes('.')
+        if (hasExtension) return fullMatch
+
+        const prefix = mapKeys.find(k => importPath.startsWith(k))
+
+        if (!prefix && !importPath.startsWith('.')) return fullMatch
+
+        const targetPath = prefix
+          ? fs.resolve(
+              serveRoot,
+              importMap[prefix],
+              importPath.slice(prefix.length),
+            )
+          : fs.resolve(dir, importPath)
+
+        const isDir = await fs.isDir(targetPath)
+
+        return `${keyword}${spacing}${quote}${importPath}${isDir ? '/index' : ''}${quote}${closing}`
+      },
+    ),
+  )
+  const result = content.replace(importRegex, () => replacements.shift()!)
+  return await PluginHooks.onCompile(result, path)
+}
+
+export async function compile(
+  path: fs.AbsolutePath | Bun.BunFile,
+): Promise<string | null> {
+  if (!fs.exists(path))
+    throw new Error(`File not found: ${is.string(path) ? path : path.name}`)
+
+  path = typeof path === 'string' ? Bun.file(path) : path
+  return compileText(await path.text(), path.name! as fs.AbsolutePath)
+}
+
+type CompileResult = {
+  success: boolean
+  content?: string
+  errors?: string[]
+}
+
+export async function bundleModule(
+  path: fs.AbsolutePath,
+): Promise<CompileResult> {
+  const build = await Bun.build({
+    entrypoints: [path],
+    target: 'browser',
+    format: 'esm',
+    // Coerced, and not defensively: `Bun.build` *rejects* a non-boolean
+    // `minify` with "Expected minify to be a boolean or an object" rather than
+    // treating it as truthy, so anything that reaches this line as a string
+    // takes the whole bundle down.
+    //
+    // That is reachable from outside this repo. `PROD` is an accessor on
+    // `process.env`, and Bun's `process.env` proxy stringifies on write, so an
+    // embedder that assigns the flag at all — even `process.env.PROD = true` —
+    // leaves a string behind. The suite's own instance of this is fixed at the
+    // source (see `setModeFlag` in `src/tests/fixtures.ts`); this guards the
+    // writes we do not own.
+    minify: Boolean(import.meta.env.PROD),
+    define: await getDefines(),
+  })
+
+  if (build.success && build.outputs.length > 0) {
+    return { success: true, content: await build.outputs[0].text() }
+  }
+
+  const errors = build.logs
+    .map(log => {
+      if (!log) return ''
+      if (is.string(log)) return log
+      const msg = log.message || ''
+      const pos = log.position
+      if (!pos) return msg
+
+      return `${pos.file || ''}:${pos.line || 0}:${pos.column || 0} - ${msg}`
+    })
+    .filter(Boolean)
+
+  // `handlerLog.BUNDLE_ERR` was declared and never called, so a bundle that
+  // failed was silent here: every caller either swallowed the result
+  // (`nm.ts`, `virtual-asset.ts` fall back to serving nothing) or logged its
+  // own line, and none of them printed the diagnostics this function had
+  // already collected. The 500 the caller returns is not a description.
+  handlerLog.BUNDLE_ERR({
+    file: path,
+    error: errors.join('\n  ') || 'no diagnostics reported',
+  })
+
+  return { success: false, errors }
+}