@flight-framework/router 0.0.6 → 0.0.7

package/dist/chunk-MO2HMSZH.js

@@ -0,0 +1,479 @@
+// 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/prefetch-links.ts
+var isBrowser3 = 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 (!isBrowser3) return;
+          if (isPrefetched(page)) {
+            return;
+          }
+          prefetch(page, {
+            priority: "low",
+            includeModules: true,
+            ...options
+          });
+          setShouldRender(false);
+        }, [page, options]);
+        return null;
+      };
+    }
+  } catch {
+  }
+}
+function prefetchPages(pages, options = {}) {
+  if (!isBrowser3) return;
+  for (const page of pages) {
+    if (!isPrefetched(page)) {
+      prefetch(page, {
+        priority: "low",
+        ...options
+      });
+    }
+  }
+}
+function prefetchWhenIdle(page, options = {}) {
+  if (!isBrowser3) 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/navigate.ts
+var isBrowser4 = 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 (isBrowser4) {
+    window.location.href = url;
+  }
+  throw new Error(`Redirect to: ${url}`);
+}
+
+export {
+  subscribe,
+  getRouterContext,
+  initRouter,
+  RouterContext,
+  RouterProvider,
+  useRouter,
+  prefetch,
+  prefetchAll,
+  isPrefetched,
+  clearPrefetchCache,
+  observeForPrefetch,
+  setupIntentPrefetch,
+  PrefetchPageLinks,
+  prefetchPages,
+  prefetchWhenIdle,
+  navigate,
+  matchRoute,
+  parseParams,
+  findRoute,
+  generatePath,
+  isActive,
+  redirect
+};