@uniweb/core 0.29.8 → 0.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.29.8",
+  "version": "0.30.1",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {

package/src/locale-config.js

@@ -17,9 +17,9 @@
 
 /**
  * Extract a locale code from a declared-language entry. The contract is
- * strings-only; legacy `{ code, label }` objects are tolerated on read
- * (they appeared in older configs and the runtime's buildLocalesList
- * accepted them) but are never produced. The `'*'` wildcard marker
+ * strings-only; legacy `{ code, label }` objects are tolerated on READ — a
+ * payload built from an older config still renders — and refused where a site
+ * is built or pushed (`validateLanguageConfig`). The `'*'` wildcard marker
  * (auto-discover from `locales/`) is not a locale code.
  *
  * @param {*} entry - Declared-language entry.
@@ -101,10 +101,22 @@ export const LOCALE_DISPLAY_NAMES = {
  */
 export function localeLabel(entry) {
   if (typeof entry === 'string') {
-    return LOCALE_DISPLAY_NAMES[entry] || entry.toUpperCase()
+    return LOCALE_DISPLAY_NAMES[entry] || nativeName(entry) || entry.toUpperCase()
   }
   if (!entry || typeof entry.code !== 'string' || !entry.code) return ''
-  return entry.label || LOCALE_DISPLAY_NAMES[entry.code] || entry.code.toUpperCase()
+  return entry.label || LOCALE_DISPLAY_NAMES[entry.code] || nativeName(entry.code) || entry.code.toUpperCase()
+}
+
+// A language's name in itself (`sv` → `Svenska`, `pt-BR` → `Português (Brasil)`), where the
+// platform knows it — so a code the table above does not list still has a name, and a site
+// never needs to write one. Null when it does not know the code.
+function nativeName(code) {
+  try {
+    const name = new Intl.DisplayNames([code], { type: 'language' }).of(code)
+    return name && name !== code ? name.charAt(0).toLocaleUpperCase(code) + name.slice(1) : null
+  } catch {
+    return null
+  }
 }
 
 export function isWildcardLanguages(value) {
@@ -189,9 +201,12 @@ export function resolvePublishableLocales(config = {}) {
  * - `default-not-publishable` — the effective default is excluded from the
  *   publishable set.
  *
+ * - `object-language-entry` — a `{ code, label }` entry: languages are named by
+ *   their code (`localeLabel` gives the name). Read tolerantly, never built or pushed.
+ *
  * Warnings:
- * - `invalid-language-entry` / `invalid-publish-language-entry` — non-string
- *   entries (dropped by normalization).
+ * - `invalid-language-entry` / `invalid-publish-language-entry` — entries that
+ *   name no code (dropped by normalization).
  * - `duplicate-language` — repeated codes (deduped).
  * - `dangling-publish-language` — listed but not declared (ignored at
  *   publish, preserved in the file/wire).
@@ -225,10 +240,14 @@ export function validateLanguageConfig(config = {}) {
         })
         continue
       }
+      // ⛔ An object names a language by `code` and gives it a `label` — a label no sync can
+      // carry (a backend's list is of codes), so a site that pushed it lost it, and the push
+      // itself was refused (measured 2026-09-26). A language's name comes from its code
+      // (`localeLabel`), in every lane alike.
       if (typeof entry !== 'string') {
-        warnings.push({
-          code: entryCode,
-          message: `${field} entry for '${code}' uses the legacy object form — use the plain string '${code}'`
+        errors.push({
+          code: 'object-language-entry',
+          message: `${field} entry for '${code}' is an object — write the plain string '${code}' (a language's name comes from its code)`
         })
       }
       if (seen.has(code)) {

package/src/website.js

@@ -527,10 +527,31 @@ export default class Website {
     const indexMatch = this.pages.find((page) => page.isIndex && page.getNavRoute() === normalizedRoute)
     if (indexMatch) return indexMatch
 
-    // Priority 3: Dynamic route pattern matching
-    // Check cache first
-    if (this._dynamicPageCache.has(normalizedRoute)) {
-      return this._dynamicPageCache.get(normalizedRoute)
+    // Priority 3: Dynamic route pattern matching — on the canonical route, then on the display route,
+    // as Priorities 1 and 1b match a static page in either payload shape. A published payload's
+    // parametric page carries its locale's own pattern (`/noticias/:slug`), which only the display
+    // route matches. ⛔ Until 2026-09-26 only the canonical route was tried, so a backend-served
+    // site's `/es/noticias/x` showed the not-found page without asking for its record. The canonical
+    // route goes first so a file-lane site — whose patterns are all canonical — matches as before.
+    for (const candidate of new Set([normalizedRoute, normalizedStripped])) {
+      const found = this._matchDynamicPage(candidate)
+      if (found) return found
+    }
+
+    return undefined
+  }
+
+  /**
+   * The dynamic page a concrete route names, from the cache or a fresh match of the dynamic
+   * patterns — or undefined.
+   *
+   * @private
+   * @param {string} route - a concrete route, in the form the page patterns are matched against
+   * @returns {Page|undefined}
+   */
+  _matchDynamicPage(route) {
+    if (this._dynamicPageCache.has(route)) {
+      return this._dynamicPageCache.get(route)
     }
 
     // Try to match against dynamic route patterns
@@ -538,23 +559,22 @@ export default class Website {
       // Check if this is a dynamic page (has :param in route)
       if (!page.route.includes(':')) continue
 
-      const match = this._matchDynamicRoute(page.route, normalizedRoute)
+      const match = this._matchDynamicRoute(page.route, route)
       if (match) {
         // Create a dynamic page instance with the concrete route and params
-        const result = this._createDynamicPage(page, normalizedRoute, match.params)
+        const result = this._createDynamicPage(page, route, match.params)
         if (result) {
           const { page: dynamicPage, recordsLoaded } = result
           // Only cache when the records were available at creation time.
           // If DataStore was empty, skip caching so the next render recreates
           // the page with fresh data (correct title, not-found state, etc.).
           if (recordsLoaded) {
-            this._dynamicPageCache.set(normalizedRoute, dynamicPage)
+            this._dynamicPageCache.set(route, dynamicPage)
           }
           return dynamicPage
         }
       }
     }
-
     return undefined
   }