davaux 0.8.0

package/src/types.ts

@@ -0,0 +1,670 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { OmlNode } from './oml/types.js'
+
+// ─── Cookie helpers ────────────────────────────────────────────────────────────
+
+/** Options for the `Set-Cookie` header written by `ctx.cookies.set()`. */
+export interface CookieOptions {
+  httpOnly?: boolean
+  secure?: boolean
+  sameSite?: 'Strict' | 'Lax' | 'None'
+  /** Max age in seconds. */
+  maxAge?: number
+  expires?: Date
+  /** Defaults to `'/'` when not specified. */
+  path?: string
+  domain?: string
+}
+
+function sanitizeCookieAttr(val: string): string {
+  return val.replace(/[;\r\n]/g, '')
+}
+
+/** Reads incoming cookies and writes `Set-Cookie` response headers.
+ * Available as `ctx.cookies` in every handler, layout, and middleware. */
+export class CookieJar {
+  private readonly incoming: Record<string, string>
+  private readonly res: ServerResponse
+
+  constructor(req: IncomingMessage, res: ServerResponse) {
+    this.res = res
+    this.incoming = CookieJar.parse(req.headers.cookie ?? '')
+  }
+
+  private static parse(header: string): Record<string, string> {
+    const out: Record<string, string> = {}
+    for (const pair of header.split(';')) {
+      const eq = pair.indexOf('=')
+      if (eq === -1) continue
+      const name = pair.slice(0, eq).trim()
+      const value = pair.slice(eq + 1).trim()
+      if (name) out[name] = decodeURIComponent(value)
+    }
+    return out
+  }
+
+  /** Read a cookie sent by the browser. Returns `undefined` if absent. */
+  get(name: string): string | undefined {
+    return this.incoming[name]
+  }
+
+  /** Return all incoming cookies as a plain object. */
+  getAll(): Record<string, string> {
+    return { ...this.incoming }
+  }
+
+  /** Write a `Set-Cookie` header on the response. */
+  set(name: string, value: string, options: CookieOptions = {}): void {
+    const encoded = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`
+    const parts = [encoded]
+    const path = sanitizeCookieAttr(options.path ?? '/')
+
+    if (options.maxAge != null) parts.push(`Max-Age=${options.maxAge}`)
+    if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`)
+    parts.push(`Path=${path}`)
+    if (options.domain) parts.push(`Domain=${sanitizeCookieAttr(options.domain)}`)
+    if (options.httpOnly) parts.push('HttpOnly')
+    if (options.secure) parts.push('Secure')
+    if (options.sameSite) parts.push(`SameSite=${options.sameSite}`)
+
+    const existing = this.res.getHeader('Set-Cookie')
+    const prev: string[] = existing
+      ? Array.isArray(existing)
+        ? (existing as string[])
+        : [String(existing)]
+      : []
+    this.res.setHeader('Set-Cookie', [...prev, parts.join('; ')])
+  }
+
+  /** Expire a cookie by setting `Max-Age=0`. */
+  delete(name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): void {
+    this.set(name, '', { ...options, maxAge: 0, expires: new Date(0) })
+  }
+}
+
+// ─── Validation ───────────────────────────────────────────────────────────────
+
+/** Schema interface satisfied by zod, valibot, arktype, and any library whose
+ *  `.parse()` throws on invalid input. Pass a schema to `ctx.json()` or
+ *  `ctx.form()` to validate and type the parsed body in one call. */
+export interface Validator<T> {
+  parse(data: unknown): T
+}
+
+/** Thrown when a body validator rejects the request data.
+ * Caught by the framework and sent as `400 { error, issues }`. */
+export class ValidationError extends Error {
+  readonly isValidation = true
+  constructor(cause: unknown) {
+    super(cause instanceof Error ? cause.message : 'Validation failed', { cause })
+    this.name = 'ValidationError'
+  }
+}
+
+/** Thrown when a request body exceeds the configured size limit.
+ * Caught by the framework and sent as `413 Payload Too Large`. */
+export class PayloadTooLargeError extends Error {
+  readonly isPayloadTooLarge = true
+  readonly status = 413
+  constructor(limitBytes: number) {
+    super(`Payload Too Large — body exceeds ${limitBytes.toLocaleString()} bytes`)
+    this.name = 'PayloadTooLargeError'
+  }
+}
+
+// ─── Multipart ────────────────────────────────────────────────────────────────
+
+/** An uploaded file parsed from a `multipart/form-data` body. */
+export interface MultipartFile {
+  filename: string
+  mimetype: string
+  data: Buffer
+}
+
+/** Parsed result of `ctx.multipart()`. */
+export interface MultipartResult {
+  fields: Record<string, string>
+  files: Record<string, MultipartFile>
+}
+
+// ─── Redirect ─────────────────────────────────────────────────────────────────
+
+/** Thrown by `redirect()`. Never construct directly. */
+export class RedirectError extends Error {
+  readonly isRedirect = true
+  constructor(
+    public readonly url: string,
+    public readonly status: 301 | 302 | 307 | 308 = 302,
+  ) {
+    super(`Redirect → ${url}`)
+    this.name = 'RedirectError'
+  }
+}
+
+/**
+ * Throw a redirect to the given URL.
+ *
+ * **Security note:** If `url` comes from user input (e.g. `ctx.query.get('next')`),
+ * validate it before passing it here to prevent open-redirect attacks. At minimum,
+ * ensure the value starts with `/` and does not contain `//` or a protocol.
+ */
+export function redirect(url: string, status: 301 | 302 | 307 | 308 = 302): never {
+  throw new RedirectError(url, status)
+}
+
+// ─── Head context ─────────────────────────────────────────────────────────────
+
+/** Per-request `<head>` metadata. Set values in pages and layouts; the root
+ * layout renders them. Pages render before their layouts, so all values are
+ * populated by the time the root layout runs. */
+export interface HeadContext {
+  title?: string
+  description?: string
+  /** Arbitrary `<meta name="..." content="...">` entries. */
+  meta: Record<string, string>
+  /** CSS file URLs injected as `<link rel="stylesheet">`. */
+  stylesheets: string[]
+  /** JS module URLs injected as `<script type="module">`. */
+  scripts: string[]
+}
+
+// ─── Route param type inference ───────────────────────────────────────────────
+
+// Recursively collect bracket-param names from a path pattern string.
+type RouteParamNames<T extends string> = T extends `${string}[${infer Param}]${infer Rest}`
+  ? Param | RouteParamNames<Rest>
+  : never
+
+/**
+ * Infer typed route params from a file path pattern (relative to your routes
+ * directory, without the method suffix or extension).
+ *
+ * @example
+ * // src/routes/blog/[slug].page.tsx
+ * export default definePage<ExtractParams<'blog/[slug]'>>(async (ctx) => {
+ *   ctx.params.slug  // string ✓ — TypeScript error if you typo the key
+ * })
+ *
+ * // src/routes/users/[id]/posts/[postId].get.ts
+ * export default defineHandler<unknown, ExtractParams<'users/[id]/posts/[postId]'>>(async (ctx) => {
+ *   ctx.params.id     // string ✓
+ *   ctx.params.postId // string ✓
+ * })
+ */
+export type ExtractParams<T extends string> = { [K in RouteParamNames<T>]: string }
+
+// ─── Request context ──────────────────────────────────────────────────────────
+
+/**
+ * Open interface for middleware-to-handler pass-through data.
+ * Ecosystem packages augment this via declaration merging to add typed properties:
+ *
+ * @example
+ * declare module 'davaux' {
+ *   interface State {
+ *     session: Session
+ *   }
+ * }
+ */
+export interface State extends Record<string, unknown> {
+  /** Result returned by `defineAction` before the page re-renders on form POST. */
+  actionResult?: unknown
+}
+
+/**
+ * Context object passed to every page, API, layout, middleware, and error handler.
+ * @typeParam P - Typed URL params. Use `ExtractParams<'path/[param]'>` for compile-time safety.
+ */
+export interface RequestContext<P extends Record<string, string> = Record<string, string>> {
+  req: IncomingMessage
+  res: ServerResponse
+  params: P
+  query: URLSearchParams
+  url: URL
+  /** Base path for subdirectory deployments (e.g. '/docs'). Empty string in dev/SSR. */
+  basePath: string
+  cookies: CookieJar
+  /** Mutable head metadata — set in pages/layouts, rendered by the root layout. */
+  head: HeadContext
+  /** Pass-through bag for middleware → handler data. Augment via `State` interface merging. */
+  state: State
+  /** Parse the request body as JSON. Pass a validator (zod schema, etc.) to
+   *  validate and type the result; throws `ValidationError` (→ 400) on failure.
+   *  Default body size limit: 4 MB. Override with `options.maxBytes`. */
+  json<T = Record<string, unknown>>(
+    validator?: Validator<T>,
+    options?: { maxBytes?: number },
+  ): Promise<T>
+  /** Parse the request body as URL-encoded form data. Pass a validator to
+   *  validate and type the result; throws `ValidationError` (→ 400) on failure.
+   *  Default body size limit: 1 MB. Override with `options.maxBytes`.
+   *  When a field name appears more than once, the last value wins — use
+   *  `ctx.formAll()` to collect all values for multi-select / checkbox groups. */
+  form<T = Record<string, string>>(
+    validator?: Validator<T>,
+    options?: { maxBytes?: number },
+  ): Promise<T>
+  /** Like `ctx.form()`, but returns every value for every key as a `string[]`.
+   *  Use this for `<select multiple>` and repeated checkbox fields where
+   *  `ctx.form()` would silently drop all but the last value. */
+  formAll<T = Record<string, string[]>>(
+    validator?: Validator<T>,
+    options?: { maxBytes?: number },
+  ): Promise<T>
+  /** Parse a multipart/form-data request body. Returns parsed text fields and
+   *  uploaded files. Default body size limit: 10 MB. Override with `options.maxBytes`. */
+  multipart(options?: { maxBytes?: number }): Promise<MultipartResult>
+  /** Write a raw response with a custom content-type. The response is immediately
+   *  sent; no further framework serialization occurs. */
+  send(body: string | Buffer, contentType: string, status?: number): void
+  /** Write a one-time message that survives a single redirect. Requires @davaux/session. */
+  flash(key: string, value: string): void
+  /** Read and consume a flash message set by a previous request. Returns undefined if absent. */
+  flash(key: string): string | undefined
+  /**
+   * Register a named deferred HTML slot. Returns a `<?marker name="...">` placeholder node
+   * that renders inline; when the promise resolves the framework streams a
+   * `<template for="name">` element into the response to fill the slot.
+   * Polyfill scripts are injected automatically for browsers without native support.
+   */
+  defer(name: string, content: Promise<OmlNode | string>): Promise<OmlNode>
+  /** @internal Pending deferred slots registered via `ctx.defer()`. */
+  _deferredSlots: Map<string, Promise<OmlNode | string>>
+}
+
+interface FlashSession {
+  get(key: string): unknown
+  set(key: string, value: unknown): void
+  delete(key: string): void
+}
+
+const DEFAULT_FORM_LIMIT = 1_000_000 // 1 MB
+const DEFAULT_JSON_LIMIT = 4_000_000 // 4 MB
+const DEFAULT_MULTIPART_LIMIT = 10_000_000 // 10 MB
+
+function readRawBuffer(req: IncomingMessage, maxBytes: number): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    let size = 0
+    req.on('data', (chunk: Buffer) => {
+      size += chunk.length
+      if (size > maxBytes) {
+        req.destroy()
+        reject(new PayloadTooLargeError(maxBytes))
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks)))
+    req.on('error', reject)
+  })
+}
+
+function splitBuffer(buf: Buffer, sep: Buffer): Buffer[] {
+  const parts: Buffer[] = []
+  let start = 0
+  while (true) {
+    const idx = buf.indexOf(sep, start)
+    if (idx === -1) break
+    parts.push(buf.subarray(start, idx))
+    start = idx + sep.length
+  }
+  parts.push(buf.subarray(start))
+  return parts
+}
+
+function extractMultipartParam(header: string, param: string): string | undefined {
+  const rq = new RegExp(`(?:^|;)\\s*${param}="([^"]*)"`, 'i')
+  const mq = header.match(rq)
+  if (mq) return mq[1]
+  const ru = new RegExp(`(?:^|;)\\s*${param}=([^;\\s]*)`, 'i')
+  const mu = header.match(ru)
+  return mu ? mu[1] : undefined
+}
+
+function parseMultipart(body: Buffer, boundary: string): MultipartResult {
+  const fields: Record<string, string> = {}
+  const files: Record<string, MultipartFile> = {}
+
+  // Prepend \r\n so every boundary (including the first) matches `\r\n--boundary`
+  const sep = Buffer.from(`\r\n--${boundary}`)
+  const parts = splitBuffer(Buffer.concat([Buffer.from('\r\n'), body]), sep)
+
+  for (const part of parts) {
+    if (part.length < 2) continue
+    const prefix = part.subarray(0, 2).toString('ascii')
+    if (prefix === '--') break // final `--boundary--` terminator
+    if (prefix !== '\r\n') continue // preamble before first boundary
+
+    const content = part.subarray(2) // skip leading \r\n
+    const headerEnd = content.indexOf('\r\n\r\n')
+    if (headerEnd === -1) continue
+
+    const headerStr = content.subarray(0, headerEnd).toString('utf-8')
+    const partBody = content.subarray(headerEnd + 4)
+
+    const headers: Record<string, string> = {}
+    for (const line of headerStr.split('\r\n')) {
+      const colon = line.indexOf(':')
+      if (colon === -1) continue
+      headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim()
+    }
+
+    const disposition = headers['content-disposition'] ?? ''
+    const name = extractMultipartParam(disposition, 'name')
+    if (!name) continue
+
+    const filename = extractMultipartParam(disposition, 'filename')
+    if (filename !== undefined) {
+      files[name] = {
+        filename,
+        mimetype: headers['content-type'] ?? 'application/octet-stream',
+        data: partBody,
+      }
+    } else {
+      fields[name] = partBody.toString('utf-8')
+    }
+  }
+
+  return { fields, files }
+}
+
+/** @internal Construct a `RequestContext` for a given request. Used by the router and SSG. */
+export function makeContext(
+  req: IncomingMessage,
+  res: ServerResponse,
+  params: Record<string, string>,
+  url: URL,
+  basePath = '',
+): RequestContext {
+  let bodyCache: Promise<Buffer> | undefined
+  function rawBuffer(maxBytes: number): Promise<Buffer> {
+    if (bodyCache === undefined) bodyCache = readRawBuffer(req, maxBytes)
+    return bodyCache
+  }
+
+  return {
+    req,
+    res,
+    params,
+    query: url.searchParams,
+    url,
+    basePath,
+    cookies: new CookieJar(req, res),
+    head: { meta: {}, stylesheets: [], scripts: [] },
+    state: {},
+    async json<T = Record<string, unknown>>(
+      validator?: Validator<T>,
+      options?: { maxBytes?: number },
+    ) {
+      const raw: unknown = JSON.parse(
+        (await rawBuffer(options?.maxBytes ?? DEFAULT_JSON_LIMIT)).toString('utf-8'),
+      )
+      if (!validator) return raw as T
+      try {
+        return validator.parse(raw)
+      } catch (err) {
+        throw new ValidationError(err)
+      }
+    },
+    async form<T = Record<string, string>>(
+      validator?: Validator<T>,
+      options?: { maxBytes?: number },
+    ) {
+      const text = (await rawBuffer(options?.maxBytes ?? DEFAULT_FORM_LIMIT)).toString('utf-8')
+      const out: Record<string, string> = {}
+      for (const [k, v] of new URLSearchParams(text)) out[k] = v
+      if (!validator) return out as unknown as T
+      try {
+        return validator.parse(out)
+      } catch (err) {
+        throw new ValidationError(err)
+      }
+    },
+    async formAll<T = Record<string, string[]>>(
+      validator?: Validator<T>,
+      options?: { maxBytes?: number },
+    ) {
+      const text = (await rawBuffer(options?.maxBytes ?? DEFAULT_FORM_LIMIT)).toString('utf-8')
+      const out: Record<string, string[]> = {}
+      for (const [k, v] of new URLSearchParams(text)) {
+        if (out[k] === undefined) out[k] = []
+        out[k].push(v)
+      }
+      if (!validator) return out as unknown as T
+      try {
+        return validator.parse(out)
+      } catch (err) {
+        throw new ValidationError(err)
+      }
+    },
+    async multipart(options?: { maxBytes?: number }): Promise<MultipartResult> {
+      const ct = req.headers['content-type'] ?? ''
+      const boundary = extractMultipartParam(ct, 'boundary')
+      if (!boundary)
+        throw new Error(
+          '[davaux] ctx.multipart() requires a multipart/form-data request with a boundary',
+        )
+      const buf = await rawBuffer(options?.maxBytes ?? DEFAULT_MULTIPART_LIMIT)
+      return parseMultipart(buf, boundary)
+    },
+    send(body: string | Buffer, contentType: string, status = 200): void {
+      if (!res.headersSent) {
+        res.writeHead(status, { 'Content-Type': contentType })
+        res.end(body)
+      }
+    },
+    flash(key: string, value?: string): string | undefined {
+      const session = this.state.session as FlashSession | undefined
+      if (!session)
+        throw new Error(
+          '[davaux] ctx.flash() requires @davaux/session — add sessionMiddleware to your middleware config',
+        )
+      const NS = '_flash'
+      if (value !== undefined) {
+        const bag = (session.get(NS) as Record<string, string> | undefined) ?? {}
+        session.set(NS, { ...bag, [key]: value })
+        return
+      }
+      const bag = (session.get(NS) as Record<string, string> | undefined) ?? {}
+      const msg = bag[key]
+      if (msg !== undefined) {
+        const { [key as string]: _, ...rest } = bag
+        Object.keys(rest).length > 0 ? session.set(NS, rest) : session.delete(NS)
+      }
+      return msg
+    },
+    _deferredSlots: new Map<string, Promise<OmlNode | string>>(),
+    defer(name: string, content: Promise<OmlNode | string>): Promise<OmlNode> {
+      if (this._deferredSlots.size === 0) {
+        this.head.scripts.push('/_davaux/partial-updates.js')
+      }
+      this._deferredSlots.set(name, content)
+      return Promise.resolve({ type: '#raw' as const, value: `<?marker name="${name}">` })
+    },
+  }
+}
+
+// ─── Route file types ─────────────────────────────────────────────────────────
+
+/** The HTTP method (or `'page'` for full-page SSR routes) a route file handles. */
+export type RouteType = 'page' | 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options'
+
+/** A discovered route file and its compiled URL metadata. */
+export interface RouteFile {
+  filePath: string
+  urlPattern: string
+  type: RouteType
+  params: string[]
+}
+
+/** A discovered `_layout` file and the directory it covers. */
+export interface LayoutFile {
+  /** Absolute path to the _layout.tsx file */
+  filePath: string
+  /** Absolute path to the directory this layout covers */
+  dirPath: string
+}
+
+/** A discovered `_middleware` file and the directory it covers. */
+export interface MiddlewareFile {
+  /** Absolute path to the _middleware.ts file */
+  filePath: string
+  /** Absolute path to the directory this middleware covers */
+  dirPath: string
+}
+
+/** A discovered island component file and its derived hydration ID. */
+export interface IslandFile {
+  /** Absolute path to the island source file */
+  filePath: string
+  /** Island ID derived from filename — used as the key in the hydration manifest */
+  id: string
+}
+
+/** The full result of scanning a routes directory. */
+export interface ScanResult {
+  routes: RouteFile[]
+  layouts: LayoutFile[]
+  middlewares: MiddlewareFile[]
+  /** Absolute path to _error.tsx if one exists in the routes directory */
+  errorPage?: string
+}
+
+// ─── Handler types ────────────────────────────────────────────────────────────
+
+/** Function signature for a `.page.*` route handler — receives context and returns HTML or an OmlNode. */
+export type PageHandler<P extends Record<string, string> = Record<string, string>> = (
+  ctx: RequestContext<P>,
+) => string | OmlNode | Promise<string | OmlNode>
+
+/** Function signature for an API route handler — receives context and returns a JSON-serialisable value. */
+export type ApiHandler<T = unknown, P extends Record<string, string> = Record<string, string>> = (
+  ctx: RequestContext<P>,
+) => T | Promise<T>
+
+/** Function signature for a `_layout.*` handler — receives rendered children and returns HTML or an OmlNode. */
+export type LayoutHandler = (props: LayoutProps) => string | OmlNode | Promise<string | OmlNode>
+
+/** Props passed to every layout handler. */
+export interface LayoutProps {
+  /** Already-rendered inner HTML. Use as a JSX child or template literal interpolation — it will not be escaped. */
+  children: Promise<string>
+  ctx: RequestContext
+}
+
+// ─── Error page ───────────────────────────────────────────────────────────────
+
+/** Props passed to the `_error.tsx` error page handler. */
+export interface ErrorPageProps {
+  status: number
+  message: string
+  ctx: RequestContext
+}
+
+/** Function signature for the `_error.*` handler — receives status/message and returns HTML or an OmlNode. */
+export type ErrorPageHandler = (
+  props: ErrorPageProps,
+) => string | OmlNode | Promise<string | OmlNode>
+
+// ─── Developer ergonomics helpers ─────────────────────────────────────────────
+
+/**
+ * Wraps a page handler so TypeScript infers the correct return type.
+ * Handlers may return an HTML string or an OmlNode — both are handled transparently.
+ *
+ *   export default definePage(async (ctx) => <Layout>...</Layout>)
+ */
+export function definePage<P extends Record<string, string> = Record<string, string>>(
+  fn: PageHandler<P>,
+): PageHandler<P> {
+  return fn
+}
+
+/**
+ * Wraps an API route handler.
+ *
+ *   export default defineHandler(async (ctx) => ({ ok: true }))
+ */
+export function defineHandler<
+  T = unknown,
+  P extends Record<string, string> = Record<string, string>,
+>(fn: ApiHandler<T, P>): ApiHandler<T, P> {
+  return fn
+}
+
+/**
+ * Wraps a layout component.
+ *
+ *   export default defineLayout(({ children, ctx }) => <html>...</html>)
+ */
+export function defineLayout(fn: LayoutHandler): LayoutHandler {
+  return fn
+}
+
+/**
+ * Wraps the `_error.tsx` handler for type inference.
+ *
+ *   export default defineError(({ status, message, ctx }) => (
+ *     <div><h1>{status}</h1><p>{message}</p></div>
+ *   ))
+ */
+export function defineError(fn: ErrorPageHandler): ErrorPageHandler {
+  return fn
+}
+
+/** A middleware function: runs code before and/or after the next handler in the chain. */
+export type MiddlewareFn = (ctx: RequestContext, next: () => Promise<void>) => Promise<void>
+
+/**
+ * Wraps a middleware function for type inference.
+ *
+ *   export default defineMiddleware(async (ctx, next) => {
+ *     // run before the route handler
+ *     await next()
+ *     // run after
+ *   })
+ */
+export function defineMiddleware(fn: MiddlewareFn): MiddlewareFn {
+  return fn
+}
+
+/**
+ * Function signature for a form action handler.
+ * The return value (if any) is set as `ctx.state.actionResult` before the
+ * page re-renders. Throw `redirect()` to skip re-rendering entirely.
+ */
+export type ActionFn<T = unknown> = (ctx: RequestContext) => T | Promise<T>
+
+/**
+ * Wraps a form action handler co-located with a page file.
+ *
+ *   export const action = defineAction(async (ctx) => {
+ *     const { email, password } = await ctx.form()
+ *     const user = await db.authenticate(email, password)
+ *     if (!user) return { error: 'Invalid credentials' }
+ *     redirect('/dashboard')
+ *   })
+ */
+export function defineAction<T = unknown>(fn: ActionFn<T>): ActionFn<T> {
+  return fn
+}
+
+// ─── Static generation ────────────────────────────────────────────────────────
+
+/** A single set of params for a statically pre-rendered dynamic route. */
+export type StaticPath = { params: Record<string, string> }
+
+/** Function signature for `getStaticPaths` — returns all param sets to render at build time. */
+export type GetStaticPathsFn = () => StaticPath[] | Promise<StaticPath[]>
+
+/**
+ * Wraps a `getStaticPaths` export for type inference.
+ *
+ *   export const getStaticPaths = defineStaticPaths(async () => [
+ *     { params: { slug: 'hello-world' } },
+ *   ])
+ */
+export function defineStaticPaths(fn: GetStaticPathsFn): GetStaticPathsFn {
+  return fn
+}

package/tsconfig.client.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "jsxImportSource": "davaux/client",
+    "strict": true,
+    "outDir": "dist/client",
+    "rootDir": "client",
+    "declaration": true,
+    "declarationMap": true,
+    "lib": ["ESNext", "DOM"],
+    "skipLibCheck": true
+  },
+  "include": ["client/**/*"]
+}