@typed/router 0.32.0 → 1.0.0-beta.1

package/src/AST.ts

@@ -0,0 +1,166 @@
+import type { Cause } from "effect/Cause";
+import { succeedSome } from "effect/Effect";
+import type { Top } from "effect/Schema";
+import type { Transformation } from "effect/SchemaTransformation";
+import type { Fx } from "@typed/fx/Fx";
+import type { RefSubject } from "@typed/fx/RefSubject/RefSubject";
+import type { Guard } from "@typed/guard";
+import type { AnyLayer, Layout as LayoutType, MatchHandler } from "./Matcher.js";
+
+export type PathAst =
+  | PathAst.Literal
+  | PathAst.Parameter
+  | PathAst.Slash
+  | PathAst.Wildcard
+  | PathAst.QueryParams;
+
+export declare namespace PathAst {
+  export type Literal = {
+    type: "literal";
+    value: string;
+  };
+  export type Parameter = {
+    type: "parameter";
+    name: string;
+    optional?: boolean;
+    regex?: string;
+  };
+
+  export type Wildcard = {
+    type: "wildcard";
+  };
+
+  export type Slash = {
+    type: "slash";
+  };
+
+  export type QueryParams = {
+    type: "query-params";
+    value: ReadonlyArray<PathAst.QueryParam>;
+  };
+
+  export type QueryParam = {
+    type: "query-param";
+    name: string;
+    value: PathAst;
+  };
+}
+
+export const literal = (value: string): PathAst.Literal => ({ type: "literal", value });
+export const parameter = (name: string, optional?: boolean, regex?: string): PathAst.Parameter => ({
+  type: "parameter",
+  name,
+  ...(optional ? { optional } : {}),
+  ...(regex ? { regex } : {}),
+});
+export const wildcard = (): PathAst.Wildcard => ({ type: "wildcard" });
+export const slash = (): PathAst.Slash => ({ type: "slash" });
+export const queryParams = (value: ReadonlyArray<PathAst.QueryParam>): PathAst.QueryParams => ({
+  type: "query-params",
+  value,
+});
+export const queryParam = (name: string, value: PathAst): PathAst.QueryParam => ({
+  type: "query-param",
+  name,
+  value,
+});
+
+export type RouteAst = RouteAst.Path | RouteAst.Transform | RouteAst.Join;
+
+export declare namespace RouteAst {
+  export interface Path {
+    type: "path";
+    path: PathAst;
+  }
+
+  export interface Transform {
+    type: "transform";
+    from: RouteAst;
+    to: Top;
+    transformation: Transformation<any, any, any, any>;
+  }
+
+  export interface Join {
+    type: "join";
+    parts: ReadonlyArray<RouteAst>;
+  }
+}
+
+export const path = (path: PathAst): RouteAst.Path => ({ type: "path", path });
+export const transform = (
+  from: RouteAst,
+  to: Top,
+  transformation: Transformation<any, any, any, any>,
+): RouteAst.Transform => ({
+  type: "transform",
+  from,
+  to,
+  transformation,
+});
+export const join = (parts: ReadonlyArray<RouteAst>): RouteAst.Join => ({ type: "join", parts });
+
+export type MatchAst =
+  | MatchAst.Route
+  | MatchAst.Layer
+  | MatchAst.Layout
+  | MatchAst.Prefixed
+  | MatchAst.Catch;
+
+export declare namespace MatchAst {
+  export interface Route {
+    type: "route";
+    route: RouteAst;
+    guard: Guard<any, any, any, any>;
+    handler: MatchHandler<any, any, any, any>;
+  }
+
+  export interface Layer {
+    type: "layer";
+    matches: ReadonlyArray<MatchAst>;
+    deps: ReadonlyArray<AnyLayer>;
+  }
+
+  export interface Layout {
+    type: "layout";
+    matches: ReadonlyArray<MatchAst>;
+    layout: LayoutType<any, any, any, any, any, any, any>;
+  }
+
+  export interface Prefixed {
+    type: "prefixed";
+    matches: ReadonlyArray<MatchAst>;
+    prefix: RouteAst;
+  }
+
+  export interface Catch {
+    type: "catch";
+    matches: ReadonlyArray<MatchAst>;
+    f: (cause: RefSubject<Cause<any>>) => Fx<any, any, any>;
+  }
+}
+
+export const route = (
+  route: RouteAst,
+  handler: MatchHandler<any, any, any, any>,
+  guard: Guard<any, any, any, any> = succeedSome,
+): MatchAst.Route => ({ type: "route", route, guard, handler });
+
+export const layer = (
+  matches: ReadonlyArray<MatchAst>,
+  deps: ReadonlyArray<AnyLayer>,
+): MatchAst.Layer => ({ type: "layer", matches, deps });
+
+export const layout = (
+  matches: ReadonlyArray<MatchAst>,
+  layout: LayoutType<any, any, any, any, any, any, any>,
+): MatchAst.Layout => ({ type: "layout", matches, layout });
+
+export const prefixed = (
+  matches: ReadonlyArray<MatchAst>,
+  prefix: RouteAst,
+): MatchAst.Prefixed => ({ type: "prefixed", matches, prefix });
+
+export const catchCause = (
+  matches: ReadonlyArray<MatchAst>,
+  f: (cause: RefSubject<Cause<any>>) => Fx<any, any, any>,
+): MatchAst.Catch => ({ type: "catch", matches, f });

package/src/CurrentRoute.ts

@@ -1,332 +1,31 @@
-/**
- * @since 1.0.0
- */
-
-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 * as Navigation from "@typed/navigation"
-import * as Route from "@typed/route"
-import type { Cause } from "effect"
-import * as Effect from "effect/Effect"
-import { dual, pipe } from "effect/Function"
-import type * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-
-/**
- * @since 1.0.0
- */
-export interface CurrentRoute {
-  readonly route: Route.Route.Any
-  readonly parent: Option.Option<CurrentRoute>
-}
-
-/**
- * @since 1.0.0
- */
-export const CurrentRoute: Context.Tagged<CurrentRoute> = Context.Tagged<CurrentRoute>("@typed/router/CurrentRoute")
-
-/**
- * @since 1.0.0
- */
-export function makeCurrentRoute<R extends Route.Route.Any>(
-  route: R,
-  parent: Option.Option<CurrentRoute> = Option.none()
-): CurrentRoute {
-  return {
-    route,
-    parent
-  }
-}
-
-/**
- * @since 1.0.0
- */
-export function layer<R extends Route.Route.Any>(
-  route: R,
-  parent: Option.Option<CurrentRoute> = Option.none()
-): Layer.Layer<CurrentRoute> {
-  return CurrentRoute.layer(makeCurrentRoute(route, parent))
-}
-
-/**
- * @since 1.0.0
- */
-export const CurrentParams: RefSubject.Filtered<
-  Readonly<Record<string, string | ReadonlyArray<string>>>,
-  never,
-  Navigation.Navigation | CurrentRoute
-> = RefSubject.filteredFromTag(
-  Navigation.Navigation,
-  (nav) =>
-    RefSubject.filterMapEffect(
-      nav.currentEntry,
-      (e) => CurrentRoute.with(({ route }) => route.match(Navigation.getCurrentPathFromUrl(e.url)))
-    )
-)
-
-/**
- * @since 1.0.0
- */
-export const withCurrentRoute: {
-  <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, R_ extends Route.Route.Any>(
-    effect: Effect.Effect<A, E, R>,
-    route: R_
-  ): Effect.Effect<A, E, Exclude<R, CurrentRoute>>
-} = dual(
-  2,
-  <A, E, R, R_ extends Route.Route.Any>(
-    effect: Effect.Effect<A, E, R>,
-    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(makeCurrentRoute(route)))
-      }
-
-      return pipe(
-        effect,
-        CurrentRoute.provide(
-          makeCurrentRoute(parent.value.route.concat(route), parent)
-        )
-      )
-    })
-)
-
-const makeHref_ = (
-  currentPath: string,
-  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.interpolate(fullParams as any))
-}
-
-/**
- * @since 1.0.0
- */
-export function makeHref<const R extends Route.Route.Any>(
-  route: R,
-  ...[params]: Route.Route.ParamsList<R>
-): RefSubject.Filtered<string, never, Navigation.Navigation | CurrentRoute>
-export function makeHref<const R extends Route.Route.Any>(
-  route: R,
-  params: Route.Route.Params<R>
-): RefSubject.Filtered<string, never, Navigation.Navigation | CurrentRoute>
-
-export function makeHref<const R extends Route.Route.Any>(
-  route: R,
-  ...[params]: Route.Route.ParamsList<R>
-): RefSubject.Filtered<string, never, Navigation.Navigation | CurrentRoute> {
-  return RefSubject.filterMapEffect(Navigation.CurrentPath, (currentPath) =>
-    Effect.map(
-      CurrentRoute,
-      (currentRoute): Option.Option<string> => makeHref_(currentPath, currentRoute.route, route, params)
-    ))
-}
-
-const isActive_ = (
-  currentPath: string,
-  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 href: string = fullRoute.interpolate(fullParams as any)
-  const [currentPathname, currentQuery] = splitByQuery(currentPath)
-  const [hrefPathname, hrefQuery] = splitByQuery(href)
-
-  return (
-    (fullRoute.routeOptions.end
-      ? currentPathname === hrefPathname
-      : currentPathname.startsWith(hrefPathname)) &&
-    compareQueries(currentQuery, hrefQuery)
-  )
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/ServiceMap";
+import { Navigation } from "@typed/navigation/Navigation";
+import { Parse, type Route } from "./Route.js";
+
+export interface CurrentRouteTree {
+  readonly route: Route<string, any>;
+  readonly parent?: CurrentRouteTree | undefined;
+}
+
+export class CurrentRoute extends ServiceMap.Service<CurrentRoute, CurrentRouteTree>()(
+  "@typed/router/CurrentRoute",
+  {
+    make: Effect.map(Navigation.base, (base) => ({ route: Parse(base) })),
+  },
+) {
+  static readonly Default = Layer.effect(CurrentRoute, CurrentRoute.make);
+
+  static readonly extend = (route: Route.Any) =>
+    Layer.unwrap(
+      Effect.gen(function* () {
+        const services = yield* Effect.services<never>();
+        const parent = ServiceMap.getOrUndefined(services, CurrentRoute);
+        return Layer.succeed(CurrentRoute, {
+          route,
+          parent,
+        });
+      }),
+    );
 }
-
-function compareQueries(currentQuery: string, hrefQuery: string) {
-  // if hrefQuery is empty, it means that the href is a pathname only
-  if (!hrefQuery) return true
-  // if currentQuery is empty, there is no match at this point
-  if (!currentQuery) return false
-  // if the queries are equal, there is a match
-  if (currentQuery === hrefQuery) return true
-
-  const currentQueryParams = new URLSearchParams(currentQuery)
-  const hrefQueryParams = new URLSearchParams(hrefQuery)
-
-  for (const key of hrefQueryParams.keys()) {
-    const a = currentQueryParams.getAll(key).sort()
-    const b = hrefQueryParams.getAll(key).sort()
-
-    if (a.length !== b.length || !b.every((bx, i) => a[i] === bx)) return false
-  }
-
-  return true
-}
-
-function splitByQuery(path: string) {
-  const queryIndex = path.indexOf("?")
-  if (queryIndex > -1) {
-    const pathname = path.slice(0, queryIndex)
-    const query = path.slice(queryIndex + 1).trim()
-    return [pathname, query] as const
-  }
-
-  return [path, ""] as const
-}
-
-/**
- * @since 1.0.0
- */
-export function isActive<R extends Route.Route.Any>(
-  route: R,
-  ...[params]: Route.Route.ParamsList<R>
-): RefSubject.Computed<boolean, never, Navigation.Navigation | CurrentRoute>
-export function isActive<R extends Route.Route.Any>(
-  route: R,
-  params: Route.Route.Params<R>
-): RefSubject.Computed<boolean, never, Navigation.Navigation | CurrentRoute>
-export function isActive<R extends Route.Route.Any>(
-  route: R,
-  ...[params]: Route.Route.ParamsList<R>
-): RefSubject.Computed<boolean, never, Navigation.Navigation | CurrentRoute> {
-  return RefSubject.mapEffect(
-    Navigation.CurrentPath,
-    (currentPath) =>
-      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.Navigation | CurrentRoute | Route.Route.Context<R>
-> {
-  return RefSubject.filteredFromTag(
-    Navigation.Navigation,
-    (nav) =>
-      RefSubject.filterMapEffect(
-        nav.currentEntry,
-        (e) =>
-          Effect.flatMap(CurrentRoute, ({ route: parent }) =>
-            Effect.optionFromOptional(
-              Route.decode(
-                parent.concat(route) as R,
-                Navigation.getCurrentPathFromUrl(e.url)
-              )
-            ))
-      )
-  )
-}
-
-/**
- * @since 1.0.0
- */
-export const browser: Layer.Layer<CurrentRoute, never, Document.Document> = CurrentRoute.layer(
-  Effect.gen(function*() {
-    const document = yield* Document.Document
-    const base = document.querySelector("base")
-    const baseHref = base ? getBasePathname(base.href) : "/"
-
-    return {
-      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.parse(base), parent: Option.none() })
-
-const getSearchParams = (destination: Navigation.Destination) => destination.url.searchParams
-
-/**
- * @since 1.0.0
- */
-export const CurrentSearchParams: RefSubject.Computed<
-  URLSearchParams,
-  never,
-  Navigation.Navigation
-> = RefSubject.map(Navigation.CurrentEntry, getSearchParams)
-
-/**
- * @since 1.0.0
- */
-export const CurrentState = RefSubject.computedFromTag(
-  Navigation.Navigation,
-  (n) => RefSubject.map(n.currentEntry, (e) => e.state)
-)
-
-/**
- * @since 1.0.0
- */
-export type NavigateOptions<R extends Route.Route.Any> = Route.Route.ParamsAreOptional<R> extends true ? [
-    options?: Navigation.NavigateOptions & {
-      readonly params?: Route.Route.Params<R> | undefined
-    } & {
-      readonly relative?: boolean
-    }
-  ]
-  : [
-    options: Navigation.NavigateOptions & {
-      readonly params: Route.Route.Params<R>
-    } & {
-      readonly relative?: boolean
-    }
-  ]
-
-/**
- * @since 1.0.0
- */
-export const navigate = <R extends Route.Route.Any>(
-  route: R,
-  ...[options]: NavigateOptions<R>
-): Effect.Effect<
-  Navigation.Destination,
-  Navigation.NavigationError | Cause.NoSuchElementException,
-  Navigation.Navigation | CurrentRoute
-> =>
-  Effect.gen(function*(_) {
-    const params = options?.params ?? ({} as Route.Route.Params<R>)
-    const path = options?.relative === false
-      ? route.interpolate(params)
-      : yield* _(makeHref<R>(route, params))
-    return yield* _(Navigation.navigate(path))
-  })