olova 2.0.21 → 2.0.23

package/dist/index.d.ts

@@ -1,13 +1,86 @@
-import * as React from 'react';
-export { default as Link } from './Link.js';
-export { ReadonlyURLSearchParams, default as useSearchParams } from './useSearchParams.js';
-export { default as usePathname } from './usePathname.js';
-export { default as useParams, usePath } from './useParams.js';
-export { Metadata, Router, loadRoute, matchRoute } from './Router.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode } from 'react';
 
-declare const RouterContext: React.Context<{
+declare function useParams(): Record<string, string>;
+/**
+ * Returns the current pathname (without query string or hash)
+ * Similar to Next.js usePathname hook
+ */
+declare function usePathname(): string;
+/**
+ * A read-only interface for URLSearchParams
+ * Similar to Next.js useSearchParams hook
+ */
+interface ReadonlyURLSearchParams {
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string): boolean;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void;
+    toString(): string;
+    size: number;
+}
+/**
+ * Returns the current URL search parameters
+ * Similar to Next.js useSearchParams hook
+ *
+ * Example usage:
+ * const searchParams = useSearchParams();
+ * const query = searchParams.get('q'); // ?q=hello -> 'hello'
+ * const tags = searchParams.getAll('tag'); // ?tag=a&tag=b -> ['a', 'b']
+ */
+declare function useSearchParams(): ReadonlyURLSearchParams;
+declare function matchRoute(path: string): {
+    loader: any;
     params: Record<string, string>;
-    path: string;
-}>;
+    pattern: string;
+} | null;
+interface Metadata {
+    title?: string;
+    description?: string;
+    keywords?: string | string[];
+    openGraph?: {
+        title?: string;
+        description?: string;
+        url?: string;
+        siteName?: string;
+        images?: {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+        }[];
+        type?: string;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        images?: string[];
+    };
+    robots?: string;
+    canonical?: string;
+    jsonLd?: object | object[];
+}
+declare function loadRoute(path: string): Promise<{
+    module: any;
+    params: Record<string, string>;
+    metadata: Metadata | undefined;
+} | null>;
+interface RouterProps {
+    url?: string;
+    initialComponent?: React.ComponentType;
+    initialParams?: Record<string, string>;
+    onRouteChange?: (metadata: Metadata | undefined) => void;
+}
+declare function Router({ url, initialComponent, initialParams, onRouteChange }: RouterProps): react_jsx_runtime.JSX.Element;
+declare function Link({ href, children, ...props }: {
+    href: string;
+    children: ReactNode;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>): React.ReactElement;
 
-export { RouterContext };
+export { Link as L, type Metadata, Router as R, usePathname as a, useSearchParams as b, loadRoute as l, matchRoute as m, useParams as u };

package/dist/index.js

@@ -1,32 +1 @@
-import {
-  Link
-} from "./chunk-CYX762OE.js";
-import {
-  Router,
-  loadRoute,
-  matchRoute
-} from "./chunk-Y3CEUWVD.js";
-import {
-  useParams,
-  usePath
-} from "./chunk-K6EDUQDD.js";
-import {
-  RouterContext
-} from "./chunk-LOK5UEME.js";
-import {
-  usePathname
-} from "./chunk-XGX5YRJV.js";
-import {
-  useSearchParams
-} from "./chunk-NEMX72XA.js";
-export {
-  Link,
-  Router,
-  RouterContext,
-  loadRoute,
-  matchRoute,
-  useParams,
-  usePath,
-  usePathname,
-  useSearchParams
-};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/router.d.ts

@@ -0,0 +1,3 @@
+export { L as Link, Metadata, R as Router, l as loadRoute, m as matchRoute, u as useParams, a as usePathname, b as useSearchParams } from './index.js';
+import 'react/jsx-runtime';
+import 'react';

package/dist/{chunk-Y3CEUWVD.js → router.js}

@@ -1,25 +1,60 @@
-import {
-  RouterContext
-} from "./chunk-LOK5UEME.js";
-
-// Router.tsx
-import React, { useState, useEffect } from "react";
-import { routes } from "virtual:olova-routes";
-function parseMarkdown(md) {
-  return md.replace(/^### (.*$)/gim, "<h3>$1</h3>").replace(/^## (.*$)/gim, "<h2>$1</h2>").replace(/^# (.*$)/gim, "<h1>$1</h1>").replace(/\*\*\*(.*?)\*\*\*/g, "<strong><em>$1</em></strong>").replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>").replace(/\*(.*?)\*/g, "<em>$1</em>").replace(/```([\s\S]*?)```/g, "<pre><code>$1</code></pre>").replace(/`(.*?)`/g, "<code>$1</code>").replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>').replace(/\n\n/g, "</p><p>").replace(/\n/g, "<br>").replace(/^(.*)$/, "<p>$1</p>");
+// src/client/router.tsx
+import React, { useState, useEffect, createContext, useContext } from "react";
+import { routes } from "olova/routes";
+import { jsx } from "react/jsx-runtime";
+var RouterContext = createContext({ params: {}, path: "/" });
+function useParams() {
+  return useContext(RouterContext).params;
 }
-function HtmlContent({ html }) {
-  return React.createElement("div", {
-    dangerouslySetInnerHTML: { __html: html },
-    className: "olova-html-content"
+function usePathname() {
+  const [pathname, setPathname] = useState(() => {
+    if (typeof window === "undefined") return "/";
+    return window.location.pathname;
   });
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleNavigation = () => {
+      setPathname(window.location.pathname);
+    };
+    window.addEventListener("popstate", handleNavigation);
+    window.addEventListener("pushstate", handleNavigation);
+    return () => {
+      window.removeEventListener("popstate", handleNavigation);
+      window.removeEventListener("pushstate", handleNavigation);
+    };
+  }, []);
+  return pathname;
 }
-function MarkdownContent({ markdown }) {
-  const html = parseMarkdown(markdown);
-  return React.createElement("article", {
-    dangerouslySetInnerHTML: { __html: html },
-    className: "olova-markdown-content"
+function useSearchParams() {
+  const [searchParams, setSearchParams] = useState(() => {
+    if (typeof window === "undefined") return new URLSearchParams();
+    return new URLSearchParams(window.location.search);
   });
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleNavigation = () => {
+      setSearchParams(new URLSearchParams(window.location.search));
+    };
+    window.addEventListener("popstate", handleNavigation);
+    window.addEventListener("pushstate", handleNavigation);
+    return () => {
+      window.removeEventListener("popstate", handleNavigation);
+      window.removeEventListener("pushstate", handleNavigation);
+    };
+  }, []);
+  return {
+    get: (name) => searchParams.get(name),
+    getAll: (name) => searchParams.getAll(name),
+    has: (name) => searchParams.has(name),
+    keys: () => searchParams.keys(),
+    values: () => searchParams.values(),
+    entries: () => searchParams.entries(),
+    forEach: (callback) => searchParams.forEach(callback),
+    toString: () => searchParams.toString(),
+    get size() {
+      return Array.from(searchParams.keys()).length;
+    }
+  };
 }
 var normalizePath = (path) => {
   let p = path.split("?")[0].split("#")[0];
@@ -47,6 +82,22 @@ function matchRoute(path) {
   }
   return null;
 }
+function parseMarkdown(md) {
+  return md.replace(/^### (.*$)/gim, "<h3>$1</h3>").replace(/^## (.*$)/gim, "<h2>$1</h2>").replace(/^# (.*$)/gim, "<h1>$1</h1>").replace(/\*\*\*(.*?)\*\*\*/g, "<strong><em>$1</em></strong>").replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>").replace(/\*(.*?)\*/g, "<em>$1</em>").replace(/```([\s\S]*?)```/g, "<pre><code>$1</code></pre>").replace(/`(.*?)`/g, "<code>$1</code>").replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>').replace(/\n\n/g, "</p><p>").replace(/\n/g, "<br>").replace(/^(.*)$/, "<p>$1</p>");
+}
+function HtmlContent({ html }) {
+  return React.createElement("div", {
+    dangerouslySetInnerHTML: { __html: html },
+    className: "olova-html-content"
+  });
+}
+function MarkdownContent({ markdown }) {
+  const html = parseMarkdown(markdown);
+  return React.createElement("article", {
+    dangerouslySetInnerHTML: { __html: html },
+    className: "olova-markdown-content"
+  });
+}
 async function loadRoute(path) {
   const match = matchRoute(path);
   if (match) {
@@ -124,7 +175,7 @@ function Router({ url, initialComponent, initialParams, onRouteChange }) {
               onRouteChange(fallbackResult.metadata);
             }
           } else {
-            setComponent(() => () => React.createElement("div", null, "404 Not Found"));
+            setComponent(() => () => /* @__PURE__ */ jsx("div", { children: "404 Not Found" }));
             setParams({});
             if (onRouteChange) {
               onRouteChange(void 0);
@@ -138,16 +189,29 @@ function Router({ url, initialComponent, initialParams, onRouteChange }) {
       isCancelled = true;
     };
   }, [path, onRouteChange]);
-  if (!Component) return React.createElement("div", null, "Loading...");
-  return React.createElement(
-    RouterContext.Provider,
-    { value: { params, path } },
-    React.createElement(Component, params)
-  );
+  if (!Component) return /* @__PURE__ */ jsx("div", { children: "Loading..." });
+  return /* @__PURE__ */ jsx(RouterContext.Provider, { value: { params, path }, children: /* @__PURE__ */ jsx(Component, { ...params }) });
+}
+function Link({ href, children, ...props }) {
+  const handleClick = (e) => {
+    if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+    if (href.startsWith("http") || href.startsWith("//")) return;
+    e.preventDefault();
+    const currentUrl = window.location.pathname + window.location.search;
+    const targetUrl = href.startsWith("/") ? href : "/" + href;
+    if (currentUrl === targetUrl) return;
+    window.history.pushState({}, "", href);
+    window.dispatchEvent(new Event("pushstate"));
+  };
+  return /* @__PURE__ */ jsx("a", { href, onClick: handleClick, ...props, children });
 }
-
 export {
-  matchRoute,
+  Link,
+  Router,
   loadRoute,
-  Router
+  matchRoute,
+  useParams,
+  usePathname,
+  useSearchParams
 };
+//# sourceMappingURL=router.js.map

package/dist/router.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/router.tsx"],"sourcesContent":["import React, { useState, useEffect, createContext, useContext, type ReactNode } from 'react';\n\n// @ts-ignore\nimport { routes } from 'olova/routes';\n\nconst RouterContext = createContext<{ params: Record<string, string>, path: string }>({ params: {}, path: '/' });\n\nexport function useParams() {\n    return useContext(RouterContext).params;\n}\n\nexport function usePath() {\n    return useContext(RouterContext).path;\n}\n\n/**\n * Returns the current pathname (without query string or hash)\n * Similar to Next.js usePathname hook\n */\nexport function usePathname(): string {\n    const [pathname, setPathname] = useState(() => {\n        if (typeof window === 'undefined') return '/';\n        return window.location.pathname;\n    });\n\n    useEffect(() => {\n        if (typeof window === 'undefined') return;\n\n        const handleNavigation = () => {\n            setPathname(window.location.pathname);\n        };\n\n        window.addEventListener('popstate', handleNavigation);\n        window.addEventListener('pushstate', handleNavigation);\n\n        return () => {\n            window.removeEventListener('popstate', handleNavigation);\n            window.removeEventListener('pushstate', handleNavigation);\n        };\n    }, []);\n\n    return pathname;\n}\n\n/**\n * A read-only interface for URLSearchParams\n * Similar to Next.js useSearchParams hook\n */\ninterface ReadonlyURLSearchParams {\n    get(name: string): string | null;\n    getAll(name: string): string[];\n    has(name: string): boolean;\n    keys(): IterableIterator<string>;\n    values(): IterableIterator<string>;\n    entries(): IterableIterator<[string, string]>;\n    forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void;\n    toString(): string;\n    size: number;\n}\n\n/**\n * Returns the current URL search parameters\n * Similar to Next.js useSearchParams hook\n * \n * Example usage:\n * const searchParams = useSearchParams();\n * const query = searchParams.get('q'); // ?q=hello -> 'hello'\n * const tags = searchParams.getAll('tag'); // ?tag=a&tag=b -> ['a', 'b']\n */\nexport function useSearchParams(): ReadonlyURLSearchParams {\n    const [searchParams, setSearchParams] = useState<URLSearchParams>(() => {\n        if (typeof window === 'undefined') return new URLSearchParams();\n        return new URLSearchParams(window.location.search);\n    });\n\n    useEffect(() => {\n        if (typeof window === 'undefined') return;\n\n        const handleNavigation = () => {\n            setSearchParams(new URLSearchParams(window.location.search));\n        };\n\n        window.addEventListener('popstate', handleNavigation);\n        window.addEventListener('pushstate', handleNavigation);\n\n        return () => {\n            window.removeEventListener('popstate', handleNavigation);\n            window.removeEventListener('pushstate', handleNavigation);\n        };\n    }, []);\n\n    // Return a readonly interface that wraps URLSearchParams\n    return {\n        get: (name: string) => searchParams.get(name),\n        getAll: (name: string) => searchParams.getAll(name),\n        has: (name: string) => searchParams.has(name),\n        keys: () => searchParams.keys(),\n        values: () => searchParams.values(),\n        entries: () => searchParams.entries(),\n        forEach: (callback) => searchParams.forEach(callback),\n        toString: () => searchParams.toString(),\n        get size() { return Array.from(searchParams.keys()).length; }\n    };\n}\n\n// Helper to normalize paths\nconst normalizePath = (path: string) => {\n    let p = path.split('?')[0].split('#')[0];\n    if (p.length > 1 && p.endsWith('/')) p = p.slice(0, -1);\n    return p || '/';\n};\n\n// Route matching with param extraction\nexport function matchRoute(path: string) {\n    const normalizedPath = normalizePath(path);\n    const routeKeys = Object.keys(routes);\n    \n    for (const route of routeKeys) {\n        // Handle exact match first\n        if (route === normalizedPath) {\n            return { loader: routes[route], params: {}, pattern: route };\n        }\n        \n        // Convert :param and $param to regex group\n        const regexPath = route\n            .replace(/:[^\\/]+/g, '([^/]+)')\n            .replace(/\\$[^\\/]+/g, '([^/]+)');\n            \n        const regex = new RegExp(`^${regexPath}$`);\n        const match = normalizedPath.match(regex);\n        \n        if (match) {\n            const params: Record<string, string> = {};\n            const paramNames = (route.match(/[:$][^\\/]+/g) || []).map(s => s.slice(1));\n            paramNames.forEach((name, i) => {\n                params[name] = match[i + 1];\n            });\n            return { loader: routes[route], params, pattern: route };\n        }\n    }\n    return null;\n}\n\n// Metadata type - like Next.js\nexport interface Metadata {\n    title?: string;\n    description?: string;\n    keywords?: string | string[];\n    openGraph?: {\n        title?: string;\n        description?: string;\n        url?: string;\n        siteName?: string;\n        images?: { url: string; width?: number; height?: number; alt?: string }[];\n        type?: string;\n    };\n    twitter?: {\n        card?: 'summary' | 'summary_large_image' | 'app' | 'player';\n        site?: string;\n        creator?: string;\n        title?: string;\n        description?: string;\n        images?: string[];\n    };\n    robots?: string;\n    canonical?: string;\n    jsonLd?: object | object[];\n}\n\n// Simple markdown to HTML converter (basic support)\nfunction parseMarkdown(md: string): string {\n    return md\n        // Headers\n        .replace(/^### (.*$)/gim, '<h3>$1</h3>')\n        .replace(/^## (.*$)/gim, '<h2>$1</h2>')\n        .replace(/^# (.*$)/gim, '<h1>$1</h1>')\n        // Bold and italic\n        .replace(/\\*\\*\\*(.*?)\\*\\*\\*/g, '<strong><em>$1</em></strong>')\n        .replace(/\\*\\*(.*?)\\*\\*/g, '<strong>$1</strong>')\n        .replace(/\\*(.*?)\\*/g, '<em>$1</em>')\n        // Code blocks\n        .replace(/```([\\s\\S]*?)```/g, '<pre><code>$1</code></pre>')\n        .replace(/`(.*?)`/g, '<code>$1</code>')\n        // Links\n        .replace(/\\[([^\\]]+)\\]\\(([^)]+)\\)/g, '<a href=\"$2\">$1</a>')\n        // Line breaks and paragraphs\n        .replace(/\\n\\n/g, '</p><p>')\n        .replace(/\\n/g, '<br>')\n        // Wrap in paragraph\n        .replace(/^(.*)$/, '<p>$1</p>');\n}\n\n// React component for rendering HTML content\nfunction HtmlContent({ html }: { html: string }) {\n    return React.createElement('div', { \n        dangerouslySetInnerHTML: { __html: html },\n        className: 'olova-html-content'\n    });\n}\n\n// React component for rendering Markdown content\nfunction MarkdownContent({ markdown }: { markdown: string }) {\n    const html = parseMarkdown(markdown);\n    return React.createElement('article', { \n        dangerouslySetInnerHTML: { __html: html },\n        className: 'olova-markdown-content'\n    });\n}\n\nexport async function loadRoute(path: string) {\n    const match = matchRoute(path);\n    if (match) {\n        console.log(`[Router] Loading route: ${path} (pattern: ${match.pattern})`);\n        const module = await match.loader();\n        \n        // Handle HTML files\n        if (module.__isHtml) {\n            return { \n                module: {\n                    default: () => HtmlContent({ html: module.__rawHtml }),\n                },\n                params: match.params,\n                metadata: undefined\n            };\n        }\n        \n        // Handle Markdown files\n        if (module.__isMd) {\n            return { \n                module: {\n                    default: () => MarkdownContent({ markdown: module.default }),\n                },\n                params: match.params,\n                metadata: undefined\n            };\n        }\n        \n        return { \n           module,\n           params: match.params,\n           metadata: module.metadata as Metadata | undefined\n        };\n    }\n    console.warn(`[Router] No match for: ${path}`);\n    return null;\n}\n\ninterface RouterProps {\n    url?: string;\n    initialComponent?: React.ComponentType;\n    initialParams?: Record<string, string>;\n    onRouteChange?: (metadata: Metadata | undefined) => void;\n}\n\nexport function Router({ url, initialComponent, initialParams, onRouteChange }: RouterProps) {\n    const [path, setPath] = useState(() => normalizePath(url || (typeof window !== 'undefined' ? window.location.pathname : '/')));\n    const [Component, setComponent] = useState<React.ComponentType | null>(() => initialComponent || null);\n    const [params, setParams] = useState<Record<string, string>>(() => initialParams || {});\n    const hasHydrated = React.useRef(false);\n\n    useEffect(() => {\n        if (typeof window === 'undefined') return;\n\n        const handleNavigation = () => {\n            const newPath = normalizePath(window.location.pathname);\n            console.log(`[Router] Navigation event: ${newPath}`);\n            setPath(newPath);\n        };\n\n        window.addEventListener('popstate', handleNavigation);\n        window.addEventListener('pushstate', handleNavigation);\n\n        return () => {\n            window.removeEventListener('popstate', handleNavigation);\n            window.removeEventListener('pushstate', handleNavigation);\n        };\n    }, []);\n\n    useEffect(() => {\n        // Skip loading on mount if we already have the initial component for the current path\n        if (!hasHydrated.current && initialComponent && path === normalizePath(url || '')) {\n            console.log(`[Router] Hydration skipped for: ${path}`);\n            hasHydrated.current = true;\n            return;\n        }\n\n        let isCancelled = false;\n        const load = async () => {\n            const result = await loadRoute(path);\n            if (!isCancelled) {\n                if (result) {\n                    setComponent(() => result.module.default);\n                    setParams(result.params);\n                    // Call onRouteChange with new metadata for SEO updates\n                    if (onRouteChange) {\n                        onRouteChange(result.metadata);\n                    }\n                } else {\n                    // Try to load custom 404 page\n                    const fallbackResult = await loadRoute('/404');\n                    if (fallbackResult) {\n                        console.log('[Router] Serving custom 404 page');\n                        setComponent(() => fallbackResult.module.default);\n                        setParams(fallbackResult.params);\n                        if (onRouteChange) {\n                            onRouteChange(fallbackResult.metadata);\n                        }\n                    } else {\n                        // Default 404 if no custom page exists\n                        setComponent(() => () => <div>404 Not Found</div>);\n                        setParams({});\n                        if (onRouteChange) {\n                            onRouteChange(undefined);\n                        }\n                    }\n                }\n            }\n        };\n\n        load();\n        return () => { isCancelled = true; };\n    }, [path, onRouteChange]);\n\n    if (!Component) return <div>Loading...</div>;\n    \n    return (\n        <RouterContext.Provider value={{ params, path }}>\n            <Component {...params} />\n        </RouterContext.Provider>\n    );\n}\n\n// Link component - always uses SPA navigation (like Next.js)\n// Pre-rendered HTML is only for initial page load and SEO crawlers\nexport function Link({ href, children, ...props }: { href: string, children: ReactNode } & React.AnchorHTMLAttributes<HTMLAnchorElement>): React.ReactElement {\n    const handleClick = (e: React.MouseEvent<HTMLAnchorElement>) => {\n        // Allow modifier keys for new tab, etc.\n        if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;\n        // Allow external links\n        if (href.startsWith('http') || href.startsWith('//')) return;\n\n        e.preventDefault();\n        \n        // Compare full URLs (including query strings) to allow search param changes\n        const currentUrl = window.location.pathname + window.location.search;\n        const targetUrl = href.startsWith('/') ? href : '/' + href;\n        \n        if (currentUrl === targetUrl) return;\n        \n        // SPA navigation - no page reload\n        window.history.pushState({}, '', href);\n        window.dispatchEvent(new Event('pushstate'));\n    };\n\n    return (\n        <a href={href} onClick={handleClick} {...props}>\n            {children}\n        </a>\n    );\n}"],"mappings":"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","names":[]}

package/dist/routes.d.ts

@@ -0,0 +1,3 @@
+declare const routes: Record<string, () => Promise<any>>;
+
+export { routes };

package/dist/routes.js

@@ -0,0 +1,6 @@
+// src/routes.ts
+var routes = {};
+export {
+  routes
+};
+//# sourceMappingURL=routes.js.map

package/dist/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routes.ts"],"sourcesContent":["// Stub for the virtual routes module - actual routes are injected by the router plugin at build time\r\n// This is externalized so the import resolves to 'olova/routes' in user projects\r\nexport const routes: Record<string, () => Promise<any>> = {};\r\n"],"mappings":";AAEO,IAAM,SAA6C,CAAC;","names":[]}

package/dist/vite.d.ts

@@ -0,0 +1,100 @@
+import { Plugin } from 'vite';
+
+declare function olovaPlugins(): Plugin[];
+
+declare function minifyHtml(html: string): string;
+declare function generateBuildId(): string;
+declare function generateResourceHints(): string;
+declare function generateCriticalCSS(): string;
+declare function generateServiceWorkerScript(): string;
+declare function generateServiceWorkerContent(buildId: string, assets: string[]): string;
+declare function generatePerformanceMeta(): string;
+
+interface OlovaHydrationData {
+    route: string;
+    metadata?: Record<string, unknown>;
+    params?: Record<string, string>;
+    chunks?: string[];
+    isStatic?: boolean;
+}
+declare function generateOlovaHydration(data: OlovaHydrationData, buildId: string): string;
+/**
+ * Generate JSON-LD structured data script for SEO
+ * This is injected into <head> for search engine crawlers
+ */
+declare function generateJsonLd(data: OlovaHydrationData): string;
+/**
+ * Parse flight data from the page (client-side utility)
+ * Use this to access hydration data in your components
+ */
+declare function parseFlightData(): Record<string, unknown> | null;
+
+declare const colors: {
+    reset: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    underline: string;
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    bgBlack: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+    bgBlue: string;
+    bgMagenta: string;
+    bgCyan: string;
+    bgWhite: string;
+};
+declare const symbols: {
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    arrow: string;
+    arrowRight: string;
+    bullet: string;
+    filled: string;
+    lambda: string;
+    triangle: string;
+    square: string;
+    diamond: string;
+    star: string;
+    check: string;
+    cross: string;
+    pointer: string;
+};
+declare function formatTime(ms: number): string;
+declare function formatBytes(bytes: number): string;
+declare const logger: {
+    banner: (name: string, version?: string) => void;
+    header: (text: string) => void;
+    info: (text: string) => void;
+    success: (text: string, time?: number) => void;
+    error: (text: string) => void;
+    warn: (text: string) => void;
+    step: (text: string, time?: number) => void;
+    route: (route: string, type: "static" | "ssr" | "isr", size?: number, time?: number) => void;
+    indent: (text: string, level?: number) => void;
+    newline: () => void;
+    dim: (text: string) => string;
+    bold: (text: string) => string;
+    cyan: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magenta: (text: string) => string;
+};
+declare function createTimer(): {
+    elapsed: () => number;
+    format: () => string;
+};
+
+export { type OlovaHydrationData, colors, createTimer, formatBytes, formatTime, generateBuildId, generateCriticalCSS, generateJsonLd, generateOlovaHydration, generatePerformanceMeta, generateResourceHints, generateServiceWorkerContent, generateServiceWorkerScript, logger, minifyHtml, olovaPlugins, parseFlightData, symbols };