@typed/router 0.13.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/router",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -19,18 +19,20 @@
     }
   },
   "dependencies": {
-    "@effect/data": "^0.12.2",
-    "@effect/io": "^0.25.11",
-    "@typed/context": "0.13.0",
-    "@typed/dom": "8.13.0",
-    "@typed/fx": "1.13.0",
-    "@typed/html": "3.13.0",
-    "@typed/path": "0.4.0",
-    "@typed/route": "0.10.0"
+    "@effect/data": "^0.16.0",
+    "@effect/io": "^0.35.1",
+    "@typed/context": "0.15.0",
+    "@typed/dom": "8.15.0",
+    "@typed/html": "3.15.0",
+    "@typed/navigation": "0.2.0",
+    "@typed/fx": "1.15.0",
+    "@typed/error": "0.15.0",
+    "@typed/route": "0.12.0",
+    "@typed/path": "0.5.0"
   },
-  "gitHead": "14059cee732408d38a141b5295a999c43c6aa94b",
+  "gitHead": "781662109038798bdc35ec7a6de3551ec16aaa0a",
   "publishConfig": {
     "access": "public"
   },
   "sideEffects": false
-}
+}

package/project.json

@@ -11,20 +11,24 @@
           }
         ]
       },
-      "outputs": [
-        "{projectRoot}/dist"
-      ]
+      "outputs": ["{projectRoot}/dist"]
     },
     "lint": {
       "executor": "@nrwl/linter:eslint",
       "options": {
-        "lintFilePatterns": [
-          "packages/router/src/**/*.ts"
-        ]
+        "lintFilePatterns": ["packages/router/src/**/*.ts"]
       }
     },
     "test": {
-      "executor": "@nrwl/vite:test"
+      "executor": "@nrwl/vite:test",
+      "options": {
+        "globals": true
+      },
+      "configurations": {
+        "watch": {
+          "watch": true
+        }
+      }
     },
     "build:cjs": {
       "executor": "nx:run-commands",
@@ -36,9 +40,7 @@
         ],
         "parallel": false
       },
-      "outputs": [
-        "{projectRoot}/dist/cjs"
-      ]
+      "outputs": ["{projectRoot}/dist/cjs"]
     }
   }
 }

package/src/Link.ts

@@ -1,48 +1,138 @@
 import * as Effect from '@effect/io/Effect'
 import * as Scope from '@effect/io/Scope'
-import { assign } from '@typed/dom'
 import * as Fx from '@typed/fx'
-import { EventHandler, html, RenderContext, type Placeholder } from '@typed/html'
+import { Placeholder } from '@typed/html'
+import * as Navigation from '@typed/navigation'
 import { pathJoin } from '@typed/path'
 
-import { Router, getBasePath } from './router.js'
-
-export function Link<R = never, E = never, R2 = never>(
-  props: LinkProps<R, E, R2>,
-): Fx.Fx<R | R2 | Document | RenderContext | Router | Scope.Scope, E, HTMLAnchorElement> {
-  return Fx.gen(function* ($) {
-    const useBase = props.useBase ?? true
-    const href = useBase ? pathJoin(yield* $(getBasePath), props.href) || '/' : props.href
-    const router = yield* $(Router)
-    const clickHandler = (event: MouseEvent & { currentTarget: HTMLAnchorElement }) =>
-      Effect.gen(function* ($) {
-        if (props.fullReload) {
-          yield* $(assign(href))
-        } else {
-          yield* $(router.currentPath.set(href))
-        }
-
-        if (props.onClick) {
-          yield* $(props.onClick(event))
-        }
-      })
-
-    return html.as<HTMLAnchorElement>()`<a
-      class=${props.className}
-      href=${href}
-      onclick=${EventHandler.preventDefault(clickHandler)}
-      >${props.label}</a>`
-  })
+import { Router, getCurrentPathFromUrl } from './router.js'
+
+export interface UseLinkParams<
+  R = never,
+  E = never,
+  R2 = never,
+  E2 = never,
+  R3 = never,
+  E3 = never,
+  R4 = never,
+  E4 = never,
+  R5 = never,
+  E5 = never,
+> {
+  readonly to: Placeholder<R, E, string>
+  readonly replace?: Placeholder<R2, E2, boolean>
+  readonly state?: Placeholder<R3, E3, unknown> | unknown
+  readonly relative?: Placeholder<R4, E4, boolean>
+  readonly key?: Placeholder<R5, E5, string>
+}
+
+export namespace UseLinkParams {
+  export type Any = UseLinkParams<any, any, any, any, any, any, any, any, any, any>
+
+  export type Context<T extends Any> = Placeholder.ResourcesOf<
+    T['to'] | T['replace'] | T['state'] | T['relative'] | T['key']
+  >
+
+  export type Error<T extends Any> = Placeholder.ErrorsOf<
+    T['to'] | T['replace'] | T['state'] | T['relative'] | T['key']
+  >
+}
+
+export interface UseLink<E> {
+  readonly url: Fx.Computed<Router, E, string>
+  readonly options: Fx.Computed<never, E, Navigation.NavigateOptions>
+  readonly navigate: Effect.Effect<Router, E, Navigation.Destination>
+  readonly active: Fx.Computed<Router, E, boolean>
+}
+
+export namespace UseLink {
+  export type FromParams<T extends UseLinkParams.Any> = [UseLink<UseLinkParams.Error<T>>] extends [
+    infer U,
+  ]
+    ? U
+    : never
+}
+
+export function useLink<Params extends UseLinkParams.Any>(
+  params: Params,
+): Effect.Effect<UseLinkParams.Context<Params> | Scope.Scope, never, UseLink.FromParams<Params>> {
+  return Effect.map(
+    Effect.all([
+      Placeholder.asRef(params.to),
+      Placeholder.asRef(params.replace ?? false),
+      Placeholder.asRef(params.state ?? null),
+      Placeholder.asRef(params.key),
+      Placeholder.asRef(params.relative ?? true),
+    ] as const),
+    ([to, replace, state, key, relative]) => {
+      const url = Fx.RefSubject.tuple(to, relative).mapEffect(([to, relative]) =>
+        Effect.gen(function* ($) {
+          let url = to
+
+          // Check if we should make the URL relative to the current route
+          if (relative) {
+            const { route, params } = yield* $(Router)
+            const matched = yield* $(params)
+            const basePath = route.make(matched)
+
+            url = pathJoin(basePath, url)
+          }
+
+          return url
+        }),
+      )
+      const options = Fx.RefSubject.tuple(replace, state, key).map(
+        ([replace, state, key]): Navigation.NavigateOptions => ({
+          history: replace ? 'replace' : 'push',
+          state,
+          key: key ?? undefined,
+        }),
+      )
+
+      const active: Fx.Computed<Router, UseLinkParams.Error<Params>, boolean> = url.mapEffect(
+        (url) =>
+          Effect.gen(function* ($) {
+            const {
+              navigation: { currentEntry },
+            } = yield* $(Router)
+
+            return isActive(url, (yield* $(currentEntry)).url)
+          }),
+      )
+
+      const navigate: Effect.Effect<
+        Router,
+        UseLinkParams.Error<Params>,
+        Navigation.Destination
+      > = Effect.flatMap(Effect.all([url, options] as const), ([url, options]) =>
+        Router.withEffect((r) => r.navigation.navigate(url, options)),
+      )
+
+      return {
+        url,
+        options,
+        navigate,
+        active,
+      } satisfies UseLink.FromParams<Params>
+    },
+  )
+}
+
+export function Link<Params extends UseLinkParams.Any, R, E, A>(
+  params: Params,
+  render: (use: UseLink.FromParams<Params>) => Fx.Fx<R, E, A>,
+): Fx.Fx<Scope.Scope | R | UseLinkParams.Context<Params>, E, A> {
+  return Fx.fromFxEffect(Effect.map(useLink(params), render))
 }
 
-export interface LinkProps<R, E, R2> {
-  readonly href: string
-  readonly label: string | Placeholder<R, E>
-  readonly className?: string
-  readonly onClick?: (
-    event: MouseEvent & { currentTarget: HTMLAnchorElement },
-  ) => Effect.Effect<R2, never, unknown>
+function isActive(url: string, current: URL): boolean {
+  const { pathname } = current
 
-  readonly useBase?: boolean
-  readonly fullReload?: boolean
+  return (
+    url === current.href ||
+    url === pathname ||
+    url === pathname + current.search ||
+    url === pathname + current.hash ||
+    url === getCurrentPathFromUrl(current)
+  )
 }

package/src/Match.ts

@@ -0,0 +1,114 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fx from '@typed/fx'
+import { NavigationError } from '@typed/navigation'
+import { ParamsOf } from '@typed/path'
+import { Route } from '@typed/route'
+
+export type MatchOptions<
+  P extends string,
+  Guard extends Effect.Effect<any, NavigationError, boolean> = Effect.Effect<
+    never,
+    NavigationError,
+    boolean
+  >,
+  Matched extends Effect.Effect<any, any, any> = Effect.Effect<never, never, unknown>,
+> = {
+  readonly guard?: (params: ParamsOf<P>) => Guard
+  readonly onMatch?: (params: ParamsOf<P>) => Matched
+}
+
+export namespace MatchOptions {
+  export type Any<P extends string> =
+    | MatchOptions<P, any, any>
+    | MatchOptions<P, never, never>
+    | MatchOptions<P, any, never>
+    | MatchOptions<P, never, any>
+}
+
+export type Match<
+  in out P extends string,
+  out Rendered extends Fx.Fx<any, any, any>,
+  in out Options extends MatchOptions.Any<P> = MatchOptions<P>,
+> = {
+  readonly route: Route<P>
+  readonly render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Rendered
+  readonly options?: Options
+}
+
+export namespace Match {
+  export type Any = Match<any, any, any> | Match<any, any, never>
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export type Rendered<M extends Any> = M extends Match<any, infer R, infer _> ? R : never
+
+  export type Options<M extends Any> = M extends Match<any, any, infer Options> ? Options : never
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export type Guard<M extends Any> = [Options<M>] extends [MatchOptions<any, infer Guard, infer _>]
+    ? Guard
+    : never
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export type Matched<M extends Any> = Options<M> extends MatchOptions<any, infer _, infer Matched>
+    ? Matched
+    : never
+
+  export type Context<M extends Any> =
+    | Fx.Fx.ResourcesOf<Rendered<M>>
+    | ([Guard<M>] extends [never] ? never : Effect.Effect.Context<Guard<M>>)
+    | ([Matched<M>] extends [never] ? never : Effect.Effect.Context<Matched<M>>)
+
+  export type Error<M extends Any> =
+    | Fx.Fx.ErrorsOf<Rendered<M>>
+    | ([Guard<M>] extends [never] ? never : Exclude<Effect.Effect.Error<Guard<M>>, NavigationError>)
+    | ([Matched<M>] extends [never] ? never : Effect.Effect.Error<Matched<M>>)
+
+  export type Success<M extends Any> = Fx.Fx.OutputOf<Rendered<M>>
+}
+
+export function Match<P extends string, Rendered extends Fx.Fx<any, any, any>>(
+  route: Route<P>,
+  render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Rendered,
+): Match<P, Rendered, MatchOptions<P>>
+
+export function Match<
+  P extends string,
+  Rendered extends Fx.Fx<any, any, any>,
+  Options extends MatchOptions.Any<P>,
+>(
+  route: Route<P>,
+  render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Rendered,
+  options: Options,
+): Match<P, Rendered, Options>
+
+export function Match<
+  P extends string,
+  Rendered extends Fx.Fx<any, any, any>,
+  Options extends MatchOptions.Any<P> = MatchOptions<P, never, never>,
+>(
+  route: Route<P>,
+  render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Rendered,
+  options?: Options,
+): Match<P, Rendered, Options> | Match<P, Rendered, never> {
+  return {
+    route,
+    render,
+    options,
+  }
+}
+
+Match.lazy = function <
+  P extends string,
+  Rendered extends Fx.Fx<any, any, any>,
+  Options extends MatchOptions.Any<P> = MatchOptions<P>,
+>(
+  route: Route<P>,
+  render: () => Promise<(params: Fx.Filtered<never, never, ParamsOf<P>>) => Rendered>,
+  options?: Options,
+): Match<P, Rendered, Options> | Match<P, Rendered, never> {
+  return {
+    route,
+    render: (params) => Fx.promiseFx(() => render().then((f) => f(params))) as Rendered,
+    options,
+  }
+}

package/src/Matcher.ts

@@ -0,0 +1,139 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Debug from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Fx from '@typed/fx'
+import { RenderContext } from '@typed/html'
+import { ParamsOf } from '@typed/path'
+import { Route } from '@typed/route'
+
+import { Match, MatchOptions } from './Match.js'
+import { Redirect } from './Redirect.js'
+import { matchRoutes } from './matchRoutes.js'
+import { Router } from './router.js'
+
+export interface Matcher<Matches extends ReadonlyArray<Match.Any>> {
+  /** @internal */
+  readonly matches: Chunk.Chunk<Match.Any>
+
+  readonly match: <P extends string, R, E, A, Opts extends MatchOptions.Any<P> = MatchOptions<P>>(
+    route: Route<P>,
+    render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Fx.Fx<R, E, A>,
+    options?: Opts,
+  ) => Matcher<readonly [...Matches, Match<P, Fx.Fx<R, E, A>, Opts>]>
+
+  readonly matchLazy: <
+    P extends string,
+    R,
+    E,
+    A,
+    Opts extends MatchOptions.Any<P> = MatchOptions<P>,
+  >(
+    route: Route<P>,
+    render: () => Promise<(params: Fx.Filtered<never, never, ParamsOf<P>>) => Fx.Fx<R, E, A>>,
+    options?: Opts,
+  ) => Matcher<readonly [...Matches, Match<P, Fx.Fx<R, E, A>, Opts>]>
+
+  readonly notFound: <R, E, A>(
+    render: (params: Fx.Filtered<never, never, Readonly<Record<string, string>>>) => Fx.Fx<R, E, A>,
+  ) => Fx.Fx<
+    Router | RenderContext | R | Match.Context<Matches[number]>,
+    Exclude<E | Match.Error<Matches[number]>, Redirect>,
+    A | Match.Success<Matches[number]>
+  >
+
+  readonly concat: <OtherMatches extends ReadonlyArray<Match.Any>>(
+    other: Matcher<OtherMatches>,
+  ) => Matcher<readonly [...Matches, ...OtherMatches]>
+}
+
+export function Matcher<const Matches extends ReadonlyArray<Match.Any>>(
+  matches: Chunk.Chunk<Match.Any>,
+): Matcher<Matches> {
+  return {
+    matches,
+
+    match<P extends string, R, E, A, Opts extends MatchOptions.Any<P> = never>(
+      route: Route<P>,
+      render: (params: Fx.Filtered<never, never, ParamsOf<P>>) => Fx.Fx<R, E, A>,
+      options?: Opts,
+    ): Matcher<readonly [...Matches, Match<P, Fx.Fx<R, E, A>, Opts>]> {
+      return Matcher(Chunk.append(matches, Match(route, render, options || {})))
+    },
+
+    matchLazy<P extends string, R, E, A, Opts extends MatchOptions.Any<P> = never>(
+      route: Route<P>,
+      render: () => Promise<(params: Fx.Filtered<never, never, ParamsOf<P>>) => Fx.Fx<R, E, A>>,
+      options?: Opts,
+    ): Matcher<readonly [...Matches, Match<P, Fx.Fx<R, E, A>, Opts>]> {
+      return Matcher(Chunk.append(matches, Match.lazy(route, render, options || {})))
+    },
+
+    notFound: <R, E, A>(
+      render: (
+        params: Fx.Filtered<never, never, Readonly<Record<string, string>>>,
+      ) => Fx.Fx<R, E, A>,
+    ) => Fx.scoped(matchRoutes(Chunk.toReadonlyArray(matches) as Matches, render)),
+
+    concat: <OtherMatches extends ReadonlyArray<Match.Any>>(
+      other: Matcher<OtherMatches>,
+    ): Matcher<readonly [...Matches, ...OtherMatches]> => {
+      return Matcher(Chunk.appendAll(matches, other.matches))
+    },
+  }
+}
+
+export const { match, matchLazy } = Matcher<readonly []>(Chunk.empty())
+
+export const notFound: {
+  <R, E, A>(
+    render: (params: Fx.Filtered<never, never, Readonly<Record<string, string>>>) => Fx.Fx<R, E, A>,
+  ): <Matches extends readonly Match.Any[]>(
+    matcher: Matcher<Matches>,
+  ) => Fx.Fx<
+    Router | R | Match.Context<Matches[number]>,
+    Exclude<E | Match.Error<Matches[number]>, Redirect>,
+    A | Fx.Fx.OutputOf<Match.Rendered<Matches[number]>>
+  >
+
+  <Matches extends readonly Match.Any[], R, E, A>(
+    matcher: Matcher<Matches>,
+    render: (params: Fx.Filtered<never, never, Readonly<Record<string, string>>>) => Fx.Fx<R, E, A>,
+  ): Fx.Fx<
+    Router | R | Match.Context<Matches[number]>,
+    Exclude<E | Match.Error<Matches[number]>, Redirect>,
+    A | Fx.Fx.OutputOf<Match.Rendered<Matches[number]>>
+  >
+} = Debug.dual(
+  2,
+  <Matches extends readonly Match.Any[], R, E, A>(
+    matcher: Matcher<Matches>,
+    render: (params: Fx.Filtered<never, never, Readonly<Record<string, string>>>) => Fx.Fx<R, E, A>,
+  ) => matcher.notFound(render),
+)
+
+export const redirectEffect: {
+  <R, E>(
+    effect: Effect.Effect<R, E, never>,
+  ): <Matches extends readonly Match.Any[]>(
+    matcher: Matcher<Matches>,
+  ) => Fx.Fx<
+    Router | R | Match.Context<Matches[number]>,
+    Exclude<E | Match.Error<Matches[number]>, Redirect>,
+    Match.Success<Matches[number]>
+  >
+
+  <Matches extends readonly Match.Any[], R, E>(
+    matcher: Matcher<Matches>,
+    effect: Effect.Effect<R, E, never>,
+  ): Fx.Fx<
+    Router | R | Match.Context<Matches[number]>,
+    Exclude<E | Match.Error<Matches[number]>, Redirect>,
+    Match.Success<Matches[number]>
+  >
+} = Debug.dual(
+  2,
+  <Matches extends readonly Match.Any[], R, E>(
+    matcher: Matcher<Matches>,
+    effect: Effect.Effect<R, E, never>,
+  ) => notFound(matcher, () => Fx.fromEffect(effect)),
+)

package/src/Navigation.ts

@@ -0,0 +1,24 @@
+import * as Fx from '@typed/fx'
+import { Placeholder } from '@typed/html'
+import { NavigateOptions } from '@typed/navigation'
+
+import { Redirect } from './Redirect.js'
+
+export interface NavigationParams<R, E, R2, E2> {
+  // Configure the URL to navigate to
+  readonly url: Placeholder<R, E, string>
+  // Configure the options for the navigation, using @typed/navigation
+  readonly options?: Placeholder<R2, E2, NavigateOptions>
+}
+
+export function Navigation<R = never, E = never, R2 = never, E2 = never>(
+  params: NavigationParams<R, E, R2, E2>,
+): Fx.Fx<R | R2, E | E2 | Redirect, null> {
+  return Fx.startWith(
+    Fx.switchMapEffect(
+      Fx.combine(Placeholder.asFx(params.url), Placeholder.asFx(params.options)),
+      ([url, options]) => Redirect.redirect(url, options),
+    ),
+    null,
+  )
+}

package/src/Redirect.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/io/Effect'
+import * as E from '@typed/error'
+import * as Fx from '@typed/fx'
+import { NavigateOptions } from '@typed/navigation'
+
+export class Redirect extends E.tagged('@typed/router/Redirect') {
+  constructor(
+    readonly url: string,
+    readonly options?: NavigateOptions,
+  ) {
+    super(`Redirect to ${url}`)
+  }
+
+  static redirect(url: string, options?: NavigateOptions): Effect.Effect<never, Redirect, never> {
+    return Effect.fail(new Redirect(url, options))
+  }
+
+  static redirectFx(url: string, options?: NavigateOptions): Fx.Fx<never, Redirect, never> {
+    return Fx.fail(new Redirect(url, options))
+  }
+}

package/src/ScrollRestoration.ts

@@ -0,0 +1,110 @@
+import * as Duration from '@effect/data/Duration'
+import { pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Scope from '@effect/io/Scope'
+import * as Fx from '@typed/fx'
+import { ElementRef } from '@typed/html'
+import * as Navigation from '@typed/navigation'
+
+export interface ScrollRestorationParams<A extends HTMLElement> {
+  readonly ref: ElementRef<A>
+  readonly behavior?: ScrollBehavior
+  readonly retries?: number
+  readonly retryDelay?: (depth: number) => Duration.Duration
+}
+
+export type ScrollRestorationState = {
+  readonly scrollRestoration?: {
+    readonly scrollLeft: number
+    readonly scrollTop: number
+  }
+}
+
+const defaultDelay = (depth: number) => Duration.millis(10 * depth)
+
+export function ScrollRestoration<A extends HTMLElement>(
+  params: ScrollRestorationParams<A>,
+): Fx.Fx<Navigation.Navigation | Scope.Scope, never, null> {
+  return Fx.gen(function* ($) {
+    const { retries = 3, retryDelay = defaultDelay } = params
+    const { onNavigation, onNavigationEnd } = yield* $(Navigation.Navigation)
+
+    yield* $(
+      onNavigation((ev) =>
+        Effect.catchTag(
+          Effect.gen(function* ($) {
+            const state = (ev.destination.state ?? {}) as ScrollRestorationState
+
+            // If ScrollRestoration is not set, set it
+            if (!state.scrollRestoration) {
+              const el = yield* $(params.ref.element)
+              const scrollLeft = el.scrollLeft
+              const scrollTop = el.scrollTop
+
+              return yield* $(
+                Navigation.redirect(ev.destination.url.href, {
+                  history:
+                    ev.navigationType === Navigation.NavigationType.Replace ? 'replace' : 'push',
+                  state: {
+                    ...state,
+                    scrollRestoration: {
+                      scrollLeft,
+                      scrollTop,
+                    },
+                  },
+                }),
+              )
+            }
+          }),
+          // If there is not Element to scroll, ignore the error
+          'NoSuchElementException',
+          Effect.succeed,
+        ),
+      ),
+    )
+
+    yield* $(
+      onNavigationEnd(function restoreScroll(ev, depth = 0): Effect.Effect<never, never, void> {
+        return pipe(
+          Effect.gen(function* ($) {
+            if (depth > retries) {
+              return
+            }
+
+            const state = (ev.destination.state ?? {}) as ScrollRestorationState
+
+            // Restore scroll position on back/forward navigation
+            if (
+              ev.navigationType === Navigation.NavigationType.Back ||
+              ev.navigationType === Navigation.NavigationType.Forward
+            ) {
+              const scrollRestoration = state?.scrollRestoration
+
+              if (scrollRestoration) {
+                const el = yield* $(params.ref.element)
+
+                el.scroll({
+                  left: scrollRestoration.scrollLeft,
+                  top: scrollRestoration.scrollTop,
+                  behavior: params.behavior || 'smooth',
+                })
+              }
+            }
+          }),
+          // HACK: This isn't great, we should have some kind of way of letting the
+          // navigation know when an external render has finished.
+          Effect.catchTag(
+            // If there is not Element to scroll, attempt to retry a few times.
+            'NoSuchElementException',
+            () => {
+              const d = depth + 1
+              return Effect.delay(restoreScroll(ev, d), retryDelay(d))
+            },
+          ),
+        )
+      }),
+    )
+
+    return Fx.succeed(null)
+  })
+}

package/src/index.ts

@@ -1,4 +1,8 @@
-export * from './router.js'
 export * from './Link.js'
-export * from './RouteMatcher.js'
-export * from './RouteMatch.js'
+export * from './Match.js'
+export * from './Matcher.js'
+export * from './matchRoutes.js'
+export * from './Navigation.js'
+export * from './Redirect.js'
+export * from './router.js'
+export * from './ScrollRestoration.js'