olova 2.0.17 → 2.0.19

package/dist/Link.d.ts

@@ -0,0 +1,8 @@
+import React__default, { ReactNode } from 'react';
+
+declare function Link({ href, children, ...props }: {
+    href: string;
+    children: ReactNode;
+} & React__default.AnchorHTMLAttributes<HTMLAnchorElement>): React__default.ReactElement;
+
+export { Link, Link as default };

package/dist/Link.js

@@ -0,0 +1,8 @@
+import {
+  Link,
+  Link_default
+} from "./chunk-CYX762OE.js";
+export {
+  Link,
+  Link_default as default
+};

package/dist/Router.d.ts

@@ -0,0 +1,53 @@
+import React__default from 'react';
+
+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 matchRoute(path: string): {
+    loader: any;
+    params: Record<string, string>;
+    pattern: string;
+} | null;
+declare function loadRoute(path: string): Promise<{
+    module: any;
+    params: Record<string, string>;
+    metadata: Metadata | undefined;
+} | null>;
+interface RouterProps {
+    url?: string;
+    initialComponent?: React__default.ComponentType;
+    initialParams?: Record<string, string>;
+    onRouteChange?: (metadata: Metadata | undefined) => void;
+}
+declare function Router({ url, initialComponent, initialParams, onRouteChange }: RouterProps): React__default.DetailedReactHTMLElement<React__default.HTMLAttributes<HTMLElement>, HTMLElement> | React__default.FunctionComponentElement<React__default.ProviderProps<{
+    params: Record<string, string>;
+    path: string;
+}>>;
+
+export { type Metadata, Router, loadRoute, matchRoute };

package/dist/Router.js

@@ -0,0 +1,11 @@
+import {
+  Router,
+  loadRoute,
+  matchRoute
+} from "./chunk-Y3CEUWVD.js";
+import "./chunk-LOK5UEME.js";
+export {
+  Router,
+  loadRoute,
+  matchRoute
+};

package/dist/chunk-CYX762OE.js

@@ -0,0 +1,21 @@
+// Link.tsx
+import { jsx } from "react/jsx-runtime";
+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 });
+}
+var Link_default = Link;
+
+export {
+  Link,
+  Link_default
+};

package/dist/chunk-K6EDUQDD.js

@@ -0,0 +1,19 @@
+import {
+  RouterContext
+} from "./chunk-LOK5UEME.js";
+
+// useParams.ts
+import { useContext } from "react";
+function useParams() {
+  return useContext(RouterContext).params;
+}
+function usePath() {
+  return useContext(RouterContext).path;
+}
+var useParams_default = useParams;
+
+export {
+  useParams,
+  usePath,
+  useParams_default
+};

package/dist/chunk-LOK5UEME.js

@@ -0,0 +1,7 @@
+// context.ts
+import { createContext } from "react";
+var RouterContext = createContext({ params: {}, path: "/" });
+
+export {
+  RouterContext
+};

package/dist/chunk-NEMX72XA.js

@@ -0,0 +1,39 @@
+// useSearchParams.ts
+import { useState, useEffect } from "react";
+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 useSearchParams_default = useSearchParams;
+
+export {
+  useSearchParams,
+  useSearchParams_default
+};

package/dist/chunk-XGX5YRJV.js

@@ -0,0 +1,27 @@
+// usePathname.ts
+import { useState, useEffect } from "react";
+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;
+}
+var usePathname_default = usePathname;
+
+export {
+  usePathname,
+  usePathname_default
+};

package/dist/chunk-Y3CEUWVD.js

@@ -0,0 +1,153 @@
+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>");
+}
+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"
+  });
+}
+var normalizePath = (path) => {
+  let p = path.split("?")[0].split("#")[0];
+  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p || "/";
+};
+function matchRoute(path) {
+  const normalizedPath = normalizePath(path);
+  const routeKeys = Object.keys(routes);
+  for (const route of routeKeys) {
+    if (route === normalizedPath) {
+      return { loader: routes[route], params: {}, pattern: route };
+    }
+    const regexPath = route.replace(/:[^\/]+/g, "([^/]+)").replace(/\$[^\/]+/g, "([^/]+)");
+    const regex = new RegExp(`^${regexPath}$`);
+    const match = normalizedPath.match(regex);
+    if (match) {
+      const params = {};
+      const paramNames = (route.match(/[:$][^\/]+/g) || []).map((s) => s.slice(1));
+      paramNames.forEach((name, i) => {
+        params[name] = match[i + 1];
+      });
+      return { loader: routes[route], params, pattern: route };
+    }
+  }
+  return null;
+}
+async function loadRoute(path) {
+  const match = matchRoute(path);
+  if (match) {
+    console.log(`[Router] Loading route: ${path} (pattern: ${match.pattern})`);
+    const module = await match.loader();
+    if (module.__isHtml) {
+      return {
+        module: {
+          default: () => HtmlContent({ html: module.__rawHtml })
+        },
+        params: match.params,
+        metadata: void 0
+      };
+    }
+    if (module.__isMd) {
+      return {
+        module: {
+          default: () => MarkdownContent({ markdown: module.default })
+        },
+        params: match.params,
+        metadata: void 0
+      };
+    }
+    return {
+      module,
+      params: match.params,
+      metadata: module.metadata
+    };
+  }
+  console.warn(`[Router] No match for: ${path}`);
+  return null;
+}
+function Router({ url, initialComponent, initialParams, onRouteChange }) {
+  const [path, setPath] = useState(() => normalizePath(url || (typeof window !== "undefined" ? window.location.pathname : "/")));
+  const [Component, setComponent] = useState(() => initialComponent || null);
+  const [params, setParams] = useState(() => initialParams || {});
+  const hasHydrated = React.useRef(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleNavigation = () => {
+      const newPath = normalizePath(window.location.pathname);
+      console.log(`[Router] Navigation event: ${newPath}`);
+      setPath(newPath);
+    };
+    window.addEventListener("popstate", handleNavigation);
+    window.addEventListener("pushstate", handleNavigation);
+    return () => {
+      window.removeEventListener("popstate", handleNavigation);
+      window.removeEventListener("pushstate", handleNavigation);
+    };
+  }, []);
+  useEffect(() => {
+    if (!hasHydrated.current && initialComponent && path === normalizePath(url || "")) {
+      console.log(`[Router] Hydration skipped for: ${path}`);
+      hasHydrated.current = true;
+      return;
+    }
+    let isCancelled = false;
+    const load = async () => {
+      const result = await loadRoute(path);
+      if (!isCancelled) {
+        if (result) {
+          setComponent(() => result.module.default);
+          setParams(result.params);
+          if (onRouteChange) {
+            onRouteChange(result.metadata);
+          }
+        } else {
+          const fallbackResult = await loadRoute("/404");
+          if (fallbackResult) {
+            console.log("[Router] Serving custom 404 page");
+            setComponent(() => fallbackResult.module.default);
+            setParams(fallbackResult.params);
+            if (onRouteChange) {
+              onRouteChange(fallbackResult.metadata);
+            }
+          } else {
+            setComponent(() => () => React.createElement("div", null, "404 Not Found"));
+            setParams({});
+            if (onRouteChange) {
+              onRouteChange(void 0);
+            }
+          }
+        }
+      }
+    };
+    load();
+    return () => {
+      isCancelled = true;
+    };
+  }, [path, onRouteChange]);
+  if (!Component) return React.createElement("div", null, "Loading...");
+  return React.createElement(
+    RouterContext.Provider,
+    { value: { params, path } },
+    React.createElement(Component, params)
+  );
+}
+
+export {
+  matchRoute,
+  loadRoute,
+  Router
+};

package/dist/client.d.ts

@@ -0,0 +1,5 @@
+import React__default from 'react';
+
+declare function hydrate(RootLayout?: React__default.ComponentType<any>): Promise<void>;
+
+export { hydrate };

package/dist/client.js

@@ -0,0 +1,72 @@
+import {
+  Router,
+  loadRoute
+} from "./chunk-Y3CEUWVD.js";
+import "./chunk-LOK5UEME.js";
+
+// client.tsx
+import React from "react";
+import { hydrateRoot, createRoot } from "react-dom/client";
+async function hydrate(RootLayout) {
+  const hydrationData = window.__OLOVA_DATA__;
+  const url = window.location.pathname;
+  let Component;
+  let params = {};
+  if (hydrationData) {
+    const result = await loadRoute(url);
+    if (result) {
+      Component = result.module.default;
+      params = hydrationData.params;
+    }
+  }
+  if (!Component) {
+    const result = await loadRoute(url);
+    if (result) {
+      Component = result.module.default;
+      params = result.params;
+    } else {
+      const fallback = await loadRoute("/404");
+      if (fallback) {
+        Component = fallback.module.default;
+        params = fallback.params;
+      } else {
+        Component = () => React.createElement("div", null, "404 Not Found");
+      }
+    }
+  }
+  if (RootLayout) {
+    const App = React.createElement(
+      RootLayout,
+      null,
+      React.createElement(Router, {
+        url,
+        initialComponent: Component,
+        initialParams: params
+      })
+    );
+    if (hydrationData) {
+      hydrateRoot(document, App);
+    } else {
+      createRoot(document).render(App);
+    }
+  } else {
+    const root = document.getElementById("root");
+    if (root) {
+      const App = React.createElement(Router, {
+        url,
+        initialComponent: Component,
+        initialParams: params
+      });
+      if (hydrationData) {
+        hydrateRoot(root, App);
+      } else {
+        createRoot(root).render(App);
+      }
+    }
+  }
+}
+if (typeof window !== "undefined" && !window.__OLOVA_HYDRATE_MANUAL__) {
+}
+export {
+  hydrate
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+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';
+
+declare const RouterContext: React.Context<{
+    params: Record<string, string>;
+    path: string;
+}>;
+
+export { RouterContext };

package/dist/index.js

@@ -0,0 +1,32 @@
+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
+};

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import React__default from 'react';
+import { Metadata } from './Router.js';
+
+declare function render(url: string, RootLayout?: React__default.ComponentType<any>): Promise<{
+    html: string;
+    hydrationData: {
+        params: {};
+        metadata: Metadata;
+    };
+}>;
+declare function renderShellWithMetadata(metadata: Metadata): string;
+
+export { render, renderShellWithMetadata };

package/dist/server.js

@@ -0,0 +1,87 @@
+import {
+  Router,
+  loadRoute
+} from "./chunk-Y3CEUWVD.js";
+import "./chunk-LOK5UEME.js";
+
+// server.tsx
+import React from "react";
+import { renderToString } from "react-dom/server";
+function renderShell(content, metadata) {
+  const title = metadata.title || "My Framework";
+  const description = metadata.description || "";
+  const head = `
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title}</title>
+    <meta name="description" content="${description}" />
+    ${metadata.keywords ? `<meta name="keywords" content="${Array.isArray(metadata.keywords) ? metadata.keywords.join(",") : metadata.keywords}" />` : ""}
+    ${metadata.robots ? `<meta name="robots" content="${metadata.robots}" />` : ""}
+    ${metadata.canonical ? `<link rel="canonical" href="${metadata.canonical}" />` : ""}
+    `;
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    ${head}
+  </head>
+  <body>
+    <div id="root">${content}</div>
+  </body>
+</html>`;
+}
+async function render(url, RootLayout) {
+  const result = await loadRoute(url);
+  let Component = void 0;
+  let params = {};
+  let metadata = {};
+  if (result) {
+    Component = result.module.default;
+    params = result.params;
+    metadata = result.metadata || {};
+  } else {
+    const fallback = await loadRoute("/404");
+    if (fallback) {
+      Component = fallback.module.default;
+      params = fallback.params;
+      metadata = fallback.metadata || {};
+    } else {
+      Component = () => React.createElement("div", null, "404 Not Found");
+    }
+  }
+  let appHtml;
+  if (RootLayout) {
+    const App = React.createElement(
+      RootLayout,
+      null,
+      React.createElement(Router, {
+        url,
+        initialComponent: Component,
+        initialParams: params
+      })
+    );
+    appHtml = "<!DOCTYPE html>" + renderToString(App);
+  } else {
+    const content = renderToString(
+      React.createElement(Router, {
+        url,
+        initialComponent: Component,
+        initialParams: params
+      })
+    );
+    appHtml = renderShell(content, metadata);
+  }
+  return {
+    html: appHtml,
+    hydrationData: {
+      params,
+      metadata
+    }
+  };
+}
+function renderShellWithMetadata(metadata) {
+  return renderShell("", metadata);
+}
+export {
+  render,
+  renderShellWithMetadata
+};

package/dist/useParams.d.ts

@@ -0,0 +1,4 @@
+declare function useParams(): Record<string, string>;
+declare function usePath(): string;
+
+export { useParams as default, useParams, usePath };

package/dist/useParams.js

@@ -0,0 +1,11 @@
+import {
+  useParams,
+  useParams_default,
+  usePath
+} from "./chunk-K6EDUQDD.js";
+import "./chunk-LOK5UEME.js";
+export {
+  useParams_default as default,
+  useParams,
+  usePath
+};

package/dist/usePathname.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the current pathname (without query string or hash)
+ * Similar to Next.js usePathname hook
+ */
+declare function usePathname(): string;
+
+export { usePathname as default, usePathname };

package/dist/usePathname.js

@@ -0,0 +1,8 @@
+import {
+  usePathname,
+  usePathname_default
+} from "./chunk-XGX5YRJV.js";
+export {
+  usePathname_default as default,
+  usePathname
+};

package/dist/useSearchParams.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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;
+
+export { type ReadonlyURLSearchParams, useSearchParams as default, useSearchParams };

package/dist/useSearchParams.js

@@ -0,0 +1,8 @@
+import {
+  useSearchParams,
+  useSearchParams_default
+} from "./chunk-NEMX72XA.js";
+export {
+  useSearchParams_default as default,
+  useSearchParams
+};