@unitflow/router 0.1.0

package/dist/router.js

@@ -0,0 +1,870 @@
+import { Event, Model, Store } from "@unitflow/core";
+import { Registry } from "@unitflow/core/registry";
+import * as Context from "effect/Context";
+import * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+const RouteTypeId = Symbol.for("@unitflow/router/Route");
+const RouteGroupTypeId = Symbol.for("@unitflow/router/RouteGroup");
+const PipeableProto = {
+    pipe() {
+        return pipeArguments(this, arguments);
+    },
+};
+export const search = (decode, options) => ({
+    ...PipeableProto,
+    decode,
+    ...(options?.encode === undefined ? {} : { encode: options.encode }),
+    "~input": undefined,
+    "~output": undefined,
+    "~error": undefined,
+    "~services": undefined,
+});
+export const schemaSearch = (schema, options) => search((raw) => Schema.decodeUnknownEffect(schema)(raw, options));
+export const Middleware = () => (id) => () => {
+    const Service = Context.Service()(id);
+    return class extends Service {
+        static make = (handler) => Layer.effect(Service, Effect.map(Effect.context(), (services) => (context) => 
+        // The captured context covers exactly `R`; the cast erases
+        // the generic TypeScript cannot discharge here.
+        // eslint-disable-next-line revizo/no-type-assertion
+        Effect.provide(handler(context), services)));
+    };
+};
+export const isRoute = (value) => typeof value === "object" && value !== null && RouteTypeId in value;
+export const route = (id, options) => ({
+    ...PipeableProto,
+    [RouteTypeId]: RouteTypeId,
+    id,
+    path: normalizePath(options.path),
+    options: { ...options, path: normalizePath(options.path) },
+    middlewares: [],
+    "~types": undefined,
+});
+const prefixRoute = (current, prefix) => {
+    const path = joinPaths(prefix, current.path);
+    // Spread (not `route(...)`) so `middlewares` and the pipe method survive.
+    return {
+        ...current,
+        path,
+        options: { ...current.options, path },
+    };
+};
+const RouteGroupProto = {
+    add(...added) {
+        return group(...this.routes, ...added);
+    },
+    merge(...groups) {
+        return group(...this.routes, ...groups.flatMap((current) => current.routes));
+    },
+    prefix(prefix) {
+        return group(...this.routes.map((current) => prefixRoute(current, prefix)));
+    },
+    middleware(middleware) {
+        return group(...this.routes.map((current) => ({
+            ...current,
+            middlewares: [...current.middlewares, middleware],
+        })));
+    },
+};
+export const group = (...routes) => Object.assign(Object.create(PipeableProto), RouteGroupProto, {
+    [RouteGroupTypeId]: RouteGroupTypeId,
+    routes,
+});
+export const makeGroup = group;
+export const add = (...routes) => group(...routes);
+export const merge = (...groups) => group(...groups.flatMap((current) => current.routes));
+export const prefix = (routeGroup, path) => routeGroup.prefix(path);
+export const routes = (routeGroup) => routeGroup.routes;
+/**
+ * The history capability, provided as a LAYER — `Router.make` declares
+ * routes only, the environment decides how locations are read and written:
+ *
+ * ```ts
+ * AppRouter.layer.pipe(Layer.provideMerge(Router.browserHistoryLayer))
+ * // tests:
+ * AppRouter.layer.pipe(Layer.provideMerge(Router.memoryHistoryLayer({ initialEntries: ["/"] })))
+ * ```
+ */
+export class History extends Context.Service()("@unitflow/router/History") {
+}
+export const browserHistoryLayer = Layer.succeed(History, History.of({ make: (options) => createBrowserHistory(options) }));
+export const hashHistoryLayer = Layer.succeed(History, History.of({ make: (options) => createHashHistory(options) }));
+export const memoryHistoryLayer = (options) => Layer.succeed(History, History.of({
+    make: ({ parseSearch }) => createMemoryHistory(options?.initialEntries === undefined
+        ? { parseSearch }
+        : { initialEntries: options.initialEntries, parseSearch }),
+}));
+/** A middleware/codec verdict, NOT a crash: it travels the typed error
+ * channel purely as the short-circuit — `navigate` catches it and follows
+ * the redirect before anything commits. */
+export class RedirectError extends Data.TaggedError("RedirectError") {
+}
+export class NotFoundError extends Data.TaggedError("NotFoundError") {
+}
+export const isRedirectError = (value) => value instanceof RedirectError;
+export const isNotFoundError = (value) => value instanceof NotFoundError;
+export const make = (id, routeGroup, options = {}) => {
+    // The `routes` model's per-key claim — `Model.get(router.routes, K)`
+    // returns THE route with id K — is only sound if ids are unique: the unit
+    // resolves its route by `find(route.id === key)`. Enforce the
+    // precondition here instead of silently matching the first duplicate.
+    const seenIds = new Set();
+    for (const current of routeGroup.routes) {
+        if (seenIds.has(current.id)) {
+            throw new Error(`Unitflow router "${id}" has duplicate route id "${current.id}".`);
+        }
+        seenIds.add(current.id);
+    }
+    const service = Model.Service()(id)({
+        lifetime: "keepAlive",
+        make: () => makeShape(routeGroup, options),
+    });
+    const router = Object.assign(service, {
+        group: routeGroup,
+        options,
+        routerType: undefined,
+    });
+    // The per-key shape map is carried by the RouteModel interface itself
+    // (the cast below) rather than the builder's `Shapes` argument: with
+    // `Group` still generic TypeScript cannot verify the mapped-type
+    // constraint and overload resolution falls apart.
+    const routesService = Model.Service()(`${id}/routes`)()({
+        make: (routeId) => Effect.gen(function* () {
+            const ports = yield* Model.get(router);
+            const match = Store.combine([ports.outputs.matches], (matches) => Option.fromNullishOr(matches.find((current) => current.route.id === routeId)), { name: `router.routes.${routeId}.match` });
+            const opened = Store.combine([match], Option.isSome, {
+                name: `router.routes.${routeId}.opened`,
+            });
+            const params = Store.combine([match], Option.map((current) => current.params), {
+                name: `router.routes.${routeId}.params`,
+            });
+            const search = Store.combine([match], Option.map((current) => current.search), {
+                name: `router.routes.${routeId}.search`,
+            });
+            const provided = Store.combine([match], Option.map((current) => current.provided), {
+                name: `router.routes.${routeId}.provided`,
+            });
+            return {
+                inputs: {},
+                outputs: { opened, params, search, provided },
+                ui: { opened, params, search, provided },
+            };
+        }),
+    });
+    const routes = routesService;
+    const model = Object.assign(router, {
+        buildLocation: (options) => Effect.flatMap(getController(router), (api) => api.buildLocationEffect(options)),
+        buildHref: (options) => Effect.flatMap(getController(router), (api) => api.buildHrefEffect(options)),
+    });
+    return { NavigationModel: model, RouteModel: routes };
+};
+/** INTERNAL (used by RouterView): the pages model — one singleton owning
+ * the router and every mapped page model, the view tree's root. */
+export const makePages = (model, pageMap) => {
+    const pagesService = Model.Service()(`${model.modelKey}/pages`)({
+        make: () => Effect.gen(function* () {
+            // The engine is a singleton (void key); the erased generic hides that.
+            // eslint-disable-next-line revizo/no-type-assertion
+            const routerPorts = yield* Model.get(model);
+            const ui = { router: routerPorts };
+            for (const [routeId, pageModel] of Object.entries(pageMap)) {
+                if (pageModel !== undefined) {
+                    ui[routeId] = yield* Model.get(pageModel);
+                }
+            }
+            return { inputs: {}, outputs: {}, ui };
+        }),
+    });
+    return Object.assign(pagesService, { router: model });
+};
+const makeShape = (routeGroup, options) => Effect.gen(function* () {
+    const parseSearch = options.parseSearch ?? defaultParseSearch;
+    const stringifySearch = options.stringifySearch ?? defaultStringifySearch;
+    const history = (yield* History).make({ parseSearch });
+    const compiled = routeGroup.routes.map(compileRoute).sort((a, b) => b.score - a.score);
+    const blockers = new Set();
+    let disposed = false;
+    let ignoreNextHistory = false;
+    let currentState = {
+        status: "idle",
+        location: history.location,
+        resolvedLocation: history.location,
+        matches: [],
+    };
+    const state = Store.make(currentState, {
+        name: "router.state",
+    });
+    const setState = (next) => Effect.flatMap(Effect.sync(() => {
+        currentState = next;
+    }), () => Store.set(state, next));
+    const runMaybe = (evaluate) => Effect.flatMap(Effect.try({
+        try: evaluate,
+        catch: (error) => error,
+    }), (value) => Effect.isEffect(value)
+        ? value
+        : Effect.succeed(value));
+    const decodeSearch = (current, raw) => {
+        const definition = current.options.search;
+        if (definition === undefined)
+            return Effect.succeed({});
+        if (isSchemaCodec(definition)) {
+            return Schema.decodeUnknownEffect(definition)(raw);
+        }
+        return runMaybe(() => definition.decode(raw));
+    };
+    const parseParams = (current, raw) => {
+        const schema = current.options.params;
+        if (schema !== undefined) {
+            return Schema.decodeUnknownEffect(schema)(raw);
+        }
+        const parse = current.options.parseParams;
+        if (parse === undefined)
+            return Effect.succeed(raw);
+        return runMaybe(() => parse(raw));
+    };
+    const resolveMatches = (location) => Effect.gen(function* () {
+        const pathname = stripBasepath(location.pathname, options.basepath);
+        const exactMatches = compiled
+            .map((compiledRoute) => ({ compiledRoute, match: compiledRoute.exact.exec(pathname) }))
+            .filter((item) => item.match !== null)
+            .sort((a, b) => b.compiledRoute.score - a.compiledRoute.score);
+        const leaf = exactMatches[0];
+        if (leaf === undefined)
+            return yield* Effect.fail(new NotFoundError({}));
+        const branch = compiled
+            .map((compiledRoute) => ({ compiledRoute, match: compiledRoute.prefix.exec(pathname) }))
+            .filter((item) => item.match !== null)
+            .sort((a, b) => a.compiledRoute.length - b.compiledRoute.length ||
+            a.compiledRoute.score - b.compiledRoute.score);
+        const matches = [];
+        // Guard results accumulate parent-first down the branch; a guard
+        // shared by several routes in the branch runs once per navigation.
+        let provided = {};
+        const ranGuards = new Set();
+        for (const item of branch) {
+            const rawParams = extractParams(item.compiledRoute, item.match);
+            const params = yield* parseParams(item.compiledRoute.route, rawParams);
+            if (params === false)
+                continue;
+            const routeSearch = yield* decodeSearch(item.compiledRoute.route, location.search);
+            const routeContext = {
+                route: item.compiledRoute.route,
+                location,
+                params,
+                search: routeSearch,
+                path: item.compiledRoute.route.path,
+            };
+            // Guards run parent-first, before anything commits: a failure here
+            // (RedirectError/NotFoundError) aborts the whole navigation.
+            for (const middleware of item.compiledRoute.route.middlewares) {
+                if (ranGuards.has(middleware))
+                    continue;
+                ranGuards.add(middleware);
+                const handler = yield* middleware;
+                const value = yield* handler(routeContext);
+                if (value !== undefined && value !== null && typeof value === "object") {
+                    provided = { ...provided, ...value };
+                }
+            }
+            const meta = item.compiledRoute.route.options.meta?.(routeContext) ?? [];
+            const links = item.compiledRoute.route.options.links?.(routeContext) ?? [];
+            matches.push({
+                id: item.compiledRoute.route.id,
+                route: item.compiledRoute.route,
+                pathname: item.match[0] === "" ? "/" : item.match[0],
+                params,
+                search: routeSearch,
+                provided,
+                staticData: item.compiledRoute.route.options.staticData ?? {},
+                meta,
+                links,
+                status: "success",
+            });
+        }
+        if (!matches.some((match) => match.route === leaf.compiledRoute.route)) {
+            return yield* Effect.fail(new NotFoundError({}));
+        }
+        return matches;
+    });
+    const load = (location, displayLocation) => Effect.gen(function* () {
+        yield* setState({
+            ...currentState,
+            status: "pending",
+            pendingLocation: displayLocation,
+        });
+        return yield* resolveMatches(location);
+    });
+    const encodeParams = (targetRoute, params) => {
+        const source = params === true || params === undefined ? {} : params;
+        const schema = targetRoute.options.params;
+        if (schema !== undefined) {
+            return Effect.map(Schema.encodeUnknownEffect(schema)(source), (encoded) => toPathParams(encoded));
+        }
+        if (targetRoute.options.stringifyParams !== undefined) {
+            return runMaybe(() => targetRoute.options.stringifyParams?.(source) ?? {});
+        }
+        return Effect.succeed(toPathParams(source));
+    };
+    const encodeSearch = (targetRoute, searchInput) => {
+        if (searchInput === true)
+            return Effect.succeed(currentState.location.search);
+        const resolvedSearch = resolveSearchInput(searchInput, currentState.location.search);
+        const definition = targetRoute.options.search;
+        if (definition === undefined)
+            return Effect.succeed(toRawSearch(resolvedSearch));
+        if (isSchemaCodec(definition)) {
+            return Effect.map(Schema.encodeUnknownEffect(definition)(resolvedSearch), (encoded) => toRawSearch(encoded));
+        }
+        if (definition.encode === undefined)
+            return Effect.succeed(toRawSearch(resolvedSearch));
+        return Effect.succeed(definition.encode(resolvedSearch));
+    };
+    const buildLocationEffect = (toOptions) => Effect.gen(function* () {
+        const foundRoute = routeGroup.routes.find((current) => current.path === toOptions.to);
+        if (foundRoute === undefined) {
+            return yield* Effect.fail(new Error(`Unitflow router cannot build unknown route "${String(toOptions.to)}".`));
+        }
+        const targetRoute = foundRoute;
+        const routeParams = yield* encodeParams(targetRoute, toOptions.params);
+        const pathname = yield* Effect.try({
+            try: () => addBasepath(interpolatePath(targetRoute.path, routeParams), options.basepath),
+            catch: (error) => error,
+        });
+        const rawSearch = yield* encodeSearch(targetRoute, toOptions.search);
+        const searchString = stringifySearch(rawSearch);
+        const hash = toOptions.hash === true ? currentState.location.hash : toOptions.hash ?? "";
+        return makeLocation(`${pathname}${searchString}${hash === "" ? "" : `#${hash}`}`, parseSearch, toOptions.state);
+    });
+    const buildLocation = (toOptions) => {
+        const exit = Effect.runSyncExit(buildLocationEffect(toOptions));
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        throw exitToError(exit);
+    };
+    const buildHref = (toOptions) => buildLocation(toOptions).href;
+    const buildHrefEffect = (toOptions) => Effect.map(buildLocationEffect(toOptions), (location) => location.href);
+    const shouldBlock = (to, ignoreBlocker) => Effect.gen(function* () {
+        if (ignoreBlocker === true)
+            return false;
+        for (const blocker of blockers) {
+            const blocked = yield* Effect.tryPromise({
+                try: () => Promise.resolve(blocker({ from: currentState.location, to })),
+                catch: (error) => error,
+            });
+            if (blocked)
+                return true;
+        }
+        return false;
+    });
+    const handleError = (error, location, resolvedLocation) => setState({
+        status: isNotFoundError(error) ? "not-found" : "error",
+        location: location ?? currentState.location,
+        resolvedLocation: resolvedLocation ?? currentState.resolvedLocation,
+        matches: location === undefined ? currentState.matches : [],
+        error,
+    });
+    const commitLocation = (location) => Effect.exit(load(location, location)).pipe(Effect.flatMap((exit) => {
+        if (Exit.isSuccess(exit)) {
+            return setState({
+                status: "success",
+                location,
+                resolvedLocation: location,
+                matches: exit.value,
+            });
+        }
+        const error = exitToError(exit);
+        // A middleware redirect on the initial load or a history pop
+        // follows through instead of surfacing as an error state.
+        if (isRedirectError(error)) {
+            return navigate({ ...error.options, replace: true });
+        }
+        return handleError(error, location, location);
+    }));
+    const navigate = (navigateOptions) => Effect.gen(function* () {
+        const resolvedLocationExit = yield* Effect.exit(buildLocationEffect(navigateOptions));
+        if (Exit.isFailure(resolvedLocationExit)) {
+            yield* handleError(exitToError(resolvedLocationExit));
+            return;
+        }
+        const resolvedLocation = resolvedLocationExit.value;
+        const displayLocationExit = navigateOptions.mask === undefined
+            ? Exit.succeed(resolvedLocation)
+            : yield* Effect.exit(buildLocationEffect(navigateOptions.mask));
+        if (Exit.isFailure(displayLocationExit)) {
+            yield* handleError(exitToError(displayLocationExit));
+            return;
+        }
+        const displayLocation = displayLocationExit.value;
+        const blockedExit = yield* Effect.exit(shouldBlock(displayLocation, navigateOptions.ignoreBlocker));
+        if (Exit.isFailure(blockedExit)) {
+            yield* handleError(exitToError(blockedExit));
+            return;
+        }
+        if (blockedExit.value)
+            return;
+        if (navigateOptions.reloadDocument === true && typeof window !== "undefined") {
+            window.location.assign(displayLocation.href);
+            return;
+        }
+        const exit = yield* Effect.exit(load(resolvedLocation, displayLocation));
+        if (Exit.isSuccess(exit)) {
+            ignoreNextHistory = true;
+            if (navigateOptions.replace === true)
+                history.replace(displayLocation.href, displayLocation.state);
+            else
+                history.push(displayLocation.href, displayLocation.state);
+            yield* setState({
+                status: "success",
+                location: displayLocation,
+                resolvedLocation,
+                matches: exit.value,
+            });
+            if (navigateOptions.resetScroll !== false && typeof window !== "undefined") {
+                window.scrollTo(0, 0);
+            }
+            return;
+        }
+        const error = exitToError(exit);
+        if (isRedirectError(error)) {
+            yield* navigate({ ...error.options, replace: true });
+            return;
+        }
+        yield* handleError(error);
+    });
+    const matchRoute = (matchOptions) => {
+        const location = buildLocation(matchOptions);
+        const current = currentState.resolvedLocation;
+        const pathMatches = matchOptions.exact === true
+            ? current.pathname === location.pathname
+            : current.pathname === location.pathname ||
+                current.pathname.startsWith(`${trimRight(location.pathname)}/`);
+        if (!pathMatches)
+            return false;
+        if (matchOptions.includeHash === true && current.hash !== location.hash)
+            return false;
+        if (matchOptions.includeSearch === true && !searchEquals(current.search, location.search))
+            return false;
+        return true;
+    };
+    const addBlocker = (blocker) => Effect.sync(() => {
+        blockers.add(blocker);
+    });
+    const removeBlocker = (blocker) => Effect.sync(() => {
+        blockers.delete(blocker);
+    });
+    const dispose = () => Effect.sync(() => {
+        disposed = true;
+        blockers.clear();
+    });
+    const controller = {
+        group: routeGroup,
+        routes: routeGroup.routes,
+        options,
+        history,
+        buildLocation,
+        buildHref,
+        buildLocationEffect,
+        buildHrefEffect,
+        matchRoute,
+    };
+    const navigateEvent = yield* Event.make({ name: "router.navigate" }).pipe(Event.handler((payload) => navigate(payload)));
+    const addBlockerEvent = yield* Event.make({ name: "router.addBlocker" }).pipe(Event.handler((blocker) => addBlocker(blocker)));
+    const removeBlockerEvent = yield* Event.make({ name: "router.removeBlocker" }).pipe(Event.handler((blocker) => removeBlocker(blocker)));
+    const location = Store.combine([state], (value) => value.location, {
+        name: "router.location",
+    });
+    const matches = Store.combine([state], (value) => value.matches, {
+        name: "router.matches",
+    });
+    const api = Store.make(controller, { name: "router.api" });
+    const historyChanged = yield* Event.make({ name: "router.historyChanged" }).pipe(Event.handler((nextLocation) => (disposed ? Effect.void : commitLocation(nextLocation))));
+    const registry = yield* Registry;
+    const historyChannel = yield* Event.pubsub(historyChanged);
+    const unsubscribeHistory = history.subscribe((nextLocation) => {
+        if (ignoreNextHistory) {
+            ignoreNextHistory = false;
+            return;
+        }
+        // The FULL dispatch step: counting, pubsub AND handler delivery. A
+        // bare trackPublish+publishUnsafe pair feeds subscribers but never the
+        // attached handler — history-driven navigation (back/forward, manual
+        // URL) would silently do nothing.
+        Event.dispatchUnsafe(registry, historyChannel, historyChanged, nextLocation);
+    });
+    yield* Effect.addFinalizer(() => Effect.flatMap(Effect.sync(() => {
+        unsubscribeHistory();
+    }), () => dispose()));
+    yield* commitLocation(history.location);
+    return {
+        inputs: {
+            navigate: navigateEvent,
+            addBlocker: addBlockerEvent,
+            removeBlocker: removeBlockerEvent,
+        },
+        outputs: {
+            state,
+            location,
+            matches,
+            api,
+        },
+        ui: {
+            state,
+            location,
+            matches,
+            navigate: navigateEvent,
+            api,
+        },
+    };
+});
+const exitToError = (exit) => {
+    if (Exit.isSuccess(exit))
+        return undefined;
+    const failure = exit.cause.reasons.find(Cause.isFailReason);
+    return failure === undefined ? exit.cause : failure.error;
+};
+const getController = (router) => Effect.gen(function* () {
+    const ports = yield* Model.get(router);
+    return yield* Store.get(ports.outputs.api);
+});
+export const createMemoryHistory = (options) => {
+    const parseSearch = options?.parseSearch ?? defaultParseSearch;
+    const entries = options?.initialEntries?.length ? [...options.initialEntries] : ["/"];
+    let index = 0;
+    let current = makeLocation(entries[index] ?? "/", parseSearch);
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener(current);
+    };
+    return {
+        get location() {
+            return current;
+        },
+        push(href, state) {
+            entries.splice(index + 1, entries.length - index - 1, href);
+            index += 1;
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        replace(href, state) {
+            entries[index] = href;
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+};
+export const createBrowserHistory = (options) => {
+    if (typeof window === "undefined")
+        return createMemoryHistory(options);
+    const parseSearch = options?.parseSearch ?? defaultParseSearch;
+    let current = makeLocation(`${window.location.pathname}${window.location.search}${window.location.hash}`, parseSearch, window.history.state);
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener(current);
+    };
+    const onPopState = (event) => {
+        current = makeLocation(`${window.location.pathname}${window.location.search}${window.location.hash}`, parseSearch, event.state);
+        notify();
+    };
+    window.addEventListener("popstate", onPopState);
+    return {
+        get location() {
+            return current;
+        },
+        push(href, state) {
+            window.history.pushState(state, "", href);
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        replace(href, state) {
+            window.history.replaceState(state, "", href);
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0)
+                    window.removeEventListener("popstate", onPopState);
+            };
+        },
+    };
+};
+export const createHashHistory = (options) => {
+    if (typeof window === "undefined")
+        return createMemoryHistory(options);
+    const parseSearch = options?.parseSearch ?? defaultParseSearch;
+    const read = () => {
+        const hash = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+        return makeLocation(hash === "" ? "/" : hash, parseSearch, window.history.state);
+    };
+    let current = read();
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener(current);
+    };
+    const onHashChange = () => {
+        current = read();
+        notify();
+    };
+    window.addEventListener("hashchange", onHashChange);
+    return {
+        get location() {
+            return current;
+        },
+        push(href, state) {
+            window.history.pushState(state, "", `#${href}`);
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        replace(href, state) {
+            window.history.replaceState(state, "", `#${href}`);
+            current = makeLocation(href, parseSearch, state);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0)
+                    window.removeEventListener("hashchange", onHashChange);
+            };
+        },
+    };
+};
+export const defaultParseSearch = (searchString) => {
+    const params = new URLSearchParams(searchString.startsWith("?") ? searchString.slice(1) : searchString);
+    const out = {};
+    for (const [key, value] of params) {
+        const decoded = decodeSearchValue(value);
+        const existing = out[key];
+        if (existing === undefined)
+            out[key] = decoded;
+        else
+            out[key] = Array.isArray(existing) ? [...existing, decoded] : [existing, decoded];
+    }
+    return out;
+};
+export const defaultStringifySearch = (searchRecord) => {
+    const params = new URLSearchParams();
+    const append = (key, value) => {
+        if (value === undefined)
+            return;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                append(key, item);
+            return;
+        }
+        params.append(key, encodeSearchValue(value));
+    };
+    for (const key of Object.keys(searchRecord).sort())
+        append(key, searchRecord[key]);
+    const stringified = params.toString();
+    return stringified === "" ? "" : `?${stringified}`;
+};
+const isSchemaCodec = (value) => typeof value === "object" && value !== null && "ast" in value && !("decode" in value);
+const toRawSearch = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const record = value;
+    const out = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (item === undefined) {
+            out[key] = undefined;
+        }
+        else if (Array.isArray(item)) {
+            out[key] = item.map((entry) => String(entry));
+        }
+        else {
+            out[key] = String(item);
+        }
+    }
+    return out;
+};
+const toPathParams = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const record = value;
+    const out = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (item !== undefined && item !== null)
+            out[key] = String(item);
+    }
+    return out;
+};
+const decodeSearchValue = (value) => {
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "string" ? parsed : value;
+    }
+    catch {
+        return value;
+    }
+};
+const encodeSearchValue = (value) => {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || value === null) {
+        return JSON.stringify(value);
+    }
+    return JSON.stringify(value);
+};
+const makeLocation = (href, parseSearch, state) => {
+    const url = new URL(href, "http://unitflow.local");
+    const pathname = normalizePath(url.pathname);
+    const searchString = url.search;
+    const hash = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+    return {
+        pathname,
+        search: parseSearch(searchString),
+        searchString,
+        hash,
+        href: `${pathname}${searchString}${hash === "" ? "" : `#${hash}`}`,
+        state,
+    };
+};
+const normalizePath = (path) => {
+    if (path === "")
+        return "/";
+    const withSlash = path.startsWith("/") ? path : `/${path}`;
+    return withSlash.length > 1 && withSlash.endsWith("/") ? withSlash.slice(0, -1) : withSlash;
+};
+const trimRight = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+const joinPaths = (prefixPath, path) => {
+    const left = normalizePath(prefixPath);
+    const right = normalizePath(path);
+    if (left === "/")
+        return right;
+    if (right === "/")
+        return left;
+    return `${trimRight(left)}${right}`;
+};
+const addBasepath = (path, basepath) => basepath === undefined || basepath === "/" ? path : joinPaths(basepath, path);
+const stripBasepath = (path, basepath) => {
+    if (basepath === undefined || basepath === "/")
+        return path;
+    const normalized = normalizePath(basepath);
+    return path === normalized ? "/" : path.startsWith(`${normalized}/`) ? path.slice(normalized.length) : path;
+};
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const compileRoute = (current) => {
+    const path = normalizePath(current.path);
+    if (path === "/") {
+        return {
+            route: current,
+            exact: /^\/?$/,
+            prefix: /^\//,
+            paramNames: [],
+            score: 0,
+            length: 0,
+        };
+    }
+    const segments = path.slice(1).split("/");
+    const paramNames = [];
+    let pattern = "^";
+    let score = 0;
+    for (const segment of segments) {
+        if (segment.startsWith(":")) {
+            const optional = segment.endsWith("?");
+            const name = segment.slice(1, optional ? -1 : undefined);
+            paramNames.push({ name, optional });
+            pattern += optional ? "(?:/([^/]+))?" : "/([^/]+)";
+            score += optional ? 3 : 5;
+        }
+        else if (segment.startsWith("*")) {
+            const name = segment.slice(1) || "_splat";
+            paramNames.push({ name, optional: false });
+            pattern += "/(.*)";
+            score += 1;
+        }
+        else {
+            pattern += `/${escapeRegex(segment)}`;
+            score += 10;
+        }
+    }
+    const flags = current.options.caseSensitive === true ? "" : "i";
+    return {
+        route: current,
+        exact: new RegExp(`${pattern}/?$`, flags),
+        prefix: new RegExp(`${pattern}(?=/|$)`, flags),
+        paramNames,
+        score: score + segments.length,
+        length: segments.length,
+    };
+};
+const extractParams = (compiled, match) => {
+    const params = {};
+    compiled.paramNames.forEach((param, index) => {
+        const value = match[index + 1];
+        if (value !== undefined)
+            params[param.name] = decodeURIComponent(value);
+    });
+    return params;
+};
+const interpolatePath = (path, params) => {
+    const source = (params ?? {});
+    const segments = normalizePath(path).split("/");
+    const out = [];
+    for (const segment of segments) {
+        if (segment === "")
+            continue;
+        if (segment.startsWith(":")) {
+            const optional = segment.endsWith("?");
+            const name = segment.slice(1, optional ? -1 : undefined);
+            const value = source[name];
+            if (value === undefined || value === null) {
+                if (optional)
+                    continue;
+                throw new Error(`Unitflow router missing path param "${name}" for "${path}".`);
+            }
+            out.push(encodeURIComponent(String(value)));
+        }
+        else if (segment.startsWith("*")) {
+            const name = segment.slice(1) || "_splat";
+            const value = source[name];
+            if (value === undefined || value === null) {
+                throw new Error(`Unitflow router missing splat param "${name}" for "${path}".`);
+            }
+            out.push(String(value).split("/").map(encodeURIComponent).join("/"));
+        }
+        else {
+            out.push(segment);
+        }
+    }
+    return out.length === 0 ? "/" : `/${out.join("/")}`;
+};
+const resolveSearchInput = (searchInput, current) => {
+    if (searchInput === undefined)
+        return {};
+    if (searchInput === true)
+        return current;
+    return typeof searchInput === "function" ? searchInput(current) : searchInput;
+};
+const stableStringify = (value) => {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+        .join(",")}}`;
+};
+const searchEquals = (a, b) => stableStringify(a) === stableStringify(b);
+//# sourceMappingURL=router.js.map