@real-router/svelte 0.2.6 → 0.2.8

package/dist/RouterProvider.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
   import { getNavigator } from "@real-router/core";
   import { createRouteSource } from "@real-router/sources";
-  import { createRouteAnnouncer } from "dom-utils";
+  import { createRouteAnnouncer } from "./dom-utils";
   import { setContext } from "svelte";
 
   import { createReactiveSource } from "./createReactiveSource.svelte";

package/dist/actions/link.svelte.js

@@ -1,6 +1,6 @@
 import { getContext } from "svelte";
 import { ROUTER_KEY } from "../context";
-import { shouldNavigate, applyLinkA11y } from "dom-utils";
+import { shouldNavigate, applyLinkA11y } from "../dom-utils";
 /**
  * Factory function that captures router context during component initialization.
  * Must be called during component init (not inside event handlers or effects).

package/dist/components/Link.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
   import { useIsActiveRoute } from "../composables/useIsActiveRoute.svelte";
   import { useRouter } from "../composables/useRouter.svelte";
-  import { shouldNavigate, buildHref, buildActiveClassName } from "dom-utils";
+  import { shouldNavigate, buildHref, buildActiveClassName } from "../dom-utils";
 
   import type { NavigationOptions, Params } from "@real-router/core";
   import type { Snippet } from "svelte";

package/dist/dom-utils/index.d.ts

@@ -0,0 +1,3 @@
+export { createRouteAnnouncer } from "./route-announcer";
+export { shouldNavigate, buildHref, buildActiveClassName, applyLinkA11y, } from "./link-utils";
+export type { RouteAnnouncerOptions } from "./route-announcer";

package/dist/dom-utils/index.js

@@ -0,0 +1,2 @@
+export { createRouteAnnouncer } from "./route-announcer";
+export { shouldNavigate, buildHref, buildActiveClassName, applyLinkA11y, } from "./link-utils";

package/dist/dom-utils/link-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Router, Params } from "@real-router/core";
+export declare function shouldNavigate(evt: MouseEvent): boolean;
+export declare function buildHref(router: Router, routeName: string, routeParams: Params): string | undefined;
+export declare function buildActiveClassName(isActive: boolean, activeClassName: string | undefined, baseClassName: string | undefined): string | undefined;
+export declare function applyLinkA11y(element: HTMLElement): void;

package/dist/dom-utils/link-utils.js

@@ -0,0 +1,41 @@
+export function shouldNavigate(evt) {
+    return (evt.button === 0 &&
+        !evt.metaKey &&
+        !evt.altKey &&
+        !evt.ctrlKey &&
+        !evt.shiftKey);
+}
+// Lives in dom-utils (not core/utils) because buildUrl is injected by browser-plugin via extendRouter()
+export function buildHref(router, routeName, routeParams) {
+    try {
+        const buildUrl = router.buildUrl;
+        if (buildUrl) {
+            return buildUrl(routeName, routeParams);
+        }
+        return router.buildPath(routeName, routeParams);
+    }
+    catch {
+        console.error(`[real-router] Route "${routeName}" is not defined. The element will render without an href attribute.`);
+        return undefined;
+    }
+}
+export function buildActiveClassName(isActive, activeClassName, baseClassName) {
+    if (isActive && activeClassName) {
+        return baseClassName
+            ? `${baseClassName} ${activeClassName}`.trim()
+            : activeClassName;
+    }
+    return baseClassName ?? undefined;
+}
+export function applyLinkA11y(element) {
+    if (element instanceof HTMLAnchorElement ||
+        element instanceof HTMLButtonElement) {
+        return;
+    }
+    if (!element.getAttribute("role")) {
+        element.setAttribute("role", "link");
+    }
+    if (!element.getAttribute("tabindex")) {
+        element.setAttribute("tabindex", "0");
+    }
+}

package/dist/dom-utils/route-announcer.d.ts

@@ -0,0 +1,8 @@
+import type { Router, State } from "@real-router/core";
+export interface RouteAnnouncerOptions {
+    prefix?: string;
+    getAnnouncementText?: (route: State) => string;
+}
+export declare function createRouteAnnouncer(router: Router, options?: RouteAnnouncerOptions): {
+    destroy: () => void;
+};

package/dist/dom-utils/route-announcer.js

@@ -0,0 +1,89 @@
+const CLEAR_DELAY = 7000;
+const SAFARI_READY_DELAY = 100;
+const ANNOUNCER_ATTR = "data-real-router-announcer";
+const INTERNAL_ROUTE_PREFIX = "@@";
+const VISUALLY_HIDDEN = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);clip-path:inset(50%);white-space:nowrap;border:0";
+export function createRouteAnnouncer(router, options) {
+    const prefix = options?.prefix ?? "Navigated to ";
+    const getCustomText = options?.getAnnouncementText;
+    let isInitialNavigation = true;
+    let isReady = false;
+    let isDestroyed = false;
+    let lastAnnouncedText = "";
+    let clearTimeoutId;
+    const announcer = getOrCreateAnnouncer();
+    const safariTimeoutId = setTimeout(() => {
+        isReady = true;
+    }, SAFARI_READY_DELAY);
+    const unsubscribe = router.subscribe(({ route }) => {
+        if (isInitialNavigation) {
+            isInitialNavigation = false;
+            return;
+        }
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+                if (isDestroyed) {
+                    return;
+                }
+                const text = resolveText(route, prefix, getCustomText);
+                if (text && text !== lastAnnouncedText && isReady) {
+                    lastAnnouncedText = text;
+                    clearTimeout(clearTimeoutId);
+                    announcer.textContent = text;
+                    clearTimeoutId = setTimeout(() => {
+                        announcer.textContent = "";
+                        lastAnnouncedText = "";
+                    }, CLEAR_DELAY);
+                    manageFocus();
+                }
+            });
+        });
+    });
+    return {
+        destroy() {
+            isDestroyed = true;
+            unsubscribe();
+            clearTimeout(clearTimeoutId);
+            clearTimeout(safariTimeoutId);
+            removeAnnouncer();
+        },
+    };
+}
+function getOrCreateAnnouncer() {
+    const existing = document.querySelector(`[${ANNOUNCER_ATTR}]`);
+    if (existing) {
+        return existing;
+    }
+    const element = document.createElement("div");
+    element.setAttribute("style", VISUALLY_HIDDEN);
+    element.setAttribute("aria-live", "assertive");
+    element.setAttribute("aria-atomic", "true");
+    element.setAttribute(ANNOUNCER_ATTR, "");
+    document.body.prepend(element);
+    return element;
+}
+function removeAnnouncer() {
+    document.querySelector(`[${ANNOUNCER_ATTR}]`)?.remove();
+}
+function resolveText(route, prefix, getCustomText) {
+    if (getCustomText) {
+        return getCustomText(route);
+    }
+    const h1 = document.querySelector("h1");
+    const h1Text = h1?.textContent.trim() ?? "";
+    const routeName = route.name.startsWith(INTERNAL_ROUTE_PREFIX)
+        ? ""
+        : route.name;
+    const rawText = h1Text || document.title || routeName || globalThis.location.pathname;
+    return `${prefix}${rawText}`;
+}
+function manageFocus() {
+    const h1 = document.querySelector("h1");
+    if (!h1) {
+        return;
+    }
+    if (!h1.hasAttribute("tabindex")) {
+        h1.setAttribute("tabindex", "-1");
+    }
+    h1.focus({ preventScroll: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@real-router/svelte",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "description": "Svelte 5 integration for Real-Router",
   "svelte": "./dist/index.js",
@@ -13,8 +13,7 @@
     }
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "homepage": "https://github.com/greydragon888/real-router",
   "repository": {
@@ -44,10 +43,9 @@
   "license": "MIT",
   "sideEffects": false,
   "dependencies": {
-    "@real-router/core": "^0.45.0",
-    "@real-router/route-utils": "^0.1.11",
-    "@real-router/sources": "^0.4.1",
-    "dom-utils": "^0.2.7"
+    "@real-router/core": "^0.45.1",
+    "@real-router/route-utils": "^0.1.12",
+    "@real-router/sources": "^0.4.2"
   },
   "devDependencies": {
     "@sveltejs/package": "2.5.7",
@@ -59,7 +57,8 @@
     "svelte": "5.54.0",
     "svelte-check": "4.4.5",
     "svelte-eslint-parser": "1.6.0",
-    "@real-router/browser-plugin": "^0.11.4"
+    "@real-router/browser-plugin": "^0.11.5",
+    "dom-utils": "^0.2.7"
   },
   "peerDependencies": {
     "svelte": ">=5.7.0"

package/src/RouterProvider.svelte

@@ -1,51 +0,0 @@
-<script lang="ts">
-  import { getNavigator } from "@real-router/core";
-  import { createRouteSource } from "@real-router/sources";
-  import { createRouteAnnouncer } from "dom-utils";
-  import { setContext } from "svelte";
-
-  import { createReactiveSource } from "./createReactiveSource.svelte";
-  import { NAVIGATOR_KEY, ROUTE_KEY, ROUTER_KEY } from "./context";
-
-  import type { Router } from "@real-router/core";
-  import type { Snippet } from "svelte";
-
-  let {
-    router,
-    children,
-    announceNavigation,
-  }: { router: Router; children: Snippet; announceNavigation?: boolean } =
-    $props();
-
-  $effect(() => {
-    if (!announceNavigation) return;
-    const announcer = createRouteAnnouncer(router);
-    return () => announcer.destroy();
-  });
-
-  const navigator = getNavigator(router);
-  const source = createRouteSource(router);
-  const reactive = createReactiveSource(source);
-
-  setContext(ROUTER_KEY, router);
-  setContext(NAVIGATOR_KEY, navigator);
-  setContext(ROUTE_KEY, {
-    navigator,
-    get route() {
-      return {
-        get current() {
-          return reactive.current.route;
-        },
-      };
-    },
-    get previousRoute() {
-      return {
-        get current() {
-          return reactive.current.previousRoute;
-        },
-      };
-    },
-  });
-</script>
-
-{@render children()}

package/src/actions/link.svelte.ts

@@ -1,90 +0,0 @@
-import { getContext } from "svelte";
-import type { ActionReturn } from "svelte/action";
-import type { Router, Params, NavigationOptions } from "@real-router/core";
-import { ROUTER_KEY } from "../context";
-import { shouldNavigate, applyLinkA11y } from "dom-utils";
-
-export interface LinkActionParams {
-  name: string;
-  params?: Params;
-  options?: NavigationOptions;
-}
-
-/**
- * Factory function that captures router context during component initialization.
- * Must be called during component init (not inside event handlers or effects).
- *
- * @returns Action function for use with `use:` directive
- * @throws Error if called outside RouterProvider
- *
- * @example
- * ```svelte
- * <script>
- *   import { createLinkAction } from '@real-router/svelte';
- *   const link = createLinkAction();
- * </script>
- *
- * <button use:link={{ name: 'home' }}>Home</button>
- * <a use:link={{ name: 'users', params: { id: '123' } }}>User Profile</a>
- * ```
- */
-export function createLinkAction(): (
-  node: HTMLElement,
-  params: LinkActionParams,
-) => ActionReturn<LinkActionParams> {
-  const router = getContext<Router | undefined>(ROUTER_KEY);
-
-  if (!router) {
-    throw new Error("createLinkAction must be called inside a RouterProvider");
-  }
-
-  return function link(
-    node: HTMLElement,
-    params: LinkActionParams,
-  ): ActionReturn<LinkActionParams> {
-    let currentParams = params;
-
-    applyLinkA11y(node);
-
-    function handleClick(evt: MouseEvent) {
-      if (!shouldNavigate(evt)) return;
-      evt.preventDefault();
-      // router is guaranteed to exist due to check in factory
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      router!
-        .navigate(
-          currentParams.name,
-          currentParams.params ?? {},
-          currentParams.options ?? {},
-        )
-        .catch(() => {});
-    }
-
-    function handleKeyDown(evt: KeyboardEvent) {
-      if (evt.key === "Enter" && !(node instanceof HTMLButtonElement)) {
-        // router is guaranteed to exist due to check in factory
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        router!
-          .navigate(
-            currentParams.name,
-            currentParams.params ?? {},
-            currentParams.options ?? {},
-          )
-          .catch(() => {});
-      }
-    }
-
-    node.addEventListener("click", handleClick);
-    node.addEventListener("keydown", handleKeyDown);
-
-    return {
-      update(newParams: LinkActionParams) {
-        currentParams = newParams;
-      },
-      destroy() {
-        node.removeEventListener("click", handleClick);
-        node.removeEventListener("keydown", handleKeyDown);
-      },
-    };
-  };
-}

package/src/components/Lazy.svelte

@@ -1,47 +0,0 @@
-<script lang="ts">
-  import type { Component } from "svelte";
-
-  let {
-    loader,
-    fallback,
-  }: {
-    loader: () => Promise<{ default: Component }>;
-    fallback?: Component | undefined;
-  } = $props();
-
-  let LoadedComponent = $state<Component | null>(null);
-  let error = $state<Error | null>(null);
-  let loading = $state(true);
-
-  $effect(() => {
-    loading = true;
-    error = null;
-    LoadedComponent = null;
-    let active = true;
-
-    loader()
-      .then((module) => {
-        if (!active) return;
-        LoadedComponent = module.default;
-        loading = false;
-      })
-      .catch((err) => {
-        if (!active) return;
-        error = err;
-        loading = false;
-      });
-
-    return () => {
-      active = false;
-    };
-  });
-</script>
-
-{#if loading && fallback}
-  {@const Fallback = fallback}
-  <Fallback />
-{:else if error}
-  <p>Error loading component: {error.message}</p>
-{:else if LoadedComponent}
-  <LoadedComponent />
-{/if}

package/src/components/Link.svelte

@@ -1,69 +0,0 @@
-<script lang="ts">
-  import { useIsActiveRoute } from "../composables/useIsActiveRoute.svelte";
-  import { useRouter } from "../composables/useRouter.svelte";
-  import { shouldNavigate, buildHref, buildActiveClassName } from "dom-utils";
-
-  import type { NavigationOptions, Params } from "@real-router/core";
-  import type { Snippet } from "svelte";
-
-  let {
-    routeName,
-    routeParams = {} as Params,
-    routeOptions = {} as NavigationOptions,
-    class: className = undefined,
-    activeClassName = "active",
-    activeStrict = false,
-    ignoreQueryParams = true,
-    target = undefined,
-    children = undefined,
-    onclick: userOnClick = undefined,
-    ...restProps
-  }: {
-    routeName: string;
-    routeParams?: Params;
-    routeOptions?: NavigationOptions;
-    class?: string;
-    activeClassName?: string;
-    activeStrict?: boolean;
-    ignoreQueryParams?: boolean;
-    target?: string;
-    children?: Snippet;
-    onclick?: (evt: MouseEvent) => void;
-    [key: string]: unknown;
-  } = $props();
-
-  const router = useRouter();
-  const activeState = useIsActiveRoute(
-    routeName,
-    routeParams,
-    activeStrict,
-    ignoreQueryParams,
-  );
-
-  const href = $derived(buildHref(router, routeName, routeParams));
-
-  const finalClassName = $derived(
-    buildActiveClassName(activeState.current, activeClassName, className),
-  );
-
-  function handleClick(evt: MouseEvent) {
-    if (userOnClick) {
-      userOnClick(evt);
-
-      if (evt.defaultPrevented) {
-        return;
-      }
-    }
-
-    if (!shouldNavigate(evt) || target === "_blank") {
-      return;
-    }
-
-    evt.preventDefault();
-    router.navigate(routeName, routeParams, routeOptions).catch(() => {});
-  }
-</script>
-
-<a {href} class={finalClassName} {target} onclick={handleClick} {...restProps}>
-  {@render children?.()}
-</a>

package/src/components/RouteView.svelte

@@ -1,46 +0,0 @@
-<script lang="ts">
-  import { UNKNOWN_ROUTE } from "@real-router/core";
-  import { startsWithSegment } from "@real-router/route-utils";
-
-  import { useRouteNode } from "../composables/useRouteNode.svelte";
-
-  import type { Snippet } from "svelte";
-
-  let {
-    nodeName,
-    notFound,
-    ...segmentSnippets
-  }: {
-    nodeName: string;
-    notFound?: Snippet;
-    [key: string]: Snippet | string | undefined;
-  } = $props();
-
-  const routeContext = useRouteNode(nodeName);
-
-  function getActiveSegment(
-    routeName: string,
-    node: string,
-    snippets: Record<string, unknown>,
-  ): string {
-    for (const segment of Object.keys(snippets)) {
-      const fullSegmentName = node ? `${node}.${segment}` : segment;
-
-      if (startsWithSegment(routeName, fullSegmentName)) {
-        return segment;
-      }
-    }
-
-    return "";
-  }
-</script>
-
-{#if routeContext.route.current}
-  {@const route = routeContext.route.current}
-  {@const segment = getActiveSegment(route.name, nodeName, segmentSnippets)}
-  {#if segment && segmentSnippets[segment]}
-    {@render (segmentSnippets[segment] as Snippet)()}
-  {:else if route.name === UNKNOWN_ROUTE && notFound}
-    {@render notFound()}
-  {/if}
-{/if}

package/src/components/RouterErrorBoundary.svelte

@@ -1,47 +0,0 @@
-<script lang="ts">
-  import { untrack } from "svelte";
-
-  import { useRouterError } from "../composables/useRouterError.svelte";
-
-  import type { RouterError, State } from "@real-router/core";
-  import type { Snippet } from "svelte";
-
-  interface Props {
-    children: Snippet;
-    fallback: Snippet<[RouterError, () => void]>;
-    onError?: (
-      error: RouterError,
-      toRoute: State | null,
-      fromRoute: State | null,
-    ) => void;
-  }
-
-  let { children, fallback, onError }: Props = $props();
-
-  const snapshot = useRouterError();
-  let dismissedVersion = $state(-1);
-
-  const visibleError = $derived(
-    snapshot.current.version > dismissedVersion
-      ? snapshot.current.error
-      : null,
-  );
-
-  function resetError(): void {
-    dismissedVersion = snapshot.current.version;
-  }
-
-  $effect(() => {
-    if (snapshot.current.error) {
-      const { error, toRoute, fromRoute } = snapshot.current;
-      untrack(() => {
-        onError?.(error, toRoute, fromRoute);
-      });
-    }
-  });
-</script>
-
-{@render children?.()}
-{#if visibleError}
-  {@render fallback(visibleError, resetError)}
-{/if}

package/src/composables/useIsActiveRoute.svelte.ts

@@ -1,22 +0,0 @@
-import { createActiveRouteSource } from "@real-router/sources";
-
-import { createReactiveSource } from "../createReactiveSource.svelte";
-import { useRouter } from "./useRouter.svelte";
-
-import type { Params } from "@real-router/core";
-
-export function useIsActiveRoute(
-  routeName: string,
-  params?: Params,
-  strict = false,
-  ignoreQueryParams = true,
-): { readonly current: boolean } {
-  const router = useRouter();
-
-  const source = createActiveRouteSource(router, routeName, params, {
-    strict,
-    ignoreQueryParams,
-  });
-
-  return createReactiveSource(source);
-}

package/src/composables/useNavigator.svelte.ts

@@ -1,15 +0,0 @@
-import { getContext } from "svelte";
-
-import { NAVIGATOR_KEY } from "../context";
-
-import type { Navigator } from "@real-router/core";
-
-export const useNavigator = (): Navigator => {
-  const navigator = getContext<Navigator | undefined>(NAVIGATOR_KEY);
-
-  if (!navigator) {
-    throw new Error("useNavigator must be used within a RouterProvider");
-  }
-
-  return navigator;
-};

package/src/composables/useRoute.svelte.ts

@@ -1,15 +0,0 @@
-import { getContext } from "svelte";
-
-import { ROUTE_KEY } from "../context";
-
-import type { RouteContext } from "../types";
-
-export const useRoute = (): RouteContext => {
-  const routeContext = getContext<RouteContext | undefined>(ROUTE_KEY);
-
-  if (!routeContext) {
-    throw new Error("useRoute must be used within a RouterProvider");
-  }
-
-  return routeContext;
-};

package/src/composables/useRouteNode.svelte.ts

@@ -1,33 +0,0 @@
-import { getNavigator } from "@real-router/core";
-import { createRouteNodeSource } from "@real-router/sources";
-
-import { createReactiveSource } from "../createReactiveSource.svelte";
-import { useRouter } from "./useRouter.svelte";
-
-import type { RouteContext } from "../types";
-
-export function useRouteNode(nodeName: string): RouteContext {
-  const router = useRouter();
-  const navigator = getNavigator(router);
-
-  const source = createRouteNodeSource(router, nodeName);
-  const reactive = createReactiveSource(source);
-
-  return {
-    navigator,
-    get route() {
-      return {
-        get current() {
-          return reactive.current.route;
-        },
-      };
-    },
-    get previousRoute() {
-      return {
-        get current() {
-          return reactive.current.previousRoute;
-        },
-      };
-    },
-  };
-}

package/src/composables/useRouteUtils.svelte.ts

@@ -1,12 +0,0 @@
-import { getPluginApi } from "@real-router/core/api";
-import { getRouteUtils } from "@real-router/route-utils";
-
-import { useRouter } from "./useRouter.svelte";
-
-import type { RouteUtils } from "@real-router/route-utils";
-
-export const useRouteUtils = (): RouteUtils => {
-  const router = useRouter();
-
-  return getRouteUtils(getPluginApi(router).getTree());
-};

package/src/composables/useRouter.svelte.ts

@@ -1,15 +0,0 @@
-import { getContext } from "svelte";
-
-import { ROUTER_KEY } from "../context";
-
-import type { Router } from "@real-router/core";
-
-export const useRouter = (): Router => {
-  const router = getContext<Router | undefined>(ROUTER_KEY);
-
-  if (!router) {
-    throw new Error("useRouter must be used within a RouterProvider");
-  }
-
-  return router;
-};

package/src/composables/useRouterError.svelte.ts

@@ -1,21 +0,0 @@
-import { createErrorSource } from "@real-router/sources";
-
-import { createReactiveSource } from "../createReactiveSource.svelte";
-import { useRouter } from "./useRouter.svelte";
-
-import type { Router } from "@real-router/core";
-import type { RouterErrorSnapshot, RouterSource } from "@real-router/sources";
-
-const cache = new WeakMap<Router, RouterSource<RouterErrorSnapshot>>();
-
-export function useRouterError(): { readonly current: RouterErrorSnapshot } {
-  const router = useRouter();
-
-  let source = cache.get(router);
-  if (!source) {
-    source = createErrorSource(router);
-    cache.set(router, source);
-  }
-
-  return createReactiveSource(source);
-}

package/src/composables/useRouterTransition.svelte.ts

@@ -1,16 +0,0 @@
-import { createTransitionSource } from "@real-router/sources";
-
-import { createReactiveSource } from "../createReactiveSource.svelte";
-import { useRouter } from "./useRouter.svelte";
-
-import type { RouterTransitionSnapshot } from "@real-router/sources";
-
-export function useRouterTransition(): {
-  readonly current: RouterTransitionSnapshot;
-} {
-  const router = useRouter();
-
-  const source = createTransitionSource(router);
-
-  return createReactiveSource(source);
-}

package/src/context.ts

@@ -1,5 +0,0 @@
-export const ROUTER_KEY = "real-router:router";
-
-export const NAVIGATOR_KEY = "real-router:navigator";
-
-export const ROUTE_KEY = "real-router:route";

package/src/createReactiveSource.svelte.ts

@@ -1,21 +0,0 @@
-import { createSubscriber } from "svelte/reactivity";
-
-import type { RouterSource } from "@real-router/sources";
-
-export function createReactiveSource<T>(source: RouterSource<T>): {
-  readonly current: T;
-} {
-  const subscribe = createSubscriber((update) => {
-    return source.subscribe(() => {
-      update();
-    });
-  });
-
-  return {
-    get current(): T {
-      subscribe();
-
-      return source.getSnapshot();
-    },
-  };
-}

package/src/index.ts

@@ -1,44 +0,0 @@
-// Components
-export { default as RouteView } from "./components/RouteView.svelte";
-
-export { default as Link } from "./components/Link.svelte";
-
-export { default as Lazy } from "./components/Lazy.svelte";
-
-export { default as RouterErrorBoundary } from "./components/RouterErrorBoundary.svelte";
-
-// Reactive Primitives
-export { createReactiveSource } from "./createReactiveSource.svelte";
-
-// Composables
-export { useRouter } from "./composables/useRouter.svelte";
-
-export { useNavigator } from "./composables/useNavigator.svelte";
-
-export { useRouteUtils } from "./composables/useRouteUtils.svelte";
-
-export { useRoute } from "./composables/useRoute.svelte";
-
-export { useRouteNode } from "./composables/useRouteNode.svelte";
-
-export { useRouterTransition } from "./composables/useRouterTransition.svelte";
-
-// Actions
-export { createLinkAction } from "./actions/link.svelte";
-
-export type { LinkActionParams } from "./actions/link.svelte";
-
-// Context
-export { default as RouterProvider } from "./RouterProvider.svelte";
-
-export { ROUTER_KEY, NAVIGATOR_KEY, ROUTE_KEY } from "./context";
-
-// Types
-export type { LinkProps, RouteContext } from "./types";
-
-export type { Navigator } from "@real-router/core";
-
-export type {
-  RouterTransitionSnapshot,
-  RouterErrorSnapshot,
-} from "@real-router/sources";

package/src/types.ts

@@ -1,23 +0,0 @@
-import type {
-  NavigationOptions,
-  Navigator,
-  Params,
-  State,
-} from "@real-router/core";
-
-export interface RouteContext {
-  readonly navigator: Navigator;
-  readonly route: { readonly current: State | undefined };
-  readonly previousRoute: { readonly current: State | undefined };
-}
-
-export interface LinkProps<P extends Params = Params> {
-  readonly routeName: string;
-  readonly routeParams?: P;
-  readonly routeOptions?: NavigationOptions;
-  readonly class?: string;
-  readonly activeClassName?: string;
-  readonly activeStrict?: boolean;
-  readonly ignoreQueryParams?: boolean;
-  readonly target?: string;
-}