@pyreon/zero 0.11.5 → 0.11.7

package/src/api-routes.ts

@@ -1,9 +1,9 @@
-import type { Middleware, MiddlewareContext } from "@pyreon/server"
+import type { Middleware, MiddlewareContext } from '@pyreon/server'
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 /** HTTP methods supported by API routes. */
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS"
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS'
 
 /** Context passed to API route handlers. */
 export interface ApiContext {
@@ -48,8 +48,8 @@ export interface ApiRouteEntry {
  * Returns extracted params or null if no match.
  */
 export function matchApiRoute(pattern: string, path: string): Record<string, string> | null {
-  const patternParts = pattern.split("/").filter(Boolean)
-  const pathParts = path.split("/").filter(Boolean)
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = path.split('/').filter(Boolean)
   const params: Record<string, string> = {}
 
   for (let i = 0; i < patternParts.length; i++) {
@@ -57,9 +57,9 @@ export function matchApiRoute(pattern: string, path: string): Record<string, str
     if (!pp) continue
 
     // Catch-all: :param*
-    if (pp.endsWith("*")) {
+    if (pp.endsWith('*')) {
       const paramName = pp.slice(1, -1)
-      params[paramName] = pathParts.slice(i).join("/")
+      params[paramName] = pathParts.slice(i).join('/')
       return params
     }
 
@@ -67,7 +67,7 @@ export function matchApiRoute(pattern: string, path: string): Record<string, str
     if (i >= pathParts.length) return null
 
     // Dynamic segment: :param
-    if (pp.startsWith(":")) {
+    if (pp.startsWith(':')) {
       params[pp.slice(1)] = pathParts[i]!
       continue
     }
@@ -81,7 +81,7 @@ export function matchApiRoute(pattern: string, path: string): Record<string, str
 
 // ─── Middleware ───────────────────────────────────────────────────────────────
 
-const HTTP_METHODS: HttpMethod[] = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]
+const HTTP_METHODS: HttpMethod[] = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
 
 /**
  * Create a middleware that dispatches API route requests.
@@ -98,12 +98,12 @@ export function createApiMiddleware(routes: ApiRouteEntry[]): Middleware {
 
       if (!handler) {
         // Route matched but method not supported
-        const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(", ")
+        const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(', ')
         return new Response(null, {
           status: 405,
           headers: {
             Allow: allowed,
-            "Content-Type": "application/json",
+            'Content-Type': 'application/json',
           },
         })
       }
@@ -126,12 +126,12 @@ export function createApiMiddleware(routes: ApiRouteEntry[]): Middleware {
  * API routes are `.ts` or `.js` files inside an `api/` directory.
  */
 export function isApiRoute(filePath: string): boolean {
-  const normalized = filePath.replace(/\\/g, "/")
+  const normalized = filePath.replace(/\\/g, '/')
   return (
-    normalized.startsWith("api/") &&
-    (normalized.endsWith(".ts") || normalized.endsWith(".js")) &&
-    !normalized.endsWith(".tsx") &&
-    !normalized.endsWith(".jsx")
+    normalized.startsWith('api/') &&
+    (normalized.endsWith('.ts') || normalized.endsWith('.js')) &&
+    !normalized.endsWith('.tsx') &&
+    !normalized.endsWith('.jsx')
   )
 }
 
@@ -147,18 +147,18 @@ export function isApiRoute(filePath: string): boolean {
 export function apiFilePathToPattern(filePath: string): string {
   let route = filePath
   // Remove extension
-  for (const ext of [".ts", ".js"]) {
+  for (const ext of ['.ts', '.js']) {
     if (route.endsWith(ext)) {
       route = route.slice(0, -ext.length)
       break
     }
   }
 
-  const segments = route.split("/")
+  const segments = route.split('/')
   const urlSegments: string[] = []
 
   for (const seg of segments) {
-    if (seg === "index") continue
+    if (seg === 'index') continue
 
     // Catch-all: [...param]
     const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/)
@@ -177,7 +177,7 @@ export function apiFilePathToPattern(filePath: string): string {
     urlSegments.push(seg)
   }
 
-  return `/${urlSegments.join("/")}`
+  return `/${urlSegments.join('/')}`
 }
 
 /**
@@ -188,7 +188,7 @@ export function generateApiRouteModule(files: string[], routesDir: string): stri
   const apiFiles = files.filter(isApiRoute)
 
   if (apiFiles.length === 0) {
-    return "export const apiRoutes = []\n"
+    return 'export const apiRoutes = []\n'
   }
 
   const imports: string[] = []
@@ -205,5 +205,5 @@ export function generateApiRouteModule(files: string[], routesDir: string): stri
     entries.push(`  { pattern: ${JSON.stringify(pattern)}, module: ${name} }`)
   }
 
-  return [...imports, "", "export const apiRoutes = [", entries.join(",\n"), "]"].join("\n")
+  return [...imports, '', 'export const apiRoutes = [', entries.join(',\n'), ']'].join('\n')
 }

package/src/app.ts

@@ -1,8 +1,8 @@
-import type { ComponentFn, Props } from "@pyreon/core"
-import { Fragment, h } from "@pyreon/core"
-import { HeadProvider } from "@pyreon/head"
-import type { RouteRecord } from "@pyreon/router"
-import { createRouter, RouterProvider, RouterView } from "@pyreon/router"
+import type { ComponentFn, Props } from '@pyreon/core'
+import { Fragment, h } from '@pyreon/core'
+import { HeadProvider } from '@pyreon/head'
+import type { RouteRecord } from '@pyreon/router'
+import { createRouter, RouterProvider, RouterView } from '@pyreon/router'
 
 // ─── App assembly ────────────────────────────────────────────────────────────
 
@@ -11,7 +11,7 @@ export interface CreateAppOptions {
   routes: RouteRecord[]
 
   /** Router mode. Default: "history" for SSR, "hash" for SPA. */
-  routerMode?: "hash" | "history"
+  routerMode?: 'hash' | 'history'
 
   /** Initial URL for SSR. */
   url?: string
@@ -31,9 +31,9 @@ export interface CreateAppOptions {
 export function createApp(options: CreateAppOptions) {
   const router = createRouter({
     routes: options.routes,
-    mode: options.routerMode ?? "history",
+    mode: options.routerMode ?? 'history',
     ...(options.url ? { url: options.url } : {}),
-    scrollBehavior: "top",
+    scrollBehavior: 'top',
   })
 
   const Layout = options.layout ?? DefaultLayout

package/src/cache.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from "@pyreon/server"
+import type { Middleware, MiddlewareContext } from '@pyreon/server'
 
 // ─── Cache control middleware ───────────────────────────────────────────────
 //
@@ -38,8 +38,8 @@ const SCRIPT_EXT = /\.(js|css|mjs)$/i
 /** @internal Exported for testing */
 export function matchGlob(pattern: string, path: string): boolean {
   // Escape regex special chars, then convert glob wildcards
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&")
-  const regex = escaped.replace(/\*/g, ".*").replace(/\?/g, ".")
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+  const regex = escaped.replace(/\*/g, '.*').replace(/\?/g, '.')
   return new RegExp(`^${regex}$`).test(path)
 }
 
@@ -62,7 +62,7 @@ function resolveControl(
   if (pageDuration > 0) {
     return `public, max-age=${pageDuration}, stale-while-revalidate=${swr}`
   }
-  return "no-cache"
+  return 'no-cache'
 }
 
 /**
@@ -97,13 +97,13 @@ export function cacheMiddleware(config: CacheConfig = {}): Middleware {
 
     for (const rule of rules) {
       if (matchGlob(rule.match, path)) {
-        ctx.headers.set("Cache-Control", rule.control)
+        ctx.headers.set('Cache-Control', rule.control)
         return
       }
     }
 
     const control = resolveControl(path, immutableDuration, staticDuration, pageDuration, swr)
-    ctx.headers.set("Cache-Control", control)
+    ctx.headers.set('Cache-Control', control)
   }
 }
 
@@ -113,11 +113,11 @@ export function cacheMiddleware(config: CacheConfig = {}): Middleware {
  */
 export function securityHeaders(): Middleware {
   return (ctx: MiddlewareContext) => {
-    ctx.headers.set("X-Content-Type-Options", "nosniff")
-    ctx.headers.set("X-Frame-Options", "DENY")
-    ctx.headers.set("X-XSS-Protection", "1; mode=block")
-    ctx.headers.set("Referrer-Policy", "strict-origin-when-cross-origin")
-    ctx.headers.set("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
+    ctx.headers.set('X-Content-Type-Options', 'nosniff')
+    ctx.headers.set('X-Frame-Options', 'DENY')
+    ctx.headers.set('X-XSS-Protection', '1; mode=block')
+    ctx.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin')
+    ctx.headers.set('Permissions-Policy', 'camera=(), microphone=(), geolocation=()')
   }
 }
 
@@ -128,9 +128,9 @@ export function securityHeaders(): Middleware {
  */
 export function varyEncoding(): Middleware {
   return (ctx: MiddlewareContext) => {
-    const existing = ctx.headers.get("Vary")
-    if (!existing?.includes("Accept-Encoding")) {
-      ctx.headers.set("Vary", existing ? `${existing}, Accept-Encoding` : "Accept-Encoding")
+    const existing = ctx.headers.get('Vary')
+    if (!existing?.includes('Accept-Encoding')) {
+      ctx.headers.set('Vary', existing ? `${existing}, Accept-Encoding` : 'Accept-Encoding')
     }
   }
 }

package/src/client.ts

@@ -1,8 +1,8 @@
-import type { ComponentFn } from "@pyreon/core"
-import { h } from "@pyreon/core"
-import type { RouteRecord } from "@pyreon/router"
-import { hydrateRoot, mount } from "@pyreon/runtime-dom"
-import { createApp } from "./app"
+import type { ComponentFn } from '@pyreon/core'
+import { h } from '@pyreon/core'
+import type { RouteRecord } from '@pyreon/router'
+import { hydrateRoot, mount } from '@pyreon/runtime-dom'
+import { createApp } from './app'
 
 // ─── Client entry factory ───────────────────────────────────────────────────
 
@@ -23,12 +23,12 @@ export interface StartClientOptions {
  * startClient({ routes })
  */
 export function startClient(options: StartClientOptions) {
-  const container = document.getElementById("app")
-  if (!container) throw new Error("[zero] Missing #app container element")
+  const container = document.getElementById('app')
+  if (!container) throw new Error('[zero] Missing #app container element')
 
   const { App } = createApp({
     routes: options.routes,
-    routerMode: "history",
+    routerMode: 'history',
     ...(options.layout ? { layout: options.layout } : {}),
   })
 

package/src/compression.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from "@pyreon/server"
+import type { Middleware, MiddlewareContext } from '@pyreon/server'
 
 // ─── Compression middleware ─────────────────────────────────────────────────
 
@@ -6,7 +6,7 @@ export interface CompressionConfig {
   /** Minimum response size in bytes to compress. Default: `1024` (1KB) */
   threshold?: number
   /** Encoding preference order. Default: `["gzip", "deflate"]` */
-  encodings?: ("gzip" | "deflate")[]
+  encodings?: ('gzip' | 'deflate')[]
 }
 
 /**
@@ -23,10 +23,10 @@ export interface CompressionConfig {
  * compressionMiddleware({ threshold: 512, encodings: ["gzip"] })
  */
 export function compressionMiddleware(config: CompressionConfig = {}): Middleware {
-  const { threshold = 1024, encodings = ["gzip", "deflate"] } = config
+  const { threshold = 1024, encodings = ['gzip', 'deflate'] } = config
 
   return (ctx: MiddlewareContext) => {
-    const acceptEncoding = ctx.req.headers.get("accept-encoding") ?? ""
+    const acceptEncoding = ctx.req.headers.get('accept-encoding') ?? ''
 
     // Find the best supported encoding
     const encoding = encodings.find((enc) => acceptEncoding.includes(enc))
@@ -35,7 +35,7 @@ export function compressionMiddleware(config: CompressionConfig = {}): Middlewar
     // Store the encoding choice for post-processing
     ctx.locals.__compressionEncoding = encoding
     ctx.locals.__compressionThreshold = threshold
-    ctx.headers.append("Vary", "Accept-Encoding")
+    ctx.headers.append('Vary', 'Accept-Encoding')
   }
 }
 
@@ -49,16 +49,16 @@ export function compressionMiddleware(config: CompressionConfig = {}): Middlewar
  */
 export async function compressResponse(
   response: Response,
-  encoding: "gzip" | "deflate",
+  encoding: 'gzip' | 'deflate',
   threshold: number,
 ): Promise<Response> {
-  const contentType = response.headers.get("content-type") ?? ""
+  const contentType = response.headers.get('content-type') ?? ''
 
   // Only compress text-based content
   if (!isCompressible(contentType)) return response
 
   // Skip if already encoded
-  if (response.headers.get("content-encoding")) return response
+  if (response.headers.get('content-encoding')) return response
 
   const body = await response.arrayBuffer()
 
@@ -68,9 +68,9 @@ export async function compressResponse(
   const compressed = await compress(body, encoding)
 
   const headers = new Headers(response.headers)
-  headers.set("Content-Encoding", encoding)
-  headers.delete("Content-Length")
-  headers.append("Vary", "Accept-Encoding")
+  headers.set('Content-Encoding', encoding)
+  headers.delete('Content-Length')
+  headers.append('Vary', 'Accept-Encoding')
 
   return new Response(compressed, {
     status: response.status,
@@ -80,12 +80,12 @@ export async function compressResponse(
 }
 
 const COMPRESSIBLE_TYPES = [
-  "text/",
-  "application/json",
-  "application/javascript",
-  "application/xml",
-  "application/xhtml+xml",
-  "image/svg+xml",
+  'text/',
+  'application/json',
+  'application/javascript',
+  'application/xml',
+  'application/xhtml+xml',
+  'image/svg+xml',
 ]
 
 /** Check if a content type is compressible. Exported for testing. */
@@ -93,8 +93,8 @@ export function isCompressible(contentType: string): boolean {
   return COMPRESSIBLE_TYPES.some((t) => contentType.includes(t))
 }
 
-async function compress(data: ArrayBuffer, encoding: "gzip" | "deflate"): Promise<ArrayBuffer> {
-  const format = encoding === "gzip" ? "gzip" : "deflate"
+async function compress(data: ArrayBuffer, encoding: 'gzip' | 'deflate'): Promise<ArrayBuffer> {
+  const format = encoding === 'gzip' ? 'gzip' : 'deflate'
   const stream = new Blob([data]).stream().pipeThrough(new CompressionStream(format))
   return new Response(stream).arrayBuffer()
 }

package/src/config.ts

@@ -1,4 +1,4 @@
-import type { ZeroConfig } from "./types"
+import type { ZeroConfig } from './types'
 
 /**
  * Define a Zero configuration.
@@ -20,15 +20,15 @@ export function defineConfig(config: ZeroConfig): ZeroConfig {
 /** Merge user config with defaults. */
 export function resolveConfig(
   userConfig: ZeroConfig = {},
-): Required<Pick<ZeroConfig, "mode" | "base" | "port" | "adapter">> & ZeroConfig {
+): Required<Pick<ZeroConfig, 'mode' | 'base' | 'port' | 'adapter'>> & ZeroConfig {
   return {
-    mode: "ssr",
-    base: "/",
+    mode: 'ssr',
+    base: '/',
     port: 3000,
-    adapter: "node",
+    adapter: 'node',
     ...userConfig,
     ssr: {
-      mode: "string",
+      mode: 'string',
       ...userConfig.ssr,
     },
   }

package/src/cors.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from "@pyreon/server"
+import type { Middleware, MiddlewareContext } from '@pyreon/server'
 
 // ─── CORS middleware ────────────────────────────────────────────────────────
 
@@ -17,8 +17,8 @@ export interface CorsConfig {
   maxAge?: number
 }
 
-const DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
-const DEFAULT_HEADERS = ["Content-Type", "Authorization"]
+const DEFAULT_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
+const DEFAULT_HEADERS = ['Content-Type', 'Authorization']
 
 /**
  * CORS middleware — handles preflight requests and sets appropriate
@@ -37,7 +37,7 @@ const DEFAULT_HEADERS = ["Content-Type", "Authorization"]
  */
 export function corsMiddleware(config: CorsConfig = {}): Middleware {
   const {
-    origin = "*",
+    origin = '*',
     methods = DEFAULT_METHODS,
     allowedHeaders = DEFAULT_HEADERS,
     exposedHeaders = [],
@@ -46,45 +46,45 @@ export function corsMiddleware(config: CorsConfig = {}): Middleware {
   } = config
 
   return (ctx: MiddlewareContext) => {
-    const requestOrigin = ctx.req.headers.get("origin") ?? ""
+    const requestOrigin = ctx.req.headers.get('origin') ?? ''
     const resolvedOrigin = resolveOrigin(origin, requestOrigin)
 
     if (!resolvedOrigin) return
 
     // Set CORS headers on all responses
-    ctx.headers.set("Access-Control-Allow-Origin", resolvedOrigin)
+    ctx.headers.set('Access-Control-Allow-Origin', resolvedOrigin)
     if (credentials) {
-      ctx.headers.set("Access-Control-Allow-Credentials", "true")
+      ctx.headers.set('Access-Control-Allow-Credentials', 'true')
     }
     if (exposedHeaders.length > 0) {
-      ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "))
+      ctx.headers.set('Access-Control-Expose-Headers', exposedHeaders.join(', '))
     }
-    if (resolvedOrigin !== "*") {
-      ctx.headers.append("Vary", "Origin")
+    if (resolvedOrigin !== '*') {
+      ctx.headers.append('Vary', 'Origin')
     }
 
     // Handle preflight
-    if (ctx.req.method === "OPTIONS") {
+    if (ctx.req.method === 'OPTIONS') {
       return new Response(null, {
         status: 204,
         headers: {
-          "Access-Control-Allow-Origin": resolvedOrigin,
-          "Access-Control-Allow-Methods": methods.join(", "),
-          "Access-Control-Allow-Headers": allowedHeaders.join(", "),
-          "Access-Control-Max-Age": String(maxAge),
-          ...(credentials ? { "Access-Control-Allow-Credentials": "true" } : {}),
+          'Access-Control-Allow-Origin': resolvedOrigin,
+          'Access-Control-Allow-Methods': methods.join(', '),
+          'Access-Control-Allow-Headers': allowedHeaders.join(', '),
+          'Access-Control-Max-Age': String(maxAge),
+          ...(credentials ? { 'Access-Control-Allow-Credentials': 'true' } : {}),
         },
       })
     }
   }
 }
 
-function resolveOrigin(config: CorsConfig["origin"], requestOrigin: string): string | null {
-  if (config === "*") return "*"
-  if (typeof config === "string") {
+function resolveOrigin(config: CorsConfig['origin'], requestOrigin: string): string | null {
+  if (config === '*') return '*'
+  if (typeof config === 'string') {
     return config === requestOrigin ? config : null
   }
-  if (typeof config === "function") {
+  if (typeof config === 'function') {
     return config(requestOrigin) ? requestOrigin : null
   }
   if (Array.isArray(config)) {

package/src/entry-server.ts

@@ -1,10 +1,10 @@
-import type { RouteRecord } from "@pyreon/router"
-import type { Middleware, MiddlewareContext } from "@pyreon/server"
-import { createHandler } from "@pyreon/server"
-import type { ApiRouteEntry } from "./api-routes"
-import { createApiMiddleware } from "./api-routes"
-import { createApp } from "./app"
-import type { RouteMiddlewareEntry, ZeroConfig } from "./types"
+import type { RouteRecord } from '@pyreon/router'
+import type { Middleware, MiddlewareContext } from '@pyreon/server'
+import { createHandler } from '@pyreon/server'
+import type { ApiRouteEntry } from './api-routes'
+import { createApiMiddleware } from './api-routes'
+import { createApp } from './app'
+import type { RouteMiddlewareEntry, ZeroConfig } from './types'
 
 // ─── Server entry factory ───────────────────────────────────────────────────
 
@@ -44,14 +44,14 @@ function createRouteMiddlewareDispatcher(entries: RouteMiddlewareEntry[]): Middl
 
 /** Simple URL pattern matcher supporting :param and :param* segments. */
 export function matchPattern(pattern: string, path: string): boolean {
-  const patternParts = pattern.split("/").filter(Boolean)
-  const pathParts = path.split("/").filter(Boolean)
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = path.split('/').filter(Boolean)
 
   for (let i = 0; i < patternParts.length; i++) {
     const pp = patternParts[i]
     if (!pp) continue
-    if (pp.endsWith("*")) return true // catch-all matches everything after
-    if (pp.startsWith(":")) continue // dynamic segment matches anything
+    if (pp.endsWith('*')) return true // catch-all matches everything after
+    if (pp.startsWith(':')) continue // dynamic segment matches anything
     if (pp !== pathParts[i]) return false
   }
 
@@ -89,14 +89,14 @@ export function createServer(options: CreateServerOptions) {
 
   const { App } = createApp({
     routes: options.routes,
-    routerMode: "history",
+    routerMode: 'history',
   })
 
   return createHandler({
     App,
     routes: options.routes,
     middleware: allMiddleware,
-    mode: config.ssr?.mode ?? "string",
+    mode: config.ssr?.mode ?? 'string',
     ...(options.template ? { template: options.template } : {}),
     ...(options.clientEntry ? { clientEntry: options.clientEntry } : {}),
   })

package/src/error-overlay.ts

@@ -3,8 +3,8 @@
  * Renders a styled HTML page with the error stack trace.
  */
 export function renderErrorOverlay(error: Error): string {
-  const title = escapeHtml(error.message || "Unknown error")
-  const stack = escapeHtml(error.stack || "")
+  const title = escapeHtml(error.message || 'Unknown error')
+  const stack = escapeHtml(error.stack || '')
 
   return `<!DOCTYPE html>
 <html lang="en">
@@ -96,17 +96,17 @@ export function renderErrorOverlay(error: Error): string {
 
 function escapeHtml(str: string): string {
   return str
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
 }
 
 function formatStack(stack: string): string {
   return stack
-    .split("\n")
+    .split('\n')
     .map((line) => {
-      if (line.includes("at ")) {
+      if (line.includes('at ')) {
         const fileMatch = line.match(/\(([^)]+)\)/)
         if (fileMatch) {
           return line.replace(fileMatch[0], `(<span class="file">${fileMatch[1]}</span>)`)
@@ -114,5 +114,5 @@ function formatStack(stack: string): string {
       }
       return line
     })
-    .join("\n")
+    .join('\n')
 }