@typed/router 0.31.0 → 1.0.0-beta.0

package/src/RouteGuard.ts

@@ -1,217 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import * as Guard from "@typed/guard"
-import * as Route from "@typed/route"
-import * as Effect from "effect/Effect"
-import { dual, flow } from "effect/Function"
-import * as Option from "effect/Option"
-
-/**
- * @since 1.0.0
- */
-export interface RouteGuard<R extends Route.Route.Any, B, E2, R2> {
-  readonly route: R
-  readonly guard: Guard.Guard<string, B, E2, R2>
-}
-
-/**
- * @since 1.0.0
- */
-export namespace RouteGuard {
-  /**
-   * @since 1.0.0
-   */
-  export type Any = RouteGuard<Route.Route.Any, any, any, any>
-
-  /**
-   * @since 1.0.0
-   */
-  export type Route<T> = T extends RouteGuard<infer _R, infer _B, infer _E2, infer _R2> ? T["route"] : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type Context<T> = T extends RouteGuard<infer _R, infer _B, infer _E2, infer R2> ? R2 : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type Error<T> = T extends RouteGuard<infer _R, infer _B, infer E2, infer _R2> ? E2 : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type Success<T> = T extends RouteGuard<infer _R, infer B, infer _E2, infer _R2> ? B : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type UpdateSuccess<R extends RouteGuard.Any, B> = RouteGuard<
-    Route<R>,
-    B,
-    Route.RouteDecodeError<R["route"]>,
-    Route.Route.Context<Route<R>>
-  >
-}
-
-/**
- * @since 1.0.0
- */
-export function make<R extends Route.Route.Any, B, E2, R2>(
-  route: R,
-  guard: Guard.Guard<string, B, E2, R2>
-): RouteGuard<R, B, E2, R2> {
-  return { route, guard }
-}
-
-/**
- * @since 1.0.0
- */
-export function fromRoute<R extends Route.Route.Any>(
-  route: R
-): RouteGuard<R, Route.Route.Type<R>, Route.RouteDecodeError<R>, Route.Route.Context<R>> {
-  return make(route, flow(Route.decode_(route), Effect.optionFromOptional))
-}
-
-/**
- * @since 1.0.0
- */
-export const map: {
-  <R extends RouteGuard.Any, C>(
-    f: (b: NoInfer<RouteGuard.Success<R>>) => C
-  ): (self: R) => RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>>
-
-  <R extends RouteGuard.Any, C>(
-    self: R,
-    f: (b: NoInfer<RouteGuard.Success<R>>) => C
-  ): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>>
-} = dual(2, function map<R extends RouteGuard.Any, C>(
-  self: R,
-  f: (b: NoInfer<RouteGuard.Success<R>>) => C
-): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>> {
-  return make(self.route, Guard.map(self.guard, f)) as any
-})
-
-/**
- * @since 1.0.0
- */
-export const mapEffect: {
-  <R extends RouteGuard.Any, C, E3, R3>(
-    f: (b: NoInfer<RouteGuard.Success<R>>) => Effect.Effect<C, E3, R3>
-  ): (self: R) => RouteGuard<RouteGuard.Route<R>, C, E3 | RouteGuard.Error<R>, R3 | RouteGuard.Context<R>>
-
-  <R extends RouteGuard.Any, C, E3, R3>(
-    self: R,
-    f: (b: NoInfer<RouteGuard.Success<R>>) => Effect.Effect<C, E3, R3>
-  ): RouteGuard<RouteGuard.Route<R>, C, E3 | RouteGuard.Error<R>, R3 | RouteGuard.Context<R>>
-} = dual(2, function mapEffect<R extends RouteGuard.Any, C, E3, R3>(
-  self: R,
-  f: (b: NoInfer<RouteGuard.Success<R>>) => Effect.Effect<C, E3, R3>
-): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R> | E3, RouteGuard.Context<R> | R3> {
-  return make(self.route, Guard.mapEffect(self.guard, f)) as any
-})
-
-/**
- * @since 1.0.0
- */
-export const filter: {
-  <R extends RouteGuard.Any>(f: (b: NoInfer<RouteGuard.Success<R>>) => boolean): (self: R) => R
-  <R extends RouteGuard.Any>(self: R, f: (b: NoInfer<RouteGuard.Success<R>>) => boolean): R
-} = dual(2, function filter<R extends RouteGuard.Any>(
-  self: R,
-  f: (b: NoInfer<RouteGuard.Success<R>>) => boolean
-): R {
-  return make(self.route, Guard.filter(self.guard, f)) as any
-})
-
-/**
- * @since 1.0.0
- */
-export const filterMap: {
-  <R extends RouteGuard.Any, C>(
-    f: (b: NoInfer<RouteGuard.Success<R>>) => Option.Option<C>
-  ): (self: R) => RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>>
-
-  <R extends RouteGuard.Any, C>(
-    self: R,
-    f: (b: NoInfer<RouteGuard.Success<R>>) => Option.Option<C>
-  ): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>>
-} = dual(2, function filterMap<R extends RouteGuard.Any, C>(
-  self: R,
-  f: (b: NoInfer<RouteGuard.Success<R>>) => Option.Option<C>
-): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R>, RouteGuard.Context<R>> {
-  return make(self.route, Guard.filterMap(self.guard, f)) as any
-})
-
-/**
- * @since 1.0.0
- */
-export const flatMap: {
-  <R extends RouteGuard.Any, C, E3, R3>(
-    guard: Guard.Guard<RouteGuard.Success<R>, C, E3, R3>
-  ): (self: R) => RouteGuard<RouteGuard.Route<R>, C, E3 | RouteGuard.Error<R>, R3 | RouteGuard.Context<R>>
-
-  <R extends RouteGuard.Any, C, E3, R3>(
-    self: R,
-    guard: Guard.Guard<RouteGuard.Success<R>, C, E3, R3>
-  ): RouteGuard<RouteGuard.Route<R>, C, E3 | RouteGuard.Error<R>, R3 | RouteGuard.Context<R>>
-} = dual(2, function flatMap<R extends RouteGuard.Any, C, E3, R3>(
-  self: R,
-  guard: Guard.Guard<RouteGuard.Success<R>, C, E3, R3>
-): RouteGuard<RouteGuard.Route<R>, C, RouteGuard.Error<R> | E3, RouteGuard.Context<R> | R3> {
-  return make(self.route, Guard.compose(self.guard, guard)) as any
-})
-
-/**
- * @since 1.0.0
- */
-export const concat: {
-  <R extends RouteGuard.Any>(
-    other: R
-  ): <L extends RouteGuard.Any>(self: L) => RouteGuard<
-    Route.Route.Concat<RouteGuard.Route<L>, RouteGuard.Route<R>>,
-    RouteGuard.Success<L> & RouteGuard.Success<R>,
-    RouteGuard.Error<L> | RouteGuard.Error<R>,
-    RouteGuard.Context<L> | RouteGuard.Context<R>
-  >
-
-  <L extends RouteGuard.Any, R extends RouteGuard.Any>(
-    self: L,
-    other: R
-  ): RouteGuard<
-    Route.Route.Concat<RouteGuard.Route<L>, RouteGuard.Route<R>>,
-    RouteGuard.Success<L> & RouteGuard.Success<R>,
-    RouteGuard.Error<L> | RouteGuard.Error<R>,
-    RouteGuard.Context<L> | RouteGuard.Context<R>
-  >
-} = dual(2, function concat<L extends RouteGuard.Any, R extends RouteGuard.Any>(
-  self: L,
-  other: R
-): RouteGuard<
-  Route.Route.Concat<RouteGuard.Route<L>, RouteGuard.Route<R>>,
-  RouteGuard.Success<L> & RouteGuard.Success<R>,
-  RouteGuard.Error<L> | RouteGuard.Error<R>,
-  RouteGuard.Context<L> | RouteGuard.Context<R>
-> {
-  return make<
-    Route.Route.Concat<RouteGuard.Route<L>, RouteGuard.Route<R>>,
-    RouteGuard.Success<L> & RouteGuard.Success<R>,
-    RouteGuard.Error<L> | RouteGuard.Error<R>,
-    RouteGuard.Context<L> | RouteGuard.Context<R>
-  >(
-    Route.concat(self.route, other.route) as any,
-    (input) =>
-      Effect.Do.pipe(
-        Effect.bind("a", () => self.guard(input)),
-        Effect.bind("b", () => other.guard(input)),
-        Effect.map((options) =>
-          Option.map(
-            Option.all(options),
-            ({ a, b }) => ({ ...a, ...b }) as RouteGuard.Success<L> & RouteGuard.Success<R>
-          )
-        )
-      )
-  )
-})

package/src/RouteMatch.ts

@@ -1,104 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import { type Fx, middleware } from "@typed/fx/Fx"
-import type { RefSubject } from "@typed/fx/RefSubject"
-import type { Guard } from "@typed/guard"
-import type * as Route from "@typed/route"
-import { flow } from "effect/Function"
-import { type CurrentRoute, withCurrentRoute } from "./CurrentRoute.js"
-import type { MatchInput } from "./MatchInput.js"
-import { asRouteGuard } from "./MatchInput.js"
-import * as RouteGuard from "./RouteGuard.js"
-
-/**
- * @since 1.0.0
- */
-export interface RouteMatch<R extends Route.Route.Any, B, E2, R2, C, E3, R3>
-  extends RouteGuard.RouteGuard<R, B, E2, R2>
-{
-  readonly match: (ref: RefSubject<B>) => Fx<C, E3, R3>
-}
-
-/**
- * @since 1.0.0
- */
-export namespace RouteMatch {
-  /**
-   * @since 1.0.0
-   */
-  export type Any<O = any> = RouteMatch<Route.Route.Any, any, any, any, O, any, any>
-
-  /**
-   * @since 1.0.0
-   */
-  export type Context<T> = T extends
-    RouteMatch<infer _R, infer _B, infer _E2, infer _R2, infer _C, infer _E3, infer _R3> ? _R2 | _R3
-    : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type Error<T> = T extends RouteMatch<infer _R, infer _B, infer E2, infer _R2, infer _C, infer E3, infer _R3> ?
-    E2 | E3
-    : never
-
-  /**
-   * @since 1.0.0
-   */
-  export type Success<T> = T extends
-    RouteMatch<infer _R, infer _B, infer _E2, infer _R2, infer C, infer _E3, infer _R3> ? C
-    : never
-}
-
-/**
- * @since 1.0.0
- */
-export function make<R extends Route.Route.Any, B, E2, R2, C, E3, R3>(
-  route: R,
-  guard: Guard<string, B, E2, R2>,
-  match: (ref: RefSubject<B>) => Fx<C, E3, R3>
-): RouteMatch<R, B, E2, R2, C, E3, Exclude<R3, CurrentRoute>> {
-  return { route, guard, match: flow(match, middleware(withCurrentRoute(route))) }
-}
-
-/**
- * @since 1.0.0
- */
-export function fromRoute<R extends Route.Route.Any, C, E3, R3>(
-  route: R,
-  match: (ref: RefSubject<Route.Route.Type<R>>) => Fx<C, E3, R3>
-): RouteMatch<
-  R,
-  Route.Route.Type<R>,
-  Route.RouteDecodeError<R>,
-  Route.Route.Context<R>,
-  C,
-  E3,
-  Exclude<R3, CurrentRoute>
-> {
-  const { guard } = RouteGuard.fromRoute(route)
-
-  return make(route, guard, match)
-}
-
-/**
- * @since 1.0.0
- */
-export function fromInput<I extends MatchInput.Any, A, E, R>(
-  input: I,
-  match: (ref: RefSubject<MatchInput.Success<I>>) => Fx<A, E, R>
-): RouteMatch<
-  MatchInput.Route<I>,
-  MatchInput.Success<I>,
-  MatchInput.Error<I>,
-  MatchInput.Context<I>,
-  A,
-  E,
-  Exclude<R, CurrentRoute>
-> {
-  const { guard, route } = asRouteGuard(input)
-
-  return make(route, guard, match)
-}