@inlang/paraglide-js 1.7.2 → 1.7.3

package/dist/adapter-utils/index.d.ts

@@ -1,5 +1,5 @@
 export { negotiateLanguagePreferences } from './negotiation/language.js';
 export { detectLanguageFromPath } from './routing/detectLanguage.js';
-export { bestMatch, resolveRoute, parseRouteDefinition, exec, type PathDefinitionTranslations, type ParamMatcher, type RouteParam, } from './routing/routeDefinitions.js';
+export { bestMatch, resolveRoute, parseRouteDefinition, type PathDefinitionTranslations, type ParamMatcher, type RouteParam, } from './routing/routeDefinitions.js';
 export { validatePathTranslations, prettyPrintPathDefinitionIssues, } from './routing/validatePathTranslations.js';
 export { resolveUserPathDefinitions, type UserPathDefinitionTranslations, } from './routing/resolveUserPathDefinitions.js';

package/dist/adapter-utils/index.js

@@ -109,6 +109,116 @@ function detectLanguageFromPath({
   }
   return void 0;
 }
+const EMPTY = { type: "static", content: "", matched: false };
+function sort_routes(routes) {
+  const segment_cache = /* @__PURE__ */ new Map();
+  function split(id) {
+    const parts = [];
+    let i = 0;
+    while (i <= id.length) {
+      const start = id.indexOf("[", i);
+      if (start === -1) {
+        parts.push({ type: "static", content: id.slice(i), matched: false });
+        break;
+      }
+      parts.push({ type: "static", content: id.slice(i, start), matched: false });
+      const type = id[start + 1] === "[" ? "optional" : id[start + 1] === "." ? "rest" : "required";
+      const delimiter = type === "optional" ? "]]" : "]";
+      const end = id.indexOf(delimiter, start);
+      if (end === -1) {
+        throw new Error(`Invalid route ID ${id}`);
+      }
+      const content = id.slice(start, i = end + delimiter.length);
+      parts.push({
+        type,
+        content,
+        matched: content.includes("=")
+      });
+    }
+    return parts;
+  }
+  function get_parts(segment) {
+    if (!segment_cache.has(segment)) {
+      segment_cache.set(segment, split(segment));
+    }
+    return segment_cache.get(segment);
+  }
+  return routes.sort((route_a, route_b) => {
+    var _a, _b, _c, _d, _e, _f;
+    const segments_a = split_route_id(route_a).map(get_parts);
+    const segments_b = split_route_id(route_b).map(get_parts);
+    for (let i = 0; i < Math.max(segments_a.length, segments_b.length); i += 1) {
+      const segment_a = segments_a[i] ?? [EMPTY];
+      const segment_b = segments_b[i] ?? [EMPTY];
+      for (let j = 0; j < Math.max(segment_a.length, segment_b.length); j += 1) {
+        const a = segment_a[j];
+        const b = segment_b[j];
+        const dynamic = !!(j % 2);
+        if (dynamic) {
+          if (!a)
+            return -1;
+          if (!b)
+            return 1;
+          const next_a = ((_a = segment_a[j + 1]) == null ? void 0 : _a.content) || ((_c = (_b = segments_a[i + 1]) == null ? void 0 : _b[0]) == null ? void 0 : _c.content);
+          const next_b = ((_d = segment_b[j + 1]) == null ? void 0 : _d.content) || ((_f = (_e = segments_b[i + 1]) == null ? void 0 : _e[0]) == null ? void 0 : _f.content);
+          if (a.type === "rest" && b.type === "rest") {
+            if (next_a && next_b)
+              continue;
+            if (next_a)
+              return -1;
+            if (next_b)
+              return 1;
+          }
+          if (a.type === "rest") {
+            return next_a && !next_b ? -1 : 1;
+          }
+          if (b.type === "rest") {
+            return next_b && !next_a ? 1 : -1;
+          }
+          if (a.matched !== b.matched) {
+            return a.matched ? -1 : 1;
+          }
+          if (a.type !== b.type) {
+            if (a.type === "required")
+              return -1;
+            if (b.type === "required")
+              return 1;
+          }
+        } else if ((a == null ? void 0 : a.content) !== (b == null ? void 0 : b.content)) {
+          if (a === EMPTY)
+            return -1;
+          if (b === EMPTY)
+            return 1;
+          return sort_static(a.content, b.content);
+        }
+      }
+    }
+    return route_a < route_b ? 1 : -1;
+  });
+}
+function split_route_id(id) {
+  return get_route_segments(
+    id.replace(/\[\[[^\]]+\]\](?!$)/g, "")
+  ).filter(Boolean);
+}
+function sort_static(a, b) {
+  if (a === b)
+    return 0;
+  let i = 0;
+  while (a[i] || b[i]) {
+    const char_a = a[i];
+    const char_b = b[i];
+    if (char_a !== char_b) {
+      if (char_a === void 0)
+        return 1;
+      if (char_b === void 0)
+        return -1;
+      return char_a < char_b ? -1 : 1;
+    }
+    i++;
+  }
+  return 0;
+}
 const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
 function parseRouteDefinition(id) {
   const params = [];
@@ -157,9 +267,7 @@ function parseRouteDefinition(id) {
             param_pattern.exec(content)
           );
           if (!match) {
-            throw new Error(
-              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
-            );
+            throw new Error(`Invalid param: ${content}`);
           }
           const [, is_optional, is_rest, name, matcher] = match;
           params.push({
@@ -181,7 +289,7 @@ function parseRouteDefinition(id) {
 function exec(match, params, matchers) {
   const result = {};
   const values = match.slice(1);
-  const values_needing_match = values.filter((value) => value !== void 0);
+  const values_needing_match = values.filter((v) => v !== void 0);
   let buffered = 0;
   for (const [i, param] of params.entries()) {
     let value = values[i - buffered];
@@ -225,28 +333,24 @@ function escape(str) {
 }
 const basic_param_pattern = /\[(\[)?(\.\.\.)?(\w+?)(?:=(\w+))?\]\]?/g;
 function resolveRoute(id, params) {
-  const segments = get_route_segments(id);
-  return "/" + segments.map(
+  return "/" + get_route_segments(id).map(
     (segment) => segment.replace(basic_param_pattern, (_, optional, rest, name) => {
       const param_value = params[name];
       if (!param_value) {
-        if (optional)
-          return "";
-        if (rest && param_value !== void 0)
+        if (optional || rest && param_value !== void 0)
           return "";
-        throw new Error(`Missing parameter '${name}' in route ${id}`);
+        else
+          throw new Error(`Missing parameter '${name}' in route ${id}`);
       }
-      if (param_value.startsWith("/") || param_value.endsWith("/"))
-        throw new Error(
-          `Parameter '${name}' in route ${id} cannot start or end with a slash -- this would cause an invalid route like foo//bar`
-        );
+      if (param_value[0] == "/" || param_value.endsWith("/"))
+        throw new Error(`Parameter '${name}' in route ${id} cannot start or end with a slash`);
       return param_value;
     })
   ).filter(Boolean).join("/");
 }
 function bestMatch(canonicalPath, pathDefinitions, matchers) {
-  let bestMatch2 = void 0;
-  for (const pathDefinition of pathDefinitions) {
+  const sorted = sort_routes(pathDefinitions);
+  for (const pathDefinition of sorted) {
     const route = parseRouteDefinition(pathDefinition);
     const match = route.pattern.exec(removeTrailingSlash(canonicalPath));
     if (!match)
@@ -254,34 +358,14 @@ function bestMatch(canonicalPath, pathDefinitions, matchers) {
     const params = exec(match, route.params, matchers);
     if (!params)
       continue;
-    if (!bestMatch2) {
-      bestMatch2 = { params, route, id: pathDefinition };
-      continue;
-    }
-    const bestMatchNumParams = Object.keys(bestMatch2.route.params).length;
-    const currentMatchNumParams = Object.keys(route.params).length;
-    if (bestMatchNumParams < currentMatchNumParams) {
-      continue;
-    }
-    if (bestMatchNumParams > currentMatchNumParams) {
-      bestMatch2 = { params, route, id: pathDefinition };
-      continue;
-    }
-    if (bestMatchNumParams === currentMatchNumParams && route.pattern.source.length < bestMatch2.route.pattern.source.length) {
-      bestMatch2 = { params, route, id: pathDefinition };
-    }
+    return { params, id: pathDefinition };
   }
-  return bestMatch2 ? {
-    id: bestMatch2.id,
-    params: bestMatch2.params
-  } : void 0;
+  return void 0;
 }
 function removeTrailingSlash(path) {
   return path.endsWith("/") ? path.slice(0, -1) : path;
 }
-function get_route_segments(route) {
-  return route.slice(1).split("/");
-}
+const get_route_segments = (route) => route.slice(1).split("/");
 function validatePathTranslations(pathTranslations, availableLanguageTags, matchers) {
   const issues = [];
   const expectedLanguages = new Set(availableLanguageTags);
@@ -375,7 +459,6 @@ const fromMessage = (message, availableLanguageTags) => Object.fromEntries(
 export {
   bestMatch,
   detectLanguageFromPath,
-  exec,
   negotiateLanguagePreferences,
   parseRouteDefinition,
   prettyPrintPathDefinitionIssues,

package/dist/adapter-utils/routing/routeDefinitions.d.ts

@@ -1,6 +1,10 @@
 export type PathDefinitionTranslations<T extends string = string> = {
     [canonicalPath: `/${string}`]: Record<T, `/${string}`>;
 };
+type Route = {
+    params: RouteParam[];
+    pattern: RegExp;
+};
 export type RouteParam = {
     name: string;
     matcher: string;
@@ -12,10 +16,7 @@ export type ParamMatcher = (segment: string) => boolean;
 /**
  * Creates the regex pattern, extracts parameter names, and generates types for a route
  */
-export declare function parseRouteDefinition(id: string): {
-    params: RouteParam[];
-    pattern: RegExp;
-};
+export declare function parseRouteDefinition(id: string): Route;
 export declare function exec(match: RegExpMatchArray, params: RouteParam[], matchers: Record<string, ParamMatcher>): Record<string, string> | undefined;
 /**
  * Populate a route ID with params to resolve a pathname.
@@ -43,3 +44,12 @@ export declare function bestMatch(canonicalPath: string, pathDefinitions: string
     params: Record<string, string>;
     id: string;
 } | undefined;
+/**
+ * Splits a route id into its segments, removing segments that
+ * don't affect the path (i.e. groups). The root route is represented by `/`
+ * and will be returned as `['']`.
+ * @param {string} route
+ * @returns string[]
+ */
+export declare const get_route_segments: (route: string) => string[];
+export {};

package/dist/adapter-utils/routing/sortRoutes.d.ts

@@ -0,0 +1 @@
+export declare function sort_routes(routes: string[]): string[];

package/dist/cli/index.js

@@ -32234,7 +32234,7 @@ const addParaglideJsToDevDependencies = async (ctx) => {
   const ctx1 = await updatePackageJson({
     devDependencies: async (devDeps) => ({
       ...devDeps,
-      "@inlang/paraglide-js": "1.7.2"
+      "@inlang/paraglide-js": "1.7.3"
     })
   })(ctx);
   ctx.logger.success("Added @inlang/paraglide-js to the devDependencies in package.json.");
@@ -32321,7 +32321,7 @@ const steps = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   runCompiler,
   updatePackageJson
 }, Symbol.toStringTag, { value: "Module" }));
-const cli = new Command().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version("1.7.2");
+const cli = new Command().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version("1.7.3");
 export {
   defaults as Defaults,
   steps as Steps,