@pyreon/zero 0.11.4 → 0.11.6

package/src/font.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite"
+import type { Plugin } from 'vite'
 
 // ─── Font optimization ──────────────────────────────────────────────────────
 //
@@ -57,11 +57,11 @@ export interface LocalFont {
   src: string
   /** Single weight (400) or variable range ("100 900"). */
   weight?: number | `${number} ${number}`
-  style?: "normal" | "italic"
+  style?: 'normal' | 'italic'
   display?: FontDisplay
 }
 
-export type FontDisplay = "auto" | "block" | "swap" | "fallback" | "optional"
+export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional'
 
 /** Metrics for generating size-adjusted fallback fonts to reduce CLS. */
 export interface FallbackMetrics {
@@ -98,7 +98,7 @@ type ResolvedFont = StaticFont | VariableFont
  * Normalize a GoogleFontInput (string or object) into a ResolvedFont.
  */
 export function resolveGoogleFont(input: GoogleFontInput): ResolvedFont {
-  if (typeof input === "string") {
+  if (typeof input === 'string') {
     return parseGoogleFamily(input)
   }
 
@@ -127,13 +127,13 @@ export function resolveGoogleFont(input: GoogleFontInput): ResolvedFont {
  * Variable with italic: "Inter:ital,wght@100..900"
  */
 export function parseGoogleFamily(input: string): ResolvedFont {
-  const parts = input.split(":")
-  const family = (parts[0] ?? "").trim()
+  const parts = input.split(':')
+  const family = (parts[0] ?? '').trim()
   const spec = parts[1]
   let italic = false
 
   if (spec) {
-    italic = spec.includes("ital")
+    italic = spec.includes('ital')
 
     // Variable font range syntax: wght@100..900
     const rangeMatch = spec.match(/wght@(\d+)\.\.(\d+)/)
@@ -153,7 +153,7 @@ export function parseGoogleFamily(input: string): ResolvedFont {
         family,
         italic,
         variable: false,
-        weights: weightMatch[1].split(";").map(Number),
+        weights: weightMatch[1].split(';').map(Number),
       }
     }
   }
@@ -164,11 +164,11 @@ export function parseGoogleFamily(input: string): ResolvedFont {
 /**
  * Generate a Google Fonts CSS URL.
  */
-export function googleFontsUrl(families: ResolvedFont[], display: FontDisplay = "swap"): string {
+export function googleFontsUrl(families: ResolvedFont[], display: FontDisplay = 'swap'): string {
   const params = families
     .map((f) => {
-      const axes = f.italic ? "ital,wght" : "wght"
-      const name = f.family.replace(/ /g, "+")
+      const axes = f.italic ? 'ital,wght' : 'wght'
+      const name = f.family.replace(/ /g, '+')
 
       if (f.variable) {
         const range = `${f.weightRange[0]}..${f.weightRange[1]}`
@@ -176,10 +176,10 @@ export function googleFontsUrl(families: ResolvedFont[], display: FontDisplay =
         return `family=${name}:${axes}@${value}`
       }
 
-      const values = f.weights.map((w) => (f.italic ? `0,${w};1,${w}` : String(w))).join(";")
+      const values = f.weights.map((w) => (f.italic ? `0,${w};1,${w}` : String(w))).join(';')
       return `family=${name}:${axes}@${values}`
     })
-    .join("&")
+    .join('&')
 
   return `https://fonts.googleapis.com/css2?${params}&display=${display}`
 }
@@ -193,12 +193,12 @@ function localFontFaces(fonts: LocalFont[], display: FontDisplay): string {
       (f) => `@font-face {
   font-family: "${f.family}";
   src: url("${f.src}");
-  font-weight: ${f.weight ?? "400"};
-  font-style: ${f.style ?? "normal"};
+  font-weight: ${f.weight ?? '400'};
+  font-style: ${f.style ?? 'normal'};
   font-display: ${f.display ?? display};
 }`,
     )
-    .join("\n\n")
+    .join('\n\n')
 }
 
 /**
@@ -219,10 +219,10 @@ function fallbackFontFaces(fallbacks: Record<string, FallbackMetrics>): string {
       return `@font-face {
   font-family: "${family} Fallback";
   src: local("${metrics.fallback}");
-${overrides.join("\n")}
+${overrides.join('\n')}
 }`
     })
-    .join("\n\n")
+    .join('\n\n')
 }
 
 /**
@@ -231,18 +231,18 @@ ${overrides.join("\n")}
 function preloadTags(fonts: LocalFont[]): string {
   return fonts
     .map((f) => {
-      const ext = f.src.split(".").pop()
+      const ext = f.src.split('.').pop()
       const type =
-        ext === "woff2"
-          ? "font/woff2"
-          : ext === "woff"
-            ? "font/woff"
-            : ext === "ttf"
-              ? "font/ttf"
-              : "font/otf"
+        ext === 'woff2'
+          ? 'font/woff2'
+          : ext === 'woff'
+            ? 'font/woff'
+            : ext === 'ttf'
+              ? 'font/ttf'
+              : 'font/otf'
       return `<link rel="preload" href="${f.src}" as="font" type="${type}" crossorigin>`
     })
-    .join("\n")
+    .join('\n')
 }
 
 /**
@@ -251,8 +251,8 @@ function preloadTags(fonts: LocalFont[]): string {
 async function downloadGoogleFontsCSS(url: string): Promise<string> {
   const response = await fetch(url, {
     headers: {
-      "User-Agent":
-        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      'User-Agent':
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
     },
   })
   if (!response.ok) {
@@ -300,8 +300,8 @@ async function selfHostFonts(
   let rewrittenCss = css
 
   for (const url of fontUrls) {
-    const urlParts = url.split("/")
-    const fileName = urlParts.at(-1)?.split("?")[0] ?? "font"
+    const urlParts = url.split('/')
+    const fileName = urlParts.at(-1)?.split('?')[0] ?? 'font'
     const content = await downloadFontFile(url)
 
     fontFiles.push({ name: fileName, content })
@@ -334,27 +334,27 @@ async function selfHostFonts(
  * }
  */
 export function fontPlugin(config: FontConfig = {}): Plugin {
-  const display = config.display ?? "swap"
+  const display = config.display ?? 'swap'
   const shouldPreload = config.preload !== false
   const shouldSelfHost = config.selfHost !== false
   const googleFamilies = (config.google ?? []).map(resolveGoogleFont)
 
   let isBuild = false
-  let selfHostedCSS = ""
+  let selfHostedCSS = ''
   let selfHostedFontFiles: Array<{ name: string; content: Buffer }> = []
 
   return {
-    name: "pyreon-zero-fonts",
+    name: 'pyreon-zero-fonts',
 
     configResolved(resolvedConfig) {
-      isBuild = resolvedConfig.command === "build"
+      isBuild = resolvedConfig.command === 'build'
     },
 
     async buildStart() {
       if (isBuild && shouldSelfHost && googleFamilies.length > 0) {
         const cssUrl = googleFontsUrl(googleFamilies, display)
         try {
-          const result = await selfHostFonts(cssUrl, "assets/fonts")
+          const result = await selfHostFonts(cssUrl, 'assets/fonts')
           selfHostedCSS = result.css
           selfHostedFontFiles = result.fontFiles
         } catch {
@@ -367,7 +367,7 @@ export function fontPlugin(config: FontConfig = {}): Plugin {
       // Emit self-hosted font files as assets
       for (const file of selfHostedFontFiles) {
         this.emitFile({
-          type: "asset",
+          type: 'asset',
           fileName: `assets/fonts/${file.name}`,
           source: file.content,
         })
@@ -388,7 +388,7 @@ export function fontPlugin(config: FontConfig = {}): Plugin {
       collectLocalFontTags(tags, config, shouldPreload, display)
 
       if (tags.length === 0) return html
-      return html.replace("</head>", `${tags.join("\n")}\n</head>`)
+      return html.replace('</head>', `${tags.join('\n')}\n</head>`)
     },
   }
 }
@@ -408,8 +408,8 @@ function collectGoogleFontTags(
     tags.push(`<style>${opts.selfHostedCSS}</style>`)
     if (opts.shouldPreload) {
       for (const file of opts.selfHostedFontFiles.slice(0, opts.googleFamilies.length)) {
-        const ext = file.name.split(".").pop()
-        const type = ext === "woff2" ? "font/woff2" : "font/woff"
+        const ext = file.name.split('.').pop()
+        const type = ext === 'woff2' ? 'font/woff2' : 'font/woff'
         tags.push(
           `<link rel="preload" href="/assets/fonts/${file.name}" as="font" type="${type}" crossorigin>`,
         )
@@ -446,6 +446,6 @@ function collectLocalFontTags(
 export function fontVariables(families: Record<string, string>): string {
   const vars = Object.entries(families)
     .map(([key, value]) => `  --font-${key}: ${value};`)
-    .join("\n")
+    .join('\n')
   return `:root {\n${vars}\n}`
 }

package/src/fs-router.ts

@@ -1,4 +1,4 @@
-import type { FileRoute, RenderMode } from "./types"
+import type { FileRoute, RenderMode } from './types'
 
 // ─── File-system route conventions ──────────────────────────────────────────
 //
@@ -25,7 +25,7 @@ import type { FileRoute, RenderMode } from "./types"
 //   _loading    → loading component
 //   (group)     → route group (directory ignored in URL)
 
-const ROUTE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"]
+const ROUTE_EXTENSIONS = ['.tsx', '.jsx', '.ts', '.js']
 
 /**
  * Parse a set of file paths (relative to routes dir) into FileRoute objects.
@@ -33,7 +33,7 @@ const ROUTE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"]
  * @param files Array of file paths like ["index.tsx", "users/[id].tsx"]
  * @param defaultMode Default rendering mode from config
  */
-export function parseFileRoutes(files: string[], defaultMode: RenderMode = "ssr"): FileRoute[] {
+export function parseFileRoutes(files: string[], defaultMode: RenderMode = 'ssr'): FileRoute[] {
   return files
     .filter((f) => ROUTE_EXTENSIONS.some((ext) => f.endsWith(ext)))
     .map((filePath) => parseFilePath(filePath, defaultMode))
@@ -51,19 +51,19 @@ function parseFilePath(filePath: string, defaultMode: RenderMode): FileRoute {
   }
 
   const fileName = getFileName(route)
-  const isLayout = fileName === "_layout"
-  const isError = fileName === "_error"
-  const isLoading = fileName === "_loading"
-  const isCatchAll = route.includes("[...")
+  const isLayout = fileName === '_layout'
+  const isError = fileName === '_error'
+  const isLoading = fileName === '_loading'
+  const isCatchAll = route.includes('[...')
 
   // Get directory path (strip groups for consistent grouping)
-  const parts = route.split("/")
+  const parts = route.split('/')
   parts.pop() // remove filename
-  const dirPath = parts.filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/")
+  const dirPath = parts.filter((s) => !(s.startsWith('(') && s.endsWith(')'))).join('/')
 
   // Convert file path to URL pattern
   const urlPath = filePathToUrlPath(route)
-  const depth = urlPath === "/" ? 0 : urlPath.split("/").filter(Boolean).length
+  const depth = urlPath === '/' ? 0 : urlPath.split('/').filter(Boolean).length
 
   return {
     filePath,
@@ -91,18 +91,18 @@ function parseFilePath(filePath: string, defaultMode: RenderMode): FileRoute {
  *   "_layout"          → "/"              (layout marker)
  */
 export function filePathToUrlPath(filePath: string): string {
-  const segments = filePath.split("/")
+  const segments = filePath.split('/')
   const urlSegments: string[] = []
 
   for (const seg of segments) {
     // Skip route groups "(name)"
-    if (seg.startsWith("(") && seg.endsWith(")")) continue
+    if (seg.startsWith('(') && seg.endsWith(')')) continue
 
     // Skip special files
-    if (seg === "_layout" || seg === "_error" || seg === "_loading") continue
+    if (seg === '_layout' || seg === '_error' || seg === '_loading') continue
 
     // "index" maps to the parent path
-    if (seg === "index") continue
+    if (seg === 'index') continue
 
     // Catch-all: [...param] → :param*
     const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/)
@@ -121,8 +121,8 @@ export function filePathToUrlPath(filePath: string): string {
     urlSegments.push(seg)
   }
 
-  const path = `/${urlSegments.join("/")}`
-  return path || "/"
+  const path = `/${urlSegments.join('/')}`
+  return path || '/'
 }
 
 /** Sort routes: static before dynamic, catch-all last. */
@@ -132,16 +132,16 @@ function sortRoutes(a: FileRoute, b: FileRoute): number {
   // Layouts go first within same depth
   if (a.isLayout !== b.isLayout) return a.isLayout ? -1 : 1
   // Static segments before dynamic
-  const aDynamic = a.urlPath.includes(":")
-  const bDynamic = b.urlPath.includes(":")
+  const aDynamic = a.urlPath.includes(':')
+  const bDynamic = b.urlPath.includes(':')
   if (aDynamic !== bDynamic) return aDynamic ? 1 : -1
   // Alphabetical
   return a.urlPath.localeCompare(b.urlPath)
 }
 
 function getFileName(filePath: string): string {
-  const parts = filePath.split("/")
-  return parts[parts.length - 1] ?? ""
+  const parts = filePath.split('/')
+  return parts[parts.length - 1] ?? ''
 }
 
 // ─── Route generation (for Vite plugin) ─────────────────────────────────────
@@ -175,7 +175,7 @@ function getOrCreateChild(node: RouteNode, segment: string): RouteNode {
 function resolveNode(root: RouteNode, dirPath: string): RouteNode {
   let node = root
   if (dirPath) {
-    for (const segment of dirPath.split("/")) {
+    for (const segment of dirPath.split('/')) {
       node = getOrCreateChild(node, segment)
     }
   }
@@ -208,10 +208,10 @@ export function generateRouteModule(files: string[], routesDir: string): string
   const imports: string[] = []
   let importCounter = 0
 
-  function nextImport(filePath: string, exportName = "default"): string {
+  function nextImport(filePath: string, exportName = 'default'): string {
     const name = `_${importCounter++}`
     const fullPath = `${routesDir}/${filePath}`
-    if (exportName === "default") {
+    if (exportName === 'default') {
       imports.push(`import ${name} from "${fullPath}"`)
     } else {
       imports.push(`import { ${exportName} as ${name} } from "${fullPath}"`)
@@ -225,7 +225,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
     const opts: string[] = []
     if (loadingName) opts.push(`loading: ${loadingName}`)
     if (errorName) opts.push(`error: ${errorName}`)
-    const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : ""
+    const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : ''
     imports.push(`const ${name} = lazy(() => import("${fullPath}")${optsStr})`)
     return name
   }
@@ -260,7 +260,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
       props.push(`${indent}  errorComponent: ${mod}.error`)
     }
 
-    return `${indent}{\n${props.join(",\n")}\n${indent}}`
+    return `${indent}{\n${props.join(',\n')}\n${indent}}`
   }
 
   function wrapWithLayout(
@@ -271,7 +271,7 @@ export function generateRouteModule(files: string[], routesDir: string): string
   ): string {
     const layout = node.layout as FileRoute
     const layoutMod = nextModuleImport(layout.filePath)
-    const layoutComp = nextImport(layout.filePath, "layout")
+    const layoutComp = nextImport(layout.filePath, 'layout')
 
     const props: string[] = [
       `${indent}path: ${JSON.stringify(layout.urlPath)}`,
@@ -284,17 +284,17 @@ export function generateRouteModule(files: string[], routesDir: string): string
       props.push(`${indent}errorComponent: ${errorName}`)
     }
     if (children.length > 0) {
-      props.push(`${indent}children: [\n${children.join(",\n")}\n${indent}]`)
+      props.push(`${indent}children: [\n${children.join(',\n')}\n${indent}]`)
     }
 
-    return `${indent}{\n${props.map((p) => `  ${p}`).join(",\n")}\n${indent}}`
+    return `${indent}{\n${props.map((p) => `  ${p}`).join(',\n')}\n${indent}}`
   }
 
   /**
    * Generate route definitions for a tree node.
    */
   function generateNode(node: RouteNode, depth: number): string[] {
-    const indent = "  ".repeat(depth + 1)
+    const indent = '  '.repeat(depth + 1)
 
     const errorName = node.error ? nextImport(node.error.filePath) : undefined
     const loadingName = node.loading ? nextImport(node.loading.filePath) : undefined
@@ -320,9 +320,9 @@ export function generateRouteModule(files: string[], routesDir: string): string
 
   return [
     `import { lazy } from "@pyreon/router"`,
-    "",
+    '',
     ...imports,
-    "",
+    '',
     // Filter out undefined properties at runtime
     `function clean(routes) {`,
     `  return routes.map(r => {`,
@@ -332,11 +332,11 @@ export function generateRouteModule(files: string[], routesDir: string): string
     `    return c`,
     `  })`,
     `}`,
-    "",
+    '',
     `export const routes = clean([`,
-    routeDefs.join(",\n"),
+    routeDefs.join(',\n'),
     `])`,
-  ].join("\n")
+  ].join('\n')
 }
 
 /**
@@ -359,11 +359,11 @@ export function generateMiddlewareModule(files: string[], routesDir: string): st
 
   return [
     ...imports,
-    "",
+    '',
     `export const routeMiddleware = [`,
-    entries.join(",\n"),
+    entries.join(',\n'),
     `].filter(e => e.middleware)`,
-  ].join("\n")
+  ].join('\n')
 }
 
 /**
@@ -371,8 +371,8 @@ export function generateMiddlewareModule(files: string[], routesDir: string): st
  * Returns paths relative to the routes directory.
  */
 export async function scanRouteFiles(routesDir: string): Promise<string[]> {
-  const { readdir } = await import("node:fs/promises")
-  const { join, relative } = await import("node:path")
+  const { readdir } = await import('node:fs/promises')
+  const { join, relative } = await import('node:path')
 
   const files: string[] = []