Variable Router

Type Declaration

• catchAll: <
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E,
      E2,
      R2,
  >(
      handler: (error: E) => Element.Element<HTMLElement | SVGElement, E2, R2>,
  ) => <R>(router: Router<P, S, D, E, R>) => Router<P, S, D, E2, R2 | R>

  Catch all errors from all routes. This removes errors from the error channel entirely.

  Example

  const router = Router.empty.pipe(
    Router.concat(HomeRoute),
    Router.concat(UserRoute),
    Router.catchAll((error) => ErrorPage({ error })),
  );
  Copy

• catchIf: <
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E,
      E2,
      R2,
  >(
      predicate: (error: E) => boolean,
      handler: (error: E) => Element.Element<HTMLElement | SVGElement, E2, R2>,
  ) => <R>(router: Router<P, S, D, E, R>) => Router<P, S, D, E2, R2 | R>

  Catch errors from all routes using a predicate.

  Example

  const router = Router.empty.pipe(
    Router.concat(HomeRoute),
    Router.concat(UserRoute),
    Router.catchIf(
      (e) => e._tag === "NotFound",
      () => NotFoundPage()
    ),
  );
  Copy

• catchTag: <
      const K extends string,
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E2,
      R2,
  >(
      tag: K,
      handler: (
          error: { _tag: K },
      ) => Element.Element<HTMLElement | SVGElement, E2, R2>,
  ) => <E extends { _tag: string }, R>(
      router: Router<P, S, D, E, R>,
  ) => Router<P, S, D, E2 | Exclude<E, { _tag: K }>, R2 | R>

  Catch errors with a specific _tag from all routes.

  Example

  const router = Router.empty.pipe(
    Router.concat(HomeRoute),
    Router.concat(UserRoute),
    Router.catchTag("NotFound", () => NotFoundPage()),
    Router.catchTag("Unauthorized", () => LoginPage()),
  );
  Copy

• concat: {
      <
          Path extends string,
          P extends Record<string, unknown>,
          S extends Record<string, unknown>,
          D,
          E,
          R,
      >(
          route: Route<Path, P, S, D, E, R>,
      ): <
          P2 extends Record<string, unknown>,
          S2 extends Record<string, unknown>,
          D2,
          E2,
          R2,
      >(
          router: Router<P2, S2, D2, E2, R2>,
      ) => Router<P & P2, S & S2, D | D2, E | E2, R | R2>;
      <
          P extends Record<string, unknown>,
          S extends Record<string, unknown>,
          D,
          E,
          R,
      >(
          other: Router<P, S, D, E, R>,
      ): <
          P2 extends Record<string, unknown>,
          S2 extends Record<string, unknown>,
          D2,
          E2,
          R2,
      >(
          router: Router<P2, S2, D2, E2, R2>,
      ) => Router<P & P2, S & S2, D | D2, E | E2, R | R2>;
  }

  Add a route or merge another router. This is polymorphic - accepts both Route and Router.

  Example

  const router = Router.empty.pipe(
    Router.concat(HomeRoute),
    Router.concat(UserRoute),
    Router.concat(adminRouter),
  );
  Copy

• empty: Router<never, never, never, never, never>

  An empty router with no routes.

• fallback: <E, R>(
      render: () => Element.Element<HTMLElement | SVGElement, E, R>,
  ) => <
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E2,
      R2,
  >(
      router: Router<P, S, D, E2, R2>,
  ) => Router<P, S, D, E | E2, R | R2>

  Set the fallback render function for when no route matches.

  Example

  const router = Router.empty.pipe(
    Router.concat(HomeRoute),
    Router.fallback(() => NotFoundPage()),
  );
  Copy

• findMatch: <P extends Record<string, unknown>, S extends Record<string, unknown>, D, E, R>(
      router: Router<P, S, D, E, R>,
      pathname: string,
  ) => Option<
      { params: Record<string, string>; route: Route<string, P, S, D, E, R> },
  >

  Find the best matching route for a pathname. Routes are sorted by specificity - more specific routes match first.

• guard: <P extends Record<string, unknown>, S extends Record<string, unknown>, D, E, R>(
      condition: Readable.Readable<boolean> | Effect<boolean, never, never>,
      protectedRouter: Router<P, S, D, E, R>,
      options:
          | { redirect: string }
          | {
              fallback: () => Element.Element<
                  HTMLElement
                  | SVGElement,
                  never,
                  never,
              >;
          },
  ) => <
      P2 extends Record<string, unknown>,
      S2 extends Record<string, unknown>,
      D2,
      E2,
      R2,
  >(
      router: Router<P2, S2, D2, E2, R2>,
  ) => Router<P & P2, S & S2, D | D2, E | E2, R | R2>

  Protect routes with a guard condition. If the guard is false, redirects or renders fallback.

  Example

  const protectedRouter = Router.empty.pipe(
    Router.concat(DashboardRoute),
    Router.concat(ProfileRoute),
  );
  
  const router = Router.empty.pipe(
    Router.concat(publicRouter),
    Router.guard(isAuthenticated, protectedRouter, { redirect: "/login" }),
  );
  Copy

• isRouter: (value: unknown) => value is Router<never, never, never, never, never>

  Check if a value is a Router.

• layout: <E, R>(
      wrapper: <A extends HTMLElement | SVGElement, E, R>(
          children: Element.Element<A, E, R>,
      ) => Element.Element<HTMLElement, E, R>,
  ) => <
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E2,
      R2,
  >(
      router: Router<P, S, D, E2, R2>,
  ) => Router<P, S, D, E | E2, R | R2>

  Wrap all routes in a layout. Layouts are applied inside-out (first layout is innermost).

  Example

  const dashboardRouter = Router.empty.pipe(
    Router.concat(DashboardHomeRoute),
    Router.concat(SettingsRoute),
    Router.layout(SidebarLayout),
    Router.layout(AppShell),
  );
  // Renders: AppShell(SidebarLayout(matchedRoute))
  Copy

• parseParams: <P extends Record<string, unknown>, S extends Record<string, unknown>, D, E, R>(
      route: Route<string, P, S, D, E, R>,
      rawParams: Record<string, string>,
  ) => Effect<P, unknown>

  Parse and validate params using the route's schema.

• parseSearchParams: <P extends Record<string, unknown>, S extends Record<string, unknown>, D, E, R>(
      route: Route<string, P, S, D, E, R>,
      searchParams: URLSearchParams,
  ) => Effect<S, unknown>

  Parse search params from URLSearchParams.

• prefixAll: (
      prefix: string,
  ) => <
      P extends Record<string, unknown>,
      S extends Record<string, unknown>,
      D,
      E,
      R,
  >(
      router: Router<P, S, D, E, R>,
  ) => Router<P, S, D, E, R>

  Add a prefix to all routes in the router.

  Example

  const adminRouter = Router.empty.pipe(
    Router.concat(AdminDashboardRoute),
    Router.concat(AdminUsersRoute),
    Router.prefixAll("/admin"),
  );
  // Routes: /admin, /admin/users
  Copy