davaux 0.8.0

package/src/env.d.ts

@@ -0,0 +1,5 @@
+// Ambient type declarations for assets that davaux handles at build time.
+// Reference this file from your project:
+//   /// <reference types="davaux/env" />
+
+declare module '*.css' {}

package/src/errors.ts

@@ -0,0 +1,64 @@
+import type { Message } from 'esbuild'
+
+export function formatBuildErrors(errors: Message[]): string {
+  return errors
+    .map((e) => {
+      const lines: string[] = [`  ${e.text}`]
+      if (e.location) {
+        lines.push(`  at ${e.location.file}:${e.location.line}:${e.location.column}`)
+        if (e.location.lineText.trim()) lines.push(`  > ${e.location.lineText.trim()}`)
+      }
+      return lines.join('\n')
+    })
+    .join('\n\n')
+}
+
+export function frameworkWarn(message: string, hint?: string): void {
+  console.warn(`[davaux] ${message}`)
+  if (hint) console.warn(`  hint: ${hint}`)
+}
+
+export function frameworkError(message: string, hint?: string): never {
+  console.error(`\n[davaux] ${message}`)
+  if (hint) console.error(`  hint: ${hint}`)
+  process.exit(1)
+}
+
+export function handleBuildError(label: string, err: unknown): never {
+  if (
+    err != null &&
+    typeof err === 'object' &&
+    Array.isArray((err as { errors?: unknown }).errors)
+  ) {
+    const msgs = (err as { errors: Message[] }).errors
+    if (msgs.length > 0) {
+      console.error(`\n[davaux] ${label} failed:\n${formatBuildErrors(msgs)}`)
+      const cjsPkg = detectCjsPackage(msgs)
+      if (cjsPkg) {
+        console.error(
+          `\n  Hint: "${cjsPkg}" uses CommonJS require() and cannot be bundled by esbuild.\n` +
+            `  Add it to the external list in davaux.config.ts:\n\n` +
+            `    export default defineConfig({\n` +
+            `      external: ['${cjsPkg}'],\n` +
+            `    })\n`,
+        )
+      }
+      process.exit(1)
+    }
+  }
+  console.error(`\n[davaux] ${label} failed:`, err)
+  process.exit(1)
+}
+
+// Detects "Dynamic require of X is not supported" errors and extracts the
+// originating package name from the error location, so we can suggest adding
+// it to `external`.
+function detectCjsPackage(errors: Message[]): string | null {
+  for (const e of errors) {
+    if (!/[Dd]ynamic require/.test(e.text)) continue
+    const file = e.location?.file ?? ''
+    const m = file.match(/node_modules\/((?:@[^/]+\/)?[^/]+)/)
+    if (m) return m[1]
+  }
+  return null
+}

package/src/generate.ts

@@ -0,0 +1,228 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+
+const VALID_TYPES = ['page', 'api', 'layout', 'island', 'middleware'] as const
+type GenerateType = (typeof VALID_TYPES)[number]
+
+const VALID_METHODS = ['get', 'post', 'put', 'patch', 'delete'] as const
+type HttpMethod = (typeof VALID_METHODS)[number]
+
+export function generate(args: string[], cwd: string): void {
+  const [type, pathArg, ...rest] = args
+
+  if (!type || !VALID_TYPES.includes(type as GenerateType)) {
+    if (type) console.error(`[davaux] Unknown generator "${type}"`)
+    printUsage()
+    process.exit(1)
+  }
+
+  const routesDir = resolve(cwd, 'src', 'routes')
+  const islandsDir = resolve(cwd, 'src', 'islands')
+
+  switch (type as GenerateType) {
+    case 'page':
+      genPage(pathArg, routesDir, cwd)
+      break
+    case 'api': {
+      const methodArg = getFlag('--method', rest) ?? 'get'
+      if (!VALID_METHODS.includes(methodArg as HttpMethod)) {
+        console.error(`[davaux] Invalid method "${methodArg}". Valid: ${VALID_METHODS.join(', ')}`)
+        process.exit(1)
+      }
+      genApi(pathArg, routesDir, methodArg as HttpMethod, cwd)
+      break
+    }
+    case 'layout':
+      genLayout(pathArg, routesDir, cwd)
+      break
+    case 'island':
+      genIsland(pathArg, islandsDir, cwd)
+      break
+    case 'middleware':
+      genMiddleware(pathArg, routesDir, cwd)
+      break
+  }
+}
+
+// ─── Generators ───────────────────────────────────────────────────────────────
+
+function genPage(pathArg: string | undefined, routesDir: string, cwd: string) {
+  if (!pathArg) {
+    console.error('[davaux] Usage: davaux generate page <path>')
+    console.error('  Example: davaux generate page about')
+    console.error('  Example: davaux generate page blog/[slug]')
+    process.exit(1)
+  }
+  const filePath = join(routesDir, `${pathArg}.page.tsx`)
+  writeGenerated(filePath, cwd, pageTemplate(pathArg))
+}
+
+function genApi(pathArg: string | undefined, routesDir: string, method: HttpMethod, cwd: string) {
+  if (!pathArg) {
+    console.error('[davaux] Usage: davaux generate api <path> [--method get|post|put|patch|delete]')
+    process.exit(1)
+  }
+  const filePath = join(routesDir, `${pathArg}.${method}.ts`)
+  writeGenerated(filePath, cwd, apiTemplate(pathArg))
+}
+
+function genLayout(pathArg: string | undefined, routesDir: string, cwd: string) {
+  const filePath = pathArg
+    ? join(routesDir, pathArg, '_layout.tsx')
+    : join(routesDir, '_layout.tsx')
+  writeGenerated(filePath, cwd, layoutTemplate())
+}
+
+function genIsland(nameArg: string | undefined, islandsDir: string, cwd: string) {
+  if (!nameArg) {
+    console.error('[davaux] Usage: davaux generate island <Name>')
+    console.error('  Example: davaux generate island Counter')
+    process.exit(1)
+  }
+  const filePath = join(islandsDir, `${nameArg}.tsx`)
+  writeGenerated(filePath, cwd, islandTemplate(nameArg))
+}
+
+function genMiddleware(pathArg: string | undefined, routesDir: string, cwd: string) {
+  const filePath = pathArg
+    ? join(routesDir, pathArg, '_middleware.ts')
+    : join(routesDir, '_middleware.ts')
+  writeGenerated(filePath, cwd, middlewareTemplate())
+}
+
+// ─── Templates ────────────────────────────────────────────────────────────────
+
+function pageTemplate(routePath: string): string {
+  const title = toTitle(lastSegment(routePath))
+  const hasParams = routePath.includes('[')
+
+  if (hasParams) {
+    return `import { definePage, defineStaticPaths, type ExtractParams } from 'davaux'
+
+export const getStaticPaths = defineStaticPaths(async () => [
+  // Return one entry per URL to pre-render with \`davaux static\`
+  { params: { ${firstParam(routePath)}: 'example' } },
+])
+
+export default definePage<ExtractParams<'${routePath}'>>((ctx) => {
+  return <h1>${title}: {ctx.params.${firstParam(routePath)}}</h1>
+})
+`
+  }
+
+  return `import { definePage } from 'davaux'
+
+export default definePage((ctx) => {
+  ctx.head.title = '${title}'
+  return <h1>${title}</h1>
+})
+`
+}
+
+function apiTemplate(routePath: string): string {
+  const hasParams = routePath.includes('[')
+
+  if (hasParams) {
+    return `import { defineHandler, type ExtractParams } from 'davaux'
+
+export default defineHandler<unknown, ExtractParams<'${routePath}'>>(async (_ctx) => {
+  return { ok: true }
+})
+`
+  }
+
+  return `import { defineHandler } from 'davaux'
+
+export default defineHandler(async (_ctx) => {
+  return { ok: true }
+})
+`
+}
+
+function layoutTemplate(): string {
+  return `import { defineLayout } from 'davaux'
+
+export default defineLayout(({ children }) => (
+  <div>
+    {children as unknown as string}
+  </div>
+))
+`
+}
+
+function islandTemplate(name: string): string {
+  return `import { createSignal } from 'davaux/client'
+
+export default function ${name}() {
+  const [count, setCount] = createSignal(0)
+  return (
+    <button type="button" onClick={() => setCount(count() + 1)}>
+      {() => count()}
+    </button>
+  )
+}
+`
+}
+
+function middlewareTemplate(): string {
+  return `import { defineMiddleware } from 'davaux'
+
+export default defineMiddleware(async (_ctx, next) => {
+  await next()
+})
+`
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function writeGenerated(filePath: string, cwd: string, content: string) {
+  if (existsSync(filePath)) {
+    console.error(`[davaux] File already exists: ${relative(cwd, filePath)}`)
+    process.exit(1)
+  }
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, content, 'utf8')
+  console.log(`[davaux] Created ${relative(cwd, filePath)}`)
+}
+
+function lastSegment(routePath: string): string {
+  const segments = routePath.split('/')
+  return segments[segments.length - 1]
+    .replace(/\[.*?\]/g, '')
+    .replace(/[-_]/g, ' ')
+    .trim()
+}
+
+function toTitle(segment: string): string {
+  return segment.replace(/\b\w/g, (c) => c.toUpperCase()).trim() || 'Page'
+}
+
+function firstParam(routePath: string): string {
+  const match = routePath.match(/\[(\w+)\]/)
+  return match ? match[1] : 'id'
+}
+
+function getFlag(name: string, argv: string[]): string | undefined {
+  const idx = argv.indexOf(name)
+  return idx !== -1 ? argv[idx + 1] : undefined
+}
+
+function printUsage() {
+  console.error('Usage: davaux generate <type> [path]')
+  console.error('')
+  console.error('Types:')
+  console.error('  page <path>                    Page route')
+  console.error('  api <path> [--method <method>] API route (default: get)')
+  console.error('  layout [path]                  Layout (root if no path given)')
+  console.error('  island <Name>                  Client island component')
+  console.error('  middleware [path]              Middleware (root if no path given)')
+  console.error('')
+  console.error('Examples:')
+  console.error('  davaux generate page about')
+  console.error('  davaux generate page blog/[slug]')
+  console.error('  davaux generate api users')
+  console.error('  davaux generate api users --method post')
+  console.error('  davaux generate layout admin')
+  console.error('  davaux generate island Counter')
+  console.error('  davaux generate middleware admin')
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+export { island } from './island.js'
+export type { JSX } from './jsx-runtime.js'
+export { createLink } from './link.js'
+export type {
+  OmlBlueprint,
+  OmlComponent,
+  OmlElement,
+  OmlFragment,
+  OmlFragmentOptions,
+  OmlNode,
+  OmlPageHandler,
+  OmlPropSchema,
+  OmlProps,
+  OmlPropType,
+  OmlRaw,
+  OmlText,
+} from './oml/index.js'
+export {
+  blueprintToFile,
+  clearAllFragments,
+  defineFragment,
+  defineOmlPage,
+  parseOml,
+  parseOmlBlueprint,
+  renderToHtml,
+  renderToJsx,
+} from './oml/index.js'
+export { batch, createEffect, createMemo, createSignal, untrack } from './signal.js'
+export type {
+  ActionFn,
+  ApiHandler,
+  CookieOptions,
+  ErrorPageHandler,
+  ErrorPageProps,
+  ExtractParams,
+  GetStaticPathsFn,
+  IslandFile,
+  LayoutFile,
+  LayoutHandler,
+  LayoutProps,
+  MiddlewareFile,
+  MiddlewareFn,
+  MultipartFile,
+  MultipartResult,
+  PageHandler,
+  RequestContext,
+  RouteFile,
+  RouteType,
+  ScanResult,
+  State,
+  StaticPath,
+  Validator,
+} from './types.js'
+export {
+  CookieJar,
+  defineAction,
+  defineError,
+  defineHandler,
+  defineLayout,
+  defineMiddleware,
+  definePage,
+  defineStaticPaths,
+  PayloadTooLargeError,
+  RedirectError,
+  redirect,
+  ValidationError,
+} from './types.js'

package/src/island.ts

@@ -0,0 +1,47 @@
+import type { JSX } from './jsx-runtime.js'
+
+/** A component intended to run on both server and client. */
+export type IslandComponent<P extends Record<string, unknown> = Record<string, unknown>> = (
+  props: P,
+) => JSX.Element
+
+let counter = 0
+
+/**
+ * Mark a component as a client island. Write the component once — the framework
+ * compiles it for both server and client automatically.
+ *
+ * On the server: renders initial HTML and embeds serialized props in `data-props`.
+ * On the client: `hydrate()` picks up `[data-island]` elements and remounts the
+ * component with full signal reactivity.
+ *
+ * @example
+ * // src/islands/Counter.tsx
+ * import { island } from 'davaux'
+ * import { createSignal } from 'davaux/client'
+ *
+ * function Counter({ initial = 0 }: { initial?: number }) {
+ *   const [count, setCount] = createSignal(initial)
+ *   return <button onClick={() => setCount(c => c + 1)}>{() => count()}</button>
+ * }
+ * export default island(Counter)
+ */
+export function island<P extends Record<string, unknown>>(
+  Component: IslandComponent<P>,
+  islandId?: string,
+): (props: P) => Promise<string> {
+  const id = islandId ?? Component.name ?? `island-${counter++}`
+
+  const wrapper = async (props: P): Promise<string> => {
+    const rendered = await (Component(props) as unknown as Promise<string> | string)
+    const serialized = JSON.stringify(props)
+      .replace(/&/g, '\\u0026')
+      .replace(/</g, '\\u003c')
+      .replace(/>/g, '\\u003e')
+      .replace(/'/g, '\\u0027')
+
+    return `<div data-island="${id}" data-props='${serialized}'>${rendered}</div>`
+  }
+  Object.defineProperty(wrapper, 'name', { value: id, configurable: true })
+  return wrapper
+}