@flyewi/eleventy-plugin-redirects 0.1.2 → 0.3.0

package/README.md

@@ -37,9 +37,11 @@ By default this writes an `_redirects` file into your output directory after eve
 | `defaultStatus` | `301` | Status code used when an entry doesn't specify one. |
 | `netlify` | `true` | Write a Netlify `_redirects` file. |
 | `netlifyFile` | `"_redirects"` | Filename for the Netlify output, relative to the output directory. |
-| `apache` | `false` | Write an Apache `.htaccess` with `Redirect` directives. |
+| `apache` | `false` | Write an Apache `.htaccess` with exact-match `RedirectMatch` directives. |
 | `apacheFile` | `".htaccess"` | Filename for the Apache output. |
 | `html` | `false` | Also write a static HTML fallback page at each `from` URL (meta-refresh + `rel=canonical`), for hosts (e.g. GitHub Pages) that can't act on `_redirects`/`.htaccess`. |
+| `htmlLang` | `"en"` | `lang` attribute of the HTML fallback pages. |
+| `htmlMessage` | `"This page has moved to"` | Text shown (followed by the link) on the HTML fallback pages, for the moment before the redirect or when it doesn't fire. |
 | `log` | `true` | Log a one-line summary after each build. |
 
 ## Netlify output
@@ -54,10 +56,16 @@ If your output directory already contains an `_redirects` file (e.g. copied thro
 ## Apache output
 
 ```
-Redirect 301 /old-path/ /new-path/
-Redirect 302 /legacy-page/ /new-page/
+RedirectMatch 301 ^/old-path/$ /new-path/
+RedirectMatch 302 ^/legacy-page/$ /new-page/
 ```
 
+Each rule matches its path **exactly**, the same as in Netlify's `_redirects`: `/old-path/` redirects, `/old-path/sub/` does not. Regex characters in the path (e.g. the `.` in `/old.html`) are escaped, and paths containing spaces are quoted. The query string is passed on to the target unchanged.
+
+> **Changed in 0.3.0:** earlier versions wrote `Redirect` directives, which Apache treats as a *prefix* match (`/old-path/` also redirected `/old-path/anything` to `/new-path/anything`). If you relied on that, add the deeper paths as separate entries.
+
+Requires `mod_alias`, which is enabled on practically every Apache host, and `.htaccess` overrides (`AllowOverride FileInfo`) — on shared hosting this is usually the case.
+
 ## HTML fallback pages
 
 With `html: true`, each `from` path also gets a real HTML file at that URL (e.g. `/old-path/` → `old-path/index.html` in the output directory) containing:
@@ -65,8 +73,11 @@ With `html: true`, each `from` path also gets a real HTML file at that URL (e.g.
 ```html
 <meta http-equiv="refresh" content="0; url=/new-path/">
 <link rel="canonical" href="/new-path/">
+<script>location.replace("/new-path/" + location.hash);</script>
 ```
 
+The script redirects immediately and keeps the URL fragment (`/old-path/#section` → `/new-path/#section`), like a server-side redirect would; the meta refresh is the fallback when JavaScript is off. If the target already contains a `#fragment`, that one is kept instead.
+
 This is a static fallback for platforms without server-side redirect support — a real `_redirects`/`.htaccess` (or your host/CDN's redirect rules) is always the better option when available, since the HTML approach is a moment slower and depends on the browser executing the refresh.
 
 ## License

package/lib/formats.js

@@ -4,8 +4,28 @@ function toNetlify(list) {
   return list.map(({ from, to, status }) => `${from}  ${to}  ${status}`).join("\n") + "\n";
 }
 
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Apache splits directive arguments on whitespace; quote those that contain it.
+function apacheArg(str) {
+  return /[\s"]/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str;
+}
+
+// RedirectMatch with an anchored, escaped pattern matches the path exactly,
+// like Netlify's _redirects. Plain `Redirect` would be a prefix match
+// (/old/ would also catch /old/anything), so the same config would behave
+// differently depending on the host.
 function toApache(list) {
-  return list.map(({ from, to, status }) => `Redirect ${status} ${from} ${to}`).join("\n") + "\n";
+  return (
+    list
+      .map(({ from, to, status }) => {
+        const pattern = apacheArg(`^${escapeRegex(from)}$`);
+        return `RedirectMatch ${status} ${pattern} ${apacheArg(to)}`;
+      })
+      .join("\n") + "\n"
+  );
 }
 
 function escapeAttr(str) {
@@ -16,21 +36,32 @@ function escapeAttr(str) {
     .replace(/>/g, ">");
 }
 
+// JSON.stringify yields a valid JS string literal; escaping "<" additionally
+// keeps a target containing "</script>" from closing the inline script early.
+function toScriptString(str) {
+  return JSON.stringify(String(str)).replace(/</g, "\\u003c");
+}
+
 // A static fallback for hosts that can't act on _redirects/.htaccess (e.g.
 // GitHub Pages): an actual HTML file at the old URL that both redirects
 // browsers instantly and points crawlers at the new canonical URL.
-function toHtmlPage(to) {
+// The script runs before the meta refresh fires and carries the URL fragment
+// (#section) over, as a server-side 301 would; the meta refresh remains as the
+// no-JS fallback. A target that already has its own fragment keeps it.
+function toHtmlPage(to, { lang = "en", message = "This page has moved to" } = {}) {
   const target = escapeAttr(to);
+  const hash = String(to).includes("#") ? "" : " + location.hash";
   return `<!doctype html>
-<html lang="en">
+<html lang="${escapeAttr(lang)}">
 <head>
 <meta charset="utf-8">
-<title>Redirecting…</title>
+<title>${escapeAttr(message)} ${target}</title>
 <meta http-equiv="refresh" content="0; url=${target}">
 <link rel="canonical" href="${target}">
+<script>location.replace(${toScriptString(to)}${hash});</script>
 </head>
 <body>
-<p>This page has moved to <a href="${target}">${target}</a>.</p>
+<p>${escapeAttr(message)} <a href="${target}">${target}</a>.</p>
 </body>
 </html>
 `;

package/lib/redirects.js

@@ -10,6 +10,8 @@ const DEFAULTS = {
   netlify: true,
   apache: false,
   html: false,
+  htmlLang: "en",
+  htmlMessage: "This page has moved to",
   netlifyFile: "_redirects",
   apacheFile: ".htaccess",
   log: true,
@@ -50,7 +52,7 @@ module.exports = function redirectsPlugin(eleventyConfig, userOptions = {}) {
       // Preserve (and prepend ahead of) any existing .htaccess content, e.g.
       // hand-maintained directives (ErrorDocument, mod_deflate, mod_expires)
       // brought in via a static passthrough copy — this plugin only owns the
-      // Redirect lines, not the whole file.
+      // RedirectMatch lines, not the whole file.
       const existing = readExisting(apachePath);
       fs.writeFileSync(apachePath, toApache(list) + existing);
     }
@@ -59,7 +61,10 @@ module.exports = function redirectsPlugin(eleventyConfig, userOptions = {}) {
       for (const { from, to } of list) {
         const outPath = path.join(outputDir, toOutputPath(from));
         fs.mkdirSync(path.dirname(outPath), { recursive: true });
-        fs.writeFileSync(outPath, toHtmlPage(to));
+        fs.writeFileSync(
+          outPath,
+          toHtmlPage(to, { lang: options.htmlLang, message: options.htmlMessage })
+        );
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flyewi/eleventy-plugin-redirects",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Eleventy plugin that generates Netlify _redirects, Apache .htaccess, and static HTML fallback pages from a single redirects config.",
   "main": "lib/redirects.js",
   "type": "commonjs",