olova 2.0.61 → 2.0.63

package/dist/router.cjs

@@ -1,646 +0,0 @@
-'use strict';
-
-var react = require('react');
-var jsxRuntime = require('react/jsx-runtime');
-
-// src/router/context.ts
-var RouterContext = react.createContext(null);
-var OutletContext = react.createContext(null);
-var ssrRouter = {
-  currentPath: "/",
-  params: {},
-  searchParams: {},
-  navigate: () => {
-  },
-  push: () => {
-  },
-  replace: () => {
-  },
-  back: () => {
-  },
-  forward: () => {
-  },
-  refresh: () => {
-  },
-  setSearchParams: () => {
-  },
-  isNavigating: false,
-  prefetch: () => {
-  }
-};
-function useRouter() {
-  const context = react.useContext(RouterContext);
-  if (!context) {
-    if (typeof window === "undefined") return ssrRouter;
-    throw new Error("useRouter must be used within OlovaRouter");
-  }
-  return context;
-}
-function useParams() {
-  const context = react.useContext(RouterContext);
-  return context?.params || {};
-}
-function useSearchParams() {
-  const context = react.useContext(RouterContext);
-  const searchParams = context?.searchParams || {};
-  return react.useMemo(() => {
-    const params = new URLSearchParams();
-    Object.entries(searchParams).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        value.forEach((v) => params.append(key, v));
-      } else {
-        params.set(key, value);
-      }
-    });
-    return params;
-  }, [searchParams]);
-}
-function usePathname() {
-  const context = react.useContext(RouterContext);
-  if (!context) {
-    if (typeof window === "undefined") return "/";
-    throw new Error("usePathname must be used within OlovaRouter");
-  }
-  return context.currentPath;
-}
-function useSelectedLayoutSegment() {
-  const context = react.useContext(RouterContext);
-  if (!context) return null;
-  const segments = context.currentPath.split("/").filter(Boolean);
-  return segments[0] || null;
-}
-function useSelectedLayoutSegments() {
-  const context = react.useContext(RouterContext);
-  if (!context) return [];
-  return context.currentPath.split("/").filter(Boolean);
-}
-function useIsNavigating() {
-  const context = react.useContext(RouterContext);
-  return context?.isNavigating ?? false;
-}
-function useNavigationEvent(callback) {
-  const context = react.useContext(RouterContext);
-  const currentPath = context?.currentPath;
-  const prevPath = react.useRef(currentPath || "/");
-  react.useEffect(() => {
-    if (!currentPath) return;
-    if (prevPath.current !== currentPath) {
-      callback(prevPath.current, currentPath);
-      prevPath.current = currentPath;
-    }
-  }, [currentPath, callback]);
-}
-function redirect(path, options) {
-  if (typeof window !== "undefined") {
-    if (options?.replace) {
-      window.history.replaceState({}, "", path);
-    } else {
-      window.history.pushState({}, "", path);
-    }
-    window.dispatchEvent(new PopStateEvent("popstate"));
-  }
-  throw new Error(`REDIRECT:${path}`);
-}
-function useRedirect() {
-  const { navigate, replace } = useRouter();
-  return react.useCallback((path, options) => {
-    if (options?.replace) {
-      replace(path, options);
-    } else {
-      navigate(path, options);
-    }
-  }, [navigate, replace]);
-}
-var ErrorBoundary = class extends react.Component {
-  constructor(props) {
-    super(props);
-    this.state = { hasError: false, error: null };
-  }
-  static getDerivedStateFromError(error) {
-    return { hasError: true, error };
-  }
-  componentDidCatch(error, errorInfo) {
-    console.error("[olova] Uncaught error:", error, errorInfo);
-  }
-  handleReset = () => {
-    this.setState({ hasError: false, error: null });
-  };
-  render() {
-    if (this.state.hasError) {
-      if (this.props.fallback) {
-        return this.props.fallback;
-      }
-      return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: {
-        padding: "2rem",
-        maxWidth: "600px",
-        margin: "4rem auto",
-        fontFamily: "system-ui, -apple-system, sans-serif",
-        textAlign: "center"
-      }, children: [
-        /* @__PURE__ */ jsxRuntime.jsx("h1", { style: { fontSize: "2rem", marginBottom: "1rem", color: "#e11d48" }, children: "Something went wrong" }),
-        /* @__PURE__ */ jsxRuntime.jsx("p", { style: { color: "#6b7280", marginBottom: "1.5rem" }, children: "An unexpected error occurred while rendering this page." }),
-        this.state.error && /* @__PURE__ */ jsxRuntime.jsx("pre", { style: {
-          padding: "1rem",
-          backgroundColor: "#f3f4f6",
-          borderRadius: "0.5rem",
-          fontSize: "0.875rem",
-          textAlign: "left",
-          overflow: "auto",
-          marginBottom: "1.5rem",
-          color: "#374151"
-        }, children: this.state.error.message }),
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", gap: "0.75rem", justifyContent: "center" }, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "button",
-            {
-              onClick: this.handleReset,
-              style: {
-                padding: "0.5rem 1.5rem",
-                backgroundColor: "#3b82f6",
-                color: "white",
-                border: "none",
-                borderRadius: "0.375rem",
-                cursor: "pointer",
-                fontSize: "0.875rem"
-              },
-              children: "Try Again"
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "button",
-            {
-              onClick: () => window.location.reload(),
-              style: {
-                padding: "0.5rem 1.5rem",
-                backgroundColor: "transparent",
-                color: "#3b82f6",
-                border: "1px solid #3b82f6",
-                borderRadius: "0.375rem",
-                cursor: "pointer",
-                fontSize: "0.875rem"
-              },
-              children: "Reload Page"
-            }
-          )
-        ] })
-      ] });
-    }
-    return this.props.children;
-  }
-};
-var RouteErrorBoundary = class extends react.Component {
-  constructor(props) {
-    super(props);
-    this.state = { hasError: false, error: null };
-  }
-  static getDerivedStateFromError(error) {
-    return { hasError: true, error };
-  }
-  componentDidUpdate(prevProps) {
-    if (prevProps.routePath !== this.props.routePath && this.state.hasError) {
-      this.setState({ hasError: false, error: null });
-    }
-  }
-  componentDidCatch(error, errorInfo) {
-    console.error("[olova] Route error:", error, errorInfo);
-  }
-  handleReset = () => {
-    this.setState({ hasError: false, error: null });
-  };
-  render() {
-    if (this.state.hasError && this.state.error) {
-      const FallbackComponent = this.props.fallbackComponent;
-      return /* @__PURE__ */ jsxRuntime.jsx(FallbackComponent, { error: this.state.error, reset: this.handleReset });
-    }
-    return this.props.children;
-  }
-};
-function isActive(currentPath, href, exact) {
-  const normalizedCurrent = currentPath.replace(/\/$/, "") || "/";
-  const normalizedHref = href.split("?")[0].replace(/\/$/, "") || "/";
-  if (exact) return normalizedCurrent === normalizedHref;
-  if (normalizedHref === "/") return normalizedCurrent === "/";
-  return normalizedCurrent === normalizedHref || normalizedCurrent.startsWith(normalizedHref + "/");
-}
-function createLink() {
-  const Link = ({
-    href,
-    children,
-    className,
-    activeClassName,
-    exactActiveClassName,
-    prefetch = "hover",
-    replace: shouldReplace = false,
-    scroll = true,
-    target,
-    ...rest
-  }) => {
-    const { push, replace, currentPath, prefetch: prefetchRoute } = useRouter();
-    const isSSR = typeof window === "undefined";
-    const linkRef = react.useRef(null);
-    const prefetched = react.useRef(false);
-    const isExactActive = isActive(currentPath, href, true);
-    const isPartialActive = isActive(currentPath, href, false);
-    const computedClassName = [
-      className,
-      isPartialActive && activeClassName,
-      isExactActive && exactActiveClassName
-    ].filter(Boolean).join(" ") || void 0;
-    const handlePrefetch = react.useCallback(() => {
-      if (!prefetched.current && prefetch !== false) {
-        prefetched.current = true;
-        prefetchRoute(href);
-      }
-    }, [href, prefetch, prefetchRoute]);
-    react.useEffect(() => {
-      if (isSSR || prefetch !== "viewport" || !linkRef.current) return;
-      const observer = new IntersectionObserver(
-        (entries) => {
-          if (entries[0]?.isIntersecting) {
-            handlePrefetch();
-            observer.disconnect();
-          }
-        },
-        { rootMargin: "200px" }
-      );
-      observer.observe(linkRef.current);
-      return () => observer.disconnect();
-    }, [isSSR, prefetch, handlePrefetch]);
-    const handleClick = (e) => {
-      if (rest.onClick) rest.onClick(e);
-      if (e.defaultPrevented) return;
-      if (target === "_blank" || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
-      e.preventDefault();
-      const navFn = shouldReplace ? replace : push;
-      navFn(href, { scroll });
-    };
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      "a",
-      {
-        ref: linkRef,
-        href,
-        className: computedClassName,
-        "data-active": isPartialActive || void 0,
-        "data-exact-active": isExactActive || void 0,
-        onClick: isSSR ? void 0 : handleClick,
-        onMouseEnter: isSSR || prefetch !== "hover" ? void 0 : handlePrefetch,
-        onFocus: isSSR || prefetch !== "hover" ? void 0 : handlePrefetch,
-        target,
-        ...rest,
-        children
-      }
-    );
-  };
-  return Link;
-}
-
-// src/router/matching.ts
-function matchRoute(patternParts, pathParts) {
-  const params = {};
-  const filteredPathParts = pathParts.filter(Boolean);
-  const filteredPatternParts = patternParts.filter(Boolean);
-  for (let i = 0; i < filteredPatternParts.length; i++) {
-    const patternPart = filteredPatternParts[i];
-    const pathPart = filteredPathParts[i];
-    if (patternPart === "*") {
-      params["*"] = filteredPathParts.slice(i).join("/");
-      return { match: true, params };
-    }
-    if (pathPart === void 0) {
-      return { match: false, params: {} };
-    }
-    if (patternPart.startsWith(":")) {
-      params[patternPart.slice(1)] = decodeURIComponent(pathPart);
-    } else if (patternPart !== pathPart) {
-      return { match: false, params: {} };
-    }
-  }
-  if (filteredPathParts.length > filteredPatternParts.length) {
-    return { match: false, params: {} };
-  }
-  return { match: true, params };
-}
-function matchLayoutScope(layoutPath, pathname) {
-  if (layoutPath === "/") return true;
-  const normalizedPathname = pathname.replace(/\/+$/, "") || "/";
-  const normalizedLayout = layoutPath.replace(/\/+$/, "") || "/";
-  return normalizedPathname === normalizedLayout || normalizedPathname.startsWith(normalizedLayout + "/");
-}
-function findNotFoundPage(path, notFoundPages) {
-  if (!notFoundPages || notFoundPages.length === 0) return null;
-  const normalizedPath = path.replace(/\/+$/, "") || "/";
-  const sorted = [...notFoundPages].sort(
-    (a, b) => b.pathPrefix.length - a.pathPrefix.length
-  );
-  for (const nf of sorted) {
-    if (nf.pathPrefix === "") {
-      return nf.component;
-    }
-    if (normalizedPath === nf.pathPrefix || normalizedPath.startsWith(nf.pathPrefix + "/")) {
-      return nf.component;
-    }
-  }
-  return null;
-}
-
-// src/router/search-params.ts
-function parseSearchParams(search) {
-  const params = {};
-  const urlParams = new URLSearchParams(search);
-  for (const key of urlParams.keys()) {
-    const values = urlParams.getAll(key);
-    params[key] = values.length === 1 ? values[0] : values;
-  }
-  return params;
-}
-function buildSearchString(params) {
-  const urlParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === null || value === void 0) continue;
-    if (Array.isArray(value)) {
-      value.forEach((v) => urlParams.append(key, v));
-    } else {
-      urlParams.set(key, value);
-    }
-  }
-  const str = urlParams.toString();
-  return str ? `?${str}` : "";
-}
-function normalizePath(path) {
-  if (path === "/") return path;
-  return path.replace(/\/+$/, "") || "/";
-}
-function OlovaRouter({
-  routes,
-  layouts = [],
-  notFoundPages = [],
-  notFound = /* @__PURE__ */ jsxRuntime.jsx("div", { children: "404 - Not Found" }),
-  loadingFallback = /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Loading..." }),
-  initialPath,
-  onNavigate,
-  onBeforeNavigate
-}) {
-  const isSSR = typeof window === "undefined";
-  const [currentPath, setCurrentPath] = react.useState(() => normalizePath(initialPath || (isSSR ? "/" : window.location.pathname)));
-  const [searchParams, setSearchParamsState] = react.useState(
-    () => isSSR ? {} : parseSearchParams(window.location.search)
-  );
-  const [isPending, startTransition] = react.useTransition();
-  const prevPathRef = react.useRef(currentPath);
-  const [defaultTitle] = react.useState(() => isSSR ? "" : document.title);
-  react.useEffect(() => {
-    if (isSSR) return;
-    const onPopState = () => {
-      const newPath = normalizePath(window.location.pathname);
-      startTransition(() => {
-        setCurrentPath(newPath);
-        setSearchParamsState(parseSearchParams(window.location.search));
-      });
-    };
-    window.addEventListener("popstate", onPopState);
-    return () => window.removeEventListener("popstate", onPopState);
-  }, [isSSR]);
-  const performNavigation = react.useCallback((path, options = {}, historyMethod = "push") => {
-    if (isSSR) return;
-    const { scroll = true } = options;
-    const normalizedPath = normalizePath(path.split("?")[0].split("#")[0]);
-    const hash = path.includes("#") ? "#" + path.split("#")[1] : "";
-    const search = path.includes("?") ? "?" + path.split("?")[1].split("#")[0] : "";
-    const fullUrl = normalizedPath + search + hash;
-    if (onBeforeNavigate) {
-      const result = onBeforeNavigate(currentPath, normalizedPath);
-      if (result === false) return;
-    }
-    const prevPath = currentPath;
-    if (historyMethod === "replace") {
-      window.history.replaceState({}, "", fullUrl);
-    } else {
-      window.history.pushState({}, "", fullUrl);
-    }
-    startTransition(() => {
-      setCurrentPath(normalizedPath);
-      setSearchParamsState(parseSearchParams(search));
-    });
-    if (scroll) {
-      if (hash) {
-        const el = document.getElementById(hash.slice(1));
-        if (el) {
-          el.scrollIntoView({ behavior: "smooth" });
-        } else {
-          window.scrollTo(0, 0);
-        }
-      } else {
-        window.scrollTo(0, 0);
-      }
-    }
-    if (onNavigate) {
-      onNavigate(prevPath, normalizedPath);
-    }
-  }, [isSSR, currentPath, onBeforeNavigate, onNavigate]);
-  const navigate = react.useCallback((path, options) => {
-    performNavigation(path, options, options?.replace ? "replace" : "push");
-  }, [performNavigation]);
-  const push = react.useCallback((path, options) => {
-    performNavigation(path, options, "push");
-  }, [performNavigation]);
-  const replace = react.useCallback((path, options) => {
-    performNavigation(path, options, "replace");
-  }, [performNavigation]);
-  const back = react.useCallback(() => {
-    if (!isSSR) window.history.back();
-  }, [isSSR]);
-  const forward = react.useCallback(() => {
-    if (!isSSR) window.history.forward();
-  }, [isSSR]);
-  const refresh = react.useCallback(() => {
-    if (!isSSR) {
-      startTransition(() => {
-        setCurrentPath((prev) => prev);
-      });
-    }
-  }, [isSSR]);
-  const prefetch = react.useCallback((path) => {
-    const normalizedPath = normalizePath(path.split("?")[0]);
-    const pathParts = normalizedPath.split("/").filter(Boolean);
-    for (const route of routes) {
-      const segments = route.path.split("/").filter(Boolean);
-      const result = matchRoute(segments, pathParts);
-      if (result.match && route.component) {
-        break;
-      }
-    }
-  }, [routes]);
-  const setSearchParams = react.useCallback((newParams, options = {}) => {
-    if (isSSR) return;
-    const { replace: shouldReplace = false, merge = false } = options;
-    let finalParams;
-    if (merge) {
-      finalParams = { ...searchParams, ...newParams };
-      for (const key of Object.keys(finalParams)) {
-        if (finalParams[key] === null) {
-          delete finalParams[key];
-        }
-      }
-    } else {
-      finalParams = newParams;
-    }
-    const searchString = buildSearchString(finalParams);
-    const newUrl = currentPath + searchString;
-    if (shouldReplace) {
-      window.history.replaceState({}, "", newUrl);
-    } else {
-      window.history.pushState({}, "", newUrl);
-    }
-    setSearchParamsState(parseSearchParams(searchString));
-  }, [isSSR, searchParams, currentPath]);
-  const sortedRoutes = react.useMemo(() => {
-    return [...routes].sort((a, b) => {
-      const aHasCatchAll = a.path.includes("*");
-      const bHasCatchAll = b.path.includes("*");
-      const aHasDynamic = a.path.includes(":");
-      const bHasDynamic = b.path.includes(":");
-      if (aHasCatchAll && !bHasCatchAll) return 1;
-      if (!aHasCatchAll && bHasCatchAll) return -1;
-      if (aHasDynamic && !bHasDynamic) return 1;
-      if (!aHasDynamic && bHasDynamic) return -1;
-      return b.path.length - a.path.length;
-    }).map((route) => ({
-      ...route,
-      segments: route.path.split("/").filter(Boolean)
-    }));
-  }, [routes]);
-  const applyMetadata = react.useCallback((metadata) => {
-    if (isSSR) return;
-    if (metadata?.title) {
-      document.title = metadata.title;
-    } else {
-      document.title = defaultTitle;
-    }
-    const setMetaTag = (name, content2, attr = "name") => {
-      let meta = document.querySelector(`meta[${attr}="${name}"]`);
-      if (content2) {
-        if (!meta) {
-          meta = document.createElement("meta");
-          meta.setAttribute(attr, name);
-          document.head.appendChild(meta);
-        }
-        meta.setAttribute("content", content2);
-      } else if (meta) {
-        document.head.removeChild(meta);
-      }
-    };
-    setMetaTag("description", metadata?.description);
-    setMetaTag(
-      "keywords",
-      metadata?.keywords ? Array.isArray(metadata.keywords) ? metadata.keywords.join(", ") : metadata.keywords : void 0
-    );
-    if (metadata?.openGraph) {
-      setMetaTag("og:title", metadata.openGraph.title || metadata.title, "property");
-      setMetaTag("og:description", metadata.openGraph.description || metadata.description, "property");
-      setMetaTag("og:image", metadata.openGraph.image, "property");
-      setMetaTag("og:url", metadata.openGraph.url, "property");
-      setMetaTag("og:type", metadata.openGraph.type || "website", "property");
-    }
-    let canonical = document.querySelector('link[rel="canonical"]');
-    if (metadata?.openGraph?.url) {
-      if (!canonical) {
-        canonical = document.createElement("link");
-        canonical.setAttribute("rel", "canonical");
-        document.head.appendChild(canonical);
-      }
-      canonical.setAttribute("href", metadata.openGraph.url);
-    }
-  }, [defaultTitle, isSSR]);
-  const { currentRoute, MatchedComponent, params } = react.useMemo(() => {
-    const pathParts = currentPath.split("/").filter(Boolean);
-    for (const route of sortedRoutes) {
-      if (route.path === "/" && currentPath === "/") {
-        return {
-          currentRoute: route,
-          MatchedComponent: route.component || null,
-          params: {}
-        };
-      }
-      const result = matchRoute(route.segments, pathParts);
-      if (result.match) {
-        return {
-          currentRoute: route,
-          MatchedComponent: route.component || null,
-          params: result.params
-        };
-      }
-    }
-    return {
-      currentRoute: null,
-      MatchedComponent: null,
-      params: {}
-    };
-  }, [sortedRoutes, currentPath]);
-  react.useEffect(() => {
-    prevPathRef.current = currentPath;
-  }, [currentPath]);
-  react.useEffect(() => {
-    if (isSSR) return;
-    applyMetadata(currentRoute?.metadata);
-  }, [currentRoute, applyMetadata, isSSR]);
-  const matchingLayouts = react.useMemo(() => {
-    return layouts.filter((layout) => matchLayoutScope(layout.path, currentPath)).sort((a, b) => a.path.length - b.path.length);
-  }, [layouts, currentPath]);
-  const FinalComponent = react.useMemo(() => {
-    if (MatchedComponent) return MatchedComponent;
-    return findNotFoundPage(currentPath, notFoundPages);
-  }, [MatchedComponent, currentPath, notFoundPages]);
-  const content = react.useMemo(() => {
-    const LoadingComponent = currentRoute?.loading;
-    const ErrorComponent = currentRoute?.error;
-    let result = FinalComponent ? /* @__PURE__ */ jsxRuntime.jsx(FinalComponent, {}) : notFound;
-    if (LoadingComponent) {
-      result = /* @__PURE__ */ jsxRuntime.jsx(react.Suspense, { fallback: /* @__PURE__ */ jsxRuntime.jsx(LoadingComponent, {}), children: result });
-    }
-    if (ErrorComponent) {
-      result = /* @__PURE__ */ jsxRuntime.jsx(RouteErrorBoundary, { fallbackComponent: ErrorComponent, routePath: currentPath, children: result });
-    }
-    for (let i = matchingLayouts.length - 1; i >= 0; i--) {
-      const Layout = matchingLayouts[i].layout;
-      if (!Layout) continue;
-      const wrapped = result;
-      result = /* @__PURE__ */ jsxRuntime.jsx(OutletContext.Provider, { value: { content: wrapped }, children: /* @__PURE__ */ jsxRuntime.jsx(Layout, {}) });
-    }
-    return result;
-  }, [FinalComponent, matchingLayouts, notFound, loadingFallback, currentRoute, currentPath]);
-  return /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(RouterContext.Provider, { value: {
-    currentPath,
-    params,
-    searchParams,
-    navigate,
-    push,
-    replace,
-    back,
-    forward,
-    refresh,
-    setSearchParams,
-    isNavigating: isPending,
-    prefetch
-  }, children: content }) });
-}
-function Outlet() {
-  const context = react.useContext(OutletContext);
-  if (!context) return null;
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: context.content });
-}
-
-exports.OlovaRouter = OlovaRouter;
-exports.Outlet = Outlet;
-exports.createLink = createLink;
-exports.redirect = redirect;
-exports.useIsNavigating = useIsNavigating;
-exports.useNavigationEvent = useNavigationEvent;
-exports.useParams = useParams;
-exports.usePathname = usePathname;
-exports.useRedirect = useRedirect;
-exports.useRouter = useRouter;
-exports.useSearchParams = useSearchParams;
-exports.useSelectedLayoutSegment = useSelectedLayoutSegment;
-exports.useSelectedLayoutSegments = useSelectedLayoutSegments;
-//# sourceMappingURL=router.cjs.map
-//# sourceMappingURL=router.cjs.map