@flight-framework/router 0.0.8 → 0.1.0

package/dist/preact/index.d.ts

@@ -0,0 +1,77 @@
+import { P as PrefetchStrategy, b as RouterProviderProps, a as RouterContextValue } from '../prefetch-CMmeei6-.js';
+export { L as LinkProps, N as NavigateOptions, d as PrefetchOptions, c as PrefetchPriority, R as RouteParams, 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-CMmeei6-.js';
+import * as preact$1 from 'preact';
+import { FunctionComponent, ComponentChildren } from 'preact';
+
+/**
+ * Preact Link Component
+ *
+ * Provides client-side navigation with prefetching support for Preact.
+ * API is nearly identical to React version.
+ */
+
+interface LinkProps {
+    href: string;
+    prefetch?: boolean | PrefetchStrategy;
+    replace?: boolean;
+    scroll?: boolean;
+    class?: string;
+    className?: string;
+    target?: string;
+    rel?: string;
+    'aria-label'?: string;
+    onClick?: (e: MouseEvent) => void;
+    children?: preact.ComponentChildren;
+}
+/**
+ * Preact Link Component
+ *
+ * @example
+ * ```tsx
+ * <Link href="/docs" prefetch="intent">Documentation</Link>
+ * ```
+ */
+declare const Link: FunctionComponent<LinkProps>;
+
+/**
+ * Preact Context for router
+ */
+declare const RouterContext: preact$1.Context<RouterContextValue>;
+/**
+ * Hook to access router context
+ */
+declare function useRouter(): RouterContextValue;
+/**
+ * Hook to get current pathname
+ */
+declare function usePathname(): string;
+/**
+ * Hook to get current search params
+ */
+declare function useSearchParams(): URLSearchParams;
+/**
+ * Hook to get route params
+ */
+declare function useParams(): Record<string, string>;
+interface RouterProviderComponentProps extends Partial<RouterProviderProps> {
+    children?: ComponentChildren;
+}
+/**
+ * Preact Router Provider
+ *
+ * @example
+ * ```tsx
+ * import { RouterProvider } from '@flight-framework/router/preact';
+ *
+ * function App() {
+ *     return (
+ *         <RouterProvider initialPath="/">
+ *             <YourApp />
+ *         </RouterProvider>
+ *     );
+ * }
+ * ```
+ */
+declare const RouterProvider: FunctionComponent<RouterProviderComponentProps>;
+
+export { Link, PrefetchStrategy, RouterContext, RouterContextValue, RouterProvider, RouterProviderProps, useParams, usePathname, useRouter, useSearchParams };

package/dist/preact/index.js

@@ -0,0 +1,220 @@
+import {
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe
+} from "../chunk-MO2HMSZH.js";
+
+// src/preact/Link.tsx
+import { h } from "preact";
+import { useCallback, useEffect, useRef } from "preact/hooks";
+var isBrowser = 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;
+}
+var Link = ({
+  href,
+  children,
+  class: className,
+  className: classNameProp,
+  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 (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) {
+        return;
+      }
+      if (e.button !== 0) {
+        return;
+      }
+      if (isExternal || target === "_blank") {
+        return;
+      }
+      e.preventDefault();
+      const { navigate: navigate2 } = getRouterContext();
+      navigate2(href, { replace, scroll });
+    },
+    [href, isExternal, target, replace, scroll, onClick]
+  );
+  useEffect(() => {
+    if (isExternal || !isBrowser || 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;
+  const finalClassName = className || classNameProp;
+  return h("a", {
+    ref: linkRef,
+    href,
+    class: finalClassName,
+    target,
+    rel: computedRel,
+    "aria-label": ariaLabel,
+    onClick: handleClick,
+    ...props
+  }, children);
+};
+
+// src/preact/RouterProvider.tsx
+import { h as h2, createContext } from "preact";
+import { useContext, useState, useEffect as useEffect2 } from "preact/hooks";
+var isBrowser2 = typeof window !== "undefined";
+function navigateTo(to, options = {}) {
+  if (!isBrowser2) return;
+  const { replace = false, scroll = true, state } = options;
+  if (replace) {
+    window.history.replaceState(state ?? null, "", to);
+  } else {
+    window.history.pushState(state ?? null, "", to);
+  }
+  if (scroll) {
+    window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+  }
+}
+var defaultContext = {
+  path: "/",
+  searchParams: new URLSearchParams(),
+  navigate: navigateTo,
+  back: () => isBrowser2 && window.history.back(),
+  forward: () => isBrowser2 && window.history.forward()
+};
+var RouterContext = createContext(defaultContext);
+function useRouter() {
+  return useContext(RouterContext);
+}
+function usePathname() {
+  const { path } = useContext(RouterContext);
+  return path;
+}
+function useSearchParams() {
+  const { searchParams } = useContext(RouterContext);
+  return searchParams;
+}
+function useParams() {
+  return {};
+}
+var RouterProvider = ({
+  children,
+  initialPath,
+  basePath = ""
+}) => {
+  const [routerState, setRouterState] = useState(() => {
+    const path = isBrowser2 ? window.location.pathname : initialPath || "/";
+    const searchParams = isBrowser2 ? new URLSearchParams(window.location.search) : new URLSearchParams();
+    let normalizedPath = path;
+    if (basePath && path.startsWith(basePath)) {
+      normalizedPath = path.slice(basePath.length) || "/";
+    }
+    return {
+      path: normalizedPath,
+      searchParams,
+      navigate: navigateTo,
+      back: () => isBrowser2 && window.history.back(),
+      forward: () => isBrowser2 && window.history.forward()
+    };
+  });
+  useEffect2(() => {
+    if (!isBrowser2) 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);
+    const unsubscribe = subscribe((ctx) => {
+      let path = ctx.path;
+      if (basePath && path.startsWith(basePath)) {
+        path = path.slice(basePath.length) || "/";
+      }
+      setRouterState((prev) => ({
+        ...prev,
+        path,
+        searchParams: ctx.searchParams
+      }));
+    });
+    return () => {
+      window.removeEventListener("popstate", handlePopState);
+      unsubscribe();
+    };
+  }, [basePath]);
+  return h2(RouterContext.Provider, { value: routerState }, children);
+};
+export {
+  Link,
+  RouterContext,
+  RouterProvider,
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+};

package/dist/solid/index.d.ts

@@ -0,0 +1,107 @@
+import { P as PrefetchStrategy, b as RouterProviderProps, a as RouterContextValue } from '../prefetch-CMmeei6-.js';
+export { L as LinkProps, N as NavigateOptions, d as PrefetchOptions, c as PrefetchPriority, R as RouteParams, 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-CMmeei6-.js';
+import * as solid_js from 'solid-js';
+import { JSX, Accessor } from 'solid-js';
+
+/**
+ * SolidJS Link Component
+ *
+ * Provides client-side navigation with prefetching support for SolidJS.
+ * Uses functional component pattern without JSX to avoid type conflicts.
+ */
+
+interface LinkProps {
+    href: string;
+    prefetch?: boolean | PrefetchStrategy;
+    replace?: boolean;
+    scroll?: boolean;
+    class?: string;
+    target?: string;
+    rel?: string;
+    'aria-label'?: string;
+    onClick?: (e: MouseEvent) => void;
+    children?: JSX.Element;
+}
+/**
+ * Create props for a Link anchor element
+ * Use this with spread operator on an <a> element
+ *
+ * @example
+ * ```tsx
+ * const linkProps = createLinkProps({ href: '/docs', prefetch: 'intent' });
+ * <a {...linkProps}>Docs</a>
+ * ```
+ */
+declare function createLinkProps(props: LinkProps): {
+    href: string;
+    class: string | undefined;
+    target: string | undefined;
+    rel: string | undefined;
+    'aria-label': string | undefined;
+    onClick: (e: MouseEvent) => void;
+};
+/**
+ * Solid Link action for use with ref
+ */
+declare function linkAction(node: HTMLAnchorElement, props: Accessor<{
+    href: string;
+    prefetch?: boolean | PrefetchStrategy;
+}>): void;
+/**
+ * Link component for SolidJS
+ * Re-export createLinkProps for component-like usage
+ */
+declare const Link: {
+    createProps: typeof createLinkProps;
+    action: typeof linkAction;
+};
+
+/**
+ * SolidJS Context for router
+ */
+declare const RouterContext: solid_js.Context<Accessor<RouterContextValue>>;
+/**
+ * Hook to access router context
+ */
+declare function useRouter(): RouterContextValue;
+/**
+ * Hook to get current pathname as a signal accessor
+ */
+declare function usePathname(): Accessor<string>;
+/**
+ * Hook to get current search params
+ */
+declare function useSearchParams(): Accessor<URLSearchParams>;
+/**
+ * Hook to get route params
+ */
+declare function useParams(): Accessor<Record<string, string>>;
+/**
+ * Create a router provider for SolidJS
+ *
+ * @example
+ * ```tsx
+ * import { createRouterProvider } from '@flight-framework/router/solid';
+ *
+ * const { Provider, useRouter } = createRouterProvider();
+ *
+ * function App() {
+ *     return (
+ *         <Provider>
+ *             <YourApp />
+ *         </Provider>
+ *     );
+ * }
+ * ```
+ */
+declare function createRouterProvider(options?: Partial<RouterProviderProps>): {
+    Context: solid_js.Context<Accessor<RouterContextValue>>;
+    getContext: () => RouterContextValue;
+};
+/**
+ * RouterProvider for Solid - use with JSX
+ * This is a simplified version that works with Solid's context
+ */
+declare const RouterProvider: typeof createRouterProvider;
+
+export { Link, PrefetchStrategy, RouterContext, RouterContextValue, RouterProvider, RouterProviderProps, createLinkProps, createRouterProvider, linkAction, useParams, usePathname, useRouter, useSearchParams };

package/dist/solid/index.js

@@ -0,0 +1,191 @@
+import {
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe
+} from "../chunk-MO2HMSZH.js";
+
+// src/solid/Link.ts
+import { onCleanup } from "solid-js";
+var isBrowser = 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 createLinkProps(props) {
+  const isExternal = isExternalUrl(props.href);
+  const handleClick = (e) => {
+    if (props.onClick) {
+      props.onClick(e);
+      if (e.defaultPrevented) return;
+    }
+    if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) {
+      return;
+    }
+    if (e.button !== 0) {
+      return;
+    }
+    if (isExternal || props.target === "_blank") {
+      return;
+    }
+    e.preventDefault();
+    const { navigate: navigate2 } = getRouterContext();
+    navigate2(props.href, {
+      replace: props.replace ?? false,
+      scroll: props.scroll ?? true
+    });
+  };
+  const computedRel = isExternal && props.target === "_blank" ? props.rel || "noopener noreferrer" : props.rel;
+  return {
+    href: props.href,
+    class: props.class,
+    target: props.target,
+    rel: computedRel,
+    "aria-label": props["aria-label"],
+    onClick: handleClick
+  };
+}
+function linkAction(node, props) {
+  const { href, prefetch: prefetchProp } = props();
+  const isExternal = isExternalUrl(href);
+  const prefetchStrategy = normalizePrefetchStrategy(prefetchProp);
+  let cleanup;
+  if (!isExternal && isBrowser && prefetchStrategy !== "none") {
+    switch (prefetchStrategy) {
+      case "render":
+        prefetch(href, { priority: "low" });
+        break;
+      case "viewport":
+        cleanup = observeForPrefetch(node, href);
+        break;
+      case "intent":
+      default:
+        cleanup = setupIntentPrefetch(node, href);
+        break;
+    }
+  }
+  onCleanup(() => cleanup?.());
+}
+var Link = {
+  createProps: createLinkProps,
+  action: linkAction
+};
+
+// src/solid/RouterProvider.ts
+import { createContext, useContext, createSignal as createSignal2 } from "solid-js";
+var isBrowser2 = typeof window !== "undefined";
+function navigateTo(to, options = {}) {
+  if (!isBrowser2) return;
+  const { replace = false, scroll = true, state } = options;
+  if (replace) {
+    window.history.replaceState(state ?? null, "", to);
+  } else {
+    window.history.pushState(state ?? null, "", to);
+  }
+  if (scroll) {
+    window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+  }
+}
+var defaultContext = {
+  path: "/",
+  searchParams: new URLSearchParams(),
+  navigate: navigateTo,
+  back: () => isBrowser2 && window.history.back(),
+  forward: () => isBrowser2 && window.history.forward()
+};
+var RouterContext = createContext(() => defaultContext);
+function useRouter() {
+  const getContext = useContext(RouterContext);
+  return getContext();
+}
+function usePathname() {
+  const getContext = useContext(RouterContext);
+  return () => getContext().path;
+}
+function useSearchParams() {
+  const getContext = useContext(RouterContext);
+  return () => getContext().searchParams;
+}
+function useParams() {
+  return () => ({});
+}
+function createRouterProvider(options = {}) {
+  const [path, setPath] = createSignal2(
+    isBrowser2 ? window.location.pathname : options.initialPath || "/"
+  );
+  const [searchParams, setSearchParams] = createSignal2(
+    isBrowser2 ? new URLSearchParams(window.location.search) : new URLSearchParams()
+  );
+  const getRouterContext2 = () => ({
+    path: path(),
+    searchParams: searchParams(),
+    navigate: navigateTo,
+    back: () => isBrowser2 && window.history.back(),
+    forward: () => isBrowser2 && window.history.forward()
+  });
+  if (isBrowser2) {
+    const handlePopState = () => {
+      setPath(window.location.pathname);
+      setSearchParams(new URLSearchParams(window.location.search));
+    };
+    window.addEventListener("popstate", handlePopState);
+    subscribe((ctx) => {
+      setPath(ctx.path);
+      setSearchParams(ctx.searchParams);
+    });
+  }
+  return {
+    Context: RouterContext,
+    getContext: getRouterContext2
+  };
+}
+var RouterProvider = createRouterProvider;
+export {
+  Link,
+  RouterContext,
+  RouterProvider,
+  clearPrefetchCache,
+  createLinkProps,
+  createRouterProvider,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  linkAction,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+};

package/dist/svelte/index.d.ts

@@ -0,0 +1,118 @@
+import { P as PrefetchStrategy, a as RouterContextValue } from '../prefetch-CMmeei6-.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-CMmeei6-.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 '@flight-framework/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 '@flight-framework/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 '@flight-framework/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 '@flight-framework/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,161 @@
+import {
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe
+} from "../chunk-MO2HMSZH.js";
+
+// src/svelte/Link.ts
+var isBrowser = 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" && isBrowser) {
+    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 isBrowser2 = typeof window !== "undefined";
+function createStore(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  return {
+    subscribe(callback) {
+      subscribers.add(callback);
+      callback(value);
+      return () => subscribers.delete(callback);
+    },
+    set(newValue) {
+      value = newValue;
+      subscribers.forEach((cb) => cb(value));
+    },
+    get() {
+      return value;
+    }
+  };
+}
+var routerStore = createStore(getRouterContext());
+var pathnameStore = createStore(
+  isBrowser2 ? window.location.pathname : "/"
+);
+var searchParamsStore = createStore(
+  isBrowser2 ? new URLSearchParams(window.location.search) : new URLSearchParams()
+);
+if (isBrowser2) {
+  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
+};

package/dist/vue/index.d.ts

@@ -0,0 +1,147 @@
+import { P as PrefetchStrategy, b as RouterProviderProps, a as RouterContextValue } from '../prefetch-CMmeei6-.js';
+export { L as LinkProps, N as NavigateOptions, d as PrefetchOptions, c as PrefetchPriority, R as RouteParams, 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-CMmeei6-.js';
+import * as vue from 'vue';
+import { PropType, Ref } from 'vue';
+
+/**
+ * Vue Link Component
+ *
+ * @example
+ * ```vue
+ * <template>
+ *     <Link href="/docs" prefetch="intent">Documentation</Link>
+ * </template>
+ * ```
+ */
+declare const Link: vue.DefineComponent<vue.ExtractPropTypes<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    prefetch: {
+        type: PropType<boolean | PrefetchStrategy>;
+        default: string;
+    };
+    replace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    target: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    prefetch: {
+        type: PropType<boolean | PrefetchStrategy>;
+        default: string;
+    };
+    replace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    target: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    replace: boolean;
+    scroll: boolean;
+    prefetch: boolean | PrefetchStrategy;
+    class: string;
+    target: string;
+    rel: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Vue Composables for Router
+ *
+ * Provides Vue 3 composition API composables for routing.
+ */
+
+/**
+ * Vue RouterProvider component for composition API
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { RouterProvider } from '@flight-framework/router/vue';
+ * </script>
+ *
+ * <template>
+ *     <RouterProvider initial-path="/">
+ *         <App />
+ *     </RouterProvider>
+ * </template>
+ * ```
+ */
+declare function RouterProvider(props: RouterProviderProps, { slots }: {
+    slots: {
+        default?: () => unknown;
+    };
+}): unknown;
+/**
+ * Composable to access router functions
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useRouter } from '@flight-framework/router/vue';
+ *
+ * const { navigate, back, forward } = useRouter();
+ * </script>
+ * ```
+ */
+declare function useRouter(): RouterContextValue;
+/**
+ * Composable to get current pathname
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { usePathname } from '@flight-framework/router/vue';
+ *
+ * const pathname = usePathname();
+ * </script>
+ * ```
+ */
+declare function usePathname(): Ref<string>;
+/**
+ * Composable to get current search params
+ */
+declare function useSearchParams(): Ref<URLSearchParams>;
+/**
+ * Composable to get route params
+ */
+declare function useParams(): Ref<Record<string, string>>;
+
+export { Link, PrefetchStrategy, RouterContextValue, RouterProvider, RouterProviderProps, useParams, usePathname, useRouter, useSearchParams };

package/dist/vue/index.js

@@ -0,0 +1,224 @@
+import {
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe
+} from "../chunk-MO2HMSZH.js";
+
+// src/vue/Link.ts
+import { defineComponent, ref, onMounted, onUnmounted, h } from "vue";
+var isBrowser = 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;
+}
+var Link = defineComponent({
+  name: "FlightLink",
+  props: {
+    href: {
+      type: String,
+      required: true
+    },
+    prefetch: {
+      type: [Boolean, String],
+      default: "none"
+    },
+    replace: {
+      type: Boolean,
+      default: false
+    },
+    scroll: {
+      type: Boolean,
+      default: true
+    },
+    class: {
+      type: String,
+      default: void 0
+    },
+    target: {
+      type: String,
+      default: void 0
+    },
+    rel: {
+      type: String,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const linkRef = ref(null);
+    const isExternal = isExternalUrl(props.href);
+    const prefetchStrategy = normalizePrefetchStrategy(props.prefetch);
+    let cleanup;
+    onMounted(() => {
+      if (isExternal || !isBrowser || prefetchStrategy === "none") {
+        return;
+      }
+      const link = linkRef.value;
+      if (!link) return;
+      switch (prefetchStrategy) {
+        case "render":
+          prefetch(props.href, { priority: "low" });
+          break;
+        case "viewport":
+          cleanup = observeForPrefetch(link, props.href);
+          break;
+        case "intent":
+        default:
+          cleanup = setupIntentPrefetch(link, props.href);
+          break;
+      }
+    });
+    onUnmounted(() => {
+      cleanup?.();
+    });
+    const handleClick = (e) => {
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) {
+        return;
+      }
+      if (e.button !== 0) {
+        return;
+      }
+      if (isExternal || props.target === "_blank") {
+        return;
+      }
+      e.preventDefault();
+      const { navigate: navigate2 } = getRouterContext();
+      navigate2(props.href, { replace: props.replace, scroll: props.scroll });
+    };
+    const computedRel = isExternal && props.target === "_blank" ? props.rel || "noopener noreferrer" : props.rel;
+    return () => h("a", {
+      ref: linkRef,
+      href: props.href,
+      class: props.class,
+      target: props.target,
+      rel: computedRel,
+      onClick: handleClick
+    }, slots.default?.());
+  }
+});
+
+// src/vue/composables.ts
+import { ref as ref2, provide, inject, onMounted as onMounted2, onUnmounted as onUnmounted2 } from "vue";
+var isBrowser2 = typeof window !== "undefined";
+var RouterKey = /* @__PURE__ */ Symbol("FlightRouter");
+function navigateTo(to, options = {}) {
+  if (!isBrowser2) return;
+  const { replace = false, scroll = true, state } = options;
+  if (replace) {
+    window.history.replaceState(state ?? null, "", to);
+  } else {
+    window.history.pushState(state ?? null, "", to);
+  }
+  if (scroll) {
+    window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+  }
+}
+function RouterProvider(props, { slots }) {
+  const path = ref2(isBrowser2 ? window.location.pathname : props.initialPath || "/");
+  const searchParams = ref2(isBrowser2 ? new URLSearchParams(window.location.search) : new URLSearchParams());
+  const routerState = ref2({
+    path: path.value,
+    searchParams: searchParams.value,
+    navigate: navigateTo,
+    back: () => isBrowser2 && window.history.back(),
+    forward: () => isBrowser2 && window.history.forward()
+  });
+  provide(RouterKey, routerState);
+  if (isBrowser2) {
+    onMounted2(() => {
+      const handlePopState = () => {
+        path.value = window.location.pathname;
+        searchParams.value = new URLSearchParams(window.location.search);
+        routerState.value = {
+          ...routerState.value,
+          path: path.value,
+          searchParams: searchParams.value
+        };
+      };
+      window.addEventListener("popstate", handlePopState);
+      const unsubscribe = subscribe((ctx) => {
+        path.value = ctx.path;
+        searchParams.value = ctx.searchParams;
+        routerState.value = {
+          ...routerState.value,
+          path: ctx.path,
+          searchParams: ctx.searchParams
+        };
+      });
+      onUnmounted2(() => {
+        window.removeEventListener("popstate", handlePopState);
+        unsubscribe();
+      });
+    });
+  }
+  return slots.default?.();
+}
+function useRouter() {
+  const routerState = inject(RouterKey);
+  if (routerState) {
+    return routerState.value;
+  }
+  return getRouterContext();
+}
+function usePathname() {
+  const routerState = inject(RouterKey);
+  if (routerState) {
+    return ref2(routerState.value.path);
+  }
+  return ref2(isBrowser2 ? window.location.pathname : "/");
+}
+function useSearchParams() {
+  const routerState = inject(RouterKey);
+  if (routerState) {
+    return ref2(routerState.value.searchParams);
+  }
+  return ref2(isBrowser2 ? new URLSearchParams(window.location.search) : new URLSearchParams());
+}
+function useParams() {
+  return ref2({});
+}
+export {
+  Link,
+  RouterProvider,
+  clearPrefetchCache,
+  findRoute,
+  generatePath,
+  getRouterContext,
+  initRouter,
+  isActive,
+  isPrefetched,
+  matchRoute,
+  navigate,
+  observeForPrefetch,
+  parseParams,
+  prefetch,
+  prefetchAll,
+  prefetchPages,
+  prefetchWhenIdle,
+  redirect,
+  setupIntentPrefetch,
+  subscribe,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flight-framework/router",
-    "version": "0.0.8",
+    "version": "0.1.0",
     "description": "Agnostic client-side routing primitives for Flight Framework",
     "type": "module",
     "main": "./dist/index.js",
@@ -14,21 +14,42 @@
         "./react": {
             "types": "./dist/react/index.d.ts",
             "import": "./dist/react/index.js"
+        },
+        "./vue": {
+            "types": "./dist/vue/index.d.ts",
+            "import": "./dist/vue/index.js"
+        },
+        "./svelte": {
+            "types": "./dist/svelte/index.d.ts",
+            "import": "./dist/svelte/index.js"
+        },
+        "./solid": {
+            "types": "./dist/solid/index.d.ts",
+            "import": "./dist/solid/index.js"
+        },
+        "./preact": {
+            "types": "./dist/preact/index.d.ts",
+            "import": "./dist/preact/index.js"
         }
     },
     "files": [
         "dist"
     ],
     "scripts": {
-        "build": "tsup src/index.ts src/react/index.ts --format esm --dts --clean",
-        "dev": "tsup src/index.ts src/react/index.ts --format esm --dts --watch"
+        "build": "tsup src/index.ts src/react/index.ts src/vue/index.ts src/svelte/index.ts src/solid/index.ts src/preact/index.ts --format esm --dts --clean",
+        "dev": "tsup src/index.ts src/react/index.ts src/vue/index.ts src/svelte/index.ts src/solid/index.ts src/preact/index.ts --format esm --dts --watch"
     },
     "keywords": [
         "flight",
         "router",
         "spa",
         "navigation",
-        "ssr"
+        "ssr",
+        "react",
+        "vue",
+        "svelte",
+        "solid",
+        "preact"
     ],
     "author": "Flight Framework",
     "license": "MIT",
@@ -39,15 +60,34 @@
     },
     "devDependencies": {
         "@types/react": "^19.0.0",
+        "preact": "^10.19.0",
+        "solid-js": "^1.8.0",
         "tsup": "^8.0.0",
-        "typescript": "^5.3.0"
+        "typescript": "^5.3.0",
+        "vue": "^3.4.0"
     },
     "peerDependencies": {
-        "react": ">=18.0.0"
+        "preact": ">=10.0.0",
+        "react": ">=18.0.0",
+        "solid-js": ">=1.0.0",
+        "svelte": ">=4.0.0",
+        "vue": ">=3.0.0"
     },
     "peerDependenciesMeta": {
         "react": {
             "optional": true
+        },
+        "vue": {
+            "optional": true
+        },
+        "svelte": {
+            "optional": true
+        },
+        "solid-js": {
+            "optional": true
+        },
+        "preact": {
+            "optional": true
         }
     }
 }