mnfst 0.5.41 → 0.5.43

package/dist/manifest.router.js

@@ -173,6 +173,169 @@ function getBasePath() {
     return (typeof window.getManifestBasePath === 'function' ? window.getManifestBasePath() : '') || '';
 }
 
+// Locale codes from manifest data (same idea as ManifestRouting.matchesCondition).
+function getLocalizationCodesFromManifest() {
+    const localizationCodes = [];
+    try {
+        const manifest = window.ManifestComponentsRegistry?.manifest || window.manifest;
+        if (manifest?.data && typeof manifest.data === 'object') {
+            Object.values(manifest.data).forEach((dataSource) => {
+                if (typeof dataSource === 'object' && dataSource !== null) {
+                    Object.keys(dataSource).forEach((key) => {
+                        if (key.match(/^[a-z]{2}(-[A-Z]{2})?$/)) {
+                            localizationCodes.push(key);
+                        }
+                    });
+                }
+            });
+        }
+    } catch {
+        /* ignore */
+    }
+    return [...new Set(localizationCodes)];
+}
+
+function logicalSegmentsFromPathname(pathname) {
+    const logical = pathnameToLogical(pathname);
+    const s = logical.replace(/^\/+|\/+$/g, '');
+    return s ? s.split('/') : [];
+}
+
+const STICKY_LOCALE_SKIP_FIRST_SEGMENTS = new Set([
+    'api',
+    'assets',
+    'static',
+    'public',
+    'dist',
+    'icons',
+    'fonts',
+    'media',
+    '.well-known',
+]);
+
+const STICKY_LOCALE_STATIC_FILE_EXT = new Set([
+    'js', 'mjs', 'cjs', 'css', 'map', 'png', 'jpg', 'jpeg', 'webp', 'gif', 'svg', 'ico',
+    'woff', 'woff2', 'ttf', 'eot', 'json', 'xml', 'txt', 'pdf', 'zip', 'wasm', 'avif',
+    'mp4', 'webm', 'mp3',
+]);
+
+function shouldSkipStickyLocaleForLogicalSegments(segments) {
+    if (!segments.length) return false;
+    if (STICKY_LOCALE_SKIP_FIRST_SEGMENTS.has(segments[0])) return true;
+    const last = segments[segments.length - 1];
+    if (!last || !last.includes('.')) return false;
+    const ext = last.slice(last.lastIndexOf('.') + 1).toLowerCase();
+    return STICKY_LOCALE_STATIC_FILE_EXT.has(ext);
+}
+
+// manifest.prerender.localeRouteExclude → JSON array in meta; logical path prefixes (after locale).
+function parseLocaleRouteExcludePatterns() {
+    const meta = document.querySelector('meta[name="manifest:locale-route-exclude"]');
+    const raw = meta?.getAttribute('content') || '';
+    if (raw.trim().startsWith('[')) {
+        try {
+            const parsed = JSON.parse(raw.replace(/"/g, '"'));
+            if (Array.isArray(parsed)) {
+                return parsed.map((s) => String(s).trim()).filter(Boolean);
+            }
+        } catch {
+            /* fall through */
+        }
+    }
+    const legacy = document.querySelector('meta[name="manifest:locale-sticky-exclude"]');
+    const legacyRaw = legacy?.getAttribute('content') || '';
+    if (!legacyRaw.trim()) return [];
+    return legacyRaw.split(',').map((s) => s.trim().replace(/^\/+/, '').split('/')[0]).filter(Boolean);
+}
+
+function logicalPathMatchesLocaleRouteExclude(segments, patterns) {
+    if (!patterns.length || !segments.length) return false;
+    const lower = segments.map((s) => s.toLowerCase());
+    for (const pattern of patterns) {
+        const p = String(pattern)
+            .trim()
+            .replace(/^\/+/, '')
+            .split('/')
+            .filter(Boolean)
+            .map((x) => x.toLowerCase());
+        if (p.length === 0) continue;
+        if (lower.length < p.length) continue;
+        let match = true;
+        for (let i = 0; i < p.length; i++) {
+            if (lower[i] !== p[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) return true;
+    }
+    return false;
+}
+
+// /fr/legal/terms → /legal/terms when patterns include "legal" or "legal/terms" (prefix match).
+function normalizeRedundantLocalePrefixInUrl() {
+    if (!isPrerenderedStaticBuild()) return false;
+    const codes = getLocalizationCodesFromManifest();
+    const patterns = parseLocaleRouteExcludePatterns();
+    if (!codes.length || !patterns.length) return false;
+
+    const segs = logicalSegmentsFromPathname(window.location.pathname);
+    if (segs.length < 2) return false;
+    if (!codes.includes(segs[0])) return false;
+    const rest = segs.slice(1);
+    if (!logicalPathMatchesLocaleRouteExclude(rest, patterns)) return false;
+
+    const newLogical = '/' + rest.join('/');
+    const base = getBasePath();
+    let newPathname = base ? base.replace(/\/+$/, '') + newLogical : newLogical;
+    newPathname = newPathname.replace(/\/{2,}/g, '/');
+    if (!newPathname.startsWith('/')) newPathname = '/' + newPathname;
+    if (newPathname === window.location.pathname) return false;
+
+    const prevLogical = pathnameToLogical(window.location.pathname);
+    const u = new URL(window.location.href);
+    u.pathname = newPathname;
+    history.replaceState(null, '', u.toString());
+    currentRoute = pathnameToLogical(newPathname);
+    const np = currentRoute === '/' ? '/' : String(currentRoute).replace(/^\/|\/$/g, '');
+    window.dispatchEvent(new CustomEvent('manifest:route-change', {
+        detail: { from: prevLogical, to: currentRoute, normalizedPath: np }
+    }));
+    return true;
+}
+
+// When the URL already has a locale prefix (e.g. /zh/pricing), keep it for same-origin links
+// that omit the prefix (/articles → /zh/articles). No-op on default-locale URLs (/pricing).
+function applyStickyLocaleToPathname(absolutePathname) {
+    const codes = getLocalizationCodesFromManifest();
+    if (!codes.length) return absolutePathname;
+
+    const currentSegs = logicalSegmentsFromPathname(window.location.pathname);
+    const sticky = currentSegs.length && codes.includes(currentSegs[0]) ? currentSegs[0] : null;
+    if (!sticky) return absolutePathname;
+
+    const targetSegs = logicalSegmentsFromPathname(absolutePathname);
+    if (targetSegs.length && codes.includes(targetSegs[0])) {
+        return absolutePathname;
+    }
+
+    const routeEx = parseLocaleRouteExcludePatterns();
+    if (routeEx.length && logicalPathMatchesLocaleRouteExclude(targetSegs, routeEx)) {
+        return absolutePathname;
+    }
+
+    if (shouldSkipStickyLocaleForLogicalSegments(targetSegs)) {
+        return absolutePathname;
+    }
+
+    const base = getBasePath();
+    const newLogical = targetSegs.length ? `/${sticky}/${targetSegs.join('/')}` : `/${sticky}`;
+    const normalizedLogical = newLogical.replace(/\/{2,}/g, '/') || '/';
+    if (!base) return normalizedLogical;
+    const combined = `${base}${normalizedLogical}`.replace(/([^:])\/{2,}/g, '$1/');
+    return combined.startsWith('/') ? combined : `/${combined}`;
+}
+
 function pathnameToLogical(pathname) {
     const base = getBasePath();
     if (!base) {
@@ -252,27 +415,79 @@ function resolveHref(href) {
         const url = new URL(href, baseUrl);
         if (url.origin !== window.location.origin) return href;
         let path = url.pathname.replace(/\/$/, '') || '/';
-        if (!base) return path.startsWith('/') ? path : '/' + path;
-        if (path === base || path.startsWith(base + '/')) return path;
-        // path may be above base (e.g. /gadget when base is /src/dist) or unrelated; take only the route part and put under base so we never stack.
-        if (path.startsWith('/')) {
+        let resolved;
+        if (!base) {
+            resolved = path.startsWith('/') ? path : '/' + path;
+        } else if (path === base || path.startsWith(base + '/')) {
+            resolved = path;
+        } else if (path.startsWith('/')) {
             const pathSegs = path.split('/').filter(Boolean);
             const baseSegs = base.split('/').filter(Boolean);
             let i = 0;
             while (i < baseSegs.length && i < pathSegs.length && baseSegs[i] === pathSegs[i]) i++;
             const routeSegs = pathSegs.slice(i);
-            if (routeSegs.length) return base + '/' + routeSegs.join('/');
+            if (routeSegs.length) {
+                resolved = base + '/' + routeSegs.join('/');
+            } else {
+                const out = base + (path.startsWith('/') ? path : '/' + path);
+                resolved = out.startsWith('/') ? out : '/' + out;
+            }
+        } else {
+            const out = base + (path.startsWith('/') ? path : '/' + path);
+            resolved = out.startsWith('/') ? out : '/' + out;
         }
-        const out = base + (path.startsWith('/') ? path : '/' + path);
-        return out.startsWith('/') ? out : '/' + out;
+        return applyStickyLocaleToPathname(resolved);
     } catch {
         const base = getBasePath();
         const safe = (href || '').trim();
-        if (!safe) return base || '/';
-        return base ? (base + (safe.startsWith('/') ? safe : '/' + safe)) : (safe.startsWith('/') ? safe : '/' + safe);
+        if (!safe) return applyStickyLocaleToPathname(base || '/');
+        const raw = base ? (base + (safe.startsWith('/') ? safe : '/' + safe)) : (safe.startsWith('/') ? safe : '/' + safe);
+        return applyStickyLocaleToPathname(raw);
     }
 }
 
+// Prerendered MPA: same-origin navigations use full page loads; rewrite targets so locale prefix sticks.
+function installMpaStickyLocaleLinks() {
+    document.addEventListener('click', (event) => {
+        if (event.defaultPrevented) return;
+        if (event.button !== 0) return;
+        if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+
+        const link = event.target.closest('a');
+        if (!link || link.closest('[data-manifest-skip-locale-sticky]')) return;
+        if (link.hasAttribute('download')) return;
+
+        const hrefAttr = link.getAttribute('href');
+        if (!hrefAttr || hrefAttr.startsWith('mailto:') || hrefAttr.startsWith('tel:') || hrefAttr.startsWith('javascript:')) return;
+        if (hrefAttr.startsWith('#')) return;
+
+        let url;
+        try {
+            url = new URL(hrefAttr, window.location.href);
+        } catch {
+            return;
+        }
+        if (url.origin !== window.location.origin) return;
+
+        const path = url.pathname.replace(/\/$/, '') || '/';
+        const adjusted = applyStickyLocaleToPathname(path);
+        if (adjusted === path) return;
+
+        event.preventDefault();
+        url.pathname = adjusted;
+
+        const dest = url.toString();
+        if (link.target === '_blank') {
+            const features = link.relList?.contains('noopener') || link.relList?.contains('noreferrer')
+                ? 'noopener,noreferrer'
+                : undefined;
+            window.open(dest, '_blank', features);
+        } else {
+            window.location.assign(dest);
+        }
+    }, true);
+}
+
 // Intercept link clicks to prevent page reloads
 function interceptLinkClicks() {
     // Use capture phase to intercept before other handlers
@@ -356,20 +571,20 @@ function interceptLinkClicks() {
 
 // Initialize navigation
 function initializeNavigation() {
-    // Set initial route (logical path for matching)
     currentRoute = pathnameToLogical(window.location.pathname);
+    normalizeRedundantLocalePrefixInUrl();
 
-    // In prerendered/static output, use default browser navigation (no interception)
+    // In prerendered/static output, use default browser navigation (no SPA interception)
     if (!isPrerenderedStaticBuild()) {
-        // Intercept link clicks
         interceptLinkClicks();
 
-        // Listen for popstate events (browser back/forward)
         window.addEventListener('popstate', () => {
             if (!isInternalNavigation) {
                 handleRouteChange();
             }
         });
+    } else {
+        installMpaStickyLocaleLinks();
     }
 
     // Handle initial route

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mnfst",
-    "version": "0.5.41",
+    "version": "0.5.43",
     "private": false,
     "workspaces": [
         "templates/starter",