@typed/router 0.27.7 → 0.28.0

package/src/CurrentRoute.ts

@@ -4,23 +4,21 @@
 
 import * as Context from "@typed/context"
 import * as Document from "@typed/dom/Document"
+import type * as Fx from "@typed/fx"
 import * as RefSubject from "@typed/fx/RefSubject"
-import type { Destination, Navigation } from "@typed/navigation"
-import { CurrentEntry, CurrentPath } from "@typed/navigation"
-import type { Layer } from "effect"
-import * as Option from "effect/Option"
-
+import type { Destination } from "@typed/navigation"
+import { CurrentEntry, CurrentPath, getCurrentPathFromUrl, Navigation } from "@typed/navigation"
+import * as Route from "@typed/route"
 import * as Effect from "effect/Effect"
 import { dual, pipe } from "effect/Function"
-
-import type { ParamsOf } from "@typed/path"
-import * as Route from "@typed/route"
+import type * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 
 /**
  * @since 1.0.0
  */
-export interface CurrentRoute<P extends string = string> {
-  readonly route: Route.Route<P>
+export interface CurrentRoute {
+  readonly route: Route.Route.Any
   readonly parent: Option.Option<CurrentRoute>
 }
 
@@ -32,12 +30,12 @@ export const CurrentRoute: Context.Tagged<CurrentRoute> = Context.Tagged<Current
 /**
  * @since 1.0.0
  */
-export function make<const P extends string>(
-  route: P | Route.Route<P>,
+export function makeCurrentRoute<R extends Route.Route.Any>(
+  route: R,
   parent: Option.Option<CurrentRoute> = Option.none()
-): CurrentRoute<P> {
+): CurrentRoute {
   return {
-    route: getRoute(route),
+    route,
     parent
   }
 }
@@ -45,15 +43,11 @@ export function make<const P extends string>(
 /**
  * @since 1.0.0
  */
-export function layer<const P extends string>(
-  route: P | Route.Route<P>,
+export function layer<R extends Route.Route.Any>(
+  route: R,
   parent: Option.Option<CurrentRoute> = Option.none()
 ): Layer.Layer<CurrentRoute> {
-  return CurrentRoute.layer(make(route, parent) as any as CurrentRoute)
-}
-
-function getRoute<P extends string>(route: P | Route.Route<P>): Route.Route<P> {
-  return typeof route === "string" ? Route.fromPath(route) : route
+  return CurrentRoute.layer(makeCurrentRoute(route, parent))
 }
 
 /**
@@ -64,95 +58,139 @@ export const CurrentParams: RefSubject.Filtered<
   never,
   Navigation | CurrentRoute
 > = RefSubject
-  .filterMapEffect(CurrentPath, (path) => CurrentRoute.with(({ route }) => route.match(path)))
+  .filteredFromTag(
+    Navigation,
+    (nav) =>
+      RefSubject.filterMapEffect(
+        nav.currentEntry,
+        (e) => CurrentRoute.with(({ route }) => route.match(getCurrentPathFromUrl(e.url)))
+      )
+  )
 
 /**
  * @since 1.0.0
  */
 export const withCurrentRoute: {
-  <P extends string>(
-    route: Route.Route<P>
+  <R extends Route.Route.Any>(
+    route: R
   ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentRoute>>
 
-  <A, E, R, P extends string>(
+  <A, E, R, R_ extends Route.Route.Any>(
     effect: Effect.Effect<A, E, R>,
-    route: Route.Route<P>
+    route: R_
   ): Effect.Effect<A, E, Exclude<R, CurrentRoute>>
-} = dual(2, <A, E, R, P extends string>(
+} = dual(2, <A, E, R, R_ extends Route.Route.Any>(
   effect: Effect.Effect<A, E, R>,
-  route: Route.Route<P>
+  route: R_
 ): Effect.Effect<A, E, Exclude<R, CurrentRoute>> =>
   Effect.contextWithEffect((ctx) => {
     const parent = Context.getOption(ctx, CurrentRoute)
 
-    if (Option.isNone(parent)) return pipe(effect, CurrentRoute.provide(make(route) as any as CurrentRoute))
+    if (Option.isNone(parent)) return pipe(effect, CurrentRoute.provide(makeCurrentRoute(route)))
 
     return pipe(
       effect,
-      CurrentRoute.provide(make(parent.value.route.concat(route), parent) as CurrentRoute)
+      CurrentRoute.provide(makeCurrentRoute(parent.value.route.concat(route), parent))
     )
   }))
 
-const makeHref_ = <P extends string, P2 extends string>(
+const makeHref_ = (
   currentPath: string,
-  currentRoute: Route.Route<P>,
-  route: Route.Route<P2>,
-  ...[params]: [keyof ParamsOf<P2>] extends [never] ? [{}?] : [ParamsOf<P2>]
-) => {
+  currentRoute: Route.Route.Any,
+  route: Route.Route.Any,
+  params: {} = {}
+): Option.Option<string> => {
   const currentMatch = currentRoute.match(currentPath)
   if (Option.isNone(currentMatch)) return Option.none()
 
   const fullRoute = currentRoute.concat(route)
   const fullParams = { ...currentMatch.value, ...params }
 
-  return Option.some(fullRoute.make(fullParams as any))
+  return Option.some(fullRoute.interpolate(fullParams as any))
 }
 
 /**
  * @since 1.0.0
  */
-export function makeHref<const P extends string>(
-  pathOrRoute: Route.Route<P> | P,
-  ...params: [keyof ParamsOf<P>] extends [never] ? [{}?] : [ParamsOf<P>]
+export function makeHref<const R extends Route.Route.Any>(
+  route: R,
+  ...[params]: Route.Route.ParamsList<R>
 ): RefSubject.Filtered<string, never, Navigation | CurrentRoute> {
-  const route = typeof pathOrRoute === "string" ? Route.fromPath(pathOrRoute) : pathOrRoute
-
   return RefSubject.filterMapEffect(
     CurrentPath,
     (currentPath) =>
-      Effect.map(CurrentRoute, (currentRoute) => makeHref_(currentPath, currentRoute.route, route, ...params))
+      Effect.map(
+        CurrentRoute,
+        (currentRoute): Option.Option<string> => makeHref_(currentPath, currentRoute.route, route, params)
+      )
   )
 }
 
-const isActive_ = <P extends string, P2 extends string>(
+const isActive_ = (
   currentPath: string,
-  currentRoute: Route.Route<P>,
-  route: Route.Route<P2>,
-  ...params: [keyof ParamsOf<P2>] extends [never] ? [{}?] : [ParamsOf<P2>]
-) => {
+  currentRoute: Route.Route.Any,
+  route: Route.Route.Any,
+  params: any = {}
+): boolean => {
   const currentMatch = currentRoute.match(currentPath)
-
   if (Option.isNone(currentMatch)) return false
 
   const fullRoute = currentRoute.concat(route)
   const fullParams = { ...currentMatch.value, ...params }
-  const fullPath = fullRoute.make(fullParams as any)
-
-  return fullPath === currentPath || currentPath.startsWith(fullPath)
+  const fullPath: string = fullRoute.interpolate(fullParams as any)
+  const currentPathWithoutSearch = currentPath.split("?")[0] || "/"
+  const fullPathWithoutSearch = fullPath.split("?")[0] || "/"
+
+  if (fullPathWithoutSearch === currentPathWithoutSearch) {
+    return true
+  } else if (route.routeOptions.end) {
+    return false
+  } else {
+    return currentPathWithoutSearch.startsWith(fullPathWithoutSearch)
+  }
 }
+
 /**
  * @since 1.0.0
  */
-export function isActive<const P extends string>(
-  pathOrRoute: Route.Route<P> | P,
-  ...params: [keyof ParamsOf<P>] extends [never] ? [{}?] : [ParamsOf<P>]
+export function isActive<R extends Route.Route.Any>(
+  route: R,
+  ...[params]: Route.Route.ParamsList<R>
+): RefSubject.Computed<boolean, never, Navigation | CurrentRoute>
+export function isActive<R extends Route.Route.Any>(
+  route: R,
+  params: Route.Route.Params<R>
+): RefSubject.Computed<boolean, never, Navigation | CurrentRoute>
+export function isActive<R extends Route.Route.Any>(
+  route: R,
+  ...[params]: Route.Route.ParamsList<R>
 ): RefSubject.Computed<boolean, never, Navigation | CurrentRoute> {
-  const route = typeof pathOrRoute === "string" ? Route.fromPath(pathOrRoute) : pathOrRoute
-
   return RefSubject.mapEffect(
     CurrentPath,
     (currentPath) =>
-      Effect.map(CurrentRoute, (currentRoute) => isActive_(currentPath, currentRoute.route, route, ...params))
+      CurrentRoute.with((currentRoute): boolean => isActive_(currentPath, currentRoute.route, route, params))
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export function decode<R extends Route.Route.Any>(
+  route: R
+): Fx.RefSubject.Filtered<
+  Route.Route.Type<R>,
+  Route.RouteDecodeError<R>,
+  Navigation | CurrentRoute | Route.Route.Context<R>
+> {
+  return RefSubject.filteredFromTag(
+    Navigation,
+    (nav) =>
+      RefSubject.filterMapEffect(
+        nav.currentEntry,
+        (e) =>
+          Effect.flatMap(CurrentRoute, ({ route: parent }) =>
+            Effect.optionFromOptional(Route.decode(parent.concat(route) as R, getCurrentPathFromUrl(e.url))))
+      )
   )
 }
 
@@ -160,23 +198,32 @@ export function isActive<const P extends string>(
  * @since 1.0.0
  */
 export const browser: Layer.Layer<CurrentRoute, never, Document.Document> = CurrentRoute.layer(
-  Effect.gen(function*(_) {
-    const document = yield* _(Document.Document)
+  Effect.gen(function*() {
+    const document = yield* Document.Document
     const base = document.querySelector("base")
-    const baseHref = base ? base.href : "/"
+    const baseHref = base ? getBasePathname(base.href) : "/"
 
     return {
-      route: Route.fromPath(baseHref),
+      route: Route.parse(baseHref),
       parent: Option.none()
     }
   })
 )
 
+function getBasePathname(base: string): string {
+  try {
+    const url = new URL(base)
+    return url.pathname
+  } catch {
+    return base
+  }
+}
+
 /**
  * @since 1.0.0
  */
 export const server = (base: string = "/"): Layer.Layer<CurrentRoute> =>
-  CurrentRoute.layer({ route: Route.fromPath(base), parent: Option.none() })
+  CurrentRoute.layer({ route: Route.parse(base), parent: Option.none() })
 
 const getSearchParams = (destination: Destination): Readonly<Record<string, string>> =>
   Object.fromEntries(destination.url.searchParams)
@@ -190,4 +237,7 @@ export const CurrentSearchParams: RefSubject.Computed<Readonly<Record<string, st
 /**
  * @since 1.0.0
  */
-export const CurrentState = RefSubject.map(CurrentEntry, (d) => d.state)
+export const CurrentState = RefSubject.computedFromTag(
+  Navigation,
+  (n) => RefSubject.map(n.currentEntry, (e) => e.state)
+)

package/src/MatchInput.ts

@@ -0,0 +1,282 @@
+/**
+ * @since 1.0.0
+ */
+
+import type * as Schema from "@effect/schema/Schema"
+import type { Guard } from "@typed/guard"
+import type * as _Path from "@typed/path"
+import * as Route from "@typed/route"
+import type * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import type * as Option from "effect/Option"
+import * as RouteGuard from "./RouteGuard.js"
+
+/**
+ * @since 1.0.0
+ */
+export type MatchInput<
+  P extends string,
+  S extends Schema.Schema.All,
+  A = never,
+  E = never,
+  R = never
+> = Route.Route<P, S> | RouteGuard.RouteGuard<Route.Route<P, S>, A, E, R>
+
+/**
+ * @since 1.0.0
+ */
+export namespace MatchInput {
+  /**
+   * @since 1.0.0
+   */
+  export type Any = MatchInput<any, any, any, any, any> | MatchInput<any, never, any, any, any>
+
+  /**
+   * @since 1.0.0
+   */
+  export type Route<T> = T extends Route.Route<infer P, infer S> ? Route.Route<P, S>
+    : T extends RouteGuard.RouteGuard<Route.Route<infer P, infer S>, infer _A, infer _E, infer _R> ? Route.Route<P, S>
+    : never
+
+  /**
+   * @since 1.0.0
+   */
+  export type Path<T> = Route.Route.Path<Route<T>>
+
+  /**
+   * @since 1.0.0
+   */
+  export type ParamsOf<T> = Route.Route.Params<Route<T>>
+
+  /**
+   * @since 1.0.0
+   */
+  export type HasParams<T> = Route<T> extends Route.Route<infer P, infer _> ? _Path.HasParams<P> : false
+
+  /**
+   * @since 1.0.0
+   */
+  export type HasPathParams<T> = Route<T> extends Route.Route<infer P, infer _>
+    ? P extends `${infer P2}\\?${infer _}` ? _Path.HasParams<P2> : _Path.HasParams<P>
+    : false
+
+  /**
+   * @since 1.0.0
+   */
+  export type HasQueryParams<T> = Route<T> extends Route.Route<infer P, infer _>
+    ? P extends `${infer _}\\?${infer P2}` ? _Path.HasParams<`\\?${P2}`> : false
+    : false
+
+  /**
+   * @since 1.0.0
+   */
+  export type Success<T> = T extends Route.Route<infer _P, infer _S> ? Route.Route.Type<T>
+    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer A, infer _E, infer _R> ? A
+    : never
+
+  /**
+   * @since 1.0.0
+   */
+  export type Error<T> = T extends Route.Route<infer _P, infer _S> ? Route.RouteDecodeError<T>
+    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer _A, infer E, infer _R> ? E
+    : never
+
+  /**
+   * @since 1.0.0
+   */
+  export type Context<T> = T extends Route.Route<infer _P, infer _S> ? Route.Route.Context<T>
+    : T extends RouteGuard.RouteGuard<Route.Route<infer _P, infer _S>, infer _A, infer _E, infer R> ? R
+    : never
+
+  /**
+   * @since 1.0.0
+   */
+  export type Schema<T> = Route.Route.Schema<MatchInput.Route<T>>
+
+  /**
+   * @since 1.0.0
+   */
+  export type PathSchema<T> = Route.Route.PathSchema<MatchInput.Route<T>>
+
+  /**
+   * @since 1.0.0
+   */
+  export type QuerySchema<T> = Route.Route.QuerySchema<MatchInput.Route<T>>
+}
+
+/**
+ * @since 1.0.0
+ */
+export function asRouteGuard<I extends MatchInput.Any>(
+  input: I
+): RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>> {
+  return Route.isRoute(input) ? RouteGuard.fromRoute(input) as any : input
+}
+
+/**
+ * @since 1.0.0
+ */
+export const map: {
+  <I extends MatchInput.Any, A>(
+    f: (a: MatchInput.Success<I>) => A
+  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
+
+  <I extends MatchInput.Any, A>(
+    input: I,
+    f: (a: MatchInput.Success<I>) => A
+  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
+} = dual(2, function map<I extends MatchInput.Any, A>(
+  input: I,
+  f: (a: MatchInput.Success<I>) => A
+): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>> {
+  return RouteGuard.map<
+    RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>,
+    A
+  >(asRouteGuard<I>(input), f)
+})
+
+/**
+ * @since 1.0.0
+ */
+export const mapEffect: {
+  <I extends MatchInput.Any, A, E2, R2>(
+    f: (a: MatchInput.Success<I>) => Effect.Effect<A, E2, R2>
+  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
+
+  <I extends MatchInput.Any, A, E2, R2>(
+    input: I,
+    f: (a: MatchInput.Success<I>) => Effect.Effect<A, E2, R2>
+  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
+} = dual(2, function mapEffect<I extends MatchInput.Any, A, E2, R2>(
+  input: I,
+  f: (a: MatchInput.Success<I>) => Effect.Effect<A, E2, R2>
+): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I> | E2, MatchInput.Context<I> | R2> {
+  return RouteGuard.mapEffect<
+    RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>,
+    A,
+    E2,
+    R2
+  >(asRouteGuard<I>(input), f)
+})
+
+/**
+ * @since 1.0.0
+ */
+export const filter: {
+  <I extends MatchInput.Any>(
+    f: (a: MatchInput.Success<I>) => boolean
+  ): (
+    input: I
+  ) => RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>
+
+  <I extends MatchInput.Any>(
+    input: I,
+    f: (a: MatchInput.Success<I>) => boolean
+  ): RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>
+} = dual(2, function filter<I extends MatchInput.Any>(
+  input: I,
+  f: (a: MatchInput.Success<I>) => boolean
+): RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>> {
+  return RouteGuard.filter<
+    RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>
+  >(asRouteGuard<I>(input), f)
+})
+
+/**
+ * @since 1.0.0
+ */
+export const filterMap: {
+  <I extends MatchInput.Any, A>(
+    f: (a: MatchInput.Success<I>) => Option.Option<A>
+  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
+
+  <I extends MatchInput.Any, A>(
+    input: I,
+    f: (a: MatchInput.Success<I>) => Option.Option<A>
+  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>>
+} = dual(2, function filterMap<I extends MatchInput.Any, A>(
+  input: I,
+  f: (a: MatchInput.Success<I>) => Option.Option<A>
+): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I>, MatchInput.Context<I>> {
+  return RouteGuard.filterMap<
+    RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>,
+    A
+  >(asRouteGuard<I>(input), f)
+})
+
+/**
+ * @since 1.0.0
+ */
+export const flatMap: {
+  <I extends MatchInput.Any, A, E2, R2>(
+    guard: Guard<MatchInput.Success<I>, A, E2, R2>
+  ): (input: I) => RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
+
+  <I extends MatchInput.Any, A, E2, R2>(
+    input: I,
+    guard: Guard<MatchInput.Success<I>, A, E2, R2>
+  ): RouteGuard.RouteGuard<MatchInput.Route<I>, A, E2 | MatchInput.Error<I>, R2 | MatchInput.Context<I>>
+} = dual(2, function flatMap<I extends MatchInput.Any, A, E2, R2>(
+  input: I,
+  guard: Guard<MatchInput.Success<I>, A, E2, R2>
+): RouteGuard.RouteGuard<MatchInput.Route<I>, A, MatchInput.Error<I> | E2, MatchInput.Context<I> | R2> {
+  return RouteGuard.flatMap<
+    RouteGuard.RouteGuard<MatchInput.Route<I>, MatchInput.Success<I>, MatchInput.Error<I>, MatchInput.Context<I>>,
+    A,
+    E2,
+    R2
+  >(asRouteGuard<I>(input), guard)
+})
+
+/**
+ * @since 1.0.0
+ */
+export function concat<L extends MatchInput.Any, R extends MatchInput.Any>(
+  left: L,
+  right: R
+): RouteGuard.RouteGuard<
+  Route.Route.Concat<MatchInput.Route<L>, MatchInput.Route<R>>,
+  MatchInput.Success<L> & MatchInput.Success<R>,
+  MatchInput.Error<L> | MatchInput.Error<R>,
+  MatchInput.Context<L> | MatchInput.Context<R>
+> {
+  return RouteGuard.concat<
+    RouteGuard.RouteGuard<MatchInput.Route<L>, MatchInput.Success<L>, MatchInput.Error<L>, MatchInput.Context<L>>,
+    RouteGuard.RouteGuard<MatchInput.Route<R>, MatchInput.Success<R>, MatchInput.Error<R>, MatchInput.Context<R>>
+  >(asRouteGuard<L>(left), asRouteGuard<R>(right))
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getRoute<I extends MatchInput.Any>(input: I): MatchInput.Route<I> {
+  return asRouteGuard<I>(input).route
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getSchema<I extends MatchInput.Any>(input: I): MatchInput.Schema<I> {
+  return asRouteGuard<I>(input).route.schema
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getPathSchema<I extends MatchInput.Any>(input: I): MatchInput.PathSchema<I> {
+  return asRouteGuard<I>(input).route.pathSchema as MatchInput.PathSchema<I>
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getQuerySchema<I extends MatchInput.Any>(input: I): MatchInput.QuerySchema<I> {
+  return asRouteGuard<I>(input).route.querySchema as MatchInput.QuerySchema<I>
+}
+
+/**
+ * @since 1.0.0
+ */
+export function getPath<I extends MatchInput.Any>(input: I): MatchInput.Path<I> {
+  return asRouteGuard<I>(input).route.path
+}