@strav/http 0.2.4 → 0.2.8

package/src/view/compiler.ts

@@ -1,199 +0,0 @@
-import { TemplateError } from '@strav/kernel/exceptions/errors'
-import type { Token } from './tokenizer.ts'
-
-export interface CompilationResult {
-  code: string
-  layout?: string
-}
-
-interface StackEntry {
-  type: 'if' | 'each' | 'block'
-  line: number
-  blockName?: string
-}
-
-function escapeJs(str: string): string {
-  return str
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t')
-}
-
-export function compile(tokens: Token[]): CompilationResult {
-  const lines: string[] = []
-  const stack: StackEntry[] = []
-  let layout: string | undefined
-
-  lines.push('let __out = "";')
-  lines.push('const __blocks = {};')
-
-  for (const token of tokens) {
-    switch (token.type) {
-      case 'text':
-        lines.push(`__out += "${escapeJs(token.value)}";`)
-        break
-
-      case 'escaped':
-        lines.push(`__out += __escape(${token.value});`)
-        break
-
-      case 'raw':
-        lines.push(`__out += (${token.value});`)
-        break
-
-      case 'comment':
-        // Stripped from output
-        break
-
-      case 'vue_island': {
-        const attrs = token.attrs ?? {}
-        const propParts: string[] = []
-        for (const [name, attr] of Object.entries(attrs)) {
-          if (attr.bound) {
-            propParts.push(`${JSON.stringify(name)}: (${attr.value})`)
-          } else {
-            propParts.push(`${JSON.stringify(name)}: ${JSON.stringify(attr.value)}`)
-          }
-        }
-        const propsExpr = `{${propParts.join(', ')}}`
-        const tag = escapeJs(token.tag!)
-        lines.push('__out += \'<div data-vue="' + tag + '"\'')
-        lines.push(
-          '  + " data-props=\'" + JSON.stringify(' + propsExpr + ").replace(/'/g, '&#39;') + \"'\""
-        )
-        lines.push("  + '></div>';")
-
-        break
-      }
-
-      case 'directive':
-        compileDirective(token, lines, stack, l => {
-          layout = l
-        })
-        break
-    }
-  }
-
-  if (stack.length > 0) {
-    const unclosed = stack[stack.length - 1]!
-    throw new TemplateError(`Unclosed @${unclosed.type} block (opened at line ${unclosed.line})`)
-  }
-
-  lines.push('return { output: __out, blocks: __blocks };')
-
-  return { code: lines.join('\n'), layout }
-}
-
-function compileDirective(
-  token: Token,
-  lines: string[],
-  stack: StackEntry[],
-  setLayout: (name: string) => void
-): void {
-  switch (token.directive) {
-    case 'if':
-      if (!token.args) throw new TemplateError(`@if requires a condition at line ${token.line}`)
-      lines.push(`if (${token.args}) {`)
-      stack.push({ type: 'if', line: token.line })
-      break
-
-    case 'elseif':
-      if (!token.args) throw new TemplateError(`@elseif requires a condition at line ${token.line}`)
-      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
-        throw new TemplateError(`@elseif without matching @if at line ${token.line}`)
-      }
-      lines.push(`} else if (${token.args}) {`)
-      break
-
-    case 'else':
-      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
-        throw new TemplateError(`@else without matching @if at line ${token.line}`)
-      }
-      lines.push(`} else {`)
-      break
-
-    case 'each': {
-      if (!token.args) throw new TemplateError(`@each requires arguments at line ${token.line}`)
-      const match = token.args.match(/^\s*(\w+)\s+in\s+(.+)$/)
-      if (!match) {
-        throw new TemplateError(`@each syntax error at line ${token.line}: expected "item in list"`)
-      }
-      const itemName = match[1]!
-      const listExpr = match[2]!.trim()
-      lines.push(`{`)
-      lines.push(`  const __list = (${listExpr});`)
-      lines.push(`  for (let $index = 0; $index < __list.length; $index++) {`)
-      lines.push(`    const ${itemName} = __list[$index];`)
-      lines.push(`    const $first = $index === 0;`)
-      lines.push(`    const $last = $index === __list.length - 1;`)
-      stack.push({ type: 'each', line: token.line })
-      break
-    }
-
-    case 'layout': {
-      if (!token.args) throw new TemplateError(`@layout requires a name at line ${token.line}`)
-      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
-      setLayout(name)
-      break
-    }
-
-    case 'block': {
-      if (!token.args) throw new TemplateError(`@block requires a name at line ${token.line}`)
-      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
-      const nameStr = JSON.stringify(name)
-      // If a child template already provided this block as data, yield it.
-      // Otherwise, render the default content between @block and @end.
-      lines.push(`if (typeof ${name} !== 'undefined' && ${name} !== null) {`)
-      lines.push(`  __out += ${name};`)
-      lines.push(`  __blocks[${nameStr}] = ${name};`)
-      lines.push(`} else {`)
-      lines.push(`  __blocks[${nameStr}] = (function() { let __out = "";`)
-      stack.push({ type: 'block', line: token.line, blockName: name })
-      break
-    }
-
-    case 'include': {
-      if (!token.args) throw new TemplateError(`@include requires arguments at line ${token.line}`)
-      const match = token.args.match(/^\s*['"]([^'"]+)['"]\s*(?:,\s*(.+))?\s*$/)
-      if (!match) {
-        throw new TemplateError(
-          `@include syntax error at line ${token.line}: expected "'name'" or "'name', data"`
-        )
-      }
-      const name = match[1]!
-      const dataExpr = match[2] ? match[2].trim() : '{}'
-      lines.push(`__out += await __include(${JSON.stringify(name)}, ${dataExpr});`)
-      break
-    }
-
-    case 'islands': {
-      const src = token.args ? token.args.replace(/^['"]|['"]$/g, '').trim() : '/islands.js'
-      // Use __islandsSrc (set by IslandBuilder via ViewEngine.setGlobal) for versioned URL, fallback to static src
-      lines.push(
-        `__out += '<script src="' + (typeof __islandsSrc !== 'undefined' ? __islandsSrc : '${escapeJs(src)}') + '"><\\/script>';`
-      )
-      break
-    }
-
-    case 'end': {
-      if (!stack.length) {
-        throw new TemplateError(`Unexpected @end at line ${token.line} — no open block`)
-      }
-      const top = stack.pop()!
-      if (top.type === 'block') {
-        const nameStr = JSON.stringify(top.blockName!)
-        lines.push(`  return __out; })();`)
-        lines.push(`  __out += __blocks[${nameStr}];`)
-        lines.push(`}`)
-      } else if (top.type === 'each') {
-        lines.push(`  }`) // close for loop
-        lines.push(`}`) // close block scope
-      } else {
-        lines.push(`}`)
-      }
-      break
-    }
-  }
-}

package/src/view/engine.ts

@@ -1,139 +0,0 @@
-import { resolve, join } from 'node:path'
-import { inject } from '@strav/kernel/core/inject'
-import Configuration from '@strav/kernel/config/configuration'
-import { escapeHtml } from './escape.ts'
-import { tokenize } from './tokenizer.ts'
-import { compile } from './compiler.ts'
-import TemplateCache from './cache.ts'
-import type { CacheEntry, RenderFunction, IncludeFn } from './cache.ts'
-import { ConfigurationError, TemplateError } from '@strav/kernel/exceptions/errors'
-
-const MAX_INCLUDE_DEPTH = 50
-
-@inject
-export default class ViewEngine {
-  private static _instance: ViewEngine | null = null
-  private static _globals: Record<string, unknown> = {}
-
-  private directory: string
-  private cacheEnabled: boolean
-  private cache: TemplateCache
-
-  constructor(config: Configuration) {
-    this.directory = resolve(config.get('view.directory', 'resources/views') as string)
-    this.cacheEnabled = config.get('view.cache', true) as boolean
-    this.cache = new TemplateCache()
-    ViewEngine._instance = this
-  }
-
-  static get instance(): ViewEngine {
-    if (!ViewEngine._instance) {
-      throw new ConfigurationError('ViewEngine not configured. Register it in the container.')
-    }
-    return ViewEngine._instance
-  }
-
-  /** Register a global variable available in all templates. */
-  static setGlobal(key: string, value: unknown): void {
-    ViewEngine._globals[key] = value
-  }
-
-  async render(name: string, data: Record<string, unknown> = {}): Promise<string> {
-    const merged = { ...ViewEngine._globals, ...data }
-    return this.renderWithDepth(name, merged, 0)
-  }
-
-  private async renderWithDepth(
-    name: string,
-    data: Record<string, unknown>,
-    depth: number
-  ): Promise<string> {
-    if (depth > MAX_INCLUDE_DEPTH) {
-      throw new TemplateError(
-        `Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded — possible circular include`
-      )
-    }
-
-    const entry = await this.resolve(name)
-
-    const includeFn: IncludeFn = (includeName, includeData) => {
-      return this.renderWithDepth(includeName, { ...data, ...includeData }, depth + 1)
-    }
-
-    const result = await entry.fn(data, includeFn)
-
-    // Layout inheritance: render child first, then render layout with blocks merged
-    if (entry.layout) {
-      const layoutData = { ...data, ...result.blocks }
-      return this.renderWithDepth(entry.layout, layoutData, depth + 1)
-    }
-
-    return result.output
-  }
-
-  private async resolve(name: string): Promise<CacheEntry> {
-    const cached = this.cache.get(name)
-
-    if (cached) {
-      if (this.cacheEnabled) return cached
-      const stale = await this.cache.isStale(name)
-      if (!stale) return cached
-    }
-
-    return this.compileTemplate(name)
-  }
-
-  private async compileTemplate(name: string): Promise<CacheEntry> {
-    const filePath = this.resolvePath(name)
-    const file = Bun.file(filePath)
-
-    const exists = await file.exists()
-    if (!exists) {
-      throw new TemplateError(`Template not found: ${name} (looked at ${filePath})`)
-    }
-
-    const source = await file.text()
-    const tokens = tokenize(source)
-    const result = compile(tokens)
-    const fn = this.createRenderFunction(result.code)
-
-    const entry: CacheEntry = {
-      fn,
-      layout: result.layout,
-      mtime: file.lastModified,
-      filePath,
-    }
-
-    this.cache.set(name, entry)
-    return entry
-  }
-
-  private resolvePath(name: string): string {
-    const relativePath = name.replace(/\./g, '/') + '.strav'
-    return join(this.directory, relativePath)
-  }
-
-  private createRenderFunction(code: string): RenderFunction {
-    // Use async Function with `with` statement for scope injection.
-    // `new Function()` does not inherit strict mode, so `with` is available.
-    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
-
-    const fn = new AsyncFunction('__data', '__escape', '__include', `with (__data) {\n${code}\n}`)
-
-    return (data: Record<string, unknown>, includeFn: IncludeFn) => {
-      return fn(data, escapeHtml, includeFn)
-    }
-  }
-}
-
-export async function view(
-  name: string,
-  data: Record<string, unknown> = {},
-  status = 200
-): Promise<Response> {
-  const html = await ViewEngine.instance.render(name, data)
-  return new Response(html, {
-    status,
-    headers: { 'Content-Type': 'text/html' },
-  })
-}

package/src/view/escape.ts

@@ -1,14 +0,0 @@
-const replacements: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;',
-}
-
-const pattern = /[&<>"']/g
-
-export function escapeHtml(value: unknown): string {
-  const str = String(value ?? '')
-  return str.replace(pattern, ch => replacements[ch]!)
-}

package/src/view/index.ts

@@ -1,13 +0,0 @@
-export { default as ViewEngine, view } from './engine.ts'
-export { tokenize } from './tokenizer.ts'
-export { compile } from './compiler.ts'
-export { default as TemplateCache } from './cache.ts'
-export { escapeHtml } from './escape.ts'
-export { staticFiles } from './middleware/static.ts'
-export { IslandBuilder } from './islands/island_builder.ts'
-export { vueSfcPlugin } from './islands/vue_plugin.ts'
-
-export type { Token, TokenType, VueAttr } from './tokenizer.ts'
-export type { CompilationResult } from './compiler.ts'
-export type { CacheEntry, RenderFunction, IncludeFn, RenderResult } from './cache.ts'
-export type { IslandBuilderOptions, IslandManifest } from './islands/island_builder.ts'

package/src/view/islands/island_builder.ts

@@ -1,338 +0,0 @@
-import { resolve, join } from 'node:path'
-import {
-  readdirSync,
-  existsSync,
-  mkdirSync,
-  unlinkSync,
-  watch as fsWatch,
-  type FSWatcher,
-} from 'node:fs'
-import { brotliCompressSync, constants as zlibConstants } from 'node:zlib'
-import { vueSfcPlugin } from './vue_plugin.ts'
-import ViewEngine from '../engine.ts'
-import type { BunPlugin } from 'bun'
-
-export interface IslandBuilderOptions {
-  /** Directory containing .vue SFC files. Default: './resources/islands' */
-  islandsDir?: string
-  /** Directory where the bundle is output. Default: './public/builds' */
-  outDir?: string
-  /** Output filename. Default: 'islands.js' */
-  outFile?: string
-  /** Enable minification. Default: true in production */
-  minify?: boolean
-  /** Enable pre-compression (gzip + brotli). Default: true */
-  compress?: boolean
-  /** Base URL path for the islands script. Default: '/builds/' */
-  basePath?: string
-}
-
-export interface IslandManifest {
-  file: string
-  version: string
-  src: string
-  size: number
-  gzip?: number
-  brotli?: number
-}
-
-export class IslandBuilder {
-  private islandsDir: string
-  private outDir: string
-  private outFile: string
-  private minify: boolean
-  private compress: boolean
-  private basePath: string
-  private watcher: FSWatcher | null = null
-  private _version: string | null = null
-  private _manifest: IslandManifest | null = null
-
-  constructor(options: IslandBuilderOptions = {}) {
-    this.islandsDir = resolve(options.islandsDir ?? './resources/islands')
-    this.outDir = resolve(options.outDir ?? './public/builds')
-    this.outFile = options.outFile ?? 'islands.js'
-    this.minify = options.minify ?? Bun.env.NODE_ENV === 'production'
-    this.compress = options.compress ?? true
-    this.basePath = options.basePath ?? '/builds/'
-  }
-
-  /** The content hash of the last build, or null if not yet built. */
-  get version(): string | null {
-    return this._version
-  }
-
-  /** The versioned script src (e.g. '/islands.js?v=abc12345'), or the plain path if not yet built. */
-  get src(): string {
-    const base = this.basePath + this.outFile
-    return this._version ? `${base}?v=${this._version}` : base
-  }
-
-  /** The build manifest with file info and sizes, or null if not yet built. */
-  get manifest(): IslandManifest | null {
-    return this._manifest
-  }
-
-  /** Discover all .vue files in the islands directory (recursively). */
-  private discoverIslands(): { name: string; path: string }[] {
-    let entries: string[]
-    try {
-      entries = readdirSync(this.islandsDir, { recursive: true }) as string[]
-    } catch {
-      return []
-    }
-
-    return entries
-      .filter(f => f.endsWith('.vue'))
-      .sort()
-      .map(f => ({
-        name: f.slice(0, -4).replace(/\\/g, '/'),
-        path: join(this.islandsDir, f),
-      }))
-  }
-
-  /** Check if a setup file exists in the islands directory. */
-  private hasSetupFile(): string | null {
-    for (const ext of ['ts', 'js']) {
-      const p = join(this.islandsDir, `setup.${ext}`)
-      if (existsSync(p)) return p
-    }
-    return null
-  }
-
-  /** Generate the virtual entry point that imports all islands + mount logic. */
-  private generateEntry(islands: { name: string; path: string }[]): string {
-    const setupPath = this.hasSetupFile()
-    const lines: string[] = []
-
-    lines.push(`import { createApp, defineComponent, h, Teleport } from 'vue';`)
-    lines.push('')
-
-    if (setupPath) {
-      lines.push(`import __setup from '${setupPath}';`)
-      lines.push('')
-    }
-
-    // Import each island component
-    for (let i = 0; i < islands.length; i++) {
-      lines.push(`import __c${i} from '${islands[i]!.path}';`)
-    }
-
-    lines.push('')
-    lines.push('var components = {')
-    for (let i = 0; i < islands.length; i++) {
-      lines.push(`  '${islands[i]!.name}': __c${i},`)
-    }
-    lines.push('};')
-
-    lines.push('')
-    lines.push('function mountIslands() {')
-    lines.push('  var islands = [];')
-    lines.push("  document.querySelectorAll('[data-vue]').forEach(function(el) {")
-    lines.push('    var name = el.dataset.vue;')
-    lines.push('    if (!name) return;')
-    lines.push('    var Component = components[name];')
-    lines.push('    if (!Component) {')
-    lines.push("      console.warn('[islands] Unknown component: ' + name);")
-    lines.push('      return;')
-    lines.push('    }')
-    lines.push("    var props = JSON.parse(el.dataset.props || '{}');")
-    lines.push('    islands.push({ Component: Component, props: props, el: el });')
-    lines.push('  });')
-    lines.push('')
-    lines.push('  if (islands.length === 0) return;')
-    lines.push('')
-    lines.push('  var Root = defineComponent({')
-    lines.push('    render: function() {')
-    lines.push('      return islands.map(function(island) {')
-    lines.push(
-      '        return h(Teleport, { to: island.el }, [h(island.Component, island.props)]);'
-    )
-    lines.push('      });')
-    lines.push('    }')
-    lines.push('  });')
-    lines.push('')
-    lines.push('  var app = createApp(Root);')
-    if (setupPath) {
-      lines.push('  if (typeof __setup === "function") __setup(app);')
-    }
-    lines.push('  var root = document.createElement("div");')
-    lines.push('  root.style.display = "contents";')
-    lines.push('  document.body.appendChild(root);')
-    lines.push('  app.mount(root);')
-    lines.push('}')
-    lines.push('')
-    lines.push("if (document.readyState === 'loading') {")
-    lines.push("  document.addEventListener('DOMContentLoaded', mountIslands);")
-    lines.push('} else {')
-    lines.push('  mountIslands();')
-    lines.push('}')
-
-    return lines.join('\n')
-  }
-
-  /** Compute a short content hash for cache busting. */
-  private computeHash(content: Uint8Array): string {
-    const hasher = new Bun.CryptoHasher('md5')
-    hasher.update(content)
-    return hasher.digest('hex').slice(0, 8)
-  }
-
-  /** Generate pre-compressed versions of the bundle. */
-  private async generateCompressed(
-    outPath: string,
-    content: Uint8Array
-  ): Promise<{ gzip?: number; brotli?: number }> {
-    const sizes: { gzip?: number; brotli?: number } = {}
-
-    // Gzip
-    const gzipped = Bun.gzipSync(content as Uint8Array<ArrayBuffer>)
-    await Bun.write(outPath + '.gz', gzipped)
-    sizes.gzip = gzipped.length
-
-    // Brotli
-    try {
-      const brotli = brotliCompressSync(Buffer.from(content), {
-        params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 11 },
-      })
-      await Bun.write(outPath + '.br', brotli)
-      sizes.brotli = brotli.length
-    } catch {
-      // Brotli may not be available in all environments
-    }
-
-    return sizes
-  }
-
-  /** Remove stale compressed files. */
-  private cleanCompressed(outPath: string): void {
-    for (const ext of ['.gz', '.br']) {
-      try {
-        unlinkSync(outPath + ext)
-      } catch {
-        // File may not exist
-      }
-    }
-  }
-
-  /** Update the ViewEngine global so @islands() picks up the versioned src. */
-  private syncViewEngine(): void {
-    try {
-      ViewEngine.setGlobal('__islandsSrc', this.src)
-    } catch {
-      // ViewEngine may not be initialized yet
-    }
-  }
-
-  /** Build the islands bundle. Returns true if islands were found and built. */
-  async build(): Promise<boolean> {
-    const islands = this.discoverIslands()
-
-    if (islands.length === 0) {
-      return false
-    }
-
-    // Ensure output directory exists
-    mkdirSync(this.outDir, { recursive: true })
-
-    const entrySource = this.generateEntry(islands)
-
-    // Virtual entry plugin — resolves the synthetic entry from memory
-    const virtualEntryPlugin: BunPlugin = {
-      name: 'virtual-entry',
-      setup(build) {
-        build.onResolve({ filter: /^virtual:islands-entry$/ }, () => ({
-          path: 'virtual:islands-entry',
-          namespace: 'island-entry',
-        }))
-
-        build.onLoad({ filter: /.*/, namespace: 'island-entry' }, () => ({
-          contents: entrySource,
-          loader: 'js',
-        }))
-      },
-    }
-
-    const result = await Bun.build({
-      entrypoints: ['virtual:islands-entry'],
-      outdir: this.outDir,
-      naming: this.outFile,
-      minify: this.minify,
-      target: 'browser',
-      plugins: [virtualEntryPlugin, vueSfcPlugin()],
-      define: {
-        __VUE_OPTIONS_API__: 'true',
-        __VUE_PROD_DEVTOOLS__: 'false',
-        __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: 'false',
-      },
-    })
-
-    if (!result.success) {
-      const messages = result.logs.map(l => l.message ?? String(l)).join('\n')
-      throw new Error(`Island build failed:\n${messages}`)
-    }
-
-    // Read the output, compute version hash, optionally compress
-    const outPath = join(this.outDir, this.outFile)
-    const content = new Uint8Array(await Bun.file(outPath).arrayBuffer())
-
-    this._version = this.computeHash(content)
-
-    let compressedSizes: { gzip?: number; brotli?: number } = {}
-    if (this.compress) {
-      compressedSizes = await this.generateCompressed(outPath, content)
-    } else {
-      this.cleanCompressed(outPath)
-    }
-
-    this._manifest = {
-      file: this.outFile,
-      version: this._version,
-      src: this.src,
-      size: content.length,
-      ...compressedSizes,
-    }
-
-    // Write manifest
-    await Bun.write(
-      join(this.outDir, this.outFile.replace(/\.js$/, '.manifest.json')),
-      JSON.stringify(this._manifest, null, 2)
-    )
-
-    // Sync version with ViewEngine
-    this.syncViewEngine()
-
-    const sizeKB = (content.length / 1024).toFixed(1)
-    const gzKB = compressedSizes.gzip
-      ? ` | gzip: ${(compressedSizes.gzip / 1024).toFixed(1)}kB`
-      : ''
-    const brKB = compressedSizes.brotli
-      ? ` | br: ${(compressedSizes.brotli / 1024).toFixed(1)}kB`
-      : ''
-
-    console.log(
-      `[islands] Built ${islands.length} component(s) → ${this.outFile} (${sizeKB}kB${gzKB}${brKB}) v=${this._version}`
-    )
-    return true
-  }
-
-  /** Watch the islands directory and rebuild on changes. */
-  watch(): void {
-    if (this.watcher) return
-
-    this.build().catch(err => console.error('[islands] Build error:', err))
-
-    this.watcher = fsWatch(this.islandsDir, { recursive: true }, (_event, filename) => {
-      if (filename && !filename.endsWith('.vue') && !filename.startsWith('setup.')) return
-      console.log('[islands] Change detected, rebuilding...')
-      this.build().catch(err => console.error('[islands] Rebuild error:', err))
-    })
-
-    console.log(`[islands] Watching ${this.islandsDir}`)
-  }
-
-  /** Stop watching. */
-  unwatch(): void {
-    this.watcher?.close()
-    this.watcher = null
-  }
-}