@real-router/svelte 0.0.1

package/src/composables/useIsActiveRoute.svelte.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,15 @@
+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/useRouterTransition.svelte.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,39 @@
+// 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";
+
+// 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 } from "@real-router/sources";

package/src/types.ts

@@ -0,0 +1,23 @@
+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;
+}