@zenithbuild/router 1.0.1

package/src/runtime.ts

@@ -0,0 +1,163 @@
+/**
+ * Zenith Runtime Router (Native Bridge)
+ * 
+ * SPA-style client-side router with SSR support via native resolution.
+ */
+
+// @ts-ignore
+import native from "../index.js"
+import type {
+  RouteState,
+  NavigateOptions,
+  RouteRecord,
+  PageModule,
+  RuntimeRouteRecord,
+  RouteListener
+} from "./types"
+
+const { resolveRouteNative, generateRuntimeRouterNative } = native
+
+let currentRoute: RouteState = {
+  path: "/",
+  params: {},
+  query: {}
+}
+
+const routeListeners: Set<RouteListener> = new Set()
+let routeManifest: RuntimeRouteRecord[] = []
+let routerOutlet: HTMLElement | null = null
+
+export function initRouter(
+  manifest: RuntimeRouteRecord[],
+  outlet?: HTMLElement | string
+): void {
+  routeManifest = manifest
+  if (outlet) {
+    routerOutlet = typeof outlet === "string" ? document.querySelector(outlet) : outlet
+  }
+  window.addEventListener("popstate", handlePopState)
+  resolveAndRender(window.location.pathname, parseQueryString(window.location.search), false)
+}
+
+function parseQueryString(search: string): Record<string, string> {
+  const query: Record<string, string> = {}
+  if (!search || search === "?") return query
+  const params = new URLSearchParams(search)
+  params.forEach((value, key) => { query[key] = value; })
+  return query
+}
+
+function handlePopState(_event: PopStateEvent): void {
+  resolveAndRender(window.location.pathname, parseQueryString(window.location.search), false, false)
+}
+
+/**
+ * Resolve route - uses native implementation if available (Node.js/SSR)
+ * or falls back to JS implementation for the browser.
+ */
+export function resolveRoute(
+  pathname: string
+): { record: RuntimeRouteRecord; params: Record<string, string> } | null {
+  if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+    // SSR / Node environment
+    const resolved = resolveRouteNative(pathname, routeManifest as any)
+    if (!resolved) return null
+    return {
+      record: resolved.matched as unknown as RuntimeRouteRecord,
+      params: resolved.params
+    }
+  }
+
+  // Client-side fallback implementation
+  const normalizedPath = pathname === "" ? "/" : pathname
+  for (const route of routeManifest) {
+    const match = route.regex.exec(normalizedPath)
+    if (match) {
+      const params: Record<string, string> = {}
+      for (let i = 0; i < route.paramNames.length; i++) {
+        const paramName = route.paramNames[i]
+        const paramValue = match[i + 1]
+        if (paramName && paramValue !== undefined) {
+          params[paramName] = decodeURIComponent(paramValue)
+        }
+      }
+      return { record: route, params }
+    }
+  }
+  return null
+}
+
+async function resolveAndRender(
+  path: string,
+  query: Record<string, string>,
+  updateHistory: boolean = true,
+  replace: boolean = false
+): Promise<void> {
+  const prevRoute = { ...currentRoute }
+  const resolved = resolveRoute(path)
+
+  if (resolved) {
+    currentRoute = {
+      path,
+      params: resolved.params,
+      query,
+      matched: resolved.record as unknown as RouteRecord
+    }
+    const pageModule = resolved.record.module || (resolved.record.load ? await resolved.record.load() : null)
+    if (pageModule) await renderPage(pageModule)
+  } else {
+    currentRoute = { path, params: {}, query, matched: undefined }
+  }
+
+  if (updateHistory) {
+    const url = path + (Object.keys(query).length > 0 ? "?" + new URLSearchParams(query).toString() : "")
+    if (replace) window.history.replaceState(null, "", url)
+    else window.history.pushState(null, "", url)
+  }
+  notifyListeners(currentRoute, prevRoute)
+    ; (window as any).__zenith_route = currentRoute
+}
+
+async function renderPage(pageModule: PageModule): Promise<void> {
+  if (!routerOutlet) return
+  routerOutlet.innerHTML = pageModule.html
+  // ... logic for styles and scripts
+}
+
+function notifyListeners(route: RouteState, prevRoute: RouteState): void {
+  routeListeners.forEach(listener => { listener(route, prevRoute) })
+}
+
+export async function navigate(to: string, options: NavigateOptions = {}): Promise<void> {
+  let path, query: Record<string, string> = {}
+  if (to.includes("?")) {
+    const [pathname, search] = to.split("?")
+    path = pathname || "/"
+    query = parseQueryString("?" + (search || ""))
+  } else path = to
+
+  await resolveAndRender(path, query, true, options.replace || false)
+}
+
+export function getRoute(): RouteState { return { ...currentRoute } }
+export function onRouteChange(listener: RouteListener): () => void {
+  routeListeners.add(listener)
+  return () => { routeListeners.delete(listener) }
+}
+
+export function isActive(path: string, exact: boolean = false): boolean {
+  return exact ? currentRoute.path === path : currentRoute.path.startsWith(path)
+}
+
+export async function prefetch(path: string): Promise<void> {
+  const resolved = resolveRoute(path)
+  if (resolved && resolved.record.load && !resolved.record.module) {
+    resolved.record.module = await resolved.record.load()
+  }
+}
+
+export function isPrefetched(_path: string): boolean { return false }
+
+export function generateRuntimeRouterCode(): string {
+  return generateRuntimeRouterNative()
+}

package/src/runtime_gen.rs

@@ -0,0 +1,14 @@
+use napi_derive::napi;
+
+#[napi]
+pub fn generate_runtime_router_native() -> String {
+    format!(
+        r#"
+(function() {{
+  'use strict';
+  // Zenith Native Router Runtime
+  // ... (Full implementation would go here)
+}})();
+"#
+    )
+}

package/src/types.rs

@@ -0,0 +1,46 @@
+use napi_derive::napi;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[napi]
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SegmentType {
+    Static,
+    Dynamic,
+    CatchAll,
+    OptionalCatchAll,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[napi(object)]
+pub struct ParsedSegment {
+    pub segment_type: SegmentType,
+    pub param_name: Option<String>,
+    pub raw: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[napi(object)]
+pub struct RouteRecord {
+    pub path: String,
+    pub regex: String,
+    pub param_names: Vec<String>,
+    pub score: i32,
+    pub file_path: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[napi(object)]
+pub struct RouteState {
+    pub path: String,
+    pub params: HashMap<String, String>,
+    pub query: HashMap<String, String>,
+    pub matched: Option<RouteRecord>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[napi(object)]
+pub struct RouteManifest {
+    pub routes: Vec<RouteRecord>,
+    pub generated_at: i64,
+}

package/src/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Zenith Router Types
+ * 
+ * Re-exports types from the native Rust implementation.
+ */
+
+import {
+    RouteRecord as NativeRouteRecord,
+    RouteState as NativeRouteState,
+    RouteManifest as NativeRouteManifest,
+    SegmentType as NativeSegmentType,
+    ParsedSegment as NativeParsedSegment
+} from "../index.js"
+
+export { NativeSegmentType as SegmentType }
+
+export interface RouteRecord extends Omit<NativeRouteRecord, 'regex'> {
+    regex: RegExp
+}
+
+export interface RouteState extends Omit<NativeRouteState, 'matched'> {
+    matched?: RouteRecord
+}
+
+export interface RouteManifest extends Omit<NativeRouteManifest, 'routes'> {
+    routes: RouteRecord[]
+}
+
+export interface ParsedSegment extends NativeParsedSegment { }
+
+export interface PageModule {
+    html: string
+    scripts: string[]
+    styles: string[]
+    meta?: PageMeta
+}
+
+export interface PageMeta {
+    title?: string
+    description?: string
+    [key: string]: string | undefined
+}
+
+export interface NavigateOptions {
+    replace?: boolean
+    scrollToTop?: boolean
+    state?: Record<string, unknown>
+}
+
+export interface RouteDefinition extends RouteRecord { }
+
+export interface RuntimeRouteRecord extends RouteRecord {
+    module?: PageModule | null;
+    load?: () => Promise<PageModule>;
+}
+
+export type RouteListener = (route: RouteState, prevRoute: RouteState) => void;
+
+export interface Router {
+    readonly route: RouteState
+    navigate(to: string, options?: NavigateOptions): Promise<void>
+    resolve(path: string): { record: RouteRecord; params: Record<string, string> } | null
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "declaration": true,
+        "declarationMap": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "lib": [
+            "ES2022",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "types": [
+            "bun-types",
+            "node"
+        ]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}