@typed/navigation 0.7.0 → 0.8.1

package/src/Blocking.ts

@@ -2,10 +2,14 @@
  * @since 1.0.0
  */
 
-import type * as Computed from "@typed/fx/Computed"
 import * as RefSubject from "@typed/fx/RefSubject"
-import type { Scope } from "effect"
-import { Deferred, Effect, Option } from "effect"
+
+import * as Data from "effect/Data"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+
+import type * as Scope from "effect/Scope"
 import type {
   BeforeNavigationEvent,
   CancelNavigation,
@@ -18,8 +22,8 @@ import { cancelNavigation, Navigation, redirectToPath } from "./Navigation.js"
 /**
  * @since 1.0.0
  */
-export interface BlockNavigation extends Computed.Computed<never, never, Option.Option<Blocking>> {
-  readonly isBlocking: Computed.Computed<never, never, boolean>
+export interface BlockNavigation extends RefSubject.Computed<never, never, Option.Option<Blocking>> {
+  readonly isBlocking: RefSubject.Computed<never, never, boolean>
 }
 
 /**
@@ -36,7 +40,7 @@ type InternalBlockState = Unblocked | Blocked
 type Unblocked = {
   readonly _tag: "Unblocked"
 }
-const Unblocked: Unblocked = { _tag: "Unblocked" }
+const Unblocked: Unblocked = Data.struct({ _tag: "Unblocked" })
 
 type Blocked = {
   readonly _tag: "Blocked"
@@ -47,7 +51,7 @@ type Blocked = {
 const Blocked = (event: BeforeNavigationEvent) =>
   Effect.map(
     Deferred.make<RedirectError | CancelNavigation, void>(),
-    (deferred): Blocked => ({ _tag: "Blocked", deferred, event })
+    (deferred): Blocked => Data.struct({ _tag: "Blocked", deferred, event })
   )
 
 /**
@@ -69,7 +73,7 @@ export const useBlockNavigation = <R = never>(
 
     yield* _(
       navigation.beforeNavigation<R, never>((event) =>
-        blockState.modifyEffect((state) =>
+        RefSubject.modifyEffect(blockState, (state) =>
           Effect.gen(function*(_) {
             // Can't block twice
             if (state._tag === "Blocked") return [Option.none(), state] as const
@@ -84,14 +88,17 @@ export const useBlockNavigation = <R = never>(
               Option.some(Deferred.await(updated.deferred)),
               updated
             ] as const
-          })
-        )
+          }))
       )
     )
 
     const blockNavigation: BlockNavigation = Object.assign(
-      blockState.map((s) => s._tag === "Blocked" ? Option.some(blockedToBlocking(navigation, s)) : Option.none()),
-      { isBlocking: blockState.map((s) => s._tag === "Blocked") }
+      RefSubject.map(blockState, (s) => {
+        return s._tag === "Blocked" ? Option.some(blockedToBlocking(navigation, s)) : Option.none()
+      }),
+      {
+        isBlocking: RefSubject.map(blockState, (s) => s._tag === "Blocked")
+      }
     )
 
     return blockNavigation

package/src/Navigation.ts

@@ -5,12 +5,13 @@
 import { ParseResult } from "@effect/schema"
 import * as Schema from "@effect/schema/Schema"
 import { Tagged } from "@typed/context"
-import * as Computed from "@typed/fx/Computed"
+import * as RefSubject from "@typed/fx/RefSubject"
 import type { Uuid } from "@typed/id"
 import * as IdSchema from "@typed/id/Schema"
 import type { Option, Scope } from "effect"
-import { Data, Effect } from "effect"
 
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
 /**
  * @since 1.0.0
  */
@@ -19,15 +20,15 @@ export interface Navigation {
 
   readonly base: string
 
-  readonly currentEntry: Computed.Computed<never, never, Destination>
+  readonly currentEntry: RefSubject.Computed<never, never, Destination>
 
-  readonly entries: Computed.Computed<never, never, ReadonlyArray<Destination>>
+  readonly entries: RefSubject.Computed<never, never, ReadonlyArray<Destination>>
 
-  readonly transition: Computed.Computed<never, never, Option.Option<Transition>>
+  readonly transition: RefSubject.Computed<never, never, Option.Option<Transition>>
 
-  readonly canGoBack: Computed.Computed<never, never, boolean>
+  readonly canGoBack: RefSubject.Computed<never, never, boolean>
 
-  readonly canGoForward: Computed.Computed<never, never, boolean>
+  readonly canGoForward: RefSubject.Computed<never, never, boolean>
 
   readonly navigate: (
     url: string | URL,
@@ -75,7 +76,7 @@ const urlSchema = Schema.string.pipe(
         try {
           return Effect.succeed(new URL(s))
         } catch {
-          return Effect.fail(ParseResult.parseError([ParseResult.type(urlSchema_.ast, s, `Expected a URL`)]))
+          return Effect.fail(ParseResult.parseError(ParseResult.type(urlSchema_.ast, s, `Expected a URL`)))
         }
       }),
     (url) => Effect.succeed(url.toString())
@@ -324,7 +325,7 @@ export const reload: (
 /**
  * @since 1.0.0
  */
-export const CurrentEntry: Computed.Computed<Navigation, never, Destination> = Computed.fromTag(
+export const CurrentEntry: RefSubject.Computed<Navigation, never, Destination> = RefSubject.computedFromTag(
   Navigation,
   (nav) => nav.currentEntry
 )
@@ -339,22 +340,24 @@ export function getCurrentPathFromUrl(location: Pick<URL, "pathname" | "search"
 /**
  * @since 1.0.0
  */
-export const CurrentPath: Computed.Computed<Navigation, never, string> = CurrentEntry.map((d) =>
-  getCurrentPathFromUrl(d.url)
+export const CurrentPath: RefSubject.Computed<Navigation, never, string> = RefSubject.map(
+  CurrentEntry,
+  (d) => getCurrentPathFromUrl(d.url)
 )
 
 /**
  * @since 1.0.0
  */
-export const CurrentEntries: Computed.Computed<Navigation, never, ReadonlyArray<Destination>> = Computed.fromTag(
-  Navigation,
-  (n) => n.entries
-)
+export const CurrentEntries: RefSubject.Computed<Navigation, never, ReadonlyArray<Destination>> = RefSubject
+  .computedFromTag(
+    Navigation,
+    (n) => n.entries
+  )
 
 /**
  * @since 1.0.0
  */
-export const CanGoForward: Computed.Computed<Navigation, never, boolean> = Computed.fromTag(
+export const CanGoForward: RefSubject.Computed<Navigation, never, boolean> = RefSubject.computedFromTag(
   Navigation,
   (n) => n.canGoForward
 )
@@ -362,7 +365,7 @@ export const CanGoForward: Computed.Computed<Navigation, never, boolean> = Compu
 /**
  * @since 1.0.0
  */
-export const CanGoBack: Computed.Computed<Navigation, never, boolean> = Computed.fromTag(
+export const CanGoBack: RefSubject.Computed<Navigation, never, boolean> = RefSubject.computedFromTag(
   Navigation,
   (n) => n.canGoBack
 )
@@ -371,5 +374,8 @@ export const CanGoBack: Computed.Computed<Navigation, never, boolean> = Computed
  * @since 1.0.0
  */
 export function handleRedirect(error: RedirectError) {
-  return navigate(error.path, error.options)
+  return navigate(error.path, {
+    history: "replace",
+    ...error.options
+  })
 }

package/src/internal/fromWindow.ts

@@ -1,27 +1,29 @@
+import * as Equivalence from "@effect/schema/Equivalence"
 import { unsafeGet } from "@typed/context"
 import { Window } from "@typed/dom/Window"
-import type { Computed } from "@typed/fx/Computed"
 import * as RefSubject from "@typed/fx/RefSubject"
 import { GetRandomValues, Uuid } from "@typed/id"
-import { Effect, Exit, Fiber, Option, Runtime, Scope } from "effect"
-import type { Context, Layer } from "effect"
+
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+import * as Scope from "effect/Scope"
+
+import { Schema } from "@effect/schema"
+import type { Layer } from "effect"
 import type { Commit } from "../Layer.js"
-import type {
-  BeforeNavigationEvent,
-  BeforeNavigationHandler,
-  Destination,
-  NavigationEvent,
-  NavigationHandler,
-  Transition
-} from "../Navigation.js"
+import type { BeforeNavigationEvent, Destination, NavigationEvent, Transition } from "../Navigation.js"
 import { Navigation, NavigationError } from "../Navigation.js"
-import type { NavigationState } from "./shared.js"
+import type { ModelAndIntent } from "./shared.js"
 import {
   getOriginalState,
   getUrl,
   isPatchedState,
   makeDestination,
   makeHandlersState,
+  NavigationState,
   setupFromModelAndIntent
 } from "./shared.js"
 
@@ -94,31 +96,6 @@ function getBaseHref(window: Window) {
   return base ? base.href : "/"
 }
 
-type ModelAndIntent = {
-  readonly state: RefSubject.RefSubject<never, never, NavigationState>
-  readonly canGoBack: Computed<
-    never,
-    never,
-    boolean
-  >
-  readonly canGoForward: Computed<
-    never,
-    never,
-    boolean
-  >
-  readonly beforeHandlers: RefSubject.RefSubject<
-    never,
-    never,
-    Set<readonly [BeforeNavigationHandler<any, any>, Context.Context<any>]>
-  >
-  readonly handlers: RefSubject.RefSubject<
-    never,
-    never,
-    Set<readonly [NavigationHandler<any, any>, Context.Context<any>]>
-  >
-  readonly commit: Commit
-}
-
 const getNavigationState = (navigation: NativeNavigation): NavigationState => {
   const entries = navigation.entries().map(nativeEntryToDestination)
   const { index } = navigation.currentEntry
@@ -141,11 +118,12 @@ function setupWithNavigation(
   return Effect.gen(function*(_) {
     const state = yield* _(
       RefSubject.fromEffect(
-        Effect.sync((): NavigationState => getNavigationState(navigation))
+        Effect.sync((): NavigationState => getNavigationState(navigation)),
+        { eq: Equivalence.make(Schema.to(Schema.to(NavigationState))) }
       )
     )
-    const canGoBack = state.map((s) => s.index > 0)
-    const canGoForward = state.map((s) => s.index < s.entries.length - 1)
+    const canGoBack = RefSubject.map(state, (s) => s.index > 0)
+    const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
     const { beforeHandlers, handlers } = yield* _(makeHandlersState())
     const commit: Commit = (to: Destination, event: BeforeNavigationEvent) =>
       Effect.gen(function*(_) {
@@ -264,11 +242,12 @@ function setupWithHistory(
             ),
             (destination): NavigationState => ({ entries: [destination], index: 0, transition: Option.none() })
           )
-        )
+        ),
+        { eq: Equivalence.make(Schema.to(NavigationState)) }
       )
     )
-    const canGoBack = state.map((s) => s.index > 0)
-    const canGoForward = state.map((s) => s.index < s.entries.length - 1)
+    const canGoBack = RefSubject.map(state, (s) => s.index > 0)
+    const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
     const { beforeHandlers, handlers } = yield* _(makeHandlersState())
     const commit: Commit = ({ id, key, state, url }: Destination, event: BeforeNavigationEvent) =>
       Effect.sync(() => {
@@ -292,7 +271,7 @@ function setupWithHistory(
       beforeHandlers,
       handlers,
       commit
-    } as const
+    } as ModelAndIntent
   })
 }
 
@@ -438,11 +417,8 @@ function scopedRuntime<R>(): Effect.Effect<
     const runFork = Runtime.runFork(runtime)
 
     const run = <E, A>(effect: Effect.Effect<R | Scope.Scope, E, A>): Fiber.RuntimeFiber<E, A> => {
-      const fiber: Fiber.RuntimeFiber<E, A> = Scope.addFinalizer(
-        scope,
-        Effect.suspend(() => Fiber.interrupt(fiber))
-      ).pipe(
-        Effect.zipRight(effect),
+      const fiber: Fiber.RuntimeFiber<E, A> = effect.pipe(
+        Scope.extend(scope),
         runFork
       )
 

package/src/internal/memory.ts

@@ -1,11 +1,22 @@
+import { Schema } from "@effect/schema"
+import * as Equivalence from "@effect/schema/Equivalence"
 import * as RefSubject from "@typed/fx/RefSubject"
 import { GetRandomValues, getRandomValues } from "@typed/id"
-import { Effect, Option } from "effect"
-import type { Layer, Scope } from "effect"
+import type { Layer } from "effect"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
 import type { Commit, InitialMemoryOptions, MemoryOptions } from "../Layer.js"
 import { Navigation } from "../Navigation.js"
-import type { ModelAndIntent, NavigationState } from "./shared.js"
-import { getOriginFromUrl, getUrl, makeDestination, makeHandlersState, setupFromModelAndIntent } from "./shared.js"
+import type { ModelAndIntent } from "./shared.js"
+import {
+  getOriginFromUrl,
+  getUrl,
+  makeDestination,
+  makeHandlersState,
+  NavigationState,
+  setupFromModelAndIntent
+} from "./shared.js"
 
 export const memory = (options: MemoryOptions): Layer.Layer<never, never, Navigation> =>
   Navigation.scoped(
@@ -59,11 +70,12 @@ function setupMemory(
             index: options.currentIndex ?? options.entries.length - 1,
             transition: Option.none()
           }
-        })
+        }),
+        { eq: Equivalence.make(Schema.to(NavigationState)) }
       )
     )
-    const canGoBack = state.map((s) => s.index > 0)
-    const canGoForward = state.map((s) => s.index < s.entries.length - 1)
+    const canGoBack = RefSubject.map(state, (s) => s.index > 0)
+    const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
     const { beforeHandlers, handlers } = yield* _(makeHandlersState())
     const commit: Commit = options.commit ?? (() => Effect.unit)
 

package/src/internal/shared.ts

@@ -1,11 +1,12 @@
 import { Schema } from "@effect/schema"
 import type * as Context from "@typed/context"
-import type { Computed } from "@typed/fx/Computed"
 import * as RefSubject from "@typed/fx/RefSubject"
 import type { Uuid } from "@typed/id"
 import { GetRandomValues, makeUuid } from "@typed/id"
-import type { Scope } from "effect"
-import { Effect, Either, Option } from "effect"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
 import type { Commit } from "../Layer.js"
 import type {
   BeforeNavigationEvent,
@@ -39,12 +40,12 @@ export const getUrl = (origin: string, urlOrPath: string | URL): URL => {
 
 export type ModelAndIntent = {
   readonly state: RefSubject.RefSubject<never, never, NavigationState>
-  readonly canGoBack: Computed<
+  readonly canGoBack: RefSubject.Computed<
     never,
     never,
     boolean
   >
-  readonly canGoForward: Computed<
+  readonly canGoForward: RefSubject.Computed<
     never,
     never,
     boolean
@@ -71,9 +72,9 @@ export function setupFromModelAndIntent(
 ) {
   const { beforeHandlers, canGoBack, canGoForward, commit, handlers, state } = modelAndIntent
 
-  const entries = state.map((s) => s.entries)
-  const currentEntry = state.map((s) => s.entries[s.index])
-  const transition = state.map((s) => s.transition)
+  const entries = RefSubject.map(state, (s) => s.entries)
+  const currentEntry = RefSubject.map(state, (s) => s.entries[s.index])
+  const transition = RefSubject.map(state, (s) => s.transition)
 
   const runBeforeHandlers = (event: BeforeNavigationEvent) =>
     Effect.gen(function*(_) {
@@ -117,7 +118,7 @@ export function setupFromModelAndIntent(
       }
 
       if (matches.length > 0) {
-        yield* _(Effect.all(matches))
+        yield* _(Effect.all(matches, { discard: true }))
       }
     })
 
@@ -210,7 +211,7 @@ export function setupFromModelAndIntent(
     })
 
   const navigate = (pathOrUrl: string | URL, options?: NavigateOptions, skipCommit: boolean = false) =>
-    state.runUpdate((get, set) =>
+    state.runUpdates(({ get, set }) =>
       Effect.gen(function*(_) {
         const state = yield* _(get)
         const from = state.entries[state.index]
@@ -233,7 +234,7 @@ export function setupFromModelAndIntent(
     )
 
   const traverseTo = (key: Destination["key"], options?: { readonly info?: unknown }, skipCommit: boolean = false) =>
-    state.runUpdate((get, set) =>
+    state.runUpdates(({ get, set }) =>
       Effect.gen(function*(_) {
         const state = yield* _(get)
         const { entries, index } = state
@@ -276,7 +277,7 @@ export function setupFromModelAndIntent(
     })
 
   const reload = (options?: { readonly info?: unknown }, skipCommit: boolean = false) =>
-    state.runUpdate((get, set) =>
+    state.runUpdates(({ get, set }) =>
       Effect.gen(function*(_) {
         const { entries, index } = yield* _(state)
         const current = entries[index]
@@ -300,9 +301,9 @@ export function setupFromModelAndIntent(
       const entry = [handler, ctx] as const
 
       return Effect.zipRight(
-        beforeHandlers.update((handlers) => new Set([...handlers, entry])),
+        RefSubject.update(beforeHandlers, (handlers) => new Set([...handlers, entry])),
         Effect.addFinalizer(() =>
-          beforeHandlers.update((handlers) => {
+          RefSubject.update(beforeHandlers, (handlers) => {
             const updated = new Set(handlers)
             updated.delete(entry)
             return updated
@@ -318,9 +319,9 @@ export function setupFromModelAndIntent(
       const entry = [handler, ctx] as const
 
       return Effect.zipRight(
-        handlers.update((handlers) => new Set([...handlers, entry])),
+        RefSubject.update(handlers, (handlers) => new Set([...handlers, entry])),
         Effect.addFinalizer(() =>
-          handlers.update((handlers) => {
+          RefSubject.update(handlers, (handlers) => {
             const updated = new Set(handlers)
             updated.delete(entry)
             return updated
@@ -330,7 +331,7 @@ export function setupFromModelAndIntent(
     })
 
   const updateCurrentEntry = (options: { readonly state: unknown }) =>
-    state.runUpdate((get, set) =>
+    state.runUpdates(({ get, set }) =>
       Effect.gen(function*(_) {
         const { entries, index } = yield* _(get)
         const current = entries[index]