@viniaraujo68/plinth 0.0.0-stage → 0.2.0

package/dist/routing.svelte.js

@@ -0,0 +1,208 @@
+import { resolve } from "$app/paths";
+import { DEV } from "esm-env";
+import { createContext } from "svelte";
+/**
+ * Recover the route id SvelteKit would report for a glob key:
+ * `/src/routes/orders/[id]/+page.svelte` becomes `/orders/[id]`, and `/src/routes/+page.svelte`
+ * becomes `/`.
+ *
+ * Group segments survive the trip. `page.route.id` carries them — a route under `(app)` really
+ * is `/(app)/orders` — so stripping them here would leave the two halves of the config
+ * disagreeing about what a route id is. They are dropped later, when a pathname is built.
+ */
+const pageFileToRouteId = (file) => /\/routes(?<id>\/.*)?\/\+page\.svelte$/.exec(file)?.groups?.id ?? "/";
+/** `"/"` yields no segments, `"/orders/[id]"` yields `["orders", "[id]"]`. */
+const idSegments = (routeId) => routeId.split("/").filter(Boolean);
+const isGroup = (segment) => segment.startsWith("(") && segment.endsWith(")");
+const isParam = (segment) => segment.startsWith("[") && segment.endsWith("]");
+/**
+ * The key a param segment uses in `params`, which is never the segment itself: SvelteKit spells
+ * the same `id` as `[id]`, `[id=integer]`, `[...id]` or `[[id]]` depending on how the route
+ * captures it.
+ */
+const paramName = (segment) => segment
+    .replace(/^\[+/, "")
+    .replace(/\]+$/, "")
+    .replace(/^\.\.\./, "")
+    .split("=")[0];
+/** A segment SvelteKit is willing to match against nothing at all, hence one that may vanish. */
+const isOptionalParam = (segment) => segment.startsWith("[[") || segment.startsWith("[...");
+/**
+ * Turn a route id into a pathname against the current params.
+ *
+ * A required param with no value leaves an empty segment behind rather than disappearing. The
+ * resulting `//` is ugly, and that is the point — it only happens when a caller asks for the
+ * pathname of a dynamic route nobody is currently on, which is a bug worth seeing.
+ */
+const routeIdToPathname = (routeId, params) => {
+    const segments = [];
+    for (const segment of idSegments(routeId)) {
+        if (isGroup(segment))
+            continue;
+        if (!isParam(segment)) {
+            segments.push(segment);
+            continue;
+        }
+        const value = params[paramName(segment)] ?? "";
+        if (value === "" && isOptionalParam(segment))
+            continue;
+        segments.push(value);
+    }
+    return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+};
+const resolveTitle = (meta, params) => {
+    if (meta.title === undefined)
+        return "";
+    return typeof meta.title === "function" ? meta.title({ params }) : meta.title;
+};
+/**
+ * Reactive view over SvelteKit's own match, projected through a flat metadata map.
+ *
+ * It resolves nothing by itself — no URL parsing, no pattern matching, no ranking. SvelteKit
+ * already decided which route the user is on; this class only answers "what does the app want
+ * displayed and gated for that decision, and for its ancestors".
+ */
+export class RoutingContext {
+    config;
+    /** Every id with a real page, computed once — the filesystem cannot change while the tab is
+     * open, so this is the one part of the class that has no reason to be reactive. */
+    navigableIds;
+    /** The current URL, straight off the source. Nav chrome reads it for things the route id does
+     * not carry, such as the query string or the host. */
+    url;
+    /** The matched route id, or `null` when nothing matched — a 404, or the first paint of an
+     * error page. */
+    routeId;
+    /** Decoded params of the current match. */
+    params;
+    /**
+     * The declared prefixes of the current match, root first.
+     *
+     * Every ancestor that has a meta entry is here, plumbing included, so a gate declared halfway
+     * up the tree stays reachable (`matched.findLast((r) => r.meta.requiredRoles)`). Prefixes with
+     * no entry contribute nothing and are skipped rather than faked. Empty when `routeId` is null.
+     */
+    matched;
+    constructor(config, source) {
+        this.config = config;
+        // A plain Set: nothing ever writes to it, so a reactive one would buy a proxy and no
+        // behaviour.
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        this.navigableIds = new Set(Object.keys(config.pages).map(pageFileToRouteId));
+        this.url = $derived(source.url);
+        this.routeId = $derived(source.route.id);
+        this.params = $derived(source.params);
+        this.matched = $derived.by(() => {
+            const id = this.routeId;
+            if (id === null)
+                return [];
+            const params = this.params;
+            const segments = idSegments(id);
+            const prefixes = ["/", ...segments.map((_, i) => `/${segments.slice(0, i + 1).join("/")}`)];
+            const trail = [];
+            for (const prefix of prefixes) {
+                const meta = this.metaFor(prefix);
+                if (meta !== undefined)
+                    trail.push(this.resolve(prefix, meta, params));
+            }
+            return trail;
+        });
+        if (DEV)
+            this.reportDrift();
+    }
+    /**
+     * The direct declared children of a route id, in the order the meta map declares them.
+     *
+     * Plumbing children come back too — a caller may want to recurse past them or read their
+     * gates — so a renderer that only wants visible entries filters on `meta.title`. Labels and
+     * pathnames resolve against the current params, which only shows up when a child is itself a
+     * capture and the user is standing on it.
+     */
+    children(routeId) {
+        const prefix = routeId === "/" ? "/" : `${routeId}/`;
+        const params = this.params;
+        const found = [];
+        for (const [id, meta] of Object.entries(this.config.meta)) {
+            if (meta === undefined || id === routeId)
+                continue;
+            if (!id.startsWith(prefix))
+                continue;
+            // A remaining slash means a grandchild, which belongs to a deeper call.
+            if (id.slice(prefix.length).includes("/"))
+                continue;
+            found.push(this.resolve(id, meta, params));
+        }
+        return found;
+    }
+    /**
+     * The title of any declared route id, `""` when it is plumbing or unknown.
+     *
+     * A dynamic title is evaluated against the params of the *current* match, so asking about a
+     * capture route the user is not on hands it empty strings. Reading the label off `matched` or
+     * `children` is the normal path; this is for the odd one-off lookup.
+     */
+    label(routeId) {
+        const meta = this.config.meta[routeId];
+        return meta === undefined ? "" : resolveTitle(meta, this.params);
+    }
+    /** The single place a runtime string is narrowed to the app's route-id union. Every lookup in
+     * this class goes through it so the cast exists once instead of at four call sites. */
+    metaFor(routeId) {
+        return this.config.meta[routeId];
+    }
+    resolve(routeId, meta, params) {
+        return {
+            routeId,
+            label: resolveTitle(meta, params),
+            pathname: routeIdToPathname(routeId, params),
+            navigable: this.navigableIds.has(routeId),
+            meta,
+        };
+    }
+    /**
+     * Warn once, in dev, about the two ways the map and the filesystem drift apart.
+     *
+     * Typed keys already catch the common case at compile time. What they cannot catch is a page
+     * added without a meta entry, or a plumbing entry left behind after the last route under it
+     * was deleted — neither is a type error, and both are invisible until a crumb or a nav item
+     * quietly stops appearing.
+     */
+    reportDrift() {
+        const declared = Object.keys(this.config.meta);
+        const undeclared = [...this.navigableIds].filter((id) => !declared.includes(id));
+        if (undeclared.length > 0)
+            console.warn(`[plinth/routing] pages with no meta entry: ${undeclared.sort().join(", ")}`);
+        const orphaned = declared.filter((id) => {
+            const prefix = id === "/" ? "/" : `${id}/`;
+            return ![...this.navigableIds].some((page) => page === id || page.startsWith(prefix));
+        });
+        if (orphaned.length > 0)
+            console.warn(`[plinth/routing] meta entries with no page beneath them: ${orphaned.sort().join(", ")}`);
+    }
+}
+/**
+ * Turn a pathname computed at runtime into an href that respects the configured base path.
+ *
+ * `$app/paths`' `resolve` is typed as one overload per literal route in the app, so no value
+ * produced at runtime can ever satisfy it. This is where that gets acknowledged, once, instead
+ * of a cast at every nav item and crumb.
+ */
+export const resolvePathname = (pathname) => resolve(pathname);
+export const [getRoutingContext, setRoutingContext] = createContext();
+/**
+ * A copy of `url` with some search parameters set and others removed — `null` or `undefined`
+ * removes. It never edits the URL it was given, which is usually the page store's own and is read
+ * by everything else on the page.
+ */
+export const withSearchParams = (url, updates) => {
+    // A value handed to `goto` or an `href`, never read reactively: a `SvelteURL` would only add
+    // signals nobody subscribes to.
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    const next = new URL(url);
+    for (const [key, value] of Object.entries(updates))
+        if (value === null || value === undefined)
+            next.searchParams.delete(key);
+        else
+            next.searchParams.set(key, value);
+    return next;
+};