@escape-game-over/atlas 0.1.70 → 0.1.71

package/README.md

@@ -119,6 +119,7 @@ it returns and nothing else, resolves it, and writes `_redirects`:
 // projects/rome/redirects.ts
 export default redirects([
   { from: "/jobs", to: { route: "careers" }, kind: "permanent" }, // ✗ if Rome has no careers page
+  { from: "/en/*", to: { route: "home", locale: "en-US", splat: true }, kind: "permanent" }, // /en/faq → /en-US/faq
 ])
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.70",
+    "version": "0.1.71",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,

package/src/redirects.ts

@@ -71,13 +71,19 @@ export type SitePath = UrlPath;
  */
 export type ExternalUrl = HttpsUrl;
 
+/** A `splat` target whose source has no `*` to carry: there is no rest to keep. */
+export interface SplatNeedsWildcard<From extends string> {
+    readonly __SPLAT_WITHOUT_WILDCARD__: `"${From}" has no "/*" to carry over: a rule with \`splat: true\` needs a source ending in "/*"`;
+}
+
 /**
- * Rejects an external target that is not `https://`, naming it.
+ * Rejects an external target that is not `https://`, and a `splat` target
+ * whose source has no wildcard, naming each.
  *
- * Applied to the rules array in parameter position, so a bad URL reports on its
- * own line rather than as the whole array failing to match. The check itself is
- * `ValidHttpsUrl`, shared with the site origin — one idea of an acceptable URL,
- * stated once.
+ * Applied to the rules array in parameter position, so a bad rule reports on
+ * its own line rather than as the whole array failing to match. The URL check
+ * itself is `ValidHttpsUrl`, shared with the site origin — one idea of an
+ * acceptable URL, stated once.
  */
 export type ValidateRedirectTargets<Rules> = {
     readonly [K in keyof Rules]: Rules[K] extends {
@@ -90,7 +96,18 @@ export type ValidateRedirectTargets<Rules> = {
                   ? ValidHttpsUrl<To>
                   : Rules[K][P];
           }
-        : Rules[K];
+        : Rules[K] extends {
+                readonly from: infer From extends string;
+                readonly to: { readonly splat: true };
+            }
+          ? From extends `${string}/*`
+              ? Rules[K]
+              : {
+                    readonly [P in keyof Rules[K]]: P extends "from"
+                        ? SplatNeedsWildcard<From>
+                        : Rules[K][P];
+                }
+          : Rules[K];
 };
 
 /**
@@ -105,7 +122,28 @@ export type ValidateRedirectTargets<Rules> = {
  */
 export type RedirectTarget<Id extends string, L extends string> =
     | ExternalUrl
-    | { readonly route: Id; readonly locale?: L; readonly page?: number }
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly page?: number;
+          readonly splat?: never;
+      }
+    /**
+     * A page, with whatever the source's `*` matched kept after its path:
+     * `/en/*` to `{ route: "home", locale: "en-US", splat: true }` sends
+     * `/en/faq` to `/en-US/faq`.
+     *
+     * For an old prefix whose pages kept their slugs, so one rule answers every
+     * URL under it. The target stays a route, so the prefix it lands on is
+     * derived like every other link rather than spelled out by hand. Not with
+     * `page`: the rest of a path cannot follow a page number.
+     */
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly splat: true;
+          readonly page?: never;
+      }
     /**
      * A file served verbatim from `public/` — a PDF, a spreadsheet.
      *

package/src/site/create.ts

@@ -610,6 +610,20 @@ export function createSite<
             to: ((): string => {
                 if (typeof rule.to === "string") return rule.to;
                 if ("file" in rule.to) return rule.to.file;
+                if (rule.to.splat === true) {
+                    // Checked here too, for a rule the types could not see:
+                    // without a `*`, the host has nothing to put in `:splat`.
+                    if (!rule.from.endsWith("/*")) {
+                        throw new Error(
+                            `Redirect "${rule.from}" keeps the rest of the path (\`splat: true\`) but has no "/*" to take it from.`
+                        );
+                    }
+                    const path = pathFor(
+                        rule.to.route,
+                        rule.to.locale ?? defaultLocale
+                    );
+                    return path === "/" ? "/:splat" : `${path}/:splat`;
+                }
                 return pathFor(rule.to.route, rule.to.locale ?? defaultLocale, {
                     page: rule.to.page,
                 });