olova 2.0.17 → 2.0.18

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,9 @@
+import {
+  Link,
+  Link_default
+} from "./chunk-WNRULQF5.js";
+import "./chunk-TFRUFD5A.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,12 @@
+import {
+  Router,
+  loadRoute,
+  matchRoute
+} from "./chunk-4CH3KNWP.js";
+import "./chunk-7BXNTMPM.js";
+import "./chunk-TFRUFD5A.js";
+export {
+  Router,
+  loadRoute,
+  matchRoute
+};

package/dist/chunk-4CH3KNWP.js

@@ -0,0 +1,157 @@
+import {
+  RouterContext
+} from "./chunk-7BXNTMPM.js";
+import {
+  __toESM,
+  require_react
+} from "./chunk-TFRUFD5A.js";
+
+// Router.tsx
+var import_react = __toESM(require_react(), 1);
+import { routes } from "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 import_react.default.createElement("div", {
+    dangerouslySetInnerHTML: { __html: html },
+    className: "olova-html-content"
+  });
+}
+function MarkdownContent({ markdown }) {
+  const html = parseMarkdown(markdown);
+  return import_react.default.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] = (0, import_react.useState)(() => normalizePath(url || (typeof window !== "undefined" ? window.location.pathname : "/")));
+  const [Component, setComponent] = (0, import_react.useState)(() => initialComponent || null);
+  const [params, setParams] = (0, import_react.useState)(() => initialParams || {});
+  const hasHydrated = import_react.default.useRef(false);
+  (0, import_react.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);
+    };
+  }, []);
+  (0, import_react.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(() => () => import_react.default.createElement("div", null, "404 Not Found"));
+            setParams({});
+            if (onRouteChange) {
+              onRouteChange(void 0);
+            }
+          }
+        }
+      }
+    };
+    load();
+    return () => {
+      isCancelled = true;
+    };
+  }, [path, onRouteChange]);
+  if (!Component) return import_react.default.createElement("div", null, "Loading...");
+  return import_react.default.createElement(
+    RouterContext.Provider,
+    { value: { params, path } },
+    import_react.default.createElement(Component, params)
+  );
+}
+
+export {
+  matchRoute,
+  loadRoute,
+  Router
+};

package/dist/chunk-7BXNTMPM.js

@@ -0,0 +1,12 @@
+import {
+  __toESM,
+  require_react
+} from "./chunk-TFRUFD5A.js";
+
+// context.ts
+var import_react = __toESM(require_react(), 1);
+var RouterContext = (0, import_react.createContext)({ params: {}, path: "/" });
+
+export {
+  RouterContext
+};

package/dist/chunk-K2URQPLW.js

@@ -0,0 +1,44 @@
+import {
+  __toESM,
+  require_react
+} from "./chunk-TFRUFD5A.js";
+
+// useSearchParams.ts
+var import_react = __toESM(require_react(), 1);
+function useSearchParams() {
+  const [searchParams, setSearchParams] = (0, import_react.useState)(() => {
+    if (typeof window === "undefined") return new URLSearchParams();
+    return new URLSearchParams(window.location.search);
+  });
+  (0, import_react.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-RCRG2FBU.js

@@ -0,0 +1,32 @@
+import {
+  __toESM,
+  require_react
+} from "./chunk-TFRUFD5A.js";
+
+// usePathname.ts
+var import_react = __toESM(require_react(), 1);
+function usePathname() {
+  const [pathname, setPathname] = (0, import_react.useState)(() => {
+    if (typeof window === "undefined") return "/";
+    return window.location.pathname;
+  });
+  (0, import_react.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
+};