@typed/navigation 0.13.5 → 0.14.0

package/src/Navigation.ts

@@ -3,15 +3,16 @@
  */
 
 import type * as HttpClient from "@effect/platform/HttpClient"
-import { Parser, ParseResult } from "@effect/schema"
+import { ParseResult } from "@effect/schema"
 import * as Schema from "@effect/schema/Schema"
 import { Tagged } from "@typed/context"
 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 * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
 import type { Simplify } from "effect/Types"
 
 /**
@@ -83,40 +84,42 @@ export const Navigation: Tagged<Navigation> = Tagged<Navigation, Navigation>("@t
 
 const urlSchema_ = Schema.instanceOf(URL).pipe(Schema.equivalence((a, b) => a.href === b.href))
 
-const urlSchema = Schema.string.pipe(
+const urlSchema = Schema.String.pipe(
   Schema.transformOrFail(
     urlSchema_,
-    (s) =>
-      Effect.suspend(() => {
-        try {
-          return Effect.succeed(new URL(s))
-        } catch {
-          return Effect.fail(ParseResult.type(urlSchema_.ast, s, `Expected a URL`))
-        }
-      }),
-    (url) => Effect.succeed(url.toString())
+    {
+      decode: (s) =>
+        Effect.suspend(() => {
+          try {
+            return Effect.succeed(new URL(s))
+          } catch {
+            return Effect.fail(new ParseResult.Type(urlSchema_.ast, s, `Expected a URL`))
+          }
+        }),
+      encode: (url) => Effect.succeed(url.toString())
+    }
   )
 )
 
 /**
  * @since 1.0.0
  */
-export const Destination = Schema.struct({
+export const Destination = Schema.Struct({
   id: IdSchema.uuid,
   key: IdSchema.uuid,
   url: urlSchema,
-  state: Schema.unknown,
-  sameDocument: Schema.boolean
+  state: Schema.Unknown,
+  sameDocument: Schema.Boolean
 })
 
 /**
  * @since 1.0.0
  */
-export type DestinationJson = Schema.Schema.From<typeof Destination>
+export type DestinationJson = Schema.Schema.Encoded<typeof Destination>
 /**
  * @since 1.0.0
  */
-export interface Destination extends Schema.Schema.To<typeof Destination> {}
+export interface Destination extends Schema.Schema.Type<typeof Destination> {}
 
 /**
  * @since 1.0.0
@@ -126,76 +129,76 @@ export const ProposedDestination = Destination.pipe(Schema.omit("id", "key"))
 /**
  * @since 1.0.0
  */
-export type ProposedDestinationJson = Schema.Schema.From<typeof ProposedDestination>
+export type ProposedDestinationJson = Schema.Schema.Encoded<typeof ProposedDestination>
 /**
  * @since 1.0.0
  */
-export interface ProposedDestination extends Schema.Schema.To<typeof ProposedDestination> {}
+export interface ProposedDestination extends Schema.Schema.Type<typeof ProposedDestination> {}
 
 /**
  * @since 1.0.0
  */
-export const NavigationType = Schema.literal("push", "replace", "reload", "traverse")
+export const NavigationType = Schema.Literal("push", "replace", "reload", "traverse")
 /**
  * @since 1.0.0
  */
-export type NavigationType = Schema.Schema.To<typeof NavigationType>
+export type NavigationType = Schema.Schema.Type<typeof NavigationType>
 
 /**
  * @since 1.0.0
  */
-export const Transition = Schema.struct({
+export const Transition = Schema.Struct({
   type: NavigationType,
   from: Destination,
-  to: Schema.union(ProposedDestination, Destination)
+  to: Schema.Union(ProposedDestination, Destination)
 })
 
 /**
  * @since 1.0.0
  */
-export type TransitionJson = Schema.Schema.From<typeof Transition>
+export type TransitionJson = Schema.Schema.Encoded<typeof Transition>
 /**
  * @since 1.0.0
  */
-export interface Transition extends Schema.Schema.To<typeof Transition> {}
+export interface Transition extends Schema.Schema.Type<typeof Transition> {}
 
 /**
  * @since 1.0.0
  */
-export const BeforeNavigationEvent = Schema.struct({
+export const BeforeNavigationEvent = Schema.Struct({
   type: NavigationType,
   from: Destination,
-  delta: Schema.number,
-  to: Schema.union(ProposedDestination, Destination),
-  info: Schema.unknown
+  delta: Schema.Number,
+  to: Schema.Union(ProposedDestination, Destination),
+  info: Schema.Unknown
 })
 
 /**
  * @since 1.0.0
  */
-export type BeforeNavigationEventJson = Schema.Schema.From<typeof BeforeNavigationEvent>
+export type BeforeNavigationEventJson = Schema.Schema.Encoded<typeof BeforeNavigationEvent>
 /**
  * @since 1.0.0
  */
-export interface BeforeNavigationEvent extends Schema.Schema.To<typeof BeforeNavigationEvent> {}
+export interface BeforeNavigationEvent extends Schema.Schema.Type<typeof BeforeNavigationEvent> {}
 
 /**
  * @since 1.0.0
  */
-export const NavigationEvent = Schema.struct({
+export const NavigationEvent = Schema.Struct({
   type: NavigationType,
   destination: Destination,
-  info: Schema.unknown
+  info: Schema.Unknown
 })
 
 /**
  * @since 1.0.0
  */
-export type NavigationEventJson = Schema.Schema.From<typeof NavigationEvent>
+export type NavigationEventJson = Schema.Schema.Encoded<typeof NavigationEvent>
 /**
  * @since 1.0.0
  */
-export interface NavigationEvent extends Schema.Schema.To<typeof NavigationEvent> {}
+export interface NavigationEvent extends Schema.Schema.Type<typeof NavigationEvent> {}
 
 /**
  * @since 1.0.0
@@ -268,19 +271,19 @@ export interface NavigateOptions {
 /**
  * @since 1.0.0
  */
-export const FileSchemaFrom = Schema.struct({
-  _id: Schema.literal("File"),
-  name: Schema.string,
-  data: Schema.string // Base64 encoded
+export const FileSchemaFrom = Schema.Struct({
+  _id: Schema.Literal("File"),
+  name: Schema.String,
+  data: Schema.String // Base64 encoded
 })
 
 /**
  * @since 1.0.0
  */
-export type FileSchemaFrom = Schema.Schema.From<typeof FileSchemaFrom>
+export type FileSchemaFrom = Schema.Schema.Encoded<typeof FileSchemaFrom>
 
-const decodeBase64 = Parser.decode(Schema.Base64)
-const encodeBase64 = Parser.encode(Schema.Base64)
+const decodeBase64 = ParseResult.decode(Schema.Base64)
+const encodeBase64 = ParseResult.encode(Schema.Base64)
 
 /**
  * @since 1.0.0
@@ -288,35 +291,39 @@ const encodeBase64 = Parser.encode(Schema.Base64)
 export const FileSchema = FileSchemaFrom.pipe(
   Schema.transformOrFail(
     Schema.instanceOf(File),
-    ({ data, name }) => Effect.map(decodeBase64(data), (buffer) => new File([buffer], name)),
-    (file) =>
-      Effect.promise(() => file.arrayBuffer()).pipe(
-        Effect.flatMap((buffer) => encodeBase64(new Uint8Array(buffer))),
-        Effect.map((data): FileSchemaFrom => ({ _id: "File", name: file.name, data }))
-      )
+    {
+      decode: ({ data, name }) => Effect.map(decodeBase64(data), (buffer) => new File([buffer], name)),
+      encode: (file) =>
+        Effect.promise(() => file.arrayBuffer()).pipe(
+          Effect.flatMap((buffer) => encodeBase64(new Uint8Array(buffer))),
+          Effect.map((data): FileSchemaFrom => ({ _id: "File", name: file.name, data }))
+        )
+    }
   )
 )
 
 /**
  * @since 1.0.0
  */
-export const FormDataSchema = Schema.record(Schema.string, Schema.union(Schema.string, FileSchema)).pipe(
+export const FormDataSchema = Schema.Record(Schema.String, Schema.Union(Schema.String, FileSchema)).pipe(
   Schema.transform(
     Schema.instanceOf(FormData),
-    (formData) => {
-      const data = new FormData()
-
-      for (const [key, value] of Object.entries(formData)) {
-        if (value instanceof File) {
-          data.append(key, value, value.name)
-        } else {
-          data.append(key, value)
+    {
+      decode: (formData) => {
+        const data = new FormData()
+
+        for (const [key, value] of Object.entries(formData)) {
+          if (value instanceof File) {
+            data.append(key, value, value.name)
+          } else {
+            data.append(key, value)
+          }
         }
-      }
 
-      return data
-    },
-    (formData) => Object.fromEntries(formData.entries())
+        return data
+      },
+      encode: (formData) => Object.fromEntries(formData.entries())
+    }
   )
 )
 
@@ -325,38 +332,38 @@ const optionNullable = { as: "Option", nullable: true } as const
 /**
  * @since 1.0.0
  */
-export const FormInputSchema = Schema.struct({
-  name: Schema.optional(Schema.string, optionNullable),
-  action: Schema.optional(Schema.string, optionNullable),
-  method: Schema.optional(Schema.string, optionNullable),
-  encoding: Schema.optional(Schema.string, optionNullable),
+export const FormInputSchema = Schema.Struct({
+  name: Schema.optional(Schema.String, optionNullable),
+  action: Schema.optional(Schema.String, optionNullable),
+  method: Schema.optional(Schema.String, optionNullable),
+  encoding: Schema.optional(Schema.String, optionNullable),
   data: FormDataSchema
 })
 
 /**
  * @since 1.0.0
  */
-export type FormInputFrom = Schema.Schema.From<typeof FormInputSchema>
+export type FormInputFrom = Schema.Schema.Encoded<typeof FormInputSchema>
 
 /**
  * @since 1.0.0
  */
-export interface FormInput extends Schema.Schema.To<typeof FormInputSchema> {}
+export interface FormInput extends Schema.Schema.Type<typeof FormInputSchema> {}
 
 /**
  * @since 1.0.0
  */
-export const FormDataEvent = Schema.extend(Schema.struct({ from: Destination }), FormInputSchema)
+export const FormDataEvent = Schema.extend(Schema.Struct({ from: Destination }), FormInputSchema)
 
 /**
  * @since 1.0.0
  */
-export type FormDataEventJson = Schema.Schema.From<typeof FormDataEvent>
+export type FormDataEventJson = Schema.Schema.Encoded<typeof FormDataEvent>
 
 /**
  * @since 1.0.0
  */
-export interface FormDataEvent extends Schema.Schema.To<typeof FormDataEvent> {}
+export interface FormDataEvent extends Schema.Schema.Type<typeof FormDataEvent> {}
 
 /**
  * @since 1.0.0
@@ -461,11 +468,10 @@ export function getCurrentPathFromUrl(location: Pick<URL, "pathname" | "search"
 /**
  * @since 1.0.0
  */
-export const CurrentPath: RefSubject.Computed<string, never, Navigation> = RefSubject.map(
-  CurrentEntry,
-  (d) => getCurrentPathFromUrl(d.url)
+export const CurrentPath: RefSubject.Computed<string, never, Navigation> = RefSubject.computedFromTag(
+  Navigation,
+  (nav) => RefSubject.map(nav.currentEntry, (e) => getCurrentPathFromUrl(e.url))
 )
-
 /**
  * @since 1.0.0
  */

package/src/internal/fromWindow.ts

@@ -10,8 +10,9 @@ import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
 
-import { Schema } from "@effect/schema"
-import { Exit, type Layer } from "effect"
+import * as Schema from "@effect/schema/Schema"
+import * as Exit from "effect/Exit"
+import type * as Layer from "effect/Layer"
 import type { Commit } from "../Layer.js"
 import type { BeforeNavigationEvent, Destination, NavigationEvent, Transition } from "../Navigation.js"
 import { Navigation, NavigationError } from "../Navigation.js"
@@ -41,14 +42,12 @@ declare global {
 export const fromWindow: Layer.Layer<Navigation, never, Window> = Navigation.scoped(
   Window.withEffect((window) => {
     const getRandomValues = (length: number) => Effect.sync(() => window.crypto.getRandomValues(new Uint8Array(length)))
-    return Effect.gen(function*(_) {
-      const { run, runPromise } = yield* _(scopedRuntime<never>())
+    return Effect.gen(function*() {
+      const { run, runPromise } = yield* scopedRuntime<never>()
       const hasNativeNavigation = !!window.navigation
-      const modelAndIntent = yield* _(
-        hasNativeNavigation
-          ? setupWithNavigation(window.navigation!, runPromise)
-          : setupWithHistory(window, (event) => run(handleHistoryEvent(event)))
-      )
+      const modelAndIntent = yield* hasNativeNavigation
+        ? setupWithNavigation(window.navigation!, runPromise)
+        : setupWithHistory(window, (event) => run(handleHistoryEvent(event)))
 
       const navigation = setupFromModelAndIntent(
         modelAndIntent,
@@ -61,26 +60,28 @@ export const fromWindow: Layer.Layer<Navigation, never, Window> = Navigation.sco
       return navigation
 
       function handleHistoryEvent(event: HistoryEvent) {
-        return Effect.gen(function*(_) {
+        return Effect.gen(function*() {
           if (event._tag === "PushState") {
-            return yield* _(navigation.navigate(event.url, {}, event.skipCommit))
+            return yield* navigation.navigate(event.url, {}, event.skipCommit)
           } else if (event._tag === "ReplaceState") {
             if (Option.isSome(event.url)) {
-              return yield* _(
-                navigation.navigate(event.url.value, { history: "replace", state: event.state }, event.skipCommit)
+              return yield* navigation.navigate(
+                event.url.value,
+                { history: "replace", state: event.state },
+                event.skipCommit
               )
             } else {
-              return yield* _(navigation.updateCurrentEntry(event))
+              return yield* navigation.updateCurrentEntry(event)
             }
           } else if (event._tag === "Traverse") {
-            const { entries, index } = yield* _(modelAndIntent.state)
+            const { entries, index } = yield* modelAndIntent.state
             const toIndex = Math.min(Math.max(0, index + event.delta), entries.length - 1)
             const to = entries[toIndex]
 
-            return yield* _(navigation.traverseTo(to.key, {}, event.skipCommit))
+            return yield* navigation.traverseTo(to.key, {}, event.skipCommit)
           } else {
-            yield* _(navigation.traverseTo(event.key, {}, event.skipCommit))
-            return yield* _(navigation.updateCurrentEntry({ state: event.state }))
+            yield* navigation.traverseTo(event.key, {}, event.skipCommit)
+            return yield* navigation.updateCurrentEntry({ state: event.state })
           }
         })
       }
@@ -110,16 +111,14 @@ function setupWithNavigation(
   navigation: NativeNavigation,
   runPromise: <E, A>(effect: Effect.Effect<A, E, Scope.Scope>) => Promise<A>
 ): Effect.Effect<ModelAndIntent, never, Scope.Scope | GetRandomValues> {
-  return Effect.gen(function*(_) {
-    const state = yield* _(
-      RefSubject.fromEffect(
-        Effect.sync((): NavigationState => getNavigationState(navigation)),
-        { eq: Equivalence.make(Schema.to(Schema.to(NavigationState))) }
-      )
+  return Effect.gen(function*() {
+    const state = yield* RefSubject.fromEffect(
+      Effect.sync((): NavigationState => getNavigationState(navigation)),
+      { eq: Equivalence.make(Schema.typeSchema(Schema.typeSchema(NavigationState))) }
     )
     const canGoBack = RefSubject.map(state, (s) => s.index > 0)
     const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
-    const { beforeHandlers, formDataHandlers, handlers } = yield* _(makeHandlersState())
+    const { beforeHandlers, formDataHandlers, handlers } = yield* makeHandlersState()
     const commit: Commit = (to: Destination, event: BeforeNavigationEvent) =>
       Effect.gen(function*(_) {
         const { key, state, url } = to
@@ -144,8 +143,8 @@ function setupWithNavigation(
       })
 
     const runHandlers = (native: NativeEvent) =>
-      Effect.gen(function*(_) {
-        const eventHandlers = yield* _(handlers)
+      Effect.gen(function*() {
+        const eventHandlers = yield* handlers
         const matches: Array<Effect.Effect<unknown>> = []
 
         const event: NavigationEvent = {
@@ -155,14 +154,14 @@ function setupWithNavigation(
         }
 
         for (const [handler, ctx] of eventHandlers) {
-          const match = yield* _(handler(event), Effect.provide(ctx))
+          const match = yield* Effect.provide(handler(event), ctx)
           if (Option.isSome(match)) {
             matches.push(Effect.provide(match.value, ctx))
           }
         }
 
         if (matches.length > 0) {
-          yield* _(Effect.all(matches))
+          yield* Effect.all(matches)
         }
       })
 
@@ -217,30 +216,28 @@ function setupWithHistory(
   window: Window,
   onEvent: (event: HistoryEvent) => void
 ): Effect.Effect<ModelAndIntent, never, GetRandomValues | Scope.Scope> {
-  return Effect.gen(function*(_) {
+  return Effect.gen(function*() {
     const { location } = window
     const { original: history, unpatch } = patchHistory(window, onEvent)
 
-    yield* _(Effect.addFinalizer(() => unpatch))
-
-    const state = yield* _(
-      RefSubject.fromEffect(
-        Effect.suspend(() =>
-          Effect.map(
-            makeDestination(
-              new URL(location.href),
-              history.state,
-              location.origin
-            ),
-            (destination): NavigationState => ({ entries: [destination], index: 0, transition: Option.none() })
-          )
-        ),
-        { eq: Equivalence.make(Schema.to(NavigationState)) }
-      )
+    yield* Effect.addFinalizer(() => unpatch)
+
+    const state = yield* RefSubject.fromEffect(
+      Effect.suspend(() =>
+        Effect.map(
+          makeDestination(
+            new URL(location.href),
+            history.state,
+            location.origin
+          ),
+          (destination): NavigationState => ({ entries: [destination], index: 0, transition: Option.none() })
+        )
+      ),
+      { eq: Equivalence.make(Schema.typeSchema(NavigationState)) }
     )
     const canGoBack = RefSubject.map(state, (s) => s.index > 0)
     const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
-    const { beforeHandlers, formDataHandlers, handlers } = yield* _(makeHandlersState())
+    const { beforeHandlers, formDataHandlers, handlers } = yield* makeHandlersState()
     const commit: Commit = ({ id, key, state, url }: Destination, event: BeforeNavigationEvent) =>
       Effect.sync(() => {
         const { type } = event

package/src/internal/memory.ts

@@ -2,8 +2,8 @@ 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 type { Layer } from "effect"
 import * as Effect from "effect/Effect"
+import type * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import type { Commit, InitialMemoryOptions, MemoryOptions } from "../Layer.js"
@@ -20,9 +20,9 @@ import {
 
 export const memory = (options: MemoryOptions): Layer.Layer<Navigation> =>
   Navigation.scoped(
-    Effect.gen(function*(_) {
-      const getRandomValues = yield* _(GetRandomValues)
-      const modelAndIntent = yield* _(setupMemory(options))
+    Effect.gen(function*() {
+      const getRandomValues = yield* GetRandomValues
+      const modelAndIntent = yield* setupMemory(options)
       const current = options.entries[options.currentIndex ?? 0]
       const origin = options.origin ?? getOriginFromUrl(current.url)
       const base = options.base ?? "/"
@@ -35,11 +35,11 @@ export function initialMemory(
   options: InitialMemoryOptions
 ): Layer.Layer<Navigation> {
   return Navigation.scoped(
-    Effect.gen(function*(_) {
-      const getRandomValues = yield* _(GetRandomValues)
+    Effect.gen(function*() {
+      const getRandomValues = yield* GetRandomValues
       const origin = options.origin ?? getOriginFromUrl(options.url)
       const base = options.base ?? "/"
-      const destination = yield* _(makeDestination(getUrl(origin, options.url), options.state, origin))
+      const destination = yield* makeDestination(getUrl(origin, options.url), options.state, origin)
       const memoryOptions: MemoryOptions = {
         entries: [destination],
         origin,
@@ -47,7 +47,7 @@ export function initialMemory(
         currentIndex: 0,
         maxEntries: options.maxEntries
       }
-      const modelAndIntent = yield* _(setupMemory(memoryOptions))
+      const modelAndIntent = yield* setupMemory(memoryOptions)
 
       return setupFromModelAndIntent(modelAndIntent, origin, base, getRandomValues)
     }).pipe(Effect.provide(getRandomValues))
@@ -57,23 +57,17 @@ export function initialMemory(
 function setupMemory(
   options: MemoryOptions
 ): Effect.Effect<ModelAndIntent, never, GetRandomValues | Scope.Scope> {
-  return Effect.gen(function*(_) {
-    const state = yield* _(
-      RefSubject.fromEffect(
-        Effect.sync((): NavigationState => {
-          return {
-            entries: options.entries,
-            index: options.currentIndex ?? options.entries.length - 1,
-            transition: Option.none()
-          }
-        }),
-        { eq: Equivalence.make(Schema.to(NavigationState)) }
-      )
-    )
+  return Effect.gen(function*() {
+    const state = yield* RefSubject.of<NavigationState>({
+      entries: options.entries,
+      index: options.currentIndex ?? options.entries.length - 1,
+      transition: Option.none()
+    }, { eq: Equivalence.make(Schema.typeSchema(NavigationState)) })
+
     const canGoBack = RefSubject.map(state, (s) => s.index > 0)
     const canGoForward = RefSubject.map(state, (s) => s.index < s.entries.length - 1)
-    const { beforeHandlers, formDataHandlers, handlers } = yield* _(makeHandlersState())
-    const commit: Commit = options.commit ?? (() => Effect.unit)
+    const { beforeHandlers, formDataHandlers, handlers } = yield* makeHandlersState()
+    const commit: Commit = options.commit ?? (() => Effect.void)
 
     return {
       state,