@flight-framework/router 0.0.8 → 0.2.0

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,53 +1,93 @@
-{
-    "name": "@flight-framework/router",
-    "version": "0.0.8",
-    "description": "Agnostic client-side routing primitives for Flight Framework",
-    "type": "module",
-    "main": "./dist/index.js",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
-        },
-        "./react": {
-            "types": "./dist/react/index.d.ts",
-            "import": "./dist/react/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"
-    },
-    "keywords": [
-        "flight",
-        "router",
-        "spa",
-        "navigation",
-        "ssr"
-    ],
-    "author": "Flight Framework",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/EliosLT/Flight-framework",
-        "directory": "packages/router"
-    },
-    "devDependencies": {
-        "@types/react": "^19.0.0",
-        "tsup": "^8.0.0",
-        "typescript": "^5.3.0"
-    },
-    "peerDependencies": {
-        "react": ">=18.0.0"
-    },
-    "peerDependenciesMeta": {
-        "react": {
-            "optional": true
-        }
-    }
+{
+  "name": "@flight-framework/router",
+  "version": "0.2.0",
+  "description": "Agnostic client-side routing primitives for Flight Framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./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"
+  ],
+  "keywords": [
+    "flight",
+    "router",
+    "spa",
+    "navigation",
+    "ssr",
+    "react",
+    "vue",
+    "svelte",
+    "solid",
+    "preact"
+  ],
+  "author": "Flight Framework",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EliosLT/Flight-framework",
+    "directory": "packages/router"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "preact": "^10.19.0",
+    "solid-js": "^1.8.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vue": "^3.4.0"
+  },
+  "peerDependencies": {
+    "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
+    }
+  },
+  "scripts": {
+    "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"
+  }
 }