@blinkk/root 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/render.js

@@ -203,6 +203,46 @@ function parseAcceptLanguage(value) {
 
 // src/render/i18n-fallbacks.ts
 var UNKNOWN_COUNTRY = "zz";
+var ES_419_COUNTRIES = [
+  "ar",
+  // Argentina
+  "bo",
+  // Bolivia
+  "cl",
+  // Chile
+  "co",
+  // Colombia
+  "cr",
+  // Costa Rica
+  "cu",
+  // Cuba
+  "do",
+  // Dominican Republic
+  "ec",
+  // Ecuador
+  "sv",
+  // El Salvador
+  "gt",
+  // Guatemala
+  "hn",
+  // Honduras
+  "mx",
+  // Mexico
+  "ni",
+  // Nicaragua
+  "pa",
+  // Panama
+  "py",
+  // Paraguay
+  "pe",
+  // Peru
+  "pr",
+  // Puerto Rico
+  "uy",
+  // Uruguay
+  "ve"
+  // Venezuela
+];
 function getFallbackLocales(req) {
   var _a, _b;
   const hl = getFirstQueryParam(req, "hl");
@@ -226,9 +266,14 @@ function getFallbackLocales(req) {
     locales.add(`${langCode}_${countryCode}`);
   });
   locales.add(`ALL_${countryCode}`);
+  const isEs419Country = test419Country(countryCode);
   langs.forEach((langCode) => {
     locales.add(`${langCode}_ALL`);
     locales.add(langCode);
+    if (langCode === "es" && isEs419Country) {
+      locales.add("es-419_ALL");
+      locales.add("es-419");
+    }
   });
   return Array.from(locales);
 }
@@ -251,6 +296,9 @@ function getFallbackLanguages(req) {
     parseAcceptLanguage(acceptLangHeader).forEach((lang) => {
       if (lang.region) {
         langs.add(`${lang.code}-${lang.region}`);
+        if (lang.code === "es" && test419Country(lang.region)) {
+          langs.add("es-419");
+        }
       }
       langs.add(lang.code);
     });
@@ -279,6 +327,9 @@ function isWebCrawler(req) {
   const userAgent = userAgentHeader.toLowerCase();
   return userAgent.includes("googlebot") || userAgent.includes("bingbot") || userAgent.includes("twitterbot");
 }
+function test419Country(countryCode) {
+  return ES_419_COUNTRIES.includes(countryCode);
+}
 
 // src/render/router.ts
 import path from "node:path";
@@ -298,21 +349,26 @@ var RouteTrie = class _RouteTrie {
       return;
     }
     const [head, tail] = this.splitPath(path2);
+    if (head.startsWith("[[...") && head.endsWith("]]")) {
+      const paramName = head.slice(5, -2);
+      this.optCatchAllNodes = new CatchAllNode(paramName, route);
+      return;
+    }
     if (head.startsWith("[...") && head.endsWith("]")) {
       const paramName = head.slice(4, -1);
-      this.wildcardChild = new WildcardChild(paramName, route);
+      this.catchAllNodes = new CatchAllNode(paramName, route);
       return;
     }
     let nextNode;
     if (head.startsWith("[") && head.endsWith("]")) {
-      if (!this.paramChildren) {
-        this.paramChildren = {};
+      if (!this.paramNodes) {
+        this.paramNodes = {};
       }
       const paramName = head.slice(1, -1);
-      if (!this.paramChildren[paramName]) {
-        this.paramChildren[paramName] = new ParamChild(paramName);
+      if (!this.paramNodes[paramName]) {
+        this.paramNodes[paramName] = new ParamNode(paramName);
       }
-      nextNode = this.paramChildren[paramName].trie;
+      nextNode = this.paramNodes[paramName].trie;
     } else {
       nextNode = this.children[head];
       if (!nextNode) {
@@ -344,8 +400,8 @@ var RouteTrie = class _RouteTrie {
     if (this.route) {
       addPromise(cb("/", this.route));
     }
-    if (this.paramChildren) {
-      Object.values(this.paramChildren).forEach((paramChild) => {
+    if (this.paramNodes) {
+      Object.values(this.paramNodes).forEach((paramChild) => {
         const param = `[${paramChild.name}]`;
         paramChild.trie.walk((childPath, route) => {
           const paramUrlPath = `/${param}${childPath}`;
@@ -353,9 +409,13 @@ var RouteTrie = class _RouteTrie {
         });
       });
     }
-    if (this.wildcardChild) {
-      const wildcardUrlPath = `/[...${this.wildcardChild.name}]`;
-      addPromise(cb(wildcardUrlPath, this.wildcardChild.route));
+    if (this.catchAllNodes) {
+      const wildcardUrlPath = `/[...${this.catchAllNodes.name}]`;
+      addPromise(cb(wildcardUrlPath, this.catchAllNodes.route));
+    }
+    if (this.optCatchAllNodes) {
+      const wildcardUrlPath = `/[[...${this.optCatchAllNodes.name}]]`;
+      addPromise(cb(wildcardUrlPath, this.optCatchAllNodes.route));
     }
     for (const subpath of Object.keys(this.children)) {
       const childTrie = this.children[subpath];
@@ -371,14 +431,24 @@ var RouteTrie = class _RouteTrie {
    */
   clear() {
     this.children = {};
-    this.paramChildren = void 0;
-    this.wildcardChild = void 0;
+    this.paramNodes = void 0;
+    this.catchAllNodes = void 0;
+    this.optCatchAllNodes = void 0;
     this.route = void 0;
   }
   getRoute(urlPath, params) {
     urlPath = this.normalizePath(urlPath);
     if (urlPath === "") {
-      return this.route;
+      if (this.route) {
+        return this.route;
+      }
+      if (this.optCatchAllNodes) {
+        if (urlPath) {
+          params[this.optCatchAllNodes.name] = urlPath;
+        }
+        return this.optCatchAllNodes.route;
+      }
+      return void 0;
     }
     const [head, tail] = this.splitPath(urlPath);
     const child = this.children[head];
@@ -388,8 +458,8 @@ var RouteTrie = class _RouteTrie {
         return route;
       }
     }
-    if (this.paramChildren) {
-      for (const paramChild of Object.values(this.paramChildren)) {
+    if (this.paramNodes) {
+      for (const paramChild of Object.values(this.paramNodes)) {
         const route = paramChild.trie.getRoute(tail, params);
         if (route) {
           params[paramChild.name] = head;
@@ -397,9 +467,13 @@ var RouteTrie = class _RouteTrie {
         }
       }
     }
-    if (this.wildcardChild) {
-      params[this.wildcardChild.name] = urlPath;
-      return this.wildcardChild.route;
+    if (this.catchAllNodes) {
+      params[this.catchAllNodes.name] = urlPath;
+      return this.catchAllNodes.route;
+    }
+    if (this.optCatchAllNodes) {
+      params[this.optCatchAllNodes.name] = urlPath;
+      return this.optCatchAllNodes.route;
     }
     return void 0;
   }
@@ -407,7 +481,7 @@ var RouteTrie = class _RouteTrie {
    * Normalizes a path for inclusion into the route trie.
    */
   normalizePath(path2) {
-    return path2.replace(/^\/+/g, "");
+    return path2.replace(/^\/+/g, "").replace(/\/+$/g, "");
   }
   /**
    * Splits the parent directory from its children, e.g.:
@@ -422,13 +496,13 @@ var RouteTrie = class _RouteTrie {
     return [path2.slice(0, i), path2.slice(i + 1)];
   }
 };
-var ParamChild = class {
+var ParamNode = class {
   constructor(name) {
     this.trie = new RouteTrie();
     this.name = name;
   }
 };
-var WildcardChild = class {
+var CatchAllNode = class {
   constructor(name, route) {
     this.name = name;
     this.route = route;
@@ -436,11 +510,11 @@ var WildcardChild = class {
 };
 
 // src/render/router.ts
-function getRoutes(config) {
-  var _a, _b, _c;
-  const locales = ((_a = config.i18n) == null ? void 0 : _a.locales) || [];
-  const i18nUrlFormat = ((_b = config.i18n) == null ? void 0 : _b.urlFormat) || "/{locale}/{path}";
-  const defaultLocale = ((_c = config.i18n) == null ? void 0 : _c.defaultLocale) || "en";
+function getRoutes(rootConfig) {
+  var _a, _b;
+  const locales = ((_a = rootConfig.i18n) == null ? void 0 : _a.locales) || [];
+  const basePath = rootConfig.base || "/";
+  const defaultLocale = ((_b = rootConfig.i18n) == null ? void 0 : _b.defaultLocale) || "en";
   const routes = import.meta.glob(
     ["/routes/*.ts", "/routes/**/*.ts", "/routes/*.tsx", "/routes/**/*.tsx"],
     {
@@ -449,39 +523,58 @@ function getRoutes(config) {
   );
   const trie = new RouteTrie();
   Object.keys(routes).forEach((modulePath) => {
+    var _a2;
     const src = modulePath.slice(1);
-    let routePath = modulePath.replace(/^\/routes/, "");
-    const parts = path.parse(routePath);
+    let relativeRoutePath = modulePath.replace(/^\/routes/, "");
+    const parts = path.parse(relativeRoutePath);
     if (parts.name.startsWith("_")) {
       return;
     }
     if (parts.name === "index") {
-      routePath = parts.dir;
+      relativeRoutePath = parts.dir;
     } else {
-      routePath = path.join(parts.dir, parts.name);
+      relativeRoutePath = path.join(parts.dir, parts.name);
     }
-    const localeRoutePath = i18nUrlFormat.replace("{locale}", "[locale]").replace("{path}", routePath.replace(/^\/*/, ""));
+    const urlFormat = "/[base]/[path]";
+    const i18nUrlFormat = toSquareBrackets(
+      ((_a2 = rootConfig.i18n) == null ? void 0 : _a2.urlFormat) || "/[locale]/[base]/[path]"
+    );
+    const placeholders = {
+      base: removeSlashes(basePath),
+      path: removeSlashes(relativeRoutePath)
+    };
+    const formatUrl = (format) => {
+      var _a3;
+      const url = format.replaceAll("[base]", placeholders.base).replaceAll("[path]", placeholders.path);
+      return normalizeUrlPath(url, {
+        trailingSlash: (_a3 = rootConfig.server) == null ? void 0 : _a3.trailingSlash
+      });
+    };
+    const routePath = formatUrl(urlFormat);
+    const localeRoutePath = formatUrl(i18nUrlFormat);
     trie.add(routePath, {
       src,
       module: routes[modulePath],
       locale: defaultLocale,
       isDefaultLocale: true,
-      routePath: normalizeUrlPath(routePath),
-      localeRoutePath: normalizeUrlPath(localeRoutePath)
-    });
-    locales.forEach((locale) => {
-      const localePath = localeRoutePath.replace("[locale]", locale);
-      if (localePath !== routePath) {
-        trie.add(localePath, {
-          src,
-          module: routes[modulePath],
-          locale,
-          isDefaultLocale: false,
-          routePath,
-          localeRoutePath
-        });
-      }
+      routePath,
+      localeRoutePath
     });
+    if (i18nUrlFormat.includes("[locale]")) {
+      locales.forEach((locale) => {
+        const localePath = localeRoutePath.replace("[locale]", locale);
+        if (localePath !== relativeRoutePath) {
+          trie.add(localePath, {
+            src,
+            module: routes[modulePath],
+            locale,
+            isDefaultLocale: false,
+            routePath,
+            localeRoutePath
+          });
+        }
+      });
+    }
   });
   return trie;
 }
@@ -510,18 +603,24 @@ async function getAllPathsForRoute(urlPathFormat, route) {
         }
       );
     }
-  } else if (pathContainsPlaceholders(urlPathFormat) && !routeModule.handle) {
+  } else if (routeModule.getStaticProps && !pathContainsPlaceholders(urlPathFormat)) {
+    urlPaths.push({ urlPath: normalizeUrlPath(urlPathFormat), params: {} });
+  } else if (!routeModule.handle && !pathContainsPlaceholders(urlPathFormat)) {
+    urlPaths.push({ urlPath: normalizeUrlPath(urlPathFormat), params: {} });
+  } else if (pathContainsPlaceholders(urlPathFormat) && !routeModule.handle && !routeModule.getStaticPaths) {
     console.warn(
-      `path contains placeholders: ${urlPathFormat}, did you forget to define getStaticPaths()? more info: https://rootjs.dev/guide/routes#getStaticPaths`
+      [
+        `warning: path contains placeholders: ${urlPathFormat}.`,
+        `define either ssg getStaticPaths() or ssr handle() for route: ${route.src}.`,
+        "more info: https://rootjs.dev/guide/routes"
+      ].join("\n")
     );
-  } else {
-    urlPaths.push({ urlPath: normalizeUrlPath(urlPathFormat), params: {} });
   }
   return urlPaths;
 }
 function replaceParams(urlPathFormat, params) {
   const urlPath = urlPathFormat.replaceAll(
-    /\[(\.\.\.)?([\w\-_]*)\]/g,
+    /\[\[?(\.\.\.)?([\w\-_]*)\]?\]/g,
     (match, _wildcard, key) => {
       const val = params[key];
       if (!val) {
@@ -532,10 +631,14 @@ function replaceParams(urlPathFormat, params) {
   );
   return urlPath;
 }
-function normalizeUrlPath(urlPath) {
-  if (urlPath !== "/" && urlPath.endsWith("/")) {
+function normalizeUrlPath(urlPath, options) {
+  urlPath = urlPath.replace(/\/+/g, "/");
+  if ((options == null ? void 0 : options.trailingSlash) === false && urlPath !== "/" && urlPath.endsWith("/")) {
     urlPath = urlPath.replace(/\/*$/g, "");
   }
+  if (!urlPath.startsWith("/")) {
+    urlPath = `/${urlPath}`;
+  }
   return urlPath;
 }
 function pathContainsPlaceholders(urlPath) {
@@ -544,6 +647,17 @@ function pathContainsPlaceholders(urlPath) {
     return segment.startsWith("[") && segment.endsWith("]");
   });
 }
+function removeSlashes(str) {
+  return str.replace(/^\/*/g, "").replace(/\/*$/g, "");
+}
+function toSquareBrackets(str) {
+  if (str.includes("{") || str.includes("}")) {
+    const val = str.replaceAll("{", "[").replaceAll("}", "]");
+    console.warn(`"${str}" is a deprecated format, please switch to "${val}"`);
+    return val;
+  }
+  return str;
+}
 
 // src/render/render.tsx
 import { jsx as jsx4, jsxs as jsxs4 } from "preact/jsx-runtime";
@@ -555,7 +669,7 @@ var Renderer = class {
     this.elementGraph = options.elementGraph;
   }
   async handle(req, res, next) {
-    const url = req.path.toLowerCase();
+    const url = req.path;
     const [route, routeParams] = this.routes.get(url);
     if (!route) {
       next();
@@ -668,7 +782,12 @@ var Renderer = class {
     const routeAsset = await this.assetMap.get(route.src);
     if (routeAsset) {
       const routeCssDeps = await routeAsset.getCssDeps();
-      routeCssDeps.forEach((dep) => cssDeps.add(dep));
+      routeCssDeps.forEach((dep) => {
+        if (dep.endsWith("?inline")) {
+          return;
+        }
+        cssDeps.add(dep);
+      });
     }
     await this.collectElementDeps(mainHtml, jsDeps, cssDeps);
     await Promise.all(
@@ -903,7 +1022,12 @@ ${renderToString(page)}
         const assetJsDeps = await asset.getJsDeps();
         assetJsDeps.forEach((dep) => jsDeps.add(dep));
         const assetCssDeps = await asset.getCssDeps();
-        assetCssDeps.forEach((dep) => cssDeps.add(dep));
+        assetCssDeps.forEach((dep) => {
+          if (dep.endsWith("?inline")) {
+            return;
+          }
+          cssDeps.add(dep);
+        });
       })
     );
     return { jsDeps, cssDeps };