@flightdev/router 0.4.0

package/dist/index.js

@@ -0,0 +1,765 @@
+// src/context.ts
+var isBrowser = typeof window !== "undefined";
+var currentContext = {
+  path: "/",
+  searchParams: new URLSearchParams(),
+  navigate: () => {
+  },
+  back: () => {
+  },
+  forward: () => {
+  }
+};
+var subscribers = /* @__PURE__ */ new Set();
+function subscribe(callback) {
+  subscribers.add(callback);
+  return () => subscribers.delete(callback);
+}
+function getRouterContext() {
+  return currentContext;
+}
+function updateContext(updates) {
+  currentContext = { ...currentContext, ...updates };
+  subscribers.forEach((cb) => cb(currentContext));
+}
+function navigateTo(to, options = {}) {
+  if (!isBrowser) return;
+  const { replace = false, scroll = true, state } = options;
+  if (replace) {
+    window.history.replaceState(state ?? null, "", to);
+  } else {
+    window.history.pushState(state ?? null, "", to);
+  }
+  const url = new URL(to, window.location.origin);
+  updateContext({
+    path: url.pathname,
+    searchParams: url.searchParams
+  });
+  if (scroll) {
+    window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+  }
+}
+function initRouter(options = {}) {
+  const { initialPath, basePath = "" } = options;
+  let path;
+  let searchParams;
+  if (isBrowser) {
+    path = window.location.pathname;
+    searchParams = new URLSearchParams(window.location.search);
+  } else {
+    path = initialPath || "/";
+    searchParams = new URLSearchParams();
+  }
+  if (basePath && path.startsWith(basePath)) {
+    path = path.slice(basePath.length) || "/";
+  }
+  currentContext = {
+    path,
+    searchParams,
+    navigate: navigateTo,
+    back: () => isBrowser && window.history.back(),
+    forward: () => isBrowser && window.history.forward()
+  };
+  if (isBrowser) {
+    window.addEventListener("popstate", () => {
+      updateContext({
+        path: window.location.pathname,
+        searchParams: new URLSearchParams(window.location.search)
+      });
+    });
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    history.pushState = function(state, unused, url) {
+      originalPushState(state, unused, url);
+      if (url) {
+        const newUrl = new URL(url.toString(), window.location.origin);
+        updateContext({
+          path: newUrl.pathname,
+          searchParams: newUrl.searchParams
+        });
+      }
+    };
+    history.replaceState = function(state, unused, url) {
+      originalReplaceState(state, unused, url);
+      if (url) {
+        const newUrl = new URL(url.toString(), window.location.origin);
+        updateContext({
+          path: newUrl.pathname,
+          searchParams: newUrl.searchParams
+        });
+      }
+    };
+  }
+}
+var initialized = false;
+if (isBrowser && !initialized) {
+  initialized = true;
+  initRouter();
+}
+var RouterContext = null;
+var RouterProvider = null;
+var useRouter = getRouterContext;
+if (typeof globalThis !== "undefined") {
+  try {
+    const React = globalThis.React;
+    if (React?.createContext) {
+      const { createContext, useState, useEffect, useContext } = React;
+      const ReactRouterContext = createContext(currentContext);
+      RouterContext = ReactRouterContext;
+      RouterProvider = function FlightRouterProvider({
+        children,
+        initialPath,
+        basePath = ""
+      }) {
+        const [routerState, setRouterState] = useState(() => {
+          const path = isBrowser ? window.location.pathname : initialPath || "/";
+          const searchParams = isBrowser ? new URLSearchParams(window.location.search) : new URLSearchParams();
+          return {
+            path: basePath && path.startsWith(basePath) ? path.slice(basePath.length) || "/" : path,
+            searchParams,
+            navigate: navigateTo,
+            back: () => isBrowser && window.history.back(),
+            forward: () => isBrowser && window.history.forward()
+          };
+        });
+        useEffect(() => {
+          if (!isBrowser) return;
+          const handlePopState = () => {
+            let path = window.location.pathname;
+            if (basePath && path.startsWith(basePath)) {
+              path = path.slice(basePath.length) || "/";
+            }
+            setRouterState((prev) => ({
+              ...prev,
+              path,
+              searchParams: new URLSearchParams(window.location.search)
+            }));
+          };
+          window.addEventListener("popstate", handlePopState);
+          return () => window.removeEventListener("popstate", handlePopState);
+        }, [basePath]);
+        useEffect(() => {
+          return subscribe((ctx) => {
+            setRouterState((prev) => ({
+              ...prev,
+              path: ctx.path,
+              searchParams: ctx.searchParams
+            }));
+          });
+        }, []);
+        return React.createElement(
+          ReactRouterContext.Provider,
+          { value: routerState },
+          children
+        );
+      };
+      useRouter = function useFlightRouter() {
+        return useContext(ReactRouterContext);
+      };
+    }
+  } catch {
+  }
+}
+
+// src/prefetch.ts
+var isBrowser2 = typeof window !== "undefined";
+var supportsIntersectionObserver = isBrowser2 && "IntersectionObserver" in window;
+var prefetchedUrls = /* @__PURE__ */ new Set();
+var prefetchingUrls = /* @__PURE__ */ new Set();
+var viewportObservers = /* @__PURE__ */ new Map();
+function prefetch(href, options = {}) {
+  if (!isBrowser2) return;
+  const {
+    priority = "auto",
+    includeModules = true,
+    includeData = false
+  } = options;
+  const url = normalizeUrl(href);
+  if (prefetchedUrls.has(url) || prefetchingUrls.has(url)) {
+    return;
+  }
+  prefetchingUrls.add(url);
+  createPrefetchLink(url, "document", priority);
+  if (includeModules) {
+    prefetchModules(url, priority);
+  }
+  if (includeData) {
+    prefetchData(url, priority);
+  }
+  prefetchedUrls.add(url);
+  prefetchingUrls.delete(url);
+}
+function prefetchAll(hrefs, options = {}) {
+  for (const href of hrefs) {
+    prefetch(href, options);
+  }
+}
+function isPrefetched(href) {
+  return prefetchedUrls.has(normalizeUrl(href));
+}
+function clearPrefetchCache() {
+  prefetchedUrls.clear();
+  prefetchingUrls.clear();
+}
+function createPrefetchLink(href, as, priority) {
+  if (!isBrowser2) return null;
+  const existing = document.querySelector(
+    `link[rel="prefetch"][href="${href}"], link[rel="modulepreload"][href="${href}"]`
+  );
+  if (existing) return existing;
+  const link = document.createElement("link");
+  if (as === "script") {
+    link.rel = "modulepreload";
+  } else {
+    link.rel = "prefetch";
+    link.as = as;
+  }
+  link.href = href;
+  if (priority !== "auto" && "fetchPriority" in link) {
+    link.fetchPriority = priority;
+  }
+  if (priority === "low" && "requestIdleCallback" in window) {
+    window.requestIdleCallback(() => {
+      document.head.appendChild(link);
+    });
+  } else {
+    document.head.appendChild(link);
+  }
+  return link;
+}
+function prefetchModules(href, priority) {
+  const manifest = window.__FLIGHT_MANIFEST__;
+  if (!manifest?.routes) return;
+  const routeModules = manifest.routes[href];
+  if (!routeModules) return;
+  for (const module of routeModules) {
+    createPrefetchLink(module, "script", priority);
+  }
+}
+function prefetchData(href, priority) {
+  const dataUrl = `/_flight/data${href === "/" ? "/index" : href}.json`;
+  createPrefetchLink(dataUrl, "fetch", priority);
+}
+var sharedObserver = null;
+var observerCallbacks = /* @__PURE__ */ new Map();
+function getViewportObserver() {
+  if (!supportsIntersectionObserver) return null;
+  if (!sharedObserver) {
+    sharedObserver = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            const callback = observerCallbacks.get(entry.target);
+            if (callback) {
+              callback();
+              sharedObserver?.unobserve(entry.target);
+              observerCallbacks.delete(entry.target);
+            }
+          }
+        }
+      },
+      {
+        // Start prefetching when link is 25% visible or within 100px of viewport
+        rootMargin: "100px",
+        threshold: 0.25
+      }
+    );
+  }
+  return sharedObserver;
+}
+function observeForPrefetch(element, href) {
+  if (!supportsIntersectionObserver) {
+    return () => {
+    };
+  }
+  const observer = getViewportObserver();
+  if (!observer) return () => {
+  };
+  const callback = () => {
+    prefetch(href, { priority: "low" });
+  };
+  observerCallbacks.set(element, callback);
+  observer.observe(element);
+  const cleanup = () => {
+    observer.unobserve(element);
+    observerCallbacks.delete(element);
+    viewportObservers.delete(element);
+  };
+  viewportObservers.set(element, cleanup);
+  return cleanup;
+}
+function setupIntentPrefetch(element, href) {
+  if (!isBrowser2) return () => {
+  };
+  let prefetchTriggered = false;
+  const handleIntent = () => {
+    if (!prefetchTriggered) {
+      prefetchTriggered = true;
+      prefetch(href, { priority: "auto" });
+    }
+  };
+  element.addEventListener("mouseenter", handleIntent, { passive: true });
+  element.addEventListener("focus", handleIntent, { passive: true });
+  element.addEventListener("touchstart", handleIntent, { passive: true });
+  return () => {
+    element.removeEventListener("mouseenter", handleIntent);
+    element.removeEventListener("focus", handleIntent);
+    element.removeEventListener("touchstart", handleIntent);
+  };
+}
+function normalizeUrl(href) {
+  if (isBrowser2 && !href.startsWith("http")) {
+    try {
+      const url = new URL(href, window.location.origin);
+      return url.pathname + url.search;
+    } catch {
+      return href;
+    }
+  }
+  return href;
+}
+
+// src/link.ts
+var isBrowser3 = typeof window !== "undefined";
+function handleLinkClick(href, options, event) {
+  if (event && (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)) {
+    return;
+  }
+  if (event && event.button !== 0) {
+    return;
+  }
+  event?.preventDefault();
+  const { navigate: navigate2 } = getRouterContext();
+  navigate2(href, options);
+}
+function isExternalUrl(href) {
+  if (!href) return false;
+  return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("javascript:") || href.startsWith("#");
+}
+function normalizePrefetchStrategy(prefetchProp) {
+  if (prefetchProp === true) {
+    return "intent";
+  }
+  if (prefetchProp === false || prefetchProp === void 0) {
+    return "none";
+  }
+  return prefetchProp;
+}
+function prefetchRoute(href) {
+  prefetch(href);
+}
+var Link = null;
+if (typeof globalThis !== "undefined") {
+  try {
+    const React = globalThis.React;
+    if (React?.createElement) {
+      const { useCallback, useEffect, useRef } = React;
+      Link = function FlightLink({
+        href,
+        children,
+        className,
+        target,
+        rel,
+        prefetch: prefetchProp = "none",
+        replace = false,
+        scroll = true,
+        onClick,
+        "aria-label": ariaLabel,
+        ...props
+      }) {
+        const linkRef = useRef(null);
+        const isExternal = isExternalUrl(href);
+        const prefetchStrategy = normalizePrefetchStrategy(prefetchProp);
+        const handleClick = useCallback(
+          (e) => {
+            if (onClick) {
+              onClick(e);
+              if (e.defaultPrevented) return;
+            }
+            if (isExternal || target === "_blank") return;
+            handleLinkClick(href, { replace, scroll }, e);
+          },
+          [href, isExternal, target, replace, scroll, onClick]
+        );
+        useEffect(() => {
+          if (isExternal || !isBrowser3 || prefetchStrategy === "none") {
+            return;
+          }
+          const link = linkRef.current;
+          if (!link) return;
+          switch (prefetchStrategy) {
+            case "render":
+              prefetch(href, { priority: "low" });
+              break;
+            case "viewport":
+              return observeForPrefetch(link, href);
+            case "intent":
+            default:
+              return setupIntentPrefetch(link, href);
+          }
+        }, [href, prefetchStrategy, isExternal]);
+        const computedRel = isExternal && target === "_blank" ? rel || "noopener noreferrer" : rel;
+        return React.createElement(
+          "a",
+          {
+            ref: linkRef,
+            href,
+            className,
+            target,
+            rel: computedRel,
+            "aria-label": ariaLabel,
+            onClick: handleClick,
+            ...props
+          },
+          children
+        );
+      };
+    }
+  } catch {
+  }
+}
+function createLink(props) {
+  const {
+    href,
+    children,
+    className,
+    target,
+    rel,
+    prefetch: prefetchProp = "none",
+    replace = false,
+    scroll = true
+  } = props;
+  const anchor = document.createElement("a");
+  anchor.href = href;
+  anchor.className = className || "";
+  if (target) anchor.target = target;
+  if (rel) anchor.rel = rel;
+  if (typeof children === "string") {
+    anchor.textContent = children;
+  }
+  const isExternal = isExternalUrl(href);
+  const prefetchStrategy = normalizePrefetchStrategy(prefetchProp);
+  if (!isExternal && target !== "_blank") {
+    anchor.addEventListener("click", (e) => {
+      handleLinkClick(href, { replace, scroll }, e);
+    });
+  }
+  if (!isExternal && prefetchStrategy !== "none") {
+    switch (prefetchStrategy) {
+      case "render":
+        prefetch(href, { priority: "low" });
+        break;
+      case "viewport":
+        observeForPrefetch(anchor, href);
+        break;
+      case "intent":
+      default:
+        setupIntentPrefetch(anchor, href);
+        break;
+    }
+  }
+  return anchor;
+}
+function useLinkProps(href, options = {}) {
+  const { replace = false, scroll = true, prefetch: prefetchProp = "none" } = options;
+  const isExternal = isExternalUrl(href);
+  const prefetchStrategy = normalizePrefetchStrategy(prefetchProp);
+  const result = {
+    href,
+    onClick: (e) => {
+      if (!isExternal) {
+        handleLinkClick(href, { replace, scroll }, e);
+      }
+    }
+  };
+  if (prefetchStrategy === "intent" && !isExternal) {
+    let prefetched = false;
+    const doPrefetch = () => {
+      if (!prefetched) {
+        prefetched = true;
+        prefetch(href);
+      }
+    };
+    result.onMouseenter = doPrefetch;
+    result.onFocus = doPrefetch;
+  }
+  if (prefetchStrategy === "render" && !isExternal && isBrowser3) {
+    prefetch(href, { priority: "low" });
+  }
+  return result;
+}
+
+// src/prefetch-links.ts
+var isBrowser4 = typeof window !== "undefined";
+var PrefetchPageLinks = null;
+if (typeof globalThis !== "undefined") {
+  try {
+    const React = globalThis.React;
+    if (React?.createElement && "useEffect" in React) {
+      const { useEffect, useState } = React;
+      PrefetchPageLinks = function FlightPrefetchPageLinks({
+        page,
+        options = {}
+      }) {
+        const [shouldRender, setShouldRender] = useState(false);
+        useEffect(() => {
+          if (!isBrowser4) return;
+          if (isPrefetched(page)) {
+            return;
+          }
+          prefetch(page, {
+            priority: "low",
+            includeModules: true,
+            ...options
+          });
+          setShouldRender(false);
+        }, [page, options]);
+        return null;
+      };
+    }
+  } catch {
+  }
+}
+function prefetchPages(pages, options = {}) {
+  if (!isBrowser4) return;
+  for (const page of pages) {
+    if (!isPrefetched(page)) {
+      prefetch(page, {
+        priority: "low",
+        ...options
+      });
+    }
+  }
+}
+function prefetchWhenIdle(page, options = {}) {
+  if (!isBrowser4) return;
+  const doPrefetch = () => {
+    if (!isPrefetched(page)) {
+      prefetch(page, {
+        priority: "low",
+        ...options
+      });
+    }
+  };
+  if ("requestIdleCallback" in window) {
+    window.requestIdleCallback(doPrefetch, { timeout: 3e3 });
+  } else {
+    setTimeout(doPrefetch, 100);
+  }
+}
+
+// src/hooks.ts
+var isBrowser5 = typeof window !== "undefined";
+var pathSubscribers = /* @__PURE__ */ new Set();
+function notifyPathChange() {
+  pathSubscribers.forEach((fn) => fn());
+}
+var historyIntercepted = false;
+function interceptHistory() {
+  if (!isBrowser5 || historyIntercepted) return;
+  historyIntercepted = true;
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  history.pushState = function(state, unused, url) {
+    originalPushState(state, unused, url);
+    notifyPathChange();
+  };
+  history.replaceState = function(state, unused, url) {
+    originalReplaceState(state, unused, url);
+    notifyPathChange();
+  };
+  window.addEventListener("popstate", notifyPathChange);
+}
+if (isBrowser5) {
+  interceptHistory();
+}
+function subscribeToPathname(callback) {
+  pathSubscribers.add(callback);
+  return () => pathSubscribers.delete(callback);
+}
+function getPathnameSnapshot() {
+  return isBrowser5 ? window.location.pathname : "/";
+}
+function getPathnameServerSnapshot() {
+  return "/";
+}
+function createUsePathname(useSyncExternalStore) {
+  return function usePathname2() {
+    return useSyncExternalStore(
+      subscribeToPathname,
+      getPathnameSnapshot,
+      getPathnameServerSnapshot
+    );
+  };
+}
+var useParams = () => ({});
+var useSearchParams = () => [new URLSearchParams(), () => {
+}];
+var usePathname = () => {
+  if (isBrowser5) {
+    return window.location.pathname;
+  }
+  return "/";
+};
+if (typeof globalThis !== "undefined") {
+  try {
+    const React = globalThis.React;
+    if (React?.useSyncExternalStore) {
+      usePathname = createUsePathname(React.useSyncExternalStore);
+    }
+    if (React?.useState) {
+      const { useState, useEffect, useCallback } = React;
+      useParams = function useFlightParams() {
+        const [params, setParams] = useState({});
+        useEffect(() => {
+          const storedParams = window.__FLIGHT_PARAMS__;
+          if (storedParams) {
+            setParams(storedParams);
+          }
+        }, []);
+        return params;
+      };
+      useSearchParams = function useFlightSearchParams() {
+        const [searchParams, setSearchParamsState] = useState(
+          () => isBrowser5 ? new URLSearchParams(window.location.search) : new URLSearchParams()
+        );
+        useEffect(() => {
+          if (!isBrowser5) return;
+          const handleChange = () => {
+            setSearchParamsState(new URLSearchParams(window.location.search));
+          };
+          window.addEventListener("popstate", handleChange);
+          return () => window.removeEventListener("popstate", handleChange);
+        }, []);
+        const setSearchParams = useCallback((newParams) => {
+          if (!isBrowser5) return;
+          let params;
+          if (newParams instanceof URLSearchParams) {
+            params = newParams;
+          } else {
+            params = new URLSearchParams();
+            Object.entries(newParams).forEach(([key, value]) => {
+              if (Array.isArray(value)) {
+                value.forEach((v) => params.append(key, v));
+              } else {
+                params.set(key, value);
+              }
+            });
+          }
+          const newUrl = `${window.location.pathname}?${params.toString()}`;
+          window.history.pushState(null, "", newUrl);
+          setSearchParamsState(params);
+        }, []);
+        return [searchParams, setSearchParams];
+      };
+    }
+  } catch {
+  }
+}
+
+// src/navigate.ts
+var isBrowser6 = typeof window !== "undefined";
+function navigate(to, options = {}) {
+  const { navigate: routerNavigate } = getRouterContext();
+  routerNavigate(to, options);
+}
+function patternToRegex(pattern) {
+  const paramNames = [];
+  let regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\[\.\.\.(\w+)\\\]/g, (_, name) => {
+    paramNames.push(name);
+    return "(.+)";
+  }).replace(/\\\[(\w+)\\\]/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  }).replace(/:(\w+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  regexStr = `^${regexStr}$`;
+  return {
+    regex: new RegExp(regexStr),
+    paramNames
+  };
+}
+function matchRoute(pathname, pattern) {
+  const { regex, paramNames } = patternToRegex(pattern);
+  const match = pathname.match(regex);
+  if (!match) {
+    return { matched: false, params: {} };
+  }
+  const params = {};
+  paramNames.forEach((name, index) => {
+    params[name] = match[index + 1] || "";
+  });
+  return { matched: true, params };
+}
+function parseParams(pathname, pattern) {
+  const { params } = matchRoute(pathname, pattern);
+  return params;
+}
+function findRoute(pathname, routes) {
+  for (const route of routes) {
+    const { matched, params } = matchRoute(pathname, route.path);
+    if (matched) {
+      return {
+        route,
+        params,
+        pathname
+      };
+    }
+  }
+  return null;
+}
+function generatePath(pattern, params = {}) {
+  let path = pattern;
+  path = path.replace(/\[(\w+)\]/g, (_, name) => {
+    return params[name] || "";
+  });
+  path = path.replace(/:(\w+)/g, (_, name) => {
+    return params[name] || "";
+  });
+  return path;
+}
+function isActive(pattern) {
+  const { path } = getRouterContext();
+  const { matched } = matchRoute(path, pattern);
+  return matched;
+}
+function redirect(url) {
+  if (isBrowser6) {
+    window.location.href = url;
+  }
+  throw new Error(`Redirect to: ${url}`);
+}
+export {
+  Link,
+  PrefetchPageLinks,
+  RouterContext,
+  RouterProvider,
+  clearPrefetchCache,
+  createLink,
+  createUsePathname,
+  findRoute,
+  generatePath,
+  getPathnameServerSnapshot,
+  getPathnameSnapshot,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchRoute,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribeToPathname,
+  useLinkProps,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+};