@typed/navigation 0.18.0 → 0.18.1

package/dist/{dts/internal → internal}/shared.d.ts

@@ -1,26 +1,29 @@
-import type { HttpClientError, HttpClientResponse } from "@effect/platform";
-import { HttpClient } from "@effect/platform";
-import { Schema } from "@effect/schema";
-import type * as Context from "@typed/context";
-import * as RefSubject from "@typed/fx/RefSubject";
-import type { Uuid } from "@typed/id";
-import { GetRandomValues } from "@typed/id";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import type * as Scope from "effect/Scope";
-import type { Commit } from "../Layer.js";
-import type { BeforeNavigationEvent, BeforeNavigationHandler, FormDataHandler, FormInputFrom, NavigateOptions, NavigationError, NavigationHandler, ProposedDestination, RedirectError } from "../Navigation.js";
-import { Destination, Transition } from "../Navigation.js";
+import * as HttpClient from '@effect/platform/HttpClient';
+import { GetRandomValues, type Uuid4 } from '@typed/id';
+import * as LazyRef from '@typed/lazy-ref';
+import { Schema } from 'effect';
+import type * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type * as Scope from 'effect/Scope';
+import { Destination } from '../Destination.js';
+import { FormSubmitError, type NavigationError } from '../Error.js';
+import { TransitionEvent } from '../Event.js';
+import type { FormSubmit } from '../Forms.js';
+import type { BeforeNavigationHandler, NavigationHandler } from '../Handler.js';
+import type { Commit } from '../Layer.js';
+import type { NavigateOptions } from '../NavigateOptions.js';
+import type { ProposedDestination } from '../ProposedDestination.js';
 export type NavigationState = {
     readonly entries: ReadonlyArray<Destination>;
     readonly index: number;
-    readonly transition: Option.Option<Transition>;
+    readonly transition: Option.Option<TransitionEvent>;
 };
 export declare const NavigationState: Schema.Struct<{
     entries: Schema.Array$<Schema.Struct<{
-        id: Schema.Schema<Uuid, string, never>;
-        key: Schema.Schema<Uuid, string, never>;
-        url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>;
+        id: typeof Schema.UUID;
+        key: typeof Schema.UUID;
+        url: Schema.transformOrFail<typeof Schema.String, Schema.instanceOf<URL>, never>;
         state: typeof Schema.Unknown;
         sameDocument: typeof Schema.Boolean;
     }>>;
@@ -28,12 +31,13 @@ export declare const NavigationState: Schema.Struct<{
     transition: Schema.OptionFromNullishOr<Schema.Struct<{
         type: Schema.Literal<["push", "replace", "reload", "traverse"]>;
         from: Schema.Struct<{
-            id: Schema.Schema<Uuid, string, never>;
-            key: Schema.Schema<Uuid, string, never>;
-            url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>;
+            id: typeof Schema.UUID;
+            key: typeof Schema.UUID;
+            url: Schema.transformOrFail<typeof Schema.String, Schema.instanceOf<URL>, never>;
             state: typeof Schema.Unknown;
             sameDocument: typeof Schema.Boolean;
         }>;
+        delta: typeof Schema.Number;
         to: Schema.Union<[Schema.SchemaClass<{
             readonly url: URL;
             readonly state: unknown;
@@ -43,34 +47,32 @@ export declare const NavigationState: Schema.Struct<{
             readonly state: unknown;
             readonly sameDocument: boolean;
         }, never>, Schema.Struct<{
-            id: Schema.Schema<Uuid, string, never>;
-            key: Schema.Schema<Uuid, string, never>;
-            url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>;
+            id: typeof Schema.UUID;
+            key: typeof Schema.UUID;
+            url: Schema.transformOrFail<typeof Schema.String, Schema.instanceOf<URL>, never>;
             state: typeof Schema.Unknown;
             sameDocument: typeof Schema.Boolean;
         }>]>;
+        info: typeof Schema.Unknown;
     }>>;
 }>;
-export declare const getUrl: (origin: string, urlOrPath: string | URL) => URL;
+export declare function getUrl(origin: string, urlOrPath: string | URL, base: string): URL;
 export type ModelAndIntent = {
-    readonly state: RefSubject.RefSubject<NavigationState>;
-    readonly canGoBack: RefSubject.Computed<boolean>;
-    readonly canGoForward: RefSubject.Computed<boolean>;
-    readonly beforeHandlers: RefSubject.RefSubject<Set<readonly [BeforeNavigationHandler<any, any>, Context.Context<any>]>>;
-    readonly handlers: RefSubject.RefSubject<Set<readonly [NavigationHandler<any, any>, Context.Context<any>]>>;
-    readonly formDataHandlers: RefSubject.RefSubject<Set<readonly [FormDataHandler<any, any>, Context.Context<any>]>>;
+    readonly state: LazyRef.LazyRef<NavigationState>;
+    readonly beforeHandlers: LazyRef.LazyRef<Set<readonly [BeforeNavigationHandler<any, any>, Context.Context<any>]>>;
+    readonly handlers: LazyRef.LazyRef<Set<readonly [NavigationHandler<any, any>, Context.Context<any>]>>;
     readonly commit: Commit;
 };
-export declare function setupFromModelAndIntent(modelAndIntent: ModelAndIntent, origin: string, base: string, getRandomValues: Context.Fn.FnOf<typeof GetRandomValues>, newNavigationState?: () => NavigationState): {
+export declare function setupFromModelAndIntent(modelAndIntent: ModelAndIntent, origin: string, base: string, getRandomValues: Context.Tag.Service<typeof GetRandomValues>, newNavigationState?: () => NavigationState): {
     back: (options?: {
         readonly info?: unknown;
     }, skipCommit?: boolean) => Effect.Effect<Destination, NavigationError, never>;
     base: string;
     beforeNavigation: <R = never, R2 = never>(handler: BeforeNavigationHandler<R, R2>) => Effect.Effect<void, never, R | R2 | Scope.Scope>;
-    canGoBack: RefSubject.Computed<boolean, never, never>;
-    canGoForward: RefSubject.Computed<boolean, never, never>;
-    currentEntry: RefSubject.Computed<Destination, never, never>;
-    entries: RefSubject.Computed<readonly Destination[], never, never>;
+    canGoBack: LazyRef.Computed<boolean, never, never>;
+    canGoForward: LazyRef.Computed<boolean, never, never>;
+    currentEntry: LazyRef.Computed<Destination, never, never>;
+    entries: LazyRef.Computed<readonly Destination[], never, never>;
     forward: (options?: {
         readonly info?: unknown;
     }, skipCommit?: boolean) => Effect.Effect<Destination, NavigationError, never>;
@@ -80,32 +82,28 @@ export declare function setupFromModelAndIntent(modelAndIntent: ModelAndIntent,
     reload: (options?: {
         readonly info?: unknown;
     }, skipCommit?: boolean) => Effect.Effect<Destination, NavigationError, never>;
-    transition: RefSubject.Computed<Option.Option<Transition>, never, never>;
+    transition: LazyRef.Computed<Option.Option<TransitionEvent>, never, never>;
     traverseTo: (key: Destination["key"], options?: {
         readonly info?: unknown;
     }, skipCommit?: boolean) => Effect.Effect<Destination, NavigationError, never>;
     updateCurrentEntry: (options: {
         readonly state: unknown;
     }) => Effect.Effect<Destination, NavigationError, never>;
-    submit: (data: FormData, input?: Omit<FormInputFrom, "data">) => Effect.Effect<Option.Option<HttpClientResponse.HttpClientResponse>, NavigationError | HttpClientError.HttpClientError, Scope.Scope | HttpClient.HttpClient.Service>;
-    onFormData: <R = never, R2 = never>(handler: FormDataHandler<R, R2>) => Effect.Effect<void, never, R | R2 | Scope.Scope>;
+    submit: (form: FormSubmit) => Effect.Effect<readonly [Destination, import("@effect/platform/HttpClientResponse").HttpClientResponse], NavigationError | FormSubmitError, Scope.Scope | HttpClient.HttpClient>;
 };
-export declare function makeRedirectEvent(origin: string, redirect: RedirectError, from: Destination): Effect.Effect<BeforeNavigationEvent, never, GetRandomValues>;
 export declare function makeOrUpdateDestination(navigationState: NavigationState, url: URL, state: unknown, origin: string): Effect.Effect<Destination, never, GetRandomValues>;
 export declare function makeDestination(url: URL, state: unknown, origin: string): Effect.Effect<Destination, never, GetRandomValues>;
 export declare function upgradeProposedDestination(proposed: ProposedDestination): Effect.Effect<Destination, never, GetRandomValues>;
 export type PatchedState = {
-    readonly __typed__navigation__id__: Uuid;
-    readonly __typed__navigation__key__: Uuid;
+    readonly __typed__navigation__id__: Uuid4;
+    readonly __typed__navigation__key__: Uuid4;
     readonly __typed__navigation__state__: unknown;
 };
 export declare function isPatchedState(state: unknown): state is PatchedState;
 export declare function getOriginalState(state: unknown): unknown;
 export declare function getOriginFromUrl(url: string | URL): string;
 export declare function isDestination(proposed: ProposedDestination): proposed is Destination;
-export declare function makeHandlersState(): Effect.Effect<{
-    beforeHandlers: RefSubject.RefSubject<Set<readonly [BeforeNavigationHandler<any, any>, Context.Context<any>]>, never, never>;
-    handlers: RefSubject.RefSubject<Set<readonly [NavigationHandler<any, any>, Context.Context<any>]>, never, never>;
-    formDataHandlers: RefSubject.RefSubject<Set<readonly [FormDataHandler<any, any>, Context.Context<any>]>, never, never>;
+export declare const makeHandlersState: Effect.Effect<{
+    beforeHandlers: LazyRef.LazyRef<Set<readonly [BeforeNavigationHandler<any, any>, Context.Context<any>]>, never, never>;
+    handlers: LazyRef.LazyRef<Set<readonly [NavigationHandler<any, any>, Context.Context<any>]>, never, never>;
 }, never, Scope.Scope>;
-//# sourceMappingURL=shared.d.ts.map

package/dist/{esm/internal → internal}/shared.js

@@ -1,25 +1,54 @@
-import { Headers, HttpClient, HttpClientRequest } from "@effect/platform";
-import { Schema } from "@effect/schema";
-import * as RefSubject from "@typed/fx/RefSubject";
-import { GetRandomValues, makeUuid } from "@typed/id";
-import * as Effect from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Option from "effect/Option";
-import { Destination, Transition } from "../Navigation.js";
+import * as Headers from '@effect/platform/Headers';
+import * as HttpClient from '@effect/platform/HttpClient';
+import { GetRandomValues, makeUuid4 } from '@typed/id';
+import * as LazyRef from '@typed/lazy-ref';
+import { Cause, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import * as Option from 'effect/Option';
+import { Destination } from '../Destination.js';
+import { FormSubmitError, } from '../Error.js';
+import { TransitionEvent } from '../Event.js';
 export const NavigationState = Schema.Struct({
     entries: Schema.Array(Destination),
     index: Schema.Number,
-    transition: Schema.OptionFromNullishOr(Transition, null)
+    transition: Schema.OptionFromNullishOr(TransitionEvent, null),
 });
-export const getUrl = (origin, urlOrPath) => {
-    return typeof urlOrPath === "string" ? new URL(urlOrPath, origin) : urlOrPath;
-};
+export function getUrl(origin, urlOrPath, base) {
+    if (typeof urlOrPath === 'string') {
+        const url = new URL(urlOrPath, origin);
+        // If the URL is relative, join it with the base
+        if (isRelativeUrl(urlOrPath)) {
+            url.pathname = joinPath(base, url.pathname);
+        }
+        return url;
+    }
+    return urlOrPath;
+}
+function isRelativeUrl(url) {
+    if (url.includes('://'))
+        return false;
+    return true;
+}
+function joinPath(a, b) {
+    const aEndsWithSlash = a[a.length - 1] === '/';
+    const bStartsWithSlash = b[0] === '/';
+    if (aEndsWithSlash && bStartsWithSlash) {
+        return a + b.slice(1);
+    }
+    if (!aEndsWithSlash && !bStartsWithSlash) {
+        return `${a}/${b}`;
+    }
+    return a + b;
+}
 const REDIRECT_STATUS_CODES = new Set([301, 302, 303, 307, 308]);
 export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomValues, newNavigationState) {
-    const { beforeHandlers, canGoBack, canGoForward, commit, formDataHandlers, handlers, state } = modelAndIntent;
-    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 { beforeHandlers, commit, handlers, state } = modelAndIntent;
+    const canGoBack = LazyRef.map(state, (s) => s.index > 0);
+    const canGoForward = LazyRef.map(state, (s) => s.index < s.entries.length - 1);
+    const entries = LazyRef.map(state, (s) => s.entries);
+    const currentEntry = LazyRef.map(state, (s) => s.entries[s.index]);
+    const transition = LazyRef.map(state, (s) => s.transition);
     const runBeforeHandlers = (event) => Effect.gen(function* () {
         const handlers = yield* beforeHandlers;
         const matches = [];
@@ -27,7 +56,7 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
             const exit = yield* handler(event).pipe(Effect.provide(ctx), Effect.either);
             if (Either.isRight(exit)) {
                 const match = exit.right;
-                if (Option.isSome(match)) {
+                if (match !== undefined && Option.isSome(match)) {
                     matches.push(Effect.provide(match.value, ctx));
                 }
             }
@@ -50,7 +79,7 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
         const matches = [];
         for (const [handler, ctx] of eventHandlers) {
             const match = yield* Effect.provide(handler(event), ctx);
-            if (Option.isSome(match)) {
+            if (match !== undefined && Option.isSome(match)) {
                 matches.push(Effect.provide(match.value, ctx));
             }
         }
@@ -58,44 +87,10 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
             yield* Effect.all(matches, { discard: true });
         }
     });
-    const runFormDataHandlers = (event) => Effect.gen(function* () {
-        const handlers = yield* formDataHandlers;
-        const matches = [];
-        for (const [handler, ctx] of handlers) {
-            const exit = yield* handler(event).pipe(Effect.provide(ctx), Effect.either);
-            if (Either.isRight(exit)) {
-                const match = exit.right;
-                if (Option.isSome(match)) {
-                    matches.push(Effect.provide(match.value, ctx));
-                }
-            }
-            else {
-                return Either.left(exit.left);
-            }
-        }
-        if (matches.length > 0) {
-            for (const match of matches) {
-                const exit = yield* Effect.either(match);
-                if (Either.isLeft(exit)) {
-                    return Either.left(exit.left);
-                }
-                else if (Option.isSome(exit.right)) {
-                    return Either.right(exit.right);
-                }
-            }
-        }
-        else {
-            // Only if there are 0 matches, we'll make a request to the server ourselves
-            const response = yield* makeFormDataRequest(event, Option.getOrElse(event.action, () => event.from.url.href));
-            return Either.right(Option.some(response));
-        }
-        return Either.right(Option.none());
-    });
     const runNavigationEvent = (beforeEvent, get, set, depth, skipCommit = false) => Effect.gen(function* () {
-        let current = yield* get;
-        current = yield* set({
-            ...current,
-            transition: Option.some(beforeEvent)
+        const current = yield* set({
+            ...(yield* get),
+            transition: Option.some(beforeEvent),
         });
         if (!skipCommit) {
             const beforeError = yield* runBeforeHandlers(beforeEvent);
@@ -109,7 +104,7 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
         if (!skipCommit) {
             yield* commit(to, beforeEvent);
         }
-        if (newNavigationState) {
+        if (newNavigationState !== undefined) {
             const { entries, index } = yield* set(newNavigationState());
             return entries[index];
         }
@@ -117,21 +112,21 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
             const event = {
                 type: beforeEvent.type,
                 info: beforeEvent.info,
-                destination: to
+                destination: to,
             };
-            if (beforeEvent.type === "push") {
+            if (beforeEvent.type === 'push') {
                 const index = current.index + 1;
                 const entries = current.entries.slice(0, index).concat([to]);
                 yield* set({ entries, index, transition: Option.none() });
             }
-            else if (beforeEvent.type === "replace") {
+            else if (beforeEvent.type === 'replace') {
                 const index = current.index;
                 const before = current.entries.slice(0, index);
                 const after = current.entries.slice(index + 1);
                 const entries = [...before, to, ...after];
                 yield* set({ entries, index, transition: Option.none() });
             }
-            else if (beforeEvent.type === "reload") {
+            else if (beforeEvent.type === 'reload') {
                 yield* set({ ...current, transition: Option.none() });
             }
             else {
@@ -140,44 +135,40 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
                 yield* set({
                     ...current,
                     index: nextIndex,
-                    transition: Option.none()
+                    transition: Option.none(),
                 });
             }
             yield* runHandlers(event);
         }
         return to;
-    }).pipe(GetRandomValues.provide(getRandomValues));
+    }).pipe(Effect.provideService(GetRandomValues, getRandomValues));
     const handleError = (error, get, set, depth) => Effect.gen(function* () {
         if (depth >= 25) {
-            return yield* Effect.dieMessage(`Redirect loop detected.`);
+            return yield* Effect.dieMessage('Redirect loop detected.');
         }
         const { entries, index } = yield* get;
         const from = entries[index];
-        if (error._tag === "CancelNavigation") {
+        if (error._tag === 'CancelNavigation') {
             yield* set({ entries, index, transition: Option.none() });
             return from;
         }
         else {
-            const event = yield* makeRedirectEvent(origin, error, from);
+            const event = yield* makeRedirectEvent(origin, error, from, base);
             return yield* runNavigationEvent(event, get, set, depth + 1);
         }
-    }).pipe(GetRandomValues.provide(getRandomValues));
+    }).pipe(Effect.provideService(GetRandomValues, getRandomValues));
     const navigate = (pathOrUrl, options, skipCommit = false) => state.runUpdates(({ get, set }) => Effect.gen(function* () {
         const state = yield* get;
         const from = state.entries[state.index];
-        const history = options?.history ?? "auto";
-        const to = yield* makeOrUpdateDestination(state, getUrl(origin, pathOrUrl), options?.state, origin).pipe(GetRandomValues.provide(getRandomValues));
-        const type = history === "auto"
-            ? from.key === to.key
-                ? "replace"
-                : "push"
-            : history;
+        const history = options?.history ?? 'auto';
+        const to = yield* makeOrUpdateDestination(state, getUrl(origin, pathOrUrl, base), options?.state, origin).pipe(Effect.provideService(GetRandomValues, getRandomValues));
+        const type = history === 'auto' ? (from.key === to.key ? 'replace' : 'push') : history;
         const event = {
             type,
             from,
             to,
-            delta: type === "replace" ? 0 : 1,
-            info: options?.info
+            delta: type === 'replace' ? 0 : 1,
+            info: options?.info,
         };
         return yield* runNavigationEvent(event, get, set, 0, skipCommit);
     }));
@@ -188,15 +179,15 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
         const nextIndex = entries.findIndex((e) => e.key === key);
         if (nextIndex === -1)
             return from;
-        const id = yield* makeUuid.pipe(GetRandomValues.provide(getRandomValues));
+        const id = yield* makeUuid4.pipe(Effect.provideService(GetRandomValues, getRandomValues));
         const to = { ...entries[nextIndex], id };
         const delta = nextIndex - index;
         const event = {
-            type: "traverse",
+            type: 'traverse',
             from,
             to,
             delta,
-            info: options?.info
+            info: options?.info,
         };
         return yield* runNavigationEvent(event, get, set, 0, skipCommit);
     }));
@@ -218,82 +209,61 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
         const { entries, index } = yield* state;
         const current = entries[index];
         const event = {
-            type: "reload",
+            type: 'reload',
             from: current,
             to: current,
             delta: 0,
-            info: options?.info
+            info: options?.info,
         };
         return yield* runNavigationEvent(event, get, set, 0, skipCommit);
     }));
     const beforeNavigation = (handler) => Effect.contextWithEffect((ctx) => {
         const entry = [handler, ctx];
-        return Effect.zipRight(RefSubject.update(beforeHandlers, (handlers) => new Set([...handlers, entry])), Effect.addFinalizer(() => RefSubject.update(beforeHandlers, (handlers) => {
+        const acquire = LazyRef.update(beforeHandlers, (handlers) => new Set([...handlers, entry]));
+        const release = Effect.ignoreLogged(LazyRef.update(beforeHandlers, (handlers) => {
             const updated = new Set(handlers);
             updated.delete(entry);
             return updated;
-        })));
+        }));
+        return Effect.acquireRelease(acquire, () => release);
     });
     const onNavigation = (handler) => Effect.contextWithEffect((ctx) => {
         const entry = [handler, ctx];
-        return Effect.zipRight(RefSubject.update(handlers, (handlers) => new Set([...handlers, entry])), Effect.addFinalizer(() => RefSubject.update(handlers, (handlers) => {
+        const acquire = LazyRef.update(handlers, (handlers) => new Set([...handlers, entry]));
+        const release = Effect.ignoreLogged(LazyRef.update(handlers, (handlers) => {
             const updated = new Set(handlers);
             updated.delete(entry);
             return updated;
-        })));
+        }));
+        return Effect.acquireRelease(acquire, () => release);
     });
     const updateCurrentEntry = (options) => state.runUpdates(({ get, set }) => Effect.gen(function* () {
         const { entries, index } = yield* get;
         const current = entries[index];
         const event = {
-            type: "replace",
+            type: 'replace',
             from: current,
             to: { ...current, state: options.state },
             delta: 0,
-            info: null
+            info: null,
         };
         return yield* runNavigationEvent(event, get, set, 0);
     }));
-    const submit = (data, input) => state.runUpdates(({ get, set }) => Effect.gen(function* () {
-        const { entries, index } = yield* get;
-        const from = entries[index];
-        const event = {
-            from,
-            data,
-            name: Option.fromNullable(input?.name),
-            action: Option.fromNullable(input?.action),
-            method: Option.fromNullable(input?.method),
-            encoding: Option.fromNullable(input?.encoding)
-        };
-        const either = yield* runFormDataHandlers(event);
-        if (Either.isLeft(either)) {
-            yield* handleError(either.left, get, set, 0);
-            return Option.none();
-        }
-        else {
-            if (Option.isNone(either.right)) {
-                return either.right;
-            }
-            const response = either.right.value;
-            // If it is a redirect
-            if (REDIRECT_STATUS_CODES.has(response.status)) {
-                const location = Headers.get(response.headers, "location");
-                // And we have a location header
-                if (Option.isSome(location)) {
-                    // Then we navigate to that location
-                    yield* navigate(location.value, { history: "replace" });
-                }
+    const submit = (form) => Effect.gen(function* () {
+        const current = yield* currentEntry;
+        // Utilize the action URL if provided, otherwise use the current URL
+        const url = form.action ? getUrl(origin, form.action, base) : current.url;
+        // Submit the HTTP request
+        const response = yield* HttpClient[form.method](url, form).pipe(Effect.mapErrorCause((cause) => Cause.fail(new FormSubmitError({ cause }))));
+        // If the response is a redirect, navigate to the new URL
+        if (REDIRECT_STATUS_CODES.has(response.status)) {
+            // Get the location header
+            const location = Headers.get(response.headers, 'location');
+            if (Option.isSome(location)) {
+                return [yield* navigate(getUrl(origin, location.value, base), form), response];
             }
-            return Option.some(response);
         }
-    }));
-    const onFormData = (handler) => Effect.contextWithEffect((ctx) => {
-        const entry = [handler, ctx];
-        return Effect.zipRight(RefSubject.update(formDataHandlers, (handlers) => new Set([...handlers, entry])), Effect.addFinalizer(() => RefSubject.update(formDataHandlers, (handlers) => {
-            const updated = new Set(handlers);
-            updated.delete(entry);
-            return updated;
-        })));
+        return [current, response];
     });
     const navigation = {
         back,
@@ -312,20 +282,19 @@ export function setupFromModelAndIntent(modelAndIntent, origin, base, getRandomV
         traverseTo,
         updateCurrentEntry,
         submit,
-        onFormData
     };
     return navigation;
 }
-export function makeRedirectEvent(origin, redirect, from) {
+function makeRedirectEvent(origin, redirect, from, base) {
     return Effect.gen(function* () {
-        const url = getUrl(origin, redirect.path);
+        const url = getUrl(origin, redirect.path, base);
         const to = yield* makeDestination(url, redirect.options?.state, origin);
         const event = {
-            type: "replace",
+            type: 'replace',
             from,
             to,
             delta: 0,
-            info: redirect.options?.info
+            info: redirect.options?.info,
         };
         return event;
     });
@@ -333,16 +302,15 @@ export function makeRedirectEvent(origin, redirect, from) {
 export function makeOrUpdateDestination(navigationState, url, state, origin) {
     return Effect.gen(function* () {
         const current = navigationState.entries[navigationState.index];
-        const isSameOriginAndPath = url.origin === current.url.origin &&
-            url.pathname === current.url.pathname;
+        const isSameOriginAndPath = url.origin === current.url.origin && url.pathname === current.url.pathname;
         if (isSameOriginAndPath) {
-            const id = yield* makeUuid;
+            const id = yield* makeUuid4;
             const destination = {
                 id,
                 key: current.key,
                 url,
                 state: getOriginalState(state),
-                sameDocument: url.origin === origin
+                sameDocument: url.origin === origin,
             };
             return destination;
         }
@@ -359,42 +327,41 @@ export function makeDestination(url, state, origin) {
                 key: state.__typed__navigation__key__,
                 url,
                 state: state.__typed__navigation__state__,
-                sameDocument: url.origin === origin
+                sameDocument: url.origin === origin,
             };
             return destination;
         }
-        const id = yield* makeUuid;
-        const key = yield* makeUuid;
+        const id = yield* makeUuid4;
+        const key = yield* makeUuid4;
         const destination = {
             id,
             key,
             url,
             state,
-            sameDocument: url.origin === origin
+            sameDocument: url.origin === origin,
         };
         return destination;
     });
 }
 export function upgradeProposedDestination(proposed) {
     return Effect.gen(function* () {
-        const id = yield* makeUuid;
-        const key = yield* makeUuid;
+        const id = yield* makeUuid4;
+        const key = yield* makeUuid4;
         const destination = {
             id,
             key,
             url: proposed.url,
             state: proposed.state,
-            sameDocument: proposed.sameDocument
+            sameDocument: proposed.sameDocument,
         };
         return destination;
     });
 }
 export function isPatchedState(state) {
-    if (state === null || !(typeof state === "object") || Array.isArray(state)) {
+    if (state === null || !(typeof state === 'object') || Array.isArray(state)) {
         return false;
     }
-    if ("__typed__navigation__id__" in state &&
-        "__typed__navigation__key__" in state) {
+    if ('__typed__navigation__id__' in state && '__typed__navigation__key__' in state) {
         return true;
     }
     return false;
@@ -406,7 +373,7 @@ export function getOriginalState(state) {
 }
 export function getOriginFromUrl(url) {
     try {
-        if (typeof url === "string") {
+        if (typeof url === 'string') {
             return new URL(url).origin;
         }
         else {
@@ -414,33 +381,19 @@ export function getOriginFromUrl(url) {
         }
     }
     catch {
-        return "http://localhost";
+        return 'http://localhost';
     }
 }
 export function isDestination(proposed) {
-    return "id" in proposed && "key" in proposed;
+    return 'id' in proposed && 'key' in proposed;
 }
 const strictEqual = (a, b) => a === b;
-export function makeHandlersState() {
-    return Effect.gen(function* () {
-        const beforeHandlers = yield* RefSubject.fromEffect(Effect.sync(() => new Set()), { eq: strictEqual });
-        const handlers = yield* RefSubject.fromEffect(Effect.sync(() => new Set()), { eq: strictEqual });
-        const formDataHandlers = yield* RefSubject.fromEffect(Effect.sync(() => new Set()), { eq: strictEqual });
-        return {
-            beforeHandlers,
-            handlers,
-            formDataHandlers
-        };
-    });
-}
-function makeFormDataRequest(event, url) {
-    const headers = new globalThis.Headers();
-    if (Option.isSome(event.encoding)) {
-        headers.set("Content-Type", event.encoding.value);
-    }
-    const method = Option.getOrElse(event.method, () => "POST");
-    return Effect.flatMap(HttpClient.HttpClient, (client) => client.execute(HttpClientRequest.make(method)(url, {
-        headers: Headers.fromInput(headers)
-    }).pipe(HttpClientRequest.bodyFormData(event.data))));
-}
+export const makeHandlersState = Effect.gen(function* () {
+    const beforeHandlers = yield* LazyRef.fromEffect(Effect.sync(() => new Set()), { eq: strictEqual });
+    const handlers = yield* LazyRef.fromEffect(Effect.sync(() => new Set()), { eq: strictEqual });
+    return {
+        beforeHandlers,
+        handlers,
+    };
+});
 //# sourceMappingURL=shared.js.map