mnfst 0.5.40 → 0.5.42

package/dist/manifest.router.js

@@ -173,6 +173,87 @@ 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);
+}
+
+// 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;
+    }
+    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 +333,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
@@ -359,23 +492,27 @@ function initializeNavigation() {
     // Set initial route (logical path for matching)
     currentRoute = pathnameToLogical(window.location.pathname);
 
-    // 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
     handleRouteChange();
 }
 
+// Match the browser URL as soon as this module loads. Later chunks in the same bundle (e.g. router magic)
+// may initialize before DOMContentLoaded; getCurrentRoute() must not stay at '/' or $route breaks article pages.
+currentRoute = pathnameToLogical(window.location.pathname);
+
 // Run immediately if DOM is ready, otherwise wait
 if (document.readyState === 'loading') {
     document.addEventListener('DOMContentLoaded', initializeNavigation);
@@ -1292,6 +1429,8 @@ function initializeRouterMagic() {
         console.error('[Manifest Router Magic] Alpine is not available');
         return;
     }
+    if (window.__manifestRouterMagicInitialized) return;
+    window.__manifestRouterMagicInitialized = true;
 
     // Create a reactive object for route data (use logical path when app is in a subpath)
     const route = Alpine.reactive({
@@ -1336,6 +1475,9 @@ function initializeRouterMagic() {
     window.addEventListener('manifest:route-change', updateRoute);
     window.addEventListener('popstate', updateRoute);
 
+    // Align with navigation + locale stripping; initial reactive value can be wrong if magic ran before DOMContentLoaded.
+    updateRoute();
+
     // Register $route magic property - return the route string directly
     Alpine.magic('route', () => route.current);
 }

package/package.json

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