storyloco 2.8.0 → 2.8.1

package/README.md

@@ -394,7 +394,7 @@ The plugin will:
 
 - Fetch redirect entries from your Storyblok datasource
 - Bake them into the build as a fallback
-- Support exact matches and wildcard patterns
+- Support exact matches and wildcard patterns, with or without a trailing slash (SvelteKit strips it before hooks run, so `/old/` matches a request for `/old`)
 - Handle both internal and external redirects
 
 Redirects stay live without a rebuild: the handle fetches the datasource on a server's first request, then serves from memory and refreshes in the background once the list is a minute old. If Storyblok can't be reached, it keeps the last list it had, or the one baked in at build.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "storyloco",
-	"version": "2.8.0",
+	"version": "2.8.1",
 	"description": "A collection of slick Storyblok field plugins built with Svelte 5, TypeScript, and Tailwind CSS",
 	"keywords": [
 		"storyblok",

package/packages/vite/dist/redirects/handle.js

@@ -9,6 +9,15 @@ function normalize_path(pathname) {
         return "/";
     return pathname.startsWith("/") ? pathname : `/${pathname}`;
 }
+/**
+ * How paths are compared: leading slash, no trailing slash, query kept. SvelteKit strips a trailing
+ * slash before hooks run, so `/old/` has to match a request for `/old`.
+ */
+function match_key(path) {
+    const i = path.indexOf("?");
+    const [pathname, query] = i < 0 ? [path, ""] : [path.slice(0, i), path.slice(i)];
+    return normalize_path(pathname).replace(/(.)\/+$/, "$1") + query;
+}
 /** Absolute URL check (e.g. https://..., http://..., //cdn...) */
 function is_absolute_url(value) {
     return /^https?:\/\//i.test(value) || value.startsWith("//");
@@ -30,7 +39,7 @@ function build_rules(redirects) {
         if (key.includes("*")) {
             try {
                 rules.wildcards.push({
-                    matcher: match(to_src_pattern(key), { decode: decodeURIComponent, end: true }),
+                    matcher: match(to_src_pattern(match_key(key)), { decode: decodeURIComponent, end: true }),
                     builder: compile(to_dst_pattern(value), { encode: (x) => x }),
                 });
             }
@@ -39,8 +48,10 @@ function build_rules(redirects) {
             }
         }
         else {
-            rules.exact.set(normalize_path(key), value);
-            rules.exact.set(key.startsWith("/") ? key.slice(1) : key, value);
+            const existing = rules.exact.get(match_key(key));
+            if (existing !== undefined && existing !== value)
+                logger.warn(`${key} -> ${value} replaces ${existing}: keys match with or without a trailing slash`);
+            rules.exact.set(match_key(key), value);
         }
     }
     return rules;
@@ -90,11 +101,10 @@ function warn(err) {
 async function resolve_redirect(url) {
     const { exact, wildcards } = await current_rules();
     try {
-        const source = normalize_path(url.pathname + (url.search || ""));
-        const source_plain = source.includes("?") ? source.split("?")[0] : source;
-        const lookup = (key) => exact.get(key) ?? exact.get(key.startsWith("/") ? key.slice(1) : key);
+        const source = match_key(url.pathname + url.search);
+        const source_plain = match_key(url.pathname);
         // Prefer exact including query, then plain path
-        let target = lookup(source) ?? lookup(source_plain) ?? null;
+        let target = exact.get(source) ?? exact.get(source_plain) ?? null;
         if (!target) {
             for (const { matcher, builder } of wildcards) {
                 const m = matcher(source_plain);
@@ -109,7 +119,8 @@ async function resolve_redirect(url) {
             const result = is_absolute_url(target) ? target : normalize_path(target);
             // If source included a query and the target is a relative path without its own query,
             // we do NOT automatically forward the original query. The map should specify it.
-            if (result !== source && result !== source_plain)
+            const result_key = match_key(result);
+            if (result_key !== source && result_key !== source_plain)
                 return result;
         }
         return null;