@flight-framework/router 0.0.8 → 0.2.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 };