@flightdev/router 0.4.0

package/dist/svelte/index.d.ts

@@ -0,0 +1,118 @@
+import { P as PrefetchStrategy, a as RouterContextValue } from '../prefetch-DRp54Q7z.js';
+export { L as LinkProps, N as NavigateOptions, d as PrefetchOptions, c as PrefetchPriority, R as RouteParams, b as RouterProviderProps, S as SearchParams, w as clearPrefetchCache, l as findRoute, o as generatePath, B as getRouterContext, D as initRouter, q as isActive, v as isPrefetched, m as matchRoute, n as navigate, x as observeForPrefetch, p as parseParams, s as prefetch, t as prefetchAll, z as prefetchPages, A as prefetchWhenIdle, r as redirect, y as setupIntentPrefetch, C as subscribe } from '../prefetch-DRp54Q7z.js';
+
+/**
+ * Svelte Link Component
+ *
+ * Provides client-side navigation with prefetching support for Svelte 5.
+ * Uses Svelte 5 runes ($props) for reactive properties.
+ */
+
+/**
+ * Creates a Link component action for Svelte.
+ * Use this with Svelte's `use:` directive for full control.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { linkAction } from '@flightdev/router/svelte';
+ * </script>
+ *
+ * <a href="/docs" use:linkAction={{ prefetch: 'intent' }}>Docs</a>
+ * ```
+ */
+declare function linkAction(node: HTMLAnchorElement, options?: {
+    prefetch?: boolean | PrefetchStrategy;
+    replace?: boolean;
+    scroll?: boolean;
+}): {
+    destroy(): void;
+};
+/**
+ * Link component factory for Svelte.
+ * Returns props to spread on an anchor element.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { createLinkProps } from '@flightdev/router/svelte';
+ *
+ * const linkProps = createLinkProps('/docs', { prefetch: 'intent' });
+ * </script>
+ *
+ * <a {...linkProps}>Documentation</a>
+ * ```
+ */
+declare function createLinkProps(href: string, options?: {
+    prefetch?: boolean | PrefetchStrategy;
+    replace?: boolean;
+    scroll?: boolean;
+}): {
+    href: string;
+    onclick: (e: MouseEvent) => void;
+};
+/**
+ * Simple Link function component.
+ * For Svelte 5, use $props() in your .svelte file instead.
+ * This provides the core logic that can be used in a .svelte wrapper.
+ */
+declare const Link: {
+    createProps: typeof createLinkProps;
+    action: typeof linkAction;
+};
+
+/**
+ * Svelte Stores for Router
+ *
+ * Provides Svelte stores for reactive router state.
+ * Compatible with Svelte 4 and Svelte 5.
+ */
+
+/**
+ * Router store - provides reactive access to router context
+ */
+declare const routerStore: {
+    subscribe(callback: (value: RouterContextValue) => void): () => boolean;
+    set(newValue: RouterContextValue): void;
+    get(): RouterContextValue;
+};
+/**
+ * Pathname store - provides reactive access to current pathname
+ */
+declare const pathnameStore: {
+    subscribe(callback: (value: string) => void): () => boolean;
+    set(newValue: string): void;
+    get(): string;
+};
+/**
+ * Get current router context (non-reactive for SSR)
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { getRouter } from '@flightdev/router/svelte';
+ *
+ * const { navigate, back, forward } = getRouter();
+ * </script>
+ * ```
+ */
+declare function getRouter(): RouterContextValue;
+/**
+ * Get current pathname (non-reactive for SSR)
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { getPathname } from '@flightdev/router/svelte';
+ *
+ * const pathname = getPathname();
+ * </script>
+ * ```
+ */
+declare function getPathname(): string;
+/**
+ * Get current search params (non-reactive for SSR)
+ */
+declare function getSearchParams(): URLSearchParams;
+
+export { Link, PrefetchStrategy, RouterContextValue, getPathname, getRouter, getSearchParams, pathnameStore, routerStore };

package/dist/svelte/index.js

@@ -0,0 +1,595 @@
+// 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/navigate.ts
+var isBrowser2 = 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 (isBrowser2) {
+    window.location.href = url;
+  }
+  throw new Error(`Redirect to: ${url}`);
+}
+
+// src/prefetch.ts
+var isBrowser3 = typeof window !== "undefined";
+var supportsIntersectionObserver = isBrowser3 && "IntersectionObserver" in window;
+var prefetchedUrls = /* @__PURE__ */ new Set();
+var prefetchingUrls = /* @__PURE__ */ new Set();
+var viewportObservers = /* @__PURE__ */ new Map();
+function prefetch(href, options = {}) {
+  if (!isBrowser3) 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 (!isBrowser3) 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 (!isBrowser3) 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 (isBrowser3 && !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 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/svelte/Link.ts
+var isBrowser5 = typeof window !== "undefined";
+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 linkAction(node, options = {}) {
+  const { prefetch: prefetchProp = "none", replace = false, scroll = true } = options;
+  const href = node.getAttribute("href") || "";
+  const isExternal = isExternalUrl(href);
+  const prefetchStrategy = normalizePrefetchStrategy(prefetchProp);
+  let cleanup;
+  const handleClick = (e) => {
+    if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+    if (e.button !== 0) return;
+    if (isExternal || node.target === "_blank") return;
+    e.preventDefault();
+    const { navigate: navigate2 } = getRouterContext();
+    navigate2(href, { replace, scroll });
+  };
+  node.addEventListener("click", handleClick);
+  if (!isExternal && prefetchStrategy !== "none" && isBrowser5) {
+    switch (prefetchStrategy) {
+      case "render":
+        prefetch(href, { priority: "low" });
+        break;
+      case "viewport":
+        cleanup = observeForPrefetch(node, href);
+        break;
+      case "intent":
+      default:
+        cleanup = setupIntentPrefetch(node, href);
+        break;
+    }
+  }
+  return {
+    destroy() {
+      node.removeEventListener("click", handleClick);
+      cleanup?.();
+    }
+  };
+}
+function createLinkProps(href, options = {}) {
+  const { replace = false, scroll = true } = options;
+  const isExternal = isExternalUrl(href);
+  return {
+    href,
+    onclick: (e) => {
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      if (e.button !== 0) return;
+      if (isExternal) return;
+      e.preventDefault();
+      const { navigate: navigate2 } = getRouterContext();
+      navigate2(href, { replace, scroll });
+    }
+  };
+}
+var Link = {
+  createProps: createLinkProps,
+  action: linkAction
+};
+
+// src/svelte/stores.ts
+var isBrowser6 = typeof window !== "undefined";
+function createStore(initialValue) {
+  let value = initialValue;
+  const subscribers2 = /* @__PURE__ */ new Set();
+  return {
+    subscribe(callback) {
+      subscribers2.add(callback);
+      callback(value);
+      return () => subscribers2.delete(callback);
+    },
+    set(newValue) {
+      value = newValue;
+      subscribers2.forEach((cb) => cb(value));
+    },
+    get() {
+      return value;
+    }
+  };
+}
+var routerStore = createStore(getRouterContext());
+var pathnameStore = createStore(
+  isBrowser6 ? window.location.pathname : "/"
+);
+var searchParamsStore = createStore(
+  isBrowser6 ? new URLSearchParams(window.location.search) : new URLSearchParams()
+);
+if (isBrowser6) {
+  subscribe((ctx) => {
+    routerStore.set(ctx);
+    pathnameStore.set(ctx.path);
+    searchParamsStore.set(ctx.searchParams);
+  });
+  window.addEventListener("popstate", () => {
+    pathnameStore.set(window.location.pathname);
+    searchParamsStore.set(new URLSearchParams(window.location.search));
+  });
+}
+function getRouter() {
+  return routerStore.get();
+}
+function getPathname() {
+  return pathnameStore.get();
+}
+function getSearchParams() {
+  return searchParamsStore.get();
+}
+export {
+  Link,
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getPathname,
+  getRouter,
+  getRouterContext,
+  getSearchParams,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  pathnameStore,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  routerStore,
+  setupIntentPrefetch,
+  subscribe
+};