@absolutejs/absolute 0.19.0-beta.130 → 0.19.0-beta.131

package/dist/dev/client/headPatch.ts

@@ -0,0 +1,232 @@
+/* Head element patching for HMR updates (title, meta, favicon, etc.) */
+
+const getLinkElementKey = (elem: Element) => {
+	const rel = (elem.getAttribute('rel') || '').toLowerCase();
+	if (rel === 'icon' || rel === 'shortcut icon' || rel === 'apple-touch-icon')
+		return `link:icon:${rel}`;
+	if (rel === 'stylesheet') return null;
+	if (rel === 'preconnect')
+		return `link:preconnect:${elem.getAttribute('href') || ''}`;
+	if (rel === 'preload')
+		return `link:preload:${elem.getAttribute('href') || ''}`;
+	if (rel === 'canonical') return 'link:canonical';
+	if (rel === 'dns-prefetch')
+		return `link:dns-prefetch:${elem.getAttribute('href') || ''}`;
+
+	return null;
+};
+
+const getHeadElementKey = (elem: Element) => {
+	const tag = elem.tagName.toLowerCase();
+
+	if (tag === 'title') return 'title';
+	if (tag === 'meta' && elem.hasAttribute('charset')) return 'meta:charset';
+	if (tag === 'meta' && elem.hasAttribute('name'))
+		return `meta:name:${elem.getAttribute('name')}`;
+	if (tag === 'meta' && elem.hasAttribute('property'))
+		return `meta:property:${elem.getAttribute('property')}`;
+	if (tag === 'meta' && elem.hasAttribute('http-equiv'))
+		return `meta:http-equiv:${elem.getAttribute('http-equiv')}`;
+
+	if (tag === 'link') return getLinkElementKey(elem);
+
+	if (tag === 'script' && elem.hasAttribute('data-hmr-id'))
+		return `script:hmr:${elem.getAttribute('data-hmr-id')}`;
+	if (tag === 'script') return null;
+	if (tag === 'base') return 'base';
+
+	return null;
+};
+
+const shouldPreserveElement = (elem: Element) => {
+	if (elem.hasAttribute('data-hmr-import-map')) return true;
+	if (elem.hasAttribute('data-hmr-client')) return true;
+	if (elem.hasAttribute('data-react-refresh-setup')) return true;
+
+	const attrs = Array.from(elem.attributes);
+	for (let idx = 0; idx < attrs.length; idx++) {
+		if (attrs[idx]?.name.startsWith('data-hmr-')) return true;
+	}
+
+	if (elem.tagName === 'SCRIPT') {
+		const src = elem.getAttribute('src') || '';
+		if (src.includes('htmx.min.js') || src.includes('htmx.js')) return true;
+	}
+
+	return false;
+};
+
+const updateTitleElement = (oldEl: Element, newEl: Element) => {
+	const newTitle = newEl.textContent || '';
+	if (oldEl.textContent === newTitle) return;
+	oldEl.textContent = newTitle;
+	document.title = newTitle;
+};
+
+const updateMetaElement = (oldEl: Element, newEl: Element) => {
+	const newContent = newEl.getAttribute('content');
+	const oldContent = oldEl.getAttribute('content');
+	if (oldContent !== newContent && newContent !== null) {
+		oldEl.setAttribute('content', newContent);
+	}
+	if (!newEl.hasAttribute('charset')) return;
+	const newCharset = newEl.getAttribute('charset');
+	if (oldEl.getAttribute('charset') !== newCharset && newCharset !== null) {
+		oldEl.setAttribute('charset', newCharset);
+	}
+};
+
+const updateFaviconHref = (
+	oldEl: Element,
+	newHref: string,
+	oldHref: string
+) => {
+	const [oldBase] = oldHref.split('?');
+	const [newBase] = newHref.split('?');
+	if (oldBase === newBase) return;
+	const cacheBustedHref = `${
+		newHref + (newHref.includes('?') ? '&' : '?')
+	}t=${Date.now()}`;
+	oldEl.setAttribute('href', cacheBustedHref);
+};
+
+const updateLinkElement = (oldEl: Element, newEl: Element) => {
+	const rel = (oldEl.getAttribute('rel') || '').toLowerCase();
+	const newHref = newEl.getAttribute('href');
+	const oldHref = oldEl.getAttribute('href');
+
+	const isIcon =
+		rel === 'icon' || rel === 'shortcut icon' || rel === 'apple-touch-icon';
+
+	if (isIcon && newHref && oldHref) {
+		updateFaviconHref(oldEl, newHref, oldHref);
+	} else if (!isIcon && newHref && oldHref !== newHref) {
+		oldEl.setAttribute('href', newHref);
+	}
+
+	const attrsToCheck = ['type', 'sizes', 'crossorigin', 'as', 'media'];
+	attrsToCheck.forEach((attr) => {
+		const newVal = newEl.getAttribute(attr);
+		const oldVal = oldEl.getAttribute(attr);
+		if (newVal !== null && oldVal !== newVal) {
+			oldEl.setAttribute(attr, newVal);
+		} else if (newVal === null && oldVal !== null) {
+			oldEl.removeAttribute(attr);
+		}
+	});
+};
+
+const updateBaseElement = (oldEl: Element, newEl: Element) => {
+	const newHref = newEl.getAttribute('href');
+	const newTarget = newEl.getAttribute('target');
+	if (newHref && oldEl.getAttribute('href') !== newHref) {
+		oldEl.setAttribute('href', newHref);
+	}
+	if (newTarget && oldEl.getAttribute('target') !== newTarget) {
+		oldEl.setAttribute('target', newTarget);
+	}
+};
+
+const updateHeadElement = (oldEl: Element, newEl: Element) => {
+	const tag = oldEl.tagName.toLowerCase();
+
+	if (tag === 'title') {
+		updateTitleElement(oldEl, newEl);
+
+		return;
+	}
+
+	if (tag === 'meta') {
+		updateMetaElement(oldEl, newEl);
+
+		return;
+	}
+
+	if (tag === 'link') {
+		updateLinkElement(oldEl, newEl);
+
+		return;
+	}
+
+	if (tag === 'base') {
+		updateBaseElement(oldEl, newEl);
+	}
+};
+
+const addHeadElement = (newEl: Element) => {
+	const clone = document.createElement(newEl.tagName.toLowerCase());
+	for (const attr of Array.from(newEl.attributes)) {
+		clone.setAttribute(attr.name, attr.value);
+	}
+	clone.textContent = newEl.textContent;
+	clone.setAttribute('data-hmr-source', 'patched');
+
+	const tag = newEl.tagName.toLowerCase();
+	const { head } = document;
+	let insertBefore: Node | null = null;
+
+	if (tag === 'title') {
+		insertBefore = head.firstChild;
+	} else if (tag === 'meta') {
+		const firstLink = head.querySelector('link');
+		const firstScript = head.querySelector('script');
+		insertBefore = firstLink || firstScript;
+	} else if (tag === 'link') {
+		const firstScript = head.querySelector('script');
+		insertBefore = firstScript;
+	}
+
+	if (insertBefore) {
+		head.insertBefore(clone, insertBefore);
+	} else {
+		head.appendChild(clone);
+	}
+};
+
+const removeStaleElement = (existingEl: Element) => {
+	if (shouldPreserveElement(existingEl)) return;
+	const tag = existingEl.tagName.toLowerCase();
+	const rel = existingEl.getAttribute('rel') || '';
+	if (tag === 'link' && rel === 'stylesheet') return;
+	existingEl.remove();
+};
+
+export const patchHeadInPlace = (newHeadHTML: string) => {
+	if (!newHeadHTML) return;
+
+	const tempDiv = document.createElement('div');
+	tempDiv.innerHTML = newHeadHTML;
+
+	const existingMap = new Map<string, Element>();
+	const newMap = new Map<string, Element>();
+
+	Array.from(document.head.children).forEach((elem) => {
+		if (shouldPreserveElement(elem)) return;
+		const key = getHeadElementKey(elem);
+		if (key) {
+			existingMap.set(key, elem);
+		}
+	});
+
+	Array.from(tempDiv.children).forEach((elem) => {
+		const key = getHeadElementKey(elem);
+		if (key) {
+			newMap.set(key, elem);
+		}
+	});
+
+	newMap.forEach((newEl, key) => {
+		const existingEl = existingMap.get(key);
+		if (existingEl) {
+			updateHeadElement(existingEl, newEl);
+		} else {
+			addHeadElement(newEl);
+		}
+	});
+
+	existingMap.forEach((existingEl, key) => {
+		if (!newMap.has(key)) {
+			removeStaleElement(existingEl);
+		}
+	});
+};

package/dist/dev/client/hmrClient.ts

@@ -0,0 +1,250 @@
+/* AbsoluteJS HMR Client - Entry point
+   Initializes WebSocket connection, dispatches messages to framework handlers */
+
+import { hmrState } from '../../../types/client';
+import {
+	HMR_UPDATE_TIMEOUT_MS,
+	MAX_RECONNECT_ATTEMPTS,
+	PING_INTERVAL_MS,
+	RECONNECT_INITIAL_DELAY_MS,
+	RECONNECT_POLL_INTERVAL_MS,
+	WEBSOCKET_NORMAL_CLOSURE
+} from './constants';
+import { detectCurrentFramework } from './frameworkDetect';
+import { hideErrorOverlay, showErrorOverlay } from './errorOverlay';
+import { handleAngularUpdate } from './handlers/angular';
+import { handleReactUpdate } from './handlers/react';
+import { handleHTMLUpdate, handleScriptUpdate } from './handlers/html';
+import { handleHTMXUpdate } from './handlers/htmx';
+import { handleSvelteUpdate } from './handlers/svelte';
+import { handleVueUpdate } from './handlers/vue';
+import { reloadCSSStylesheets } from './cssUtils';
+import {
+	handleFullReload,
+	handleManifest,
+	handleModuleUpdate,
+	handleRebuildComplete,
+	handleRebuildError
+} from './handlers/rebuild';
+
+// Initialize HMR globals
+if (typeof window !== 'undefined') {
+	if (!window.__HMR_MANIFEST__) {
+		window.__HMR_MANIFEST__ = {};
+	}
+	if (!window.__HMR_MODULE_UPDATES__) {
+		window.__HMR_MODULE_UPDATES__ = [];
+	}
+	if (!window.__HMR_MODULE_VERSIONS__) {
+		window.__HMR_MODULE_VERSIONS__ = {};
+	}
+	if (!window.__HMR_SERVER_VERSIONS__) {
+		window.__HMR_SERVER_VERSIONS__ = {};
+	}
+}
+
+// Catch uncaught runtime errors and show the error overlay
+window.addEventListener('error', (evt) => {
+	if (!evt.error) return;
+	showErrorOverlay({
+		framework: detectCurrentFramework() || undefined,
+		kind: 'runtime',
+		message:
+			evt.error instanceof Error
+				? evt.error.stack || evt.error.message
+				: String(evt.error)
+	});
+});
+
+window.addEventListener('unhandledrejection', (evt) => {
+	if (!evt.reason) return;
+	showErrorOverlay({
+		framework: detectCurrentFramework() || undefined,
+		kind: 'runtime',
+		message:
+			evt.reason instanceof Error
+				? evt.reason.stack || evt.reason.message
+				: String(evt.reason)
+	});
+});
+
+const hmrUpdateTypes = new Set([
+	'angular-update',
+	'react-update',
+	'html-update',
+	'htmx-update',
+	'vue-update',
+	'svelte-update',
+	'style-update',
+	'module-update',
+	'rebuild-start'
+]);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const handleHMRMessage = (message: any) => {
+	if (hmrUpdateTypes.has(message.type)) {
+		hmrState.isHMRUpdating = true;
+		setTimeout(() => {
+			hmrState.isHMRUpdating = false;
+		}, HMR_UPDATE_TIMEOUT_MS);
+	}
+
+	switch (message.type) {
+		case 'manifest':
+			handleManifest(message);
+			break;
+		case 'rebuild-start':
+			break;
+		case 'rebuild-complete':
+			handleRebuildComplete(message);
+			break;
+		case 'framework-update':
+			break;
+		case 'module-update':
+			hideErrorOverlay();
+			handleModuleUpdate(message);
+			break;
+		case 'react-update':
+			handleReactUpdate(message);
+			break;
+		case 'script-update':
+			hideErrorOverlay();
+			handleScriptUpdate(message);
+			break;
+		case 'html-update':
+			hideErrorOverlay();
+			handleHTMLUpdate(message);
+			break;
+		case 'htmx-update':
+			hideErrorOverlay();
+			handleHTMXUpdate(message);
+			break;
+		case 'svelte-update':
+			hideErrorOverlay();
+			handleSvelteUpdate(message);
+			break;
+		case 'vue-update':
+			hideErrorOverlay();
+			handleVueUpdate(message);
+			break;
+		case 'angular-update':
+			hideErrorOverlay();
+			handleAngularUpdate(message);
+			break;
+		case 'rebuild-error':
+			handleRebuildError(message);
+			break;
+		case 'full-reload':
+			handleFullReload();
+			break;
+		case 'pong':
+			break;
+		case 'style-update':
+			reloadCSSStylesheets(message.data.manifest);
+			break;
+		default:
+			break;
+	}
+};
+
+// Prevent multiple WebSocket connections
+if (!(window.__HMR_WS__ && window.__HMR_WS__.readyState === WebSocket.OPEN)) {
+	// Determine WebSocket URL
+	const wsHost = location.hostname;
+	const wsPort =
+		location.port || (location.protocol === 'https:' ? '443' : '80');
+	const wsProtocol = location.protocol === 'https:' ? 'wss' : 'ws';
+	const wsUrl = `${wsProtocol}://${wsHost}:${wsPort}/hmr`;
+
+	const wsc = new WebSocket(wsUrl);
+	window.__HMR_WS__ = wsc;
+
+	wsc.onopen = function () {
+		hmrState.isConnected = true;
+		sessionStorage.setItem('__HMR_CONNECTED__', 'true');
+
+		const currentFramework = detectCurrentFramework();
+		wsc.send(
+			JSON.stringify({
+				framework: currentFramework,
+				type: 'ready'
+			})
+		);
+
+		if (hmrState.reconnectTimeout) {
+			clearTimeout(hmrState.reconnectTimeout);
+			hmrState.reconnectTimeout = null;
+		}
+
+		hmrState.pingInterval = setInterval(() => {
+			if (wsc.readyState === WebSocket.OPEN && hmrState.isConnected) {
+				wsc.send(JSON.stringify({ type: 'ping' }));
+			}
+		}, PING_INTERVAL_MS);
+	};
+
+	wsc.onmessage = function (event: MessageEvent) {
+		let message;
+		try {
+			message = JSON.parse(event.data);
+		} catch {
+			return;
+		}
+
+		handleHMRMessage(message);
+	};
+
+	wsc.onclose = function (event: CloseEvent) {
+		hmrState.isConnected = false;
+
+		if (hmrState.pingInterval) {
+			clearInterval(hmrState.pingInterval);
+			hmrState.pingInterval = null;
+		}
+
+		if (event.code !== WEBSOCKET_NORMAL_CLOSURE) {
+			let attempts = 0;
+			hmrState.reconnectTimeout = setTimeout(function pollServer() {
+				attempts++;
+				if (attempts > MAX_RECONNECT_ATTEMPTS) return;
+
+				fetch('/hmr-status', { cache: 'no-store' })
+					.then((res) => {
+						if (res.ok) {
+							window.location.reload();
+						} else {
+							hmrState.reconnectTimeout = setTimeout(
+								pollServer,
+								RECONNECT_POLL_INTERVAL_MS
+							);
+						}
+
+						return undefined;
+					})
+					.catch(() => {
+						hmrState.reconnectTimeout = setTimeout(
+							pollServer,
+							RECONNECT_POLL_INTERVAL_MS
+						);
+					});
+			}, RECONNECT_INITIAL_DELAY_MS);
+		}
+	};
+
+	wsc.onerror = function () {
+		hmrState.isConnected = false;
+	};
+
+	window.addEventListener('beforeunload', () => {
+		if (hmrState.isHMRUpdating) {
+			if (hmrState.pingInterval) clearInterval(hmrState.pingInterval);
+			if (hmrState.reconnectTimeout)
+				clearTimeout(hmrState.reconnectTimeout);
+
+			return;
+		}
+
+		if (hmrState.pingInterval) clearInterval(hmrState.pingInterval);
+		if (hmrState.reconnectTimeout) clearTimeout(hmrState.reconnectTimeout);
+	});
+}

package/dist/dev/client/moduleVersions.ts

@@ -0,0 +1,61 @@
+/* Module version validation and sync */
+
+export const checkModuleVersions = (
+	serverVersions: Record<string, number> | undefined,
+	clientVersions: Record<string, number> | undefined
+) => {
+	if (!serverVersions || !clientVersions) {
+		return { needsSync: false, stale: [] };
+	}
+
+	const stale = Object.entries(serverVersions)
+		.filter(([modulePath, serverVersion]) => {
+			const clientVersion = clientVersions[modulePath];
+
+			return clientVersion === undefined || clientVersion < serverVersion;
+		})
+		.map(([modulePath]) => modulePath);
+
+	return { needsSync: stale.length > 0, stale };
+};
+
+const resolveManifestPath = (
+	modulePath: string,
+	manifest: Record<string, string> | undefined
+) => {
+	if (!manifest) {
+		return modulePath;
+	}
+	for (const key of Object.keys(manifest)) {
+		const path = manifest[key] ?? modulePath;
+		if (path === modulePath || path.includes(modulePath)) {
+			return path;
+		}
+	}
+
+	return modulePath;
+};
+
+export const prefetchModules = (
+	modulePaths: string[],
+	manifest: Record<string, string> | undefined
+) => {
+	const prefetchPromises: Promise<unknown>[] = [];
+
+	for (const modulePath of modulePaths) {
+		const manifestPath = resolveManifestPath(modulePath, manifest);
+
+		const cacheBuster = `?t=${Date.now()}`;
+		const fullPath = manifestPath.startsWith('/')
+			? manifestPath + cacheBuster
+			: `/${manifestPath}${cacheBuster}`;
+
+		prefetchPromises.push(
+			import(fullPath).catch(() => {
+				/* ignore */
+			})
+		);
+	}
+
+	return Promise.all(prefetchPromises);
+};

package/dist/dev/client/reactRefreshSetup.ts

@@ -0,0 +1,34 @@
+/* React Refresh runtime setup — must be imported before any component modules.
+   Bun's reactFastRefresh flag injects $RefreshSig$/$RefreshReg$ calls into
+   component code. This module ensures those globals exist before components
+   initialize.
+
+   IMPORTANT: This module is idempotent. On HMR re-import the existing runtime
+   is preserved so new component registrations feed into the SAME RefreshRuntime
+   instance that owns the current React tree. */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore — react-refresh has no type declarations
+import RefreshRuntime from 'react-refresh/runtime';
+
+if (!window.$RefreshRuntime$) {
+	RefreshRuntime.injectIntoGlobalHook(window);
+	window.$RefreshRuntime$ = RefreshRuntime;
+	window.$RefreshReg$ = (type: unknown, id: string) =>
+		RefreshRuntime.register(type, id);
+	window.$RefreshSig$ = () =>
+		RefreshRuntime.createSignatureFunctionForTransform();
+
+	// Replay buffered registrations from the bootstrap script.
+	// The SSR HTML injects a buffering $RefreshReg$ that captures
+	// registrations before the runtime is ready.
+	const buffer = (window as unknown as Record<string, unknown>)
+		.__REFRESH_BUFFER__ as Array<[unknown, string]> | undefined;
+	if (buffer) {
+		for (const [type, id] of buffer) {
+			RefreshRuntime.register(type, id);
+		}
+		(window as unknown as Record<string, unknown>).__REFRESH_BUFFER__ =
+			undefined;
+	}
+}

package/dist/index.js

@@ -9944,7 +9944,7 @@ ${lanes.join(`
             return process.memoryUsage().heapUsed;
           },
           getFileSize(path) {
-            const stat2 = statSync2(path);
+            const stat2 = statSync(path);
             if (stat2 == null ? undefined : stat2.isFile()) {
               return stat2.size;
             }
@@ -9987,7 +9987,7 @@ ${lanes.join(`
           }
         };
         return nodeSystem;
-        function statSync2(path) {
+        function statSync(path) {
           try {
             return _fs.statSync(path, statSyncOptions);
           } catch {
@@ -10039,7 +10039,7 @@ ${lanes.join(`
             activeSession.post("Profiler.stop", (err, { profile }) => {
               var _a;
               if (!err) {
-                if ((_a = statSync2(profilePath)) == null ? undefined : _a.isDirectory()) {
+                if ((_a = statSync(profilePath)) == null ? undefined : _a.isDirectory()) {
                   profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                 }
                 try {
@@ -10148,7 +10148,7 @@ ${lanes.join(`
               let stat2;
               if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                 const name = combinePaths(path, entry);
-                stat2 = statSync2(name);
+                stat2 = statSync(name);
                 if (!stat2) {
                   continue;
                 }
@@ -10172,7 +10172,7 @@ ${lanes.join(`
           return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
         }
         function fileSystemEntryExists(path, entryKind) {
-          const stat2 = statSync2(path);
+          const stat2 = statSync(path);
           if (!stat2) {
             return false;
           }
@@ -10206,7 +10206,7 @@ ${lanes.join(`
         }
         function getModifiedTime3(path) {
           var _a;
-          return (_a = statSync2(path)) == null ? undefined : _a.mtime;
+          return (_a = statSync(path)) == null ? undefined : _a.mtime;
         }
         function setModifiedTime(path, time) {
           try {
@@ -171247,6 +171247,7 @@ import {
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync5,
   rmSync,
+  statSync,
   writeFileSync as writeFileSync3
 } from "fs";
 import { basename as basename5, dirname as dirname6, join as join13, relative as relative7, resolve as resolve11 } from "path";
@@ -205722,5 +205723,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=7D007FE1D4D246E364756E2164756E21
+//# debugId=A4B0380C43D3114264756E2164756E21
 //# sourceMappingURL=index.js.map