@typed/router 0.27.7 → 0.28.0

package/src/Matcher.ts

@@ -2,197 +2,379 @@
  * @since 1.0.0
  */
 
-import { CurrentEnvironment } from "@typed/environment"
 import * as Fx from "@typed/fx/Fx"
 import * as Match from "@typed/fx/Match"
-import * as RefSubject from "@typed/fx/RefSubject"
-import * as Guard from "@typed/guard"
-import * as Navigation from "@typed/navigation"
-import type * as Path from "@typed/path"
-import * as Route from "@typed/route"
-import type { Scope } from "effect"
+import type * as RefSubject from "@typed/fx/RefSubject"
+import type { Navigation } from "@typed/navigation"
+import { CurrentPath, isRedirectError, navigate, RedirectError } from "@typed/navigation"
+import type * as Route from "@typed/route"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
+import { dual, pipe } from "effect/Function"
 import * as Option from "effect/Option"
+import { hasProperty } from "effect/Predicate"
+import type * as Scope from "effect/Scope"
+import * as Unify from "effect/Unify"
 import type { CurrentRoute } from "./CurrentRoute.js"
-import { makeHref, withCurrentRoute } from "./CurrentRoute.js"
+import { makeHref } from "./CurrentRoute.js"
+import type { MatchInput } from "./MatchInput.js"
+import * as RouteMatch from "./RouteMatch.js"
 
 /**
  * @since 1.0.0
  */
-export interface RouteMatcher<out A, out E, out R> {
-  readonly guards: ReadonlyArray<RouteGuard<string, any, A, E, R, E, R>>
-
-  readonly match: {
-    <const P extends string, B, E2, R2>(
-      route: Route.Route<P> | P,
-      f: (ref: RefSubject.RefSubject<Path.ParamsOf<P>>) => Fx.Fx<B, E2, R2>
-    ): RouteMatcher<A | B, E | E2, R | Exclude<R2, Scope.Scope>>
-
-    <const P extends string, B, E2, R2, C, E3, R3>(
-      route: Route.Route<P> | P,
-      guard: Guard.Guard<Path.ParamsOf<P>, B, E2, R2>,
-      f: (ref: RefSubject.RefSubject<B>) => Fx.Fx<C, E3, R3>
-    ): RouteMatcher<A | C, E | E2 | E3, R | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>
-  }
+export const RouteMatcherTypeId = Symbol.for("@typed/router/RouteMatcher")
 
-  readonly to: {
-    <const P extends string, B>(
-      route: Route.Route<P> | P,
-      f: (params: Path.ParamsOf<P>) => B
-    ): RouteMatcher<A | B, E, R>
-
-    <const P extends string, B, E2, R2, C, E3, R3>(
-      route: Route.Route<P> | P,
-      guard: Guard.Guard<Path.ParamsOf<P>, B, E2, R2>,
-      f: (b: B) => C
-    ): RouteMatcher<A | C, E | E2 | E3, R | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>>
-  }
+/**
+ * @since 1.0.0
+ */
+export type RouteMatcherTypeId = typeof RouteMatcherTypeId
+
+/**
+ * @since 1.0.0
+ */
+export interface RouteMatcher<Matches extends RouteMatch.RouteMatch.Any> {
+  readonly [RouteMatcherTypeId]: RouteMatcherTypeId
+
+  readonly matches: ReadonlyArray<Matches>
+
+  readonly add: <I extends RouteMatch.RouteMatch.Any>(match: I) => RouteMatcher<Matches | I>
 
-  readonly notFound: <B, E2, R2>(
-    f: (destination: typeof Navigation.CurrentEntry) => Fx.Fx<B, E2, R2>
-  ) => Fx.Fx<
-    A | B,
-    Exclude<E | E2, Navigation.RedirectError>,
-    Navigation.Navigation | CurrentEnvironment | R | R2 | Scope.Scope
+  readonly match: <I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: RefSubject.RefSubject<MatchInput.Success<I>>) => Fx.Fx<A, E, R>
+  ) => RouteMatcher<
+    | Matches
+    | RouteMatch.RouteMatch<
+      MatchInput.Route<I>,
+      MatchInput.Success<I>,
+      MatchInput.Error<I>,
+      MatchInput.Context<I>,
+      A,
+      E,
+      R
+    >
   >
 
-  readonly redirect: <const P extends string>(
-    route: Route.Route<P> | P,
-    ...params: [keyof Path.ParamsOf<P>] extends [never] ? [{}?] : [Path.ParamsOf<P>]
-  ) => Fx.Fx<
-    A,
-    Exclude<E, Navigation.RedirectError>,
-    Navigation.Navigation | CurrentRoute | CurrentEnvironment | R | Scope.Scope
+  readonly switch: <I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: MatchInput.Success<I>) => Fx.Fx<A, E, R>
+  ) => RouteMatcher<
+    | Matches
+    | RouteMatch.RouteMatch<
+      MatchInput.Route<I>,
+      MatchInput.Success<I>,
+      MatchInput.Error<I>,
+      MatchInput.Context<I>,
+      A,
+      E,
+      R | Scope.Scope
+    >
+  >
+
+  readonly effect: <I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: MatchInput.Success<I>) => Effect.Effect<A, E, R>
+  ) => RouteMatcher<
+    | Matches
+    | RouteMatch.RouteMatch<
+      MatchInput.Route<I>,
+      MatchInput.Success<I>,
+      MatchInput.Error<I>,
+      MatchInput.Context<I>,
+      A,
+      E,
+      R | Scope.Scope
+    >
+  >
+
+  readonly to: <I extends MatchInput.Any, B>(
+    input: I,
+    f: (value: MatchInput.Success<I>) => B
+  ) => RouteMatcher<
+    | Matches
+    | RouteMatch.RouteMatch<
+      MatchInput.Route<I>,
+      MatchInput.Success<I>,
+      MatchInput.Error<I>,
+      MatchInput.Context<I>,
+      B,
+      never,
+      Scope.Scope
+    >
   >
 }
 
 /**
  * @since 1.0.0
  */
-export interface RouteGuard<
-  P extends string,
-  A,
-  O,
-  E = never,
-  R = never,
-  E2 = never,
-  R2 = never
-> {
-  readonly route: Route.Route<P>
-  readonly guard: Guard.Guard<string, A, E, R>
-  readonly match: (ref: RefSubject.RefSubject<A>) => Fx.Fx<O, E2, R2>
+export namespace RouteMatcher {
+  /**
+   * @since 1.0.0
+   */
+  export type Any = RouteMatcher<RouteMatch.RouteMatch.Any>
+
+  /**
+   * @since 1.0.0
+   */
+  export type Context<T> = T extends RouteMatcher<infer Matches> ? RouteMatch.RouteMatch.Context<Matches> : never
 }
 
-class RouteMatcherImpl<A, E, R> implements RouteMatcher<A, E, R> {
-  constructor(readonly guards: ReadonlyArray<RouteGuard<any, any, any, any, any, any, any>>) {
+class RouteMatcherImpl<Matches extends RouteMatch.RouteMatch.Any> implements RouteMatcher<Matches> {
+  readonly [RouteMatcherTypeId]: RouteMatcherTypeId = RouteMatcherTypeId
+
+  constructor(readonly matches: ReadonlyArray<Matches>) {
+    this.add = this.add.bind(this)
     this.match = this.match.bind(this)
+    this.switch = this.switch.bind(this)
+    this.effect = this.effect.bind(this)
     this.to = this.to.bind(this)
-    this.notFound = this.notFound.bind(this)
-    this.redirect = this.redirect.bind(this)
   }
 
-  match(
-    ...args: any
-  ) {
-    const route = getRoute(args[0])
-    if (args.length === 2) {
-      return new RouteMatcherImpl([...this.guards, {
-        route,
-        guard: getGuard(route),
-        match: (ref: any) => Fx.scoped(args[1](ref))
-      }]) as any
-    } else {
-      return new RouteMatcherImpl([...this.guards, {
-        route,
-        guard: getGuard(route, args[1]),
-        match: (ref: any) => Fx.scoped(args[2](ref))
-      }]) as any
-    }
+  add<I extends RouteMatch.RouteMatch.Any>(match: I): RouteMatcher<Matches | I> {
+    return new RouteMatcherImpl([...this.matches, match])
   }
 
-  to(
-    ...args: any
+  match<I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: RefSubject.RefSubject<MatchInput.Success<I>>) => Fx.Fx<A, E, R>
   ) {
-    const route = getRoute(args[0])
-    if (args.length === 2) {
-      return this.match(route, (ref: any) => RefSubject.map(ref, args[1]))
-    } else {
-      return this.match(route, args[1], (ref: any) => RefSubject.map(ref, args[2]))
-    }
+    return this.add(RouteMatch.fromInput(input, match))
   }
 
-  notFound<B, E2, R2>(
-    f: (destination: RefSubject.Computed<Navigation.Destination, never, Navigation.Navigation>) => Fx.Fx<B, E2, R2>
-  ): Fx.Fx<
-    A | B,
-    Exclude<E | E2, Navigation.RedirectError>,
-    R | R2 | CurrentEnvironment | Navigation.Navigation | Scope.Scope
-  > {
-    return Fx.fromFxEffect(CurrentEnvironment.with((env) => {
-      const onNotFound = Fx.scoped(f(Navigation.CurrentEntry))
-      let matcher: Match.ValueMatcher<string, A | B, E | E2, R | R2 | Navigation.Navigation | Scope.Scope> = Match
-        .value(
-          // Only if we're rendering in a DOM-based environment should we allow for routing to last indefinitely
-          env === "dom" || env === "test:dom" ? Navigation.CurrentPath : Fx.take(Navigation.CurrentPath, 1)
-        )
-
-      for (const { guard, match, route } of this.guards) {
-        matcher = matcher.when(guard, (ref) => Fx.middleware(match(ref), withCurrentRoute(route)))
-      }
-
-      return Fx.filterMapErrorEffect(matcher.getOrElse(() => onNotFound), (e) =>
-        Navigation.isRedirectError(e)
-          // Fork the redirect to ensure it does not occur within the same runUpdates as the initial navigation
-          ? Effect.as(Effect.forkScoped(Navigation.handleRedirect(e)), Option.none())
-          : Effect.succeedSome(e as Exclude<E | E2, Navigation.RedirectError>))
-    }))
+  switch<I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: MatchInput.Success<I>) => Fx.Fx<A, E, R>
+  ) {
+    return this.match(input, Fx.switchMap(match))
   }
 
-  redirect<const P extends string>(
-    route: P | Route.Route<P>,
-    ...params: [keyof Path.ParamsOf<P>] extends [never] ? [{}?] : [Path.ParamsOf<P>]
-  ): Fx.Fx<
-    A,
-    Exclude<E, Navigation.RedirectError>,
-    R | Navigation.Navigation | CurrentEnvironment | CurrentRoute | Scope.Scope
-  > {
-    return this.notFound(() =>
-      RefSubject.mapEffect(makeHref(route, ...params), (s) => Effect.fail(Navigation.redirectToPath(s)))
-    )
-  }
-}
-function getGuard<const P extends string, B, E2, R2>(
-  path: Route.Route<P>,
-  guard?: Guard.Guard<Path.ParamsOf<P>, B, E2, R2>
-) {
-  if (guard) {
-    return Guard.compose(path, guard)
-  } else {
-    return path.asGuard()
+  effect<I extends MatchInput.Any, A, E, R>(
+    input: I,
+    match: (ref: MatchInput.Success<I>) => Effect.Effect<A, E, R>
+  ) {
+    return this.match(input, Fx.switchMapEffect(match))
   }
-}
 
-function getRoute<const P extends string>(route: Route.Route<P> | P): Route.Route<P> {
-  return typeof route === "string" ? Route.fromPath(route) : route
+  to<I extends MatchInput.Any, B>(
+    input: I,
+    f: (value: MatchInput.Success<I>) => B
+  ) {
+    return this.match(input, Fx.map(f))
+  }
 }
 
 /**
  * @since 1.0.0
  */
-export function empty(): RouteMatcher<never, never, never> {
-  return new RouteMatcherImpl<never, never, never>([]) as any
+export function make<Matches extends RouteMatch.RouteMatch.Any>(
+  matches: ReadonlyArray<Matches>
+): RouteMatcher<Matches> {
+  return new RouteMatcherImpl(matches)
 }
 
 /**
- * @since 1.18.0
+ * @since 1.0.0
  */
-export const {
+export const empty: RouteMatcher<never> = make<never>([])
+
+const { effect, match, switch: switch_, to } = empty
+
+export {
+  /**
+   * @since 1.0.0
+   */
+  effect,
   /**
    * @since 1.0.0
    */
   match,
+  /**
+   * @since 1.0.0
+   */
+  switch_ as switch,
   /**
    * @since 1.0.0
    */
   to
-} = empty()
+}
+
+/**
+ * @since 1.0.0
+ */
+export const catchRedirectError = <A, E, R>(
+  fx: Fx.Fx<A, E | RedirectError, R>
+): Fx.Fx<A, Exclude<E, RedirectError>, R | Scope.Scope | Navigation> =>
+  Fx.filterMapErrorEffect(
+    fx,
+    Unify.unify((_) =>
+      isRedirectError(_)
+        ? Effect.as(Effect.forkScoped(Effect.ignoreLogged(navigate(_.path, _.options))), Option.none())
+        : Effect.succeedSome(_ as Exclude<typeof _, RedirectError>)
+    )
+  )
+
+/**
+ * @since 1.0.0
+ */
+export const notFound: {
+  <A, E, R>(
+    onNotFound: Fx.Fx<A, E, R>
+  ): <Matches extends RouteMatch.RouteMatch.Any>(router: RouteMatcher<Matches>) => Fx.Fx<
+    A | RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Scope.Scope | Navigation | R | RouteMatch.RouteMatch.Context<Matches>
+  >
+
+  <Matches extends RouteMatch.RouteMatch.Any, A, E, R>(
+    router: RouteMatcher<Matches>,
+    onNotFound: Fx.Fx<A, E, R>
+  ): Fx.Fx<
+    A | RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Scope.Scope | Navigation | R | RouteMatch.RouteMatch.Context<Matches>
+  >
+} = dual(2, function notFound<Matches extends RouteMatch.RouteMatch.Any, A, E, R>(
+  router: RouteMatcher<Matches>,
+  onNotFound: Fx.Fx<A, E, R>
+): Fx.Fx<
+  A | RouteMatch.RouteMatch.Success<Matches>,
+  Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+  R | Navigation | RouteMatch.RouteMatch.Context<Matches> | Scope.Scope
+> {
+  let matcher = Match.value(CurrentPath) as Match.ValueMatcher<
+    string,
+    RouteMatch.RouteMatch.Success<Matches>,
+    RouteMatch.RouteMatch.Error<Matches>,
+    RouteMatch.RouteMatch.Context<Matches> | Navigation | Scope.Scope
+  >
+
+  for (const match of router.matches) {
+    matcher = matcher.when(match.guard, match.match)
+  }
+
+  return catchRedirectError(matcher.getOrElse(() => onNotFound))
+})
+
+/**
+ * @since 1.0.0
+ */
+export const notFoundWith: {
+  <A, E, R>(
+    onNotFound: Effect.Effect<A, E, R>
+  ): <Matches extends RouteMatch.RouteMatch.Any>(router: RouteMatcher<Matches>) => Fx.Fx<
+    A | RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    R | Navigation | RouteMatch.RouteMatch.Context<Matches> | Scope.Scope
+  >
+
+  <Matches extends RouteMatch.RouteMatch.Any, A, E, R>(
+    router: RouteMatcher<Matches>,
+    onNotFound: Effect.Effect<A, E, R>
+  ): Fx.Fx<
+    A | RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    R | Navigation | RouteMatch.RouteMatch.Context<Matches> | Scope.Scope
+  >
+} = dual(2, function notFoundWith<Matches extends RouteMatch.RouteMatch.Any, A, E, R>(
+  router: RouteMatcher<Matches>,
+  onNotFound: Effect.Effect<A, E, R>
+): Fx.Fx<
+  A | RouteMatch.RouteMatch.Success<Matches>,
+  Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+  R | Navigation | RouteMatch.RouteMatch.Context<Matches> | Scope.Scope
+> {
+  return notFound(router, Fx.fromEffect(onNotFound))
+})
+
+/**
+ * @since 1.0.0
+ */
+export function isRouteMatcher<M extends RouteMatch.RouteMatch.Any = RouteMatch.RouteMatch.Any>(
+  value: unknown
+): value is RouteMatcher<M> {
+  return hasProperty(value, RouteMatcherTypeId)
+}
+
+/**
+ * @since 1.0.0
+ */
+export const redirectWith: {
+  <E, R>(
+    effect: Effect.Effect<string, E, R>
+  ): <Matches extends RouteMatch.RouteMatch.Any>(router: RouteMatcher<Matches>) => Fx.Fx<
+    RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Navigation | Scope.Scope | R | RouteMatch.RouteMatch.Context<Matches>
+  >
+
+  <Matches extends RouteMatch.RouteMatch.Any, E, R>(
+    router: RouteMatcher<Matches>,
+    effect: Effect.Effect<string, E, R>
+  ): Fx.Fx<
+    RouteMatch.RouteMatch.Success<Matches>,
+    Exclude<E | RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Navigation | Scope.Scope | R | RouteMatch.RouteMatch.Context<Matches>
+  >
+} = dual(2, function redirectWith<Matches extends RouteMatch.RouteMatch.Any, E, R>(
+  router: RouteMatcher<Matches>,
+  effect: Effect.Effect<string, E, R>
+) {
+  return notFoundWith(router, Effect.flatMap(effect, (path) => new RedirectError({ path })))
+})
+
+/**
+ * @since 1.0.0
+ */
+export const redirectTo: {
+  <R extends Route.Route.Any>(
+    route: R,
+    ...params: Route.Route.ParamsList<R>
+  ): <Matches extends RouteMatch.RouteMatch.Any>(router: RouteMatcher<Matches>) => Fx.Fx<
+    RouteMatch.RouteMatch.Success<Matches>,
+    RedirectRouteMatchError<R> | Exclude<RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Scope.Scope | Navigation | CurrentRoute | RouteMatch.RouteMatch.Context<Matches>
+  >
+
+  <Matches extends RouteMatch.RouteMatch.Any, R extends Route.Route.Any>(
+    router: RouteMatcher<Matches>,
+    route: R,
+    ...params: Route.Route.ParamsList<R>
+  ): Fx.Fx<
+    RouteMatch.RouteMatch.Success<Matches>,
+    RedirectRouteMatchError<R> | Exclude<RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Scope.Scope | Navigation | CurrentRoute | RouteMatch.RouteMatch.Context<Matches>
+  >
+} = dual(
+  (args) => isRouteMatcher(args[0]),
+  function redirect<Matches extends RouteMatch.RouteMatch.Any, R extends Route.Route.Any>(
+    router: RouteMatcher<Matches>,
+    route: R,
+    ...params: Route.Route.ParamsList<R>
+  ): Fx.Fx<
+    RouteMatch.RouteMatch.Success<Matches>,
+    RedirectRouteMatchError<R> | Exclude<RouteMatch.RouteMatch.Error<Matches>, RedirectError>,
+    Scope.Scope | Navigation | CurrentRoute | RouteMatch.RouteMatch.Context<Matches>
+  > {
+    return redirectWith(
+      router,
+      pipe(
+        Effect.catchTag(
+          makeHref<R>(route, ...params),
+          "NoSuchElementException",
+          () => Effect.fail(new RedirectRouteMatchError<R>(route, (params[0] || {}) as Route.Route.Params<R>))
+        ),
+        Effect.flatMap((path) => new RedirectError({ path }))
+      )
+    )
+  }
+)
+
+/**
+ * @since 1.0.0
+ */
+export class RedirectRouteMatchError<R extends Route.Route.Any> extends Data.TaggedError("RedirectRouteMatchError") {
+  constructor(readonly route: R, readonly params: Route.Route.Params<R>) {
+    super()
+  }
+}