mnfst 0.5.45 → 0.5.47

package/dist/manifest.data.js

@@ -207,6 +207,10 @@ const rawDataStore = new Map();
 let isInitializing = false;
 let initializationComplete = false;
 
+// Render-ready: debounced timer used by checkAndDispatchRenderReady
+let _renderReadyTimer = null;
+const RENDER_READY_QUIET_MS = 150; // ms of quiet (no loading) before firing
+
 // Deep seal an object to prevent Alpine from making it reactive
 // This prevents double-proxying which causes recursion errors
 function deepSeal(obj) {
@@ -301,6 +305,12 @@ function updateStore(dataSourceName, data, options = {}) {
 
     Alpine.store('data', updatedStore);
 
+    // When a source finishes loading (success or error), check if everything is settled.
+    // This is the primary trigger for manifest:render-ready.
+    if (!newState.loading) {
+        checkAndDispatchRenderReady();
+    }
+
     // Attach methods to array if it's an array (for new architecture)
     // This ensures methods are available on the new array reference
     if (Array.isArray(reactiveData) && window.ManifestDataProxies?.attachArrayMethods) {
@@ -766,6 +776,49 @@ function setupTeamChangeListener() {
     }
 }
 
+// Dispatch manifest:render-ready when all tracked data sources have settled.
+// Uses a debounce so rapid sequential source completions coalesce into one event.
+// The render script listens for this event instead of polling internal store state.
+function checkAndDispatchRenderReady() {
+    if (_renderReadyTimer) {
+        clearTimeout(_renderReadyTimer);
+    }
+    _renderReadyTimer = setTimeout(() => {
+        _renderReadyTimer = null;
+        try {
+            if (typeof window === 'undefined' || typeof Alpine === 'undefined') return;
+            const store = Alpine.store('data');
+            if (!store) return;
+
+            // Don't fire while a locale change is still in progress
+            if (store._localeChanging) return;
+
+            // Don't fire if any source state still shows loading
+            for (const key of Object.keys(store)) {
+                if (key.startsWith('_') && key.endsWith('_state')) {
+                    if (store[key]?.loading) return;
+                }
+            }
+
+            // Don't fire if any fetch promises are still in flight
+            if (loadingPromises.size > 0) return;
+
+            // All settled — dispatch the authoritative prerender signal
+            const locale =
+                (typeof document !== 'undefined' && document.documentElement.lang) ||
+                Alpine.store('locale')?.current ||
+                'en';
+            const sources = Object.keys(store).filter(k => !k.startsWith('_') && k !== 'all');
+
+            window.dispatchEvent(new CustomEvent('manifest:render-ready', {
+                detail: { locale, sources }
+            }));
+        } catch {
+            // Silently fail — the render script has its own timeout fallback
+        }
+    }, RENDER_READY_QUIET_MS);
+}
+
 // Listen for locale changes to reload data
 function setupLocaleChangeListener() {
     window.addEventListener('localechange', async (event) => {
@@ -900,6 +953,10 @@ function setupLocaleChangeListener() {
                 );
             }
 
+            // All localized sources have reloaded — check if everything is settled.
+            // This fires manifest:render-ready after a locale change completes end-to-end.
+            checkAndDispatchRenderReady();
+
         } catch (error) {
             console.error('[Manifest Data] Error handling locale change:', error);
             // Fallback to full reload if something goes wrong
@@ -1125,6 +1182,7 @@ window.ManifestDataStore = {
     initializeStore,
     setupLocaleChangeListener,
     setupTeamChangeListener,
+    checkAndDispatchRenderReady,
     // Operation-specific loading state helpers
     setCreatingEntry,
     clearCreatingEntry,
@@ -11732,6 +11790,9 @@ async function initializeDataSourcesPlugin() {
             if (typeof window !== 'undefined') {
                 window.dispatchEvent(new CustomEvent('manifest:data-ready'));
             }
+            // Check if all sources are settled and dispatch manifest:render-ready if so.
+            // Covers the initial-load path (no data sources, or only content pre-loaded).
+            window.ManifestDataStore?.checkAndDispatchRenderReady?.();
         };
         if (typeof Alpine !== 'undefined' && Alpine.nextTick) {
             Alpine.nextTick(flushThenDispatch);

package/dist/manifest.localization.js

@@ -97,6 +97,38 @@ function initializeLocalizationPlugin() {
         const currentUrl = new URL(window.location.href);
         const pathParts = currentUrl.pathname.split('/').filter(Boolean);
         const hasLanguageInUrl = pathParts[0] && availableLocales.includes(pathParts[0]);
+
+        // Determine path segments without any current locale prefix, for exclude-pattern checking.
+        const pathWithoutLocale = hasLanguageInUrl ? pathParts.slice(1) : pathParts;
+
+        // If the current path matches a manifest:locale-route-exclude pattern, do NOT add or
+        // change the locale prefix — this prevents an infinite redirect loop on prerendered
+        // builds where normalizeRedundantLocalePrefixInUrl() strips the locale from the URL
+        // but the localization init would otherwise re-add it via window.location.assign().
+        const routeExcludeMeta = document.querySelector('meta[name="manifest:locale-route-exclude"]');
+        if (routeExcludeMeta) {
+            try {
+                const rawContent = (routeExcludeMeta.getAttribute('content') || '').replace(/"/g, '"');
+                const patterns = JSON.parse(rawContent);
+                if (Array.isArray(patterns) && patterns.length > 0) {
+                    const lower = pathWithoutLocale.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) {
+                            // Path is locale-excluded — return URL unchanged so no navigation is triggered
+                            return currentUrl.toString();
+                        }
+                    }
+                }
+            } catch { /* ignore JSON parse errors */ }
+        }
+
         if (hasLanguageInUrl) pathParts[0] = newLang;
         else pathParts.unshift(newLang);
         currentUrl.pathname = '/' + pathParts.join('/');

package/package.json

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