@typed/router 0.32.0 → 1.0.0-beta.1

package/dist/Matcher.js

@@ -0,0 +1,633 @@
+import * as findMyWay from "find-my-way-ts";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { interrupt, isSuccess } from "effect/Exit";
+import { dual, identity } from "effect/Function";
+import * as Result from "effect/Result";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import { makeFormatterDefault } from "effect/SchemaIssue";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import { exit } from "@typed/fx/Fx";
+import { mapEffect } from "@typed/fx/Fx/combinators/mapEffect";
+import { provideServices } from "@typed/fx/Fx/combinators/provide";
+import { skipRepeats } from "@typed/fx/Fx/combinators/skipRepeats";
+import { switchMap } from "@typed/fx/Fx/combinators/switchMap";
+import { unwrap } from "@typed/fx/Fx/combinators/unwrap";
+import { fromEffect, never } from "@typed/fx/Fx/constructors/fromEffect";
+import { succeed } from "@typed/fx/Fx/constructors/succeed";
+import { fromStream } from "@typed/fx/Fx/stream";
+import { isFx } from "@typed/fx/Fx/TypeId";
+import { RefSubject } from "@typed/fx/RefSubject";
+import { CurrentPath, Navigation } from "@typed/navigation/Navigation";
+import * as AST from "./AST.js";
+import { CurrentRoute } from "./CurrentRoute.js";
+import { Join, make as makeRoute } from "./Route.js";
+function isMatchHandlerFn(handler) {
+    return typeof handler === "function";
+}
+function isHandlerOptions(value) {
+    return typeof value === "object" && value !== null && "handler" in value;
+}
+function parseMatchArgs(args) {
+    const [first, second, third] = args;
+    // Single arg: full options object (Overload 9)
+    if (second === undefined) {
+        const opts = first;
+        return {
+            route: opts.route,
+            handler: opts.handler,
+            guard: undefined,
+            layout: opts.layout,
+            catchFn: opts.catch,
+            dependencies: opts.dependencies,
+        };
+    }
+    // Two args
+    if (third === undefined) {
+        if (isHandlerOptions(second)) {
+            // Overload 3: match(route, options)
+            const opts = second;
+            return {
+                route: first,
+                handler: opts.handler,
+                guard: undefined,
+                layout: opts.layout,
+                catchFn: opts.catch,
+                dependencies: opts.dependencies,
+            };
+        }
+        // Overloads 1, 2, 4: match(route, handler)
+        return {
+            route: first,
+            handler: second,
+            guard: undefined,
+            layout: undefined,
+            catchFn: undefined,
+            dependencies: undefined,
+        };
+    }
+    // Three args
+    if (isHandlerOptions(third)) {
+        // Overload 7: match(route, guard, options)
+        const opts = third;
+        return {
+            route: first,
+            handler: opts.handler,
+            guard: second,
+            layout: opts.layout,
+            catchFn: opts.catch,
+            dependencies: opts.dependencies,
+        };
+    }
+    // Overloads 5, 6, 8: match(route, guard, handler)
+    return {
+        route: first,
+        handler: third,
+        guard: second,
+        layout: undefined,
+        catchFn: undefined,
+        dependencies: undefined,
+    };
+}
+class MatcherImpl {
+    cases;
+    constructor(cases) {
+        this.cases = cases;
+        this.match = this.match.bind(this);
+        this.catch = this.catch.bind(this);
+        this.catchTag = this.catchTag.bind(this);
+        this.layout = this.layout.bind(this);
+        this.provide = this.provide.bind(this);
+        this.provideService = this.provideService.bind(this);
+    }
+    match(...args) {
+        const parsed = parseMatchArgs(args);
+        const normalizedGuard = parsed.guard !== undefined
+            ? getGuard(parsed.guard)
+            : defaultGuard();
+        const routeAst = AST.route(parsed.route.ast, parsed.handler, normalizedGuard);
+        let matches = [routeAst];
+        if (parsed.layout !== undefined) {
+            matches = [AST.layout(matches, parsed.layout)];
+        }
+        if (parsed.catchFn !== undefined) {
+            matches = [AST.catchCause(matches, parsed.catchFn)];
+        }
+        if (parsed.dependencies !== undefined && parsed.dependencies.length > 0) {
+            matches = [AST.layer(matches, normalizeDependencies(parsed.dependencies))];
+        }
+        return new MatcherImpl([...this.cases, ...matches]);
+    }
+    prefix(route) {
+        return new MatcherImpl([AST.prefixed(this.cases, route.ast)]);
+    }
+    provide(...layers) {
+        return new MatcherImpl([AST.layer(this.cases, layers)]);
+    }
+    provideService(tag, service) {
+        return this.provideServices(ServiceMap.make(tag, service));
+    }
+    provideServices(services) {
+        return this.provide(Layer.succeedServices(services));
+    }
+    catchCause(f) {
+        return new MatcherImpl([AST.catchCause(this.cases, f)]);
+    }
+    catch(f) {
+        return this.catchCause((causeRef) => unwrap(Effect.gen(function* () {
+            const cause = yield* causeRef;
+            const result = Cause.findFail(cause);
+            if (Result.isFailure(result)) {
+                return fromEffect(Effect.failCause(result.failure));
+            }
+            return f(result.success.error);
+        })));
+    }
+    catchTag(tag, f) {
+        const rethrow = (cause) => fromEffect(Effect.failCause(cause));
+        return new MatcherImpl([
+            AST.catchCause(this.cases, (causeRef) => unwrap(Effect.gen(function* () {
+                const cause = yield* causeRef;
+                const result = Cause.findFail(cause);
+                if (Result.isFailure(result)) {
+                    return rethrow(cause);
+                }
+                if (matchesTag(tag, result.success.error)) {
+                    return f(result.success.error);
+                }
+                return rethrow(cause);
+            }))),
+        ]);
+    }
+    layout(layout) {
+        return new MatcherImpl([
+            AST.layout(this.cases, layout),
+        ]);
+    }
+    merge(...others) {
+        const allCases = [...this.cases, ...others.flatMap((m) => m.cases)];
+        return new MatcherImpl(allCases);
+    }
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+}
+function normalizeHandler(handler) {
+    if (isMatchHandlerFn(handler))
+        return (params) => toFx(handler(params));
+    return () => toFx(handler);
+}
+function toFx(value) {
+    if (isFx(value))
+        return value;
+    if (Stream.isStream(value))
+        return fromStream(value);
+    if (Effect.isEffect(value))
+        return fromEffect(value);
+    return succeed(value);
+}
+export const empty = new MatcherImpl([]);
+export const match = empty.match.bind(empty);
+/**
+ * Merge multiple matchers into one. Each matcher's layouts and provide apply only to its own routes.
+ * Use this so directory layouts (e.g. api/_layout) and directory dependencies apply only to routes under that directory.
+ */
+export function merge(...matchers) {
+    if (matchers.length === 0) {
+        return empty;
+    }
+    if (matchers.length === 1) {
+        return matchers[0];
+    }
+    const first = matchers[0];
+    const rest = matchers.slice(1);
+    return first.merge(...rest);
+}
+export class RouteGuardError extends Schema.ErrorClass("@typed/router/RouteGuardError")({
+    _tag: Schema.tag("RouteGuardError"),
+    path: Schema.String,
+    causes: Schema.Array(Schema.Unknown),
+}) {
+}
+export class RouteNotFound extends Schema.ErrorClass("@typed/router/RouteNotFound")({
+    _tag: Schema.tag("RouteNotFound"),
+    path: Schema.String,
+}) {
+}
+export class RouteDecodeError extends Schema.ErrorClass("@typed/router/RouteDecodeError")({
+    _tag: Schema.tag("RouteDecodeError"),
+    path: Schema.String,
+    cause: Schema.String,
+}) {
+}
+export function run(matcher) {
+    return unwrap(Effect.gen(function* () {
+        const fiberId = yield* Effect.fiberId;
+        const rootScope = yield* Effect.scope;
+        const current = yield* CurrentRoute;
+        const prefixed = matcher.prefix(current.route);
+        const entries = compile(prefixed.cases);
+        const router = findMyWay.make({
+            ignoreTrailingSlash: true,
+            caseSensitive: false,
+        });
+        const handlersByPath = new Map();
+        const memoMap = yield* Layer.makeMemoMap;
+        const layerManager = makeLayerManager(memoMap, rootScope, fiberId);
+        const layoutManager = makeLayoutManager(rootScope, fiberId);
+        const catchManager = makeCatchManager(rootScope, fiberId);
+        for (const entry of entries) {
+            const path = entry.route.path;
+            const existing = handlersByPath.get(path);
+            if (existing !== undefined) {
+                existing.push(entry);
+            }
+            else {
+                const list = [entry];
+                handlersByPath.set(path, list);
+                router.all(path, list);
+            }
+        }
+        let currentState = null;
+        return CurrentPath.pipe(mapEffect(Effect.fn(function* (path) {
+            const result = router.find("GET", path);
+            if (result === undefined)
+                return yield* new RouteNotFound({ path });
+            const input = { ...result.params, ...result.searchParams };
+            const entries = result.handler;
+            const guardCauses = [];
+            let matchedEntry = undefined;
+            let matchedParams = undefined;
+            let matchedPrepared = undefined;
+            for (const entry of entries) {
+                const params = yield* Effect.mapErrorEager(entry.decode(input), (cause) => new RouteDecodeError({ path, cause: makeFormatterDefault()(cause.issue) }));
+                const prepared = yield* layerManager.prepare(entry.layers);
+                const guardExit = yield* entry
+                    .guard(params)
+                    .pipe(Effect.provideServices(prepared.services), Effect.exit);
+                if (Exit.isFailure(guardExit)) {
+                    guardCauses.push(guardExit.cause);
+                    yield* prepared.rollback;
+                    continue;
+                }
+                if (Option.isNone(guardExit.value)) {
+                    yield* prepared.rollback;
+                    continue;
+                }
+                matchedEntry = entry;
+                matchedParams = guardExit.value.value;
+                matchedPrepared = prepared;
+                break;
+            }
+            if (matchedEntry === undefined || matchedPrepared === undefined) {
+                return yield* new RouteGuardError({ path, causes: guardCauses });
+            }
+            yield* matchedPrepared.commit;
+            if (currentState !== null && currentState.entry === matchedEntry) {
+                yield* RefSubject.set(currentState.params, matchedParams);
+                yield* layoutManager.updateParams(matchedEntry.layouts, matchedParams);
+                return currentState.fx;
+            }
+            if (currentState !== null) {
+                yield* Scope.close(currentState.scope, interrupt(fiberId));
+                currentState = null;
+            }
+            const scope = yield* Scope.fork(rootScope);
+            const paramsRef = yield* RefSubject.make(matchedParams).pipe(Scope.provide(scope));
+            const preparedServices = matchedPrepared.services;
+            const handlerServices = ServiceMap.merge(preparedServices, ServiceMap.make(Scope.Scope, scope));
+            const handlerFx = matchedEntry
+                .handler(paramsRef)
+                .pipe(provideServices(handlerServices));
+            const withLayouts = yield* layoutManager.apply(matchedEntry.layouts, matchedParams, handlerFx, preparedServices);
+            const withCatches = yield* catchManager.apply(matchedEntry.catches, withLayouts, preparedServices);
+            const fx = withCatches;
+            currentState = {
+                entry: matchedEntry,
+                params: paramsRef,
+                scope,
+                fx,
+            };
+            return currentState.fx;
+        })), skipRepeats, switchMap(identity));
+    }));
+}
+export const catchCause = dual(2, (input, f) => {
+    const eff = Effect.gen(function* () {
+        const fiberId = yield* Effect.fiberId;
+        const rootScope = yield* Effect.scope;
+        const fx = isFx(input) ? input : run(input);
+        const manager = makeCatchManager(rootScope, fiberId);
+        const result = yield* manager.apply([f], fx, ServiceMap.empty());
+        return result;
+    });
+    return unwrap(eff);
+});
+export const catch_ = dual(2, (input, f) => catchCause(input, (causeRef) => unwrap(Effect.gen(function* () {
+    const cause = yield* causeRef;
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return fromEffect(Effect.failCause(result.failure));
+    }
+    return f(result.success.error);
+}))));
+export { catch_ as catch };
+export const catchTag = dual(3, (input, k, f) => catchCause(input, (causeRef) => unwrap(Effect.gen(function* () {
+    const cause = yield* causeRef;
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return fromEffect(Effect.failCause(result.failure));
+    }
+    if (matchesTag(k, result.success.error)) {
+        return f(result.success.error);
+    }
+    return fromEffect(Effect.fail(result.success.error));
+}))));
+export const redirectTo = (path) => (input) => catchCause(input, (_) => Navigation.navigate(path).pipe(Effect.matchCause({
+    onFailure: () => never,
+    onSuccess: () => never,
+}), unwrap));
+const hasTag = (u) => typeof u === "object" &&
+    u !== null &&
+    "_tag" in u &&
+    typeof u["_tag"] === "string";
+const matchesTag = (tag, error) => {
+    if (!hasTag(error))
+        return false;
+    if (typeof tag === "string")
+        return error._tag === tag;
+    return tag.some((t) => t === error._tag);
+};
+function isServiceMap(dep) {
+    return !Layer.isLayer(dep);
+}
+function toSingleLayer(dep) {
+    if (isServiceMap(dep))
+        return Layer.succeedServices(dep);
+    return dep;
+}
+function normalizeDependencies(dependencies) {
+    return dependencies.map(toSingleLayer);
+}
+/**
+ * Normalize dependency input (ServiceMap | Layer | Array of either) into a single Layer.
+ * Use with `.provide(normalizeDependencyInput(deps))`.
+ */
+export function normalizeDependencyInput(input) {
+    const arr = Array.isArray(input) ? input : [input];
+    const layers = normalizeDependencies(arr);
+    return mergeLayers(layers);
+}
+function getGuard(guard) {
+    return "asGuard" in guard ? guard.asGuard() : guard;
+}
+function defaultGuard() {
+    return Effect.succeedSome;
+}
+function mergeLayers(layers) {
+    if (layers.length === 0)
+        return Layer.empty;
+    if (layers.length === 1)
+        return layers[0];
+    let current = layers[0];
+    for (let i = 1; i < layers.length; i++) {
+        current = Layer.merge(current, layers[i]);
+    }
+    return current;
+}
+/**
+ * @internal
+ */
+export function compile(cases) {
+    const entries = [];
+    const visit = (matches, context) => {
+        for (const match of matches) {
+            switch (match.type) {
+                case "route": {
+                    const baseRoute = makeRoute(match.route);
+                    const prefixedRoute = applyPrefixes(baseRoute, context.prefixes);
+                    entries.push({
+                        route: prefixedRoute,
+                        guard: getGuard(match.guard),
+                        handler: normalizeHandler(match.handler),
+                        layers: context.layers,
+                        layouts: context.layouts,
+                        catches: context.catches,
+                        decode: Schema.decodeUnknownEffect(prefixedRoute.paramsSchema),
+                    });
+                    break;
+                }
+                case "layer": {
+                    const merged = mergeLayers(match.deps);
+                    visit(match.matches, {
+                        ...context,
+                        layers: [...context.layers, merged],
+                    });
+                    break;
+                }
+                case "layout": {
+                    visit(match.matches, {
+                        ...context,
+                        layouts: [...context.layouts, match.layout],
+                    });
+                    break;
+                }
+                case "prefixed": {
+                    visit(match.matches, {
+                        ...context,
+                        prefixes: [...context.prefixes, match.prefix],
+                    });
+                    break;
+                }
+                case "catch": {
+                    visit(match.matches, {
+                        ...context,
+                        catches: [...context.catches, match.f],
+                    });
+                    break;
+                }
+            }
+        }
+    };
+    visit(cases, { layers: [], layouts: [], catches: [], prefixes: [] });
+    return entries;
+}
+function applyPrefixes(route, prefixes) {
+    if (prefixes.length === 0)
+        return route;
+    const prefixRoutes = prefixes.map((prefix) => makeRoute(prefix));
+    return Join(...prefixRoutes, route);
+}
+// Parallel scope cleanup helper
+const closeScopes = (scopes, fiberId) => Effect.forEach(scopes, (scope) => Scope.close(scope, interrupt(fiberId)), {
+    concurrency: "unbounded",
+    discard: true,
+});
+/**
+ * @internal
+ */
+export function makeLayerManager(memoMap, rootScope, fiberId) {
+    const states = new Map();
+    let order = [];
+    let cachedDesiredSet = undefined;
+    let cachedOrder = undefined;
+    const prepare = (desired) => Effect.gen(function* () {
+        const desiredSet = cachedOrder === desired
+            ? cachedDesiredSet
+            : ((cachedDesiredSet = new Set(desired)), (cachedOrder = desired), cachedDesiredSet);
+        const removed = order.filter((layer) => !desiredSet.has(layer));
+        const added = [];
+        let services = ServiceMap.empty();
+        for (const layer of desired) {
+            const existing = states.get(layer);
+            if (existing) {
+                services = ServiceMap.merge(services, existing.services);
+                continue;
+            }
+            const scope = yield* Scope.fork(rootScope);
+            const buildExit = yield* Layer.buildWithMemoMap(layer, memoMap, scope).pipe(Effect.provideServices(services), Effect.exit);
+            if (Exit.isFailure(buildExit)) {
+                for (let i = added.length - 1; i >= 0; i--) {
+                    const addedLayer = added[i];
+                    const addedState = states.get(addedLayer);
+                    if (addedState) {
+                        states.delete(addedLayer);
+                        yield* Scope.close(addedState.scope, interrupt(fiberId));
+                    }
+                }
+                yield* Scope.close(scope, buildExit);
+                return yield* Effect.failCause(buildExit.cause);
+            }
+            const servicesForLayer = buildExit.value;
+            services = ServiceMap.merge(services, servicesForLayer);
+            states.set(layer, { scope, services: servicesForLayer });
+            added.push(layer);
+        }
+        const commit = Effect.gen(function* () {
+            for (let i = removed.length - 1; i >= 0; i--) {
+                const layer = removed[i];
+                const state = states.get(layer);
+                if (state) {
+                    states.delete(layer);
+                    yield* Scope.close(state.scope, interrupt(fiberId));
+                }
+            }
+            order = desired;
+        });
+        const rollback = Effect.gen(function* () {
+            for (let i = added.length - 1; i >= 0; i--) {
+                const layer = added[i];
+                const state = states.get(layer);
+                if (state) {
+                    states.delete(layer);
+                    yield* Scope.close(state.scope, interrupt(fiberId));
+                }
+            }
+        });
+        return { services, commit, rollback };
+    });
+    return { prepare };
+}
+/**
+ * @internal
+ */
+export function makeLayoutManager(rootScope, fiberId) {
+    const states = new Map();
+    let active = [];
+    const removeUnused = (layouts) => Effect.gen(function* () {
+        const next = new Set(layouts);
+        const removed = active.filter((layout) => !next.has(layout));
+        const scopes = removed.map((layout) => {
+            const state = states.get(layout);
+            states.delete(layout);
+            return state.scope;
+        });
+        yield* closeScopes(scopes, fiberId);
+        active = layouts;
+    });
+    const apply = (layouts, paramsValue, inner, services) => Effect.gen(function* () {
+        let current = inner;
+        for (let i = layouts.length - 1; i >= 0; i--) {
+            const layout = layouts[i];
+            const state = states.get(layout);
+            if (state === undefined) {
+                const scope = yield* Scope.fork(rootScope);
+                const params = yield* RefSubject.make(paramsValue).pipe(Scope.provide(scope));
+                const content = yield* RefSubject.make(Effect.succeed(current), {
+                    eq: (left, right) => left === right,
+                }).pipe(Scope.provide(scope));
+                const fx = layout({ params, content: content.pipe(switchMap(identity)) }).pipe(provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))));
+                states.set(layout, { params, content, fx, scope });
+                current = fx;
+            }
+            else {
+                yield* RefSubject.set(state.params, paramsValue);
+                // @effect-diagnostics-next-line floatingEffect:off
+                yield* RefSubject.set(state.content, current);
+                current = state.fx;
+            }
+        }
+        yield* removeUnused(layouts);
+        return current;
+    });
+    const updateParams = (layouts, paramsValue) => Effect.forEach(layouts, (layout) => {
+        const state = states.get(layout);
+        return state !== undefined ? RefSubject.set(state.params, paramsValue) : Effect.void;
+    }, { discard: true });
+    return { apply, updateParams };
+}
+/**
+ * @internal
+ */
+export function makeCatchManager(rootScope, fiberId) {
+    const states = new Map();
+    let active = [];
+    const removeUnused = (catches) => Effect.gen(function* () {
+        const next = new Set(catches);
+        const removed = active.filter((c) => !next.has(c));
+        const scopes = removed.map((c) => {
+            const state = states.get(c);
+            states.delete(c);
+            return state.scope;
+        });
+        yield* closeScopes(scopes, fiberId);
+        active = catches;
+    });
+    const apply = (catches, inner, services) => Effect.gen(function* () {
+        let current = inner;
+        for (let i = catches.length - 1; i >= 0; i--) {
+            const catcher = catches[i];
+            const state = states.get(catcher);
+            if (state === undefined) {
+                const scope = yield* Scope.fork(rootScope);
+                const causes = yield* RefSubject.make(Cause.fail(undefined)).pipe(Scope.provide(scope));
+                const content = yield* RefSubject.make(Effect.succeed(current), {
+                    eq: (left, right) => left === right,
+                }).pipe(Scope.provide(scope));
+                const fallback = catcher(causes).pipe(provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))));
+                const fx = content.pipe(switchMap(identity), exit, mapEffect(Effect.fn(function* (e) {
+                    if (isSuccess(e))
+                        return succeed(e.value);
+                    yield* RefSubject.set(causes, e.cause);
+                    return fallback;
+                })), skipRepeats, switchMap(identity));
+                states.set(catcher, { causes, content, fx, scope });
+                current = fx;
+            }
+            else {
+                // @effect-diagnostics-next-line floatingEffect:off
+                yield* RefSubject.set(state.content, current);
+                current = state.fx;
+            }
+        }
+        yield* removeUnused(catches);
+        return current;
+    });
+    return { apply };
+}