mnfst 0.5.31 → 0.5.33

package/dist/manifest.js

@@ -117,10 +117,13 @@
 		return new Promise((resolve, reject) => {
 			const url = getPluginUrl(pluginName, version);
 
-			// Check if already loaded
+			// Skip if script with same src already in DOM (e.g. prerendered HTML or second loader run)
 			const existing = document.querySelector(`script[src="${url}"]`);
-			if (existing && existing.complete) {
-				return resolve();
+			if (existing) {
+				if (existing.complete) return resolve();
+				existing.addEventListener('load', () => resolve());
+				existing.addEventListener('error', () => reject(new Error(`Failed to load ${pluginName} from ${url}`)));
+				return;
 			}
 
 			const script = document.createElement('script');
@@ -297,6 +300,11 @@
 	detectAppwriteFromManifest();
 
 	if (config && config.plugins.length > 0) {
+		if (window.__manifestLoaderStarted) {
+			return;
+		}
+		window.__manifestLoaderStarted = true;
+
 		const MANIFEST_DEPENDENT_PLUGINS = [
 			'data', 'localization', 'components',
 			'appwrite-auth', 'appwrite-data', 'appwrite-presence'

package/dist/manifest.router.js

@@ -169,7 +169,12 @@ function getBasePath() {
 
 function pathnameToLogical(pathname) {
     const base = getBasePath();
-    if (!base || pathname === base || pathname === base + '/') return '/';
+    if (!base) {
+        const p = (pathname || '/').replace(/\/$/, '') || '/';
+        if (p === '/' || p === '/index.html' || p === '/index') return '/';
+        return p.startsWith('/') ? p : '/' + p;
+    }
+    if (pathname === base || pathname === base + '/') return '/';
     if (pathname.startsWith(base + '/')) {
         let logical = pathname.slice(base.length) || '/';
         if (logical === '/index.html' || logical === '/index') logical = '/';
@@ -592,6 +597,39 @@ function shouldElementBeVisible(element, normalizedPath) {
     return true;
 }
 
+// Resolve :attr and x-bind:attr whose value is $x.path so injected meta/link have real content (SPA + prerender).
+function resolveDataHeadBindings(element) {
+    const x = typeof window !== 'undefined' && window.$x;
+    if (!x) return;
+    const toResolve = [];
+    for (let i = 0; i < element.attributes.length; i++) {
+        const attr = element.attributes[i];
+        const name = attr.name;
+        let bindingAttr = null;
+        if (name.startsWith(':')) bindingAttr = name.slice(1);
+        else if (name.startsWith('x-bind:')) bindingAttr = name.slice(7);
+        if (!bindingAttr) continue;
+        const expr = (attr.value || '').trim();
+        if (!expr.startsWith('$x.')) continue;
+        const path = expr.slice(3).trim();
+        if (!path) continue;
+        toResolve.push({ bindingName: attr.name, attrName: bindingAttr, path });
+    }
+    for (const { bindingName, attrName, path } of toResolve) {
+        let value;
+        try {
+            value = path.split('.').reduce(function (obj, key) {
+                return obj != null && typeof obj === 'object' ? obj[key] : undefined;
+            }, x);
+        } catch (e) {
+            continue;
+        }
+        if (value === undefined) continue;
+        element.setAttribute(attrName, String(value));
+        element.removeAttribute(bindingName);
+    }
+}
+
 // Generate unique identifier for head content
 function generateHeadId(element) {
     const position = element.getAttribute('data-order');
@@ -627,10 +665,14 @@ function processElementHeadContent(element, normalizedPath) {
     const isVisible = shouldElementBeVisible(element, normalizedPath);
 
     if (isVisible) {
-        // Check if we've already injected this content
+        // Skip if already injected (in-memory) or already present in DOM (e.g. prerendered)
         if (injectedHeadContent.has(headId)) {
             return;
         }
+        if (document.head.querySelector(`[data-route-head="${headId}"]`)) {
+            injectedHeadContent.add(headId);
+            return;
+        }
 
         // Add new head content
         Array.from(headTemplate.content.children).forEach(child => {
@@ -641,8 +683,9 @@ function processElementHeadContent(element, normalizedPath) {
                 script.setAttribute('data-route-head', headId);
                 document.head.appendChild(script);
             } else {
-                // For other elements, clone and add
+                // For other elements, clone and add (resolve $x bindings so meta/link have real values in SPA)
                 const clonedChild = child.cloneNode(true);
+                resolveDataHeadBindings(clonedChild);
                 clonedChild.setAttribute('data-route-head', headId);
                 document.head.appendChild(clonedChild);
             }
@@ -826,6 +869,29 @@ window.ManifestRoutingHead = {
 
 // Router anchors
 
+// Parse pipeline syntax: 'scope | targets' (shared for directive and route-change handler)
+function parseAnchorsExpression(expr) {
+    if (!expr || expr.trim() === '') {
+        return { scope: '', targets: 'h1, h2, h3, h4, h5, h6' };
+    }
+    if (expr.includes('|')) {
+        const parts = expr.split('|').map(p => p.trim());
+        return {
+            scope: parts[0] || '',
+            targets: parts[1] || 'h1, h2, h3, h4, h5, h6'
+        };
+    }
+    return { scope: '', targets: expr };
+}
+
+function isVisible(el) {
+    if (!el || !el.getBoundingClientRect) return false;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) return false;
+    const style = window.getComputedStyle(el);
+    return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+}
+
 // Anchors functionality
 function initializeAnchors() {
 
@@ -834,24 +900,9 @@ function initializeAnchors() {
 
 
         try {
-            // Parse pipeline syntax: 'scope | targets'
-            const parseExpression = (expr) => {
-                if (!expr || expr.trim() === '') {
-                    return { scope: '', targets: 'h1, h2, h3, h4, h5, h6' };
-                }
+            const parseExpression = parseAnchorsExpression;
 
-                if (expr.includes('|')) {
-                    const parts = expr.split('|').map(p => p.trim());
-                    return {
-                        scope: parts[0] || '',
-                        targets: parts[1] || 'h1, h2, h3, h4, h5, h6'
-                    };
-                } else {
-                    return { scope: '', targets: expr };
-                }
-            };
-
-            // Extract anchors function
+            // Extract anchors function (only from visible scope containers to avoid prior-route content)
             const extractAnchors = (expr) => {
                 const parsed = parseExpression(expr);
 
@@ -859,7 +910,8 @@ function initializeAnchors() {
                 if (!parsed.scope) {
                     containers = [document.body];
                 } else {
-                    containers = Array.from(document.querySelectorAll(parsed.scope));
+                    const all = Array.from(document.querySelectorAll(parsed.scope));
+                    containers = all.filter(isVisible);
                 }
 
                 let elements = [];
@@ -1122,21 +1174,44 @@ document.addEventListener('alpine:init', () => {
     }
 });
 
-// Refresh anchors when route changes
+// Refresh anchors when route changes — wait for scope DOM to update (e.g. x-markdown) to avoid showing prior page's anchors
 window.addEventListener('manifest:route-change', () => {
-    // Immediately clear the store to hide the h5 element
     Alpine.store('anchors', { count: 0 });
 
-    // Wait longer for content to load after route change
-    setTimeout(() => {
-        const anchorElements = document.querySelectorAll('[x-anchors]');
-        anchorElements.forEach(el => {
-            const expression = el.getAttribute('x-anchors');
-            if (expression && el._x_anchorRefresh) {
-                el._x_anchorRefresh();
-            }
+    const runWhenScopeReady = (el) => {
+        const expression = el.getAttribute('x-anchors');
+        if (!expression || !el._x_anchorRefresh) return;
+        const { scope } = parseAnchorsExpression(expression);
+        if (!scope) {
+            setTimeout(() => el._x_anchorRefresh(), 400);
+            return;
+        }
+        const containers = Array.from(document.querySelectorAll(scope)).filter(isVisible);
+        const container = containers[0];
+        if (!container) {
+            el._x_anchorRefresh();
+            return;
+        }
+        let done = false;
+        const finish = () => {
+            if (done) return;
+            done = true;
+            observer?.disconnect();
+            clearTimeout(fallback);
+            el._x_anchorRefresh();
+        };
+        let t = 0;
+        const observer = new MutationObserver(() => {
+            clearTimeout(t);
+            t = setTimeout(finish, 50);
         });
-    }, 200);
+        observer.observe(container, { childList: true, subtree: true });
+        const fallback = setTimeout(finish, 800);
+    };
+
+    requestAnimationFrame(() => {
+        document.querySelectorAll('[x-anchors]').forEach(runWhenScopeReady);
+    });
 });
 
 // Refresh anchors when hash changes (for active state updates)

package/package.json

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