@pyreon/zero 0.11.8 → 0.11.10

package/src/fs-router.ts

@@ -20,9 +20,12 @@ import type { FileRoute, RenderMode } from './types'
 // Conventions:
 //   [param]     → dynamic segment  → :param
 //   [...param]  → catch-all        → :param*
-//   _layout     → layout wrapper (not a route itself)
+//   _layout     → layout wrapper — must use <RouterView /> to render child routes
+//                 (props.children is NOT passed — the router handles nesting)
 //   _error      → error component
 //   _loading    → loading component
+//   _404        → not-found component (renders on 404)
+//   _not-found  → alias for _404
 //   (group)     → route group (directory ignored in URL)
 
 const ROUTE_EXTENSIONS = ['.tsx', '.jsx', '.ts', '.js']
@@ -54,6 +57,7 @@ function parseFilePath(filePath: string, defaultMode: RenderMode): FileRoute {
   const isLayout = fileName === '_layout'
   const isError = fileName === '_error'
   const isLoading = fileName === '_loading'
+  const isNotFound = fileName === '_404' || fileName === '_not-found'
   const isCatchAll = route.includes('[...')
 
   // Get directory path (strip groups for consistent grouping)
@@ -73,6 +77,7 @@ function parseFilePath(filePath: string, defaultMode: RenderMode): FileRoute {
     isLayout,
     isError,
     isLoading,
+    isNotFound,
     isCatchAll,
     renderMode: defaultMode,
   }
@@ -99,7 +104,7 @@ export function filePathToUrlPath(filePath: string): string {
     if (seg.startsWith('(') && seg.endsWith(')')) continue
 
     // Skip special files
-    if (seg === '_layout' || seg === '_error' || seg === '_loading') continue
+    if (seg === '_layout' || seg === '_error' || seg === '_loading' || seg === '_404' || seg === '_not-found') continue
 
     // "index" maps to the parent path
     if (seg === 'index') continue
@@ -156,6 +161,8 @@ interface RouteNode {
   error?: FileRoute
   /** Loading fallback file (if any). */
   loading?: FileRoute
+  /** Not-found (404) file (if any). */
+  notFound?: FileRoute
   /** Child directories. */
   children: Map<string, RouteNode>
 }
@@ -186,6 +193,7 @@ function placeRoute(node: RouteNode, route: FileRoute) {
   if (route.isLayout) node.layout = route
   else if (route.isError) node.error = route
   else if (route.isLoading) node.loading = route
+  else if (route.isNotFound) node.notFound = route
   else node.pages.push(route)
 }
 
@@ -202,11 +210,26 @@ function buildRouteTree(routes: FileRoute[]): RouteNode {
  * Wires up layouts as parent routes with children, loaders, guards,
  * error/loading components, middleware, and meta from route module exports.
  */
-export function generateRouteModule(files: string[], routesDir: string): string {
+export interface GenerateRouteModuleOptions {
+  /**
+   * When true, skip lazy() for route components and use static imports.
+   * Use for SSG/prerender mode where all routes are rendered at build time
+   * and code splitting provides no benefit. Avoids Rolldown warnings about
+   * static + dynamic imports of the same module.
+   */
+  staticImports?: boolean
+}
+
+export function generateRouteModule(
+  files: string[],
+  routesDir: string,
+  options?: GenerateRouteModuleOptions,
+): string {
   const routes = parseFileRoutes(files)
   const tree = buildRouteTree(routes)
   const imports: string[] = []
   let importCounter = 0
+  const useStaticImports = options?.staticImports ?? false
 
   function nextImport(filePath: string, exportName = 'default'): string {
     const name = `_${importCounter++}`
@@ -222,11 +245,18 @@ export function generateRouteModule(files: string[], routesDir: string): string
   function nextLazy(filePath: string, loadingName?: string, errorName?: string): string {
     const name = `_${importCounter++}`
     const fullPath = `${routesDir}/${filePath}`
-    const opts: string[] = []
-    if (loadingName) opts.push(`loading: ${loadingName}`)
-    if (errorName) opts.push(`error: ${errorName}`)
-    const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : ''
-    imports.push(`const ${name} = lazy(() => import("${fullPath}")${optsStr})`)
+
+    if (useStaticImports) {
+      // SSG mode: static import avoids Rolldown warnings about
+      // static + dynamic imports of the same module
+      imports.push(`import ${name} from "${fullPath}"`)
+    } else {
+      const opts: string[] = []
+      if (loadingName) opts.push(`loading: ${loadingName}`)
+      if (errorName) opts.push(`error: ${errorName}`)
+      const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : ''
+      imports.push(`const ${name} = lazy(() => import("${fullPath}")${optsStr})`)
+    }
     return name
   }
 
@@ -242,6 +272,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
     indent: string,
     loadingName: string | undefined,
     errorName: string | undefined,
+    notFoundName: string | undefined,
   ): string {
     const mod = nextModuleImport(page.filePath)
     const comp = nextLazy(page.filePath, loadingName, errorName)
@@ -254,10 +285,15 @@ export function generateRouteModule(files: string[], routesDir: string): string
       `${indent}  meta: { ...${mod}.meta, renderMode: ${mod}.renderMode }`,
     ]
 
+    // Only emit errorComponent when there's an actual _error file in scope
+    // or the route module exports an error component. Avoids referencing
+    // undefined .error exports that produce noisy bundler warnings.
     if (errorName) {
       props.push(`${indent}  errorComponent: ${mod}.error || ${errorName}`)
-    } else {
-      props.push(`${indent}  errorComponent: ${mod}.error`)
+    }
+
+    if (notFoundName) {
+      props.push(`${indent}  notFoundComponent: ${notFoundName}`)
     }
 
     return `${indent}{\n${props.join(',\n')}\n${indent}}`
@@ -268,6 +304,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
     children: string[],
     indent: string,
     errorName: string | undefined,
+    notFoundName: string | undefined,
   ): string {
     const layout = node.layout as FileRoute
     const layoutMod = nextModuleImport(layout.filePath)
@@ -283,6 +320,9 @@ export function generateRouteModule(files: string[], routesDir: string): string
     if (errorName) {
       props.push(`${indent}errorComponent: ${errorName}`)
     }
+    if (notFoundName) {
+      props.push(`${indent}notFoundComponent: ${notFoundName}`)
+    }
     if (children.length > 0) {
       props.push(`${indent}children: [\n${children.join(',\n')}\n${indent}]`)
     }
@@ -298,6 +338,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
 
     const errorName = node.error ? nextImport(node.error.filePath) : undefined
     const loadingName = node.loading ? nextImport(node.loading.filePath) : undefined
+    const notFoundName = node.notFound ? nextImport(node.notFound.filePath) : undefined
 
     const childRouteDefs: string[] = []
     for (const [, childNode] of node.children) {
@@ -305,13 +346,13 @@ export function generateRouteModule(files: string[], routesDir: string): string
     }
 
     const pageRouteDefs = node.pages.map((page) =>
-      generatePageRoute(page, indent, loadingName, errorName),
+      generatePageRoute(page, indent, loadingName, errorName, notFoundName),
     )
 
     const allChildren = [...pageRouteDefs, ...childRouteDefs]
 
     if (node.layout) {
-      return [wrapWithLayout(node, allChildren, indent, errorName)]
+      return [wrapWithLayout(node, allChildren, indent, errorName, notFoundName)]
     }
     return allChildren
   }
@@ -350,7 +391,7 @@ export function generateMiddlewareModule(files: string[], routesDir: string): st
   let counter = 0
 
   for (const route of routes) {
-    if (route.isLayout || route.isError || route.isLoading) continue
+    if (route.isLayout || route.isError || route.isLoading || route.isNotFound) continue
     const name = `_mw${counter++}`
     const fullPath = `${routesDir}/${route.filePath}`
     imports.push(`import { middleware as ${name} } from "${fullPath}"`)

package/src/i18n-routing.ts

@@ -0,0 +1,299 @@
+import { createContext } from '@pyreon/core'
+import { signal } from '@pyreon/reactivity'
+import type { Plugin } from 'vite'
+
+// ─── Localized routing ─────────────────────────────────────────────────────
+//
+// Adds locale-prefixed routes to Zero's file-system router:
+// - /about → /en/about, /de/about, /cs/about
+// - / → /en, /de, /cs (or default locale without prefix)
+// - Automatic locale detection from Accept-Language header
+// - Redirect to preferred locale
+// - hreflang link generation
+//
+// Usage:
+//   import { i18nRouting } from "@pyreon/zero"
+//   export default { plugins: [zero(), i18nRouting({ locales: ["en", "de"], defaultLocale: "en" })] }
+
+export interface I18nRoutingConfig {
+  /** Supported locales. e.g. ["en", "de", "cs"] */
+  locales: string[]
+  /** Default locale — served without prefix (/ instead of /en/). */
+  defaultLocale: string
+  /** Redirect root to detected locale. Default: true */
+  detectLocale?: boolean
+  /** Cookie name to persist locale preference. Default: "locale" */
+  cookieName?: string
+  /** URL strategy. Default: "prefix-except-default" */
+  strategy?: 'prefix' | 'prefix-except-default'
+}
+
+export interface LocaleContext {
+  /** Current locale code. e.g. "en", "de" */
+  locale: string
+  /** All supported locales. */
+  locales: string[]
+  /** Default locale. */
+  defaultLocale: string
+  /** Build a localized path. e.g. localePath("/about", "de") → "/de/about" */
+  localePath: (path: string, locale?: string) => string
+  /** Get hreflang alternates for the current path. */
+  alternates: () => Array<{ locale: string; url: string }>
+}
+
+/**
+ * Detect preferred locale from Accept-Language header.
+ */
+export function detectLocaleFromHeader(
+  acceptLanguage: string | null | undefined,
+  locales: string[],
+  defaultLocale: string,
+): string {
+  if (!acceptLanguage) return defaultLocale
+
+  // Parse Accept-Language: en-US,en;q=0.9,de;q=0.8
+  const preferred = acceptLanguage
+    .split(',')
+    .map((part) => {
+      const [lang, q] = part.trim().split(';q=')
+      return {
+        lang: lang?.split('-')[0]?.toLowerCase() ?? '',
+        quality: q ? Number.parseFloat(q) : 1,
+      }
+    })
+    .sort((a, b) => b.quality - a.quality)
+
+  for (const { lang } of preferred) {
+    if (locales.includes(lang)) return lang
+  }
+
+  return defaultLocale
+}
+
+/**
+ * Extract locale from a URL path.
+ * Returns { locale, pathWithoutLocale }.
+ */
+export function extractLocaleFromPath(
+  path: string,
+  locales: string[],
+  defaultLocale: string,
+): { locale: string; pathWithoutLocale: string } {
+  const segments = path.split('/').filter(Boolean)
+  const firstSegment = segments[0]?.toLowerCase()
+
+  if (firstSegment && locales.includes(firstSegment)) {
+    return {
+      locale: firstSegment,
+      pathWithoutLocale: '/' + segments.slice(1).join('/') || '/',
+    }
+  }
+
+  return { locale: defaultLocale, pathWithoutLocale: path }
+}
+
+/**
+ * Build a localized path.
+ */
+export function buildLocalePath(
+  path: string,
+  locale: string,
+  defaultLocale: string,
+  strategy: 'prefix' | 'prefix-except-default',
+): string {
+  const clean = path === '/' ? '' : path
+  if (strategy === 'prefix-except-default' && locale === defaultLocale) {
+    return path
+  }
+  return `/${locale}${clean}`
+}
+
+/**
+ * Create a LocaleContext for use in components and loaders.
+ */
+export function createLocaleContext(
+  locale: string,
+  path: string,
+  config: I18nRoutingConfig,
+): LocaleContext {
+  const strategy = config.strategy ?? 'prefix-except-default'
+
+  return {
+    locale,
+    locales: config.locales,
+    defaultLocale: config.defaultLocale,
+
+    localePath(targetPath: string, targetLocale?: string) {
+      return buildLocalePath(
+        targetPath,
+        targetLocale ?? locale,
+        config.defaultLocale,
+        strategy,
+      )
+    },
+
+    alternates() {
+      const { pathWithoutLocale } = extractLocaleFromPath(
+        path,
+        config.locales,
+        config.defaultLocale,
+      )
+      return config.locales.map((loc) => ({
+        locale: loc,
+        url: buildLocalePath(pathWithoutLocale, loc, config.defaultLocale, strategy),
+      }))
+    },
+  }
+}
+
+/**
+ * I18n routing middleware for Zero's server.
+ *
+ * - Detects locale from URL prefix or Accept-Language header
+ * - Redirects root to preferred locale (when detectLocale is true)
+ * - Sets locale context for loaders and components
+ *
+ * @example
+ * ```ts
+ * // zero.config.ts
+ * import { i18nRouting } from "@pyreon/zero"
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     i18nRouting({
+ *       locales: ["en", "de", "cs"],
+ *       defaultLocale: "en",
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export function i18nRouting(config: I18nRoutingConfig): Plugin {
+  const strategy = config.strategy ?? 'prefix-except-default'
+  const detectEnabled = config.detectLocale !== false
+  const cookieName = config.cookieName ?? 'locale'
+
+  return {
+    name: 'pyreon-zero-i18n-routing',
+
+    // Route duplication is NOT handled here. The fs-router's `scanRouteFiles`
+    // consumes the i18n config to duplicate routes per locale at build time.
+    // This plugin only provides: (1) the server middleware for locale detection
+    // and (2) the runtime hooks (useLocale, setLocale) for client-side use.
+    configResolved() {},
+
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const url = req.url ?? '/'
+
+        // Skip static assets
+        if (url.startsWith('/@') || url.startsWith('/__') || url.includes('.')) {
+          return next()
+        }
+
+        const { locale } = extractLocaleFromPath(
+          url,
+          config.locales,
+          config.defaultLocale,
+        )
+
+        // Redirect root to detected locale
+        if (detectEnabled && url === '/') {
+          const cookies = parseCookies(req.headers.cookie)
+          const preferredFromCookie = cookies[cookieName]
+          const preferredFromHeader = detectLocaleFromHeader(
+            req.headers['accept-language'],
+            config.locales,
+            config.defaultLocale,
+          )
+          const preferred = preferredFromCookie && config.locales.includes(preferredFromCookie)
+            ? preferredFromCookie
+            : preferredFromHeader
+
+          if (strategy === 'prefix' || preferred !== config.defaultLocale) {
+            res.writeHead(302, { Location: `/${preferred}/` })
+            res.end()
+            return
+          }
+        }
+
+        // Attach locale context to request for loaders
+        ;(req as any).__locale = locale
+        ;(req as any).__localeContext = createLocaleContext(locale, url, config)
+
+        // Update the module-level signal so useLocale() returns the correct value
+        localeSignal.set(locale)
+
+        next()
+      })
+    },
+  }
+}
+
+function parseCookies(header: string | undefined): Record<string, string> {
+  if (!header) return {}
+  const result: Record<string, string> = {}
+  for (const pair of header.split(';')) {
+    const [key, value] = pair.trim().split('=')
+    if (key && value) result[key] = decodeURIComponent(value)
+  }
+  return result
+}
+
+// ─── Reactive locale hook ───────────────────────────────────────────────────
+
+/** @internal Context for the current locale. */
+export const LocaleCtx = createContext<string>('en')
+
+/** Current locale signal — set by the server middleware or client-side detection. */
+export const localeSignal = signal('en')
+
+/**
+ * Read the current locale reactively.
+ *
+ * Returns the locale signal value directly — reactive in both SSR and CSR.
+ * The server middleware sets `localeSignal` per-request, and client-side
+ * `setLocale()` updates it as well.
+ *
+ * @example
+ * ```tsx
+ * const locale = useLocale() // "en", "de", etc.
+ * ```
+ */
+export function useLocale(): string {
+  return localeSignal()
+}
+
+/**
+ * Set the locale client-side and update the URL.
+ *
+ * @example
+ * ```tsx
+ * <button onClick={() => setLocale('de')}>Deutsch</button>
+ * ```
+ */
+export function setLocale(
+  locale: string,
+  config: I18nRoutingConfig,
+): void {
+  localeSignal.set(locale)
+
+  // Persist to cookie
+  if (typeof document !== 'undefined') {
+    document.cookie = `${config.cookieName ?? 'locale'}=${locale}; path=/; max-age=31536000`
+  }
+
+  // Navigate to localized URL — use pushState to avoid full page reload
+  if (typeof window !== 'undefined') {
+    const strategy = config.strategy ?? 'prefix-except-default'
+    const { pathWithoutLocale } = extractLocaleFromPath(
+      window.location.pathname,
+      config.locales,
+      config.defaultLocale,
+    )
+    const newPath = buildLocalePath(pathWithoutLocale, locale, config.defaultLocale, strategy)
+    window.history.pushState(null, '', newPath)
+    // Dispatch popstate so @pyreon/router picks up the URL change
+    window.dispatchEvent(new PopStateEvent('popstate'))
+  }
+}

package/src/image-plugin.ts

@@ -7,7 +7,7 @@ let sharpWarned = false
 function warnSharpMissing() {
   if (sharpWarned) return
   sharpWarned = true
-  // biome-ignore lint/suspicious/noConsole: intentional build-time warning
+  // oxlint-disable-next-line no-console
   console.warn(
     '\n[zero:image] sharp not installed — images will not be optimized. Install for full support: bun add -D sharp\n',
   )