slhx agent
1220 lines
45 KiB
JavaScript
1220 lines
45 KiB
JavaScript
(() => {
|
|
const ROOT = "data-hemx-root";
|
|
const HID = "data-hid";
|
|
const SID = "data-sid";
|
|
const runtimeAbiVersion = 1;
|
|
const FINGERPRINT = "data-hemx-fp";
|
|
const STATE = "data-hemx-st";
|
|
const pending = new WeakMap();
|
|
const queues = new WeakMap();
|
|
const timers = new WeakMap();
|
|
const everyTimers = new WeakMap();
|
|
const revealObservers = new WeakMap();
|
|
const revealed = new WeakSet();
|
|
const pendingClassStates = new WeakMap();
|
|
const indicatorStates = new WeakMap();
|
|
const busyStates = new WeakMap();
|
|
const disabledStates = new WeakMap();
|
|
const sseSources = new WeakMap();
|
|
const atomStores = new WeakMap();
|
|
const dragKeys = new WeakMap();
|
|
let currentOperationId = null;
|
|
const clientHandlers = new Map();
|
|
const clientRuns = new WeakMap();
|
|
const activeRequests = new Set();
|
|
const REQUEST_TIMEOUT_MS = 10_000;
|
|
|
|
window.addEventListener("pagehide", () => {
|
|
for (const controller of activeRequests) {
|
|
controller.abort(new DOMException("hemx request cancelled because page is hidden", "AbortError"));
|
|
}
|
|
});
|
|
|
|
function roots() {
|
|
const found = [];
|
|
forEachElement(document, (el) => { if (el.hasAttribute(ROOT)) found.push(el); });
|
|
return found;
|
|
}
|
|
|
|
function rootOf(node) {
|
|
for (let el = node; el && el !== document; el = el.parentElement) {
|
|
if (el.hasAttribute && el.hasAttribute(ROOT)) return el;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function formOwner(el) {
|
|
if (!el || el.tagName === "FORM") return el;
|
|
if (el.getAttribute && el.getAttribute("form")) return elementById(rootOf(el) || document, el.getAttribute("form"));
|
|
return closestInRoot(el, rootOf(el) || document, (node) => node.tagName === "FORM");
|
|
}
|
|
|
|
function elementById(scope, id) {
|
|
if (attrEquals(scope, "id", id)) return scope;
|
|
return firstElement(scope, (el) => attrEquals(el, "id", id));
|
|
}
|
|
|
|
function formHandleId(form) {
|
|
if (!form) return null;
|
|
const holder = form.hasAttribute(HID) ? form : firstElement(form, (el) => el.hasAttribute(HID));
|
|
const raw = holder && holder.getAttribute(HID);
|
|
return raw && /^\d+$/.test(raw) ? raw : null;
|
|
}
|
|
|
|
function closestInRoot(start, root, predicate) {
|
|
for (let node = start; node && node !== root.parentNode; node = node.parentElement) {
|
|
if (predicate(node)) return node;
|
|
if (node === root) break;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function handleId(el) {
|
|
const raw = el && el.getAttribute(HID);
|
|
return raw && /^\d+$/.test(raw) ? raw : null;
|
|
}
|
|
|
|
function normalizedPolicy(value) {
|
|
return value === "latest" || value === "queue" || value === "drop" || value === "parallel" ? value : null;
|
|
}
|
|
|
|
function requestPolicy(el, eventName) {
|
|
const policy = normalizedPolicy(el.getAttribute("data-hemx-policy"));
|
|
if (policy) return policy;
|
|
if (el.hasAttribute("data-hemx-debounce") || eventName === "input") return "latest";
|
|
if (el.tagName === "FORM") return "drop";
|
|
return "parallel";
|
|
}
|
|
|
|
function showPending(el, on) {
|
|
const klass = el.getAttribute("data-hemx-pending-class");
|
|
if (klass) togglePendingClass(el, klass, on);
|
|
toggleBusy(el, on);
|
|
const root = rootOf(el) || document;
|
|
forEachElement(root, (i) => { if (i.hasAttribute("data-hemx-indicator")) toggleIndicator(i, on); });
|
|
if (el.hasAttribute("data-hemx-disable-while-pending")) {
|
|
const controls = [];
|
|
if (isDisableControl(el)) controls.push(el);
|
|
forEachElement(el, (child) => { if (isDisableControl(child)) controls.push(child); });
|
|
controls.forEach((c) => toggleDisabled(c, on));
|
|
}
|
|
}
|
|
|
|
function toggleBusy(el, on) {
|
|
const state = busyStates.get(el);
|
|
if (on) {
|
|
if (state) state.count += 1;
|
|
else busyStates.set(el, { count: 1, value: el.getAttribute("aria-busy") });
|
|
el.setAttribute("aria-busy", "true");
|
|
return;
|
|
}
|
|
if (!state) return;
|
|
state.count -= 1;
|
|
if (state.count <= 0) {
|
|
if (state.value === null) el.removeAttribute("aria-busy");
|
|
else el.setAttribute("aria-busy", state.value);
|
|
busyStates.delete(el);
|
|
}
|
|
}
|
|
|
|
function togglePendingClass(el, klass, on) {
|
|
const state = pendingClassStates.get(el);
|
|
if (on) {
|
|
if (state) state.count += 1;
|
|
else pendingClassStates.set(el, { count: 1, className: klass, hadClass: el.classList.contains(klass) });
|
|
el.classList.add(klass);
|
|
return;
|
|
}
|
|
if (!state) return;
|
|
state.count -= 1;
|
|
if (state.count <= 0) {
|
|
if (state.hadClass) el.classList.add(state.className);
|
|
else el.classList.remove(state.className);
|
|
pendingClassStates.delete(el);
|
|
}
|
|
}
|
|
|
|
function toggleIndicator(indicator, on) {
|
|
const state = indicatorStates.get(indicator);
|
|
if (on) {
|
|
if (state) state.count += 1;
|
|
else indicatorStates.set(indicator, { count: 1, hidden: indicator.hidden });
|
|
indicator.hidden = false;
|
|
return;
|
|
}
|
|
if (!state) return;
|
|
state.count -= 1;
|
|
if (state.count <= 0) {
|
|
indicator.hidden = state.hidden;
|
|
indicatorStates.delete(indicator);
|
|
}
|
|
}
|
|
|
|
function toggleDisabled(control, on) {
|
|
const state = disabledStates.get(control);
|
|
if (on) {
|
|
if (state) state.count += 1;
|
|
else disabledStates.set(control, { count: 1, disabled: control.disabled });
|
|
control.disabled = true;
|
|
return;
|
|
}
|
|
if (!state) return;
|
|
state.count -= 1;
|
|
if (state.count <= 0) {
|
|
control.disabled = state.disabled;
|
|
disabledStates.delete(control);
|
|
}
|
|
}
|
|
|
|
function formDataFor(el, eventName, source = el) {
|
|
const form = formOwner(el);
|
|
const data = form ? new FormData(form) : new FormData();
|
|
if (form && source && source !== form && source.name && !source.disabled) data.append(source.name, source.value);
|
|
const id = handleId(el) || formHandleId(form);
|
|
if (id && !data.has("__h")) data.set("__h", id);
|
|
const dragKey = eventName === "drop" && dragKeys.get(rootOf(el));
|
|
if (dragKey && !data.has("work_id")) data.set("work_id", dragKey);
|
|
for (const { name, value } of Array.from(el.attributes || [])) {
|
|
if (name.startsWith("data-") && !name.startsWith("data-hemx-") && name !== HID && name !== SID) {
|
|
data.set(name.slice(5).replace(/-/g, "_"), value);
|
|
}
|
|
}
|
|
return { form, data, multipart: form && String(form.enctype).toLowerCase() === "multipart/form-data" };
|
|
}
|
|
|
|
function urlEncoded(data) {
|
|
const encoded = new URLSearchParams();
|
|
for (const [name, value] of data.entries()) {
|
|
if (typeof File !== "undefined" && value instanceof File) continue;
|
|
encoded.append(name, value);
|
|
}
|
|
return encoded;
|
|
}
|
|
|
|
function requestBody(data, multipart) {
|
|
return multipart ? data : urlEncoded(data);
|
|
}
|
|
|
|
function requestUrl(form, data, method) {
|
|
const url = new URL((form && form.action) || location.href, location.href);
|
|
if (method === "GET") url.search = urlEncoded(data).toString();
|
|
return url.href;
|
|
}
|
|
|
|
function pageRequestUrl(form, source) {
|
|
const url = new URL((form && form.action) || location.href, location.href);
|
|
url.search = urlEncoded(successfulFormData(form, source)).toString();
|
|
return url.href;
|
|
}
|
|
|
|
function successfulFormData(form, source) {
|
|
try {
|
|
return source && source !== form ? new FormData(form, source) : new FormData(form);
|
|
} catch (_) {
|
|
return new FormData(form);
|
|
}
|
|
}
|
|
|
|
function pageFormHistoryMode(source, form) {
|
|
return historyMode(source, null) || historyMode(form, null) || historyMode(boostRoot(form), null);
|
|
}
|
|
|
|
function boostRoot(el) {
|
|
return el && closestInRoot(el.parentElement, rootOf(el), (node) => node.hasAttribute("data-hemx-boost"));
|
|
}
|
|
|
|
function historyMode(el, fallback) {
|
|
if (!el) return fallback;
|
|
const value = el.getAttribute("data-hemx-history") || el.getAttribute("data-hemx-nav") || "";
|
|
if (value === "push" || value === "replace" || value === "none") return value;
|
|
if (el.hasAttribute("data-hemx-history") || el.hasAttribute("data-hemx-nav")) return fallback || "push";
|
|
return fallback;
|
|
}
|
|
|
|
function httpError(response) {
|
|
const error = new Error(`HTTP ${response.status}`);
|
|
error.status = response.status;
|
|
return error;
|
|
}
|
|
|
|
function showError(el, error) {
|
|
const root = rootOf(el) || document;
|
|
const message = error ? (error.status ? `Request failed (${error.status})` : "Request failed") : "";
|
|
forEachElement(root, (outlet) => {
|
|
if (!outlet.hasAttribute("data-hemx-error")) return;
|
|
outlet.textContent = message;
|
|
if (message) outlet.removeAttribute("hidden");
|
|
else outlet.setAttribute("hidden", "");
|
|
});
|
|
}
|
|
|
|
async function runClient(el, event) {
|
|
const name = el.getAttribute("data-hemx-client");
|
|
const root = rootOf(el);
|
|
const policy = el.getAttribute("data-hemx-client-policy") || "latest";
|
|
const run = { root, generation: (clientRuns.get(root)?.generation || 0) + 1 };
|
|
if (policy === "drop" && clientRuns.has(root)) return;
|
|
clientRuns.set(root, run);
|
|
const active = () => clientRuns.get(root) === run && root.isConnected;
|
|
const handler = clientHandlers.get(name);
|
|
showError(el, null);
|
|
showPending(el, true);
|
|
try {
|
|
if (!handler) throw new Error(`unknown client-local hemx handler: ${name}`);
|
|
const stateVersion = Number(root.getAttribute("data-hemx-client-state-version") || "1");
|
|
const operationId = crypto.randomUUID();
|
|
const wire = await handler(
|
|
1,
|
|
event.type,
|
|
dragKeys.get(root) || el.getAttribute("data-card-id") || ("value" in el ? String(el.value) : undefined),
|
|
"checked" in el ? Boolean(el.checked) : undefined,
|
|
event.key || undefined,
|
|
stateVersion,
|
|
root.getAttribute(STATE) || "",
|
|
);
|
|
if (!(wire instanceof Uint8Array)) throw new Error(`client-local hemx handler ${name} returned an invalid effect batch`);
|
|
if (!active()) return;
|
|
currentOperationId = operationId;
|
|
try {
|
|
applyBatch(wire, root);
|
|
} finally {
|
|
currentOperationId = null;
|
|
}
|
|
if (name === "reorder_card") {
|
|
const key = dragKeys.get(root) || el.getAttribute("data-card-id");
|
|
const moved = key ? firstElement(root, (node) => node.getAttribute("data-key") === key) : null;
|
|
const focus = moved && (firstElement(moved, (node) => node.tagName === "BUTTON") || moved);
|
|
if (focus && typeof focus.focus === "function") focus.focus();
|
|
if (matchMedia("(prefers-reduced-motion: reduce)").matches) root.setAttribute("data-hemx-reduced-motion", "");
|
|
else root.removeAttribute("data-hemx-reduced-motion");
|
|
}
|
|
} catch (error) {
|
|
if (!active()) return;
|
|
const fallback = el.hasAttribute("data-hemx-client-fallback");
|
|
showError(el, error);
|
|
emit(root, "hemx:client-error", { handler: name, message: String(error), fallback });
|
|
if (fallback) await send(el, event.type, el);
|
|
} finally {
|
|
if (clientRuns.get(root) === run) clientRuns.delete(root);
|
|
if (el.isConnected) showPending(el, false);
|
|
}
|
|
}
|
|
|
|
async function send(el, eventName, source = el) {
|
|
if (el.getAttribute("data-hemx-confirm") && !confirm(el.getAttribute("data-hemx-confirm"))) return;
|
|
const { form, data, multipart } = formDataFor(el, eventName, source);
|
|
const target = form || el;
|
|
const policy = requestPolicy(target, eventName);
|
|
const active = pending.get(target);
|
|
if (active && policy === "drop") return;
|
|
if (active && policy === "latest") {
|
|
active.abort.abort();
|
|
showPending(target, false);
|
|
}
|
|
if (active && policy === "queue") {
|
|
const base = queues.get(target) || active.done;
|
|
let queued;
|
|
const next = base.then(() => send(el, eventName, source));
|
|
queued = next.catch(() => {}).finally(() => {
|
|
if (queues.get(target) === queued) queues.delete(target);
|
|
});
|
|
queues.set(target, queued);
|
|
return;
|
|
}
|
|
|
|
const abort = new AbortController();
|
|
const timeout = setTimeout(
|
|
() => abort.abort(new DOMException(`hemx request timed out after ${REQUEST_TIMEOUT_MS} ms`, "TimeoutError")),
|
|
REQUEST_TIMEOUT_MS,
|
|
);
|
|
activeRequests.add(abort);
|
|
let finish;
|
|
const done = new Promise((resolve) => { finish = resolve; });
|
|
const method = String((form && form.getAttribute("method")) || "POST").toUpperCase();
|
|
const mode = method === "GET" && form && pageFormHistoryMode(source, form);
|
|
const body = method === "GET" || method === "HEAD" ? undefined : requestBody(data, multipart);
|
|
const headers = { "X-HEMX-Partial": "1", "Accept": "application/hemx, text/html" };
|
|
if (body instanceof URLSearchParams) headers["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8";
|
|
pending.set(target, { abort, done });
|
|
showError(target, null);
|
|
showPending(target, true);
|
|
try {
|
|
if (mode) {
|
|
await navigateUrl(pageRequestUrl(form, source), rootOf(form) || rootOf(el), mode);
|
|
return;
|
|
}
|
|
savePage(roots()[0]);
|
|
const response = await fetch(requestUrl(form, data, method), {
|
|
method,
|
|
body,
|
|
headers,
|
|
credentials: "same-origin",
|
|
signal: abort.signal,
|
|
});
|
|
if (pending.get(target)?.abort !== abort && policy === "latest") return;
|
|
if (!response.ok) throw httpError(response);
|
|
await applyResponse(response, rootOf(target));
|
|
} catch (error) {
|
|
if (error.name !== "AbortError") {
|
|
showError(target, error);
|
|
emit(rootOf(target), "hemx:error", { message: String(error), status: error.status || null });
|
|
}
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
activeRequests.delete(abort);
|
|
if (pending.get(target)?.abort === abort) {
|
|
pending.delete(target);
|
|
showPending(target, false);
|
|
} else if (policy === "parallel") {
|
|
showPending(target, false);
|
|
}
|
|
finish();
|
|
}
|
|
}
|
|
|
|
async function navigate(anchor, mode = "push") {
|
|
const href = anchor.href;
|
|
const root = rootOf(anchor);
|
|
showPending(anchor, true);
|
|
try {
|
|
await navigateUrl(href, root, mode);
|
|
} finally {
|
|
showPending(anchor, false);
|
|
}
|
|
}
|
|
|
|
function snapshotPage(root) {
|
|
return root ? {
|
|
hemx: true,
|
|
pageHtml: root.innerHTML,
|
|
pageTitle: document.title,
|
|
scrollX: window.scrollX,
|
|
scrollY: window.scrollY,
|
|
} : null;
|
|
}
|
|
|
|
function savePage(root) {
|
|
const snapshot = snapshotPage(root);
|
|
if (snapshot) history.replaceState(snapshot, "", location.href);
|
|
}
|
|
|
|
function restorePage(state, root) {
|
|
if (!root || !state || typeof state.pageHtml !== "string") return false;
|
|
root.innerHTML = state.pageHtml;
|
|
if (state.pageTitle) document.title = state.pageTitle;
|
|
bindRoot(root);
|
|
requestAnimationFrame(() => scrollTo(state.scrollX, state.scrollY));
|
|
return true;
|
|
}
|
|
|
|
async function navigateUrl(href, root, mode = "replace") {
|
|
if (mode === "push") savePage(root);
|
|
const response = await fetch(href, {
|
|
headers: { "X-HEMX-Partial": "1", "Accept": "text/html" },
|
|
credentials: "same-origin",
|
|
});
|
|
if (!await applyResponse(response, root)) {
|
|
if (mode === "none") location.reload();
|
|
else location.href = href;
|
|
return;
|
|
}
|
|
if (mode === "push") history.pushState({ hemx: true }, "", href);
|
|
else if (mode === "replace") history.replaceState({ hemx: true }, "", href);
|
|
}
|
|
|
|
async function applyResponse(response, root) {
|
|
if (response.redirected) {
|
|
location.href = response.url;
|
|
return false;
|
|
}
|
|
if (!compatibleFingerprint(response, root)) {
|
|
location.reload();
|
|
return false;
|
|
}
|
|
const type = response.headers.get("content-type") || "";
|
|
if (type.includes("text/html")) return applyHtml(await response.text(), root, response.headers.get("x-hemx-title"));
|
|
if (type.includes("application/hemx")) {
|
|
applyBatch(await response.arrayBuffer(), root);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function compatibleFingerprint(response, root) {
|
|
const received = response.headers.get("x-hemx-fingerprint");
|
|
const expected = root && root.getAttribute(FINGERPRINT);
|
|
return !received || !expected || received === expected;
|
|
}
|
|
|
|
function applyBatch(buffer, root) {
|
|
let batch;
|
|
try {
|
|
batch = decodeBatch(buffer);
|
|
} catch (error) {
|
|
if (error?.code === "HEMX_UNSUPPORTED_ABI") {
|
|
location.reload();
|
|
return;
|
|
}
|
|
throw error;
|
|
}
|
|
const expected = root && root.getAttribute(FINGERPRINT);
|
|
if (expected && String(batch.fingerprint) !== expected) {
|
|
location.reload();
|
|
return;
|
|
}
|
|
const scope = root || document;
|
|
const missingTarget = batch.ops.map((op) => canApplyOp(scope, op)).find(Boolean);
|
|
if (missingTarget) {
|
|
missing(scope, missingTarget);
|
|
return;
|
|
}
|
|
for (const op of batch.ops) applyOp(scope, op);
|
|
bindPolling(scope);
|
|
bindRevealed(scope);
|
|
}
|
|
|
|
function canApplyOp(scope, op) {
|
|
if (op.kind === "put" && isAtom(op.target)) return null;
|
|
if (op.kind === "put" || op.kind === "focus") return targetFor(scope, op.target) ? null : op.target;
|
|
if (op.kind === "insert" || op.kind === "prepend") return targetFor(scope, op.target) ? null : op.target;
|
|
if (op.kind === "remove") return (op.key ? keyedTarget(scope, op.target.resource.id, op.key) : targetFor(scope, op.target)) ? null : op.target;
|
|
if (op.kind === "move") return targetFor(scope, op.target) && keyedTarget(scope, op.target.resource.id, op.key) ? null : op.target;
|
|
if (op.kind === "navigate" && op.scroll && op.scroll.kind === "element") return targetFor(scope, op.scroll.target) ? null : op.scroll.target;
|
|
return null;
|
|
}
|
|
|
|
function applyOp(scope, op) {
|
|
if (op.kind === "put") {
|
|
if (isAtom(op.target)) {
|
|
atomStore(scope).set(String(op.target.resource.id), op.payload.value);
|
|
forEachElement(scope, (element) => {
|
|
if (element.getAttribute("data-aid") === String(op.target.resource.id)) {
|
|
putPayload(element, op.payload);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
const target = targetFor(scope, op.target);
|
|
if (!target) return missing(scope, op.target);
|
|
if (op.target.scope && op.target.scope.kind === "key" && op.payload.kind === "html") replacePayload(target, op.payload, op.target.scope.value, op.target.resource.id);
|
|
else putPayload(target, op.payload);
|
|
} else if (op.kind === "insert" || op.kind === "prepend") {
|
|
const target = targetFor(scope, op.target);
|
|
if (!target) return missing(scope, op.target);
|
|
const nodes = fragmentNodes(op.payload, op.key, op.target.resource.id);
|
|
target[op.kind === "prepend" ? "prepend" : "append"](...nodes);
|
|
} else if (op.kind === "remove") {
|
|
const target = op.key ? keyedTarget(scope, op.target.resource.id, op.key) : targetFor(scope, op.target);
|
|
if (!target) return missing(scope, op.target);
|
|
target.remove();
|
|
} else if (op.kind === "move") {
|
|
const target = targetFor(scope, op.target);
|
|
const item = keyedTarget(scope, op.target.resource.id, op.key);
|
|
if (!target || !item) return missing(scope, op.target);
|
|
const before = op.before && keyedTarget(scope, op.target.resource.id, op.before);
|
|
target.insertBefore(item, before || null);
|
|
} else if (op.kind === "focus") {
|
|
const target = targetFor(scope, op.target);
|
|
if (target && target.focus) target.focus();
|
|
else return missing(scope, op.target);
|
|
} else if (op.kind === "navigate") {
|
|
if (op.mode === "redirect") location.href = op.url;
|
|
else {
|
|
history[op.mode === "replace" ? "replaceState" : "pushState"]({ hemx: true }, "", op.url);
|
|
if (op.scroll === "top") scrollTo(0, 0);
|
|
else if (op.scroll && op.scroll.kind === "element") {
|
|
const target = targetFor(scope, op.scroll.target);
|
|
if (target) target.scrollIntoView();
|
|
}
|
|
if (op.title) document.title = op.title;
|
|
}
|
|
} else if (op.kind === "emit") {
|
|
let payload = op.payload;
|
|
if (currentOperationId && op.name === "hemx:sync-patch") {
|
|
const event = JSON.parse(payload);
|
|
const patch = event && Object.getPrototypeOf(event) === Object.prototype && "patch" in event
|
|
? event.patch
|
|
: event;
|
|
if (patch.idempotencyKey !== "$hemx-interaction" || patch.operationId !== "$hemx-interaction") {
|
|
throw new Error("hemx sync patch is missing its interaction identity");
|
|
}
|
|
patch.idempotencyKey = currentOperationId;
|
|
patch.operationId = currentOperationId;
|
|
payload = JSON.stringify(event);
|
|
}
|
|
handleRuntimeEvent(scope, op.name, payload);
|
|
emit(scope, op.name, payload);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function targetFor(scope, ref) {
|
|
if (isAtom(ref)) return null;
|
|
if (ref.scope && ref.scope.kind === "key") return keyedTarget(scope, ref.resource.id, ref.scope.value);
|
|
if (ref.scope && ref.scope.kind === "field") return fieldTarget(scope, ref.resource.id, ref.scope.value);
|
|
return generatedTarget(scope, ref.resource.id);
|
|
}
|
|
|
|
function firstElement(scope, predicate) {
|
|
const stack = [];
|
|
for (let node = scope && scope.firstElementChild; node; node = node.nextElementSibling) stack.push(node);
|
|
while (stack.length) {
|
|
const node = stack.shift();
|
|
if (predicate(node)) return node;
|
|
for (let child = node.firstElementChild; child; child = child.nextElementSibling) stack.push(child);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function attrEquals(el, name, value) {
|
|
return el && el.getAttribute && el.getAttribute(name) === String(value);
|
|
}
|
|
|
|
function generatedResource(el, id) {
|
|
return attrEquals(el, "data-sid", id) || attrEquals(el, "data-slot-id", id);
|
|
}
|
|
|
|
function generatedForm(el, id) {
|
|
return attrEquals(el, "data-fid", id) || attrEquals(el, "data-form-id", id);
|
|
}
|
|
|
|
function generatedTarget(scope, id) {
|
|
if (scope && generatedResource(scope, id)) return scope;
|
|
return firstElement(scope, (el) => generatedResource(el, id));
|
|
}
|
|
|
|
function withinGeneratedResource(el, scope, id) {
|
|
for (let node = el; node && node !== scope.parentNode; node = node.parentElement) {
|
|
if (generatedResource(node, id)) return true;
|
|
if (node === scope) break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function withinGeneratedForm(el, scope, id) {
|
|
for (let node = el; node && node !== scope.parentNode; node = node.parentElement) {
|
|
if (generatedForm(node, id)) return true;
|
|
if (node === scope) break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isInputControl(el) {
|
|
return el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
|
|
}
|
|
|
|
function isDisableControl(el) {
|
|
return isInputControl(el) || (el && el.tagName === "BUTTON");
|
|
}
|
|
|
|
function isAtom(ref) {
|
|
return ref && ref.resource && ref.resource.kind === "atom";
|
|
}
|
|
|
|
function atomStore(root) {
|
|
const owner = root && root.nodeType === 1 ? root : document.documentElement;
|
|
let store = atomStores.get(owner);
|
|
if (!store) {
|
|
store = new Map();
|
|
atomStores.set(owner, store);
|
|
}
|
|
return store;
|
|
}
|
|
|
|
function atomValue(root, id) {
|
|
return atomStore(rootOf(root) || root || roots()[0]).get(String(id));
|
|
}
|
|
|
|
function keyedTarget(scope, id, key) {
|
|
return firstElement(scope, (el) => attrEquals(el, "data-key", key) && withinGeneratedResource(el, scope, id));
|
|
}
|
|
|
|
function fieldTarget(scope, id, field) {
|
|
return firstElement(scope, (el) => attrEquals(el, "name", field) && withinGeneratedForm(el, scope, id));
|
|
}
|
|
|
|
function formErrorTarget(scope, id, field) {
|
|
return firstElement(scope, (el) => attrEquals(el, "data-hemx-error-for", field) && withinGeneratedForm(el, scope, id)) ||
|
|
firstElement(scope, (el) => attrEquals(el, "name", field) && withinGeneratedForm(el, scope, id));
|
|
}
|
|
|
|
function putFormError(target, message) {
|
|
if (isInputControl(target)) target.setCustomValidity(message);
|
|
else target.textContent = message;
|
|
}
|
|
|
|
function putPayload(target, payload) {
|
|
if (payload.kind === "html") target.innerHTML = payload.value;
|
|
else if (isInputControl(target)) target.value = payload.value;
|
|
else target.textContent = payload.value;
|
|
}
|
|
|
|
function replacePayload(target, payload, key, resourceId) {
|
|
const nodes = fragmentNodes(payload, key, resourceId);
|
|
if (nodes.length) target.replaceWith(...nodes);
|
|
else target.innerHTML = "";
|
|
}
|
|
|
|
function fragmentNodes(payload, key, resourceId) {
|
|
const template = document.createElement("template");
|
|
if (payload.kind === "html") template.innerHTML = payload.value;
|
|
else template.textContent = payload.value;
|
|
const nodes = Array.from(template.content.childNodes);
|
|
const firstElement = nodes.find((node) => node.nodeType === 1);
|
|
if (firstElement && key != null && !firstElement.hasAttribute("data-key")) firstElement.setAttribute("data-key", key);
|
|
if (firstElement && resourceId != null && !firstElement.hasAttribute("data-sid")) firstElement.setAttribute("data-sid", resourceId);
|
|
return nodes;
|
|
}
|
|
|
|
function handleRuntimeEvent(scope, name, payload) {
|
|
if (name === "hemx:form-reset") {
|
|
const form = generatedFormTarget(scope, payload);
|
|
if (form && form.reset) {
|
|
form.reset();
|
|
forEachElement(form, (el) => {
|
|
if (el.hasAttribute("data-hemx-error-for")) {
|
|
if (isInputControl(el)) el.setCustomValidity("");
|
|
else el.textContent = "";
|
|
}
|
|
});
|
|
}
|
|
} else if (name === "hemx:form-error") {
|
|
const [id, field, message] = String(payload).split("\u001f");
|
|
const target = formErrorTarget(scope, id, field);
|
|
if (target) putFormError(target, message || "");
|
|
} else if (name === "hemx:form-disable-while-pending") {
|
|
const form = generatedFormTarget(scope, payload);
|
|
if (form) form.setAttribute("data-hemx-disable-while-pending", "");
|
|
}
|
|
}
|
|
|
|
function missing(root, target) {
|
|
emit(root, "hemx:missing-target", target);
|
|
return false;
|
|
}
|
|
|
|
function cssEscape(value) {
|
|
return String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
|
|
}
|
|
|
|
function applyHtml(html, root, title) {
|
|
const scope = root || document;
|
|
const doc = new DOMParser().parseFromString(html, "text/html");
|
|
const template = firstElement(doc, (el) => el.tagName === "TEMPLATE" && el.hasAttribute("data-hemx"));
|
|
const lowered = replaceLoweredSlots(scope, doc);
|
|
const named = replaceSlot(scope, doc, "content", lowered ? undefined : (template ? template.innerHTML : html));
|
|
if (!lowered && !named) {
|
|
emit(scope, "hemx:missing-content-slot", null);
|
|
return false;
|
|
}
|
|
replaceSlot(scope, doc, "nav");
|
|
const titleEl = firstElement(doc, (el) => el.tagName === "TITLE");
|
|
const nextTitle = title || (titleEl && titleEl.textContent);
|
|
if (nextTitle) document.title = nextTitle;
|
|
return true;
|
|
}
|
|
|
|
function replaceLoweredSlots(scope, doc) {
|
|
let changed = false;
|
|
forEachElement(doc.body || doc, (source) => {
|
|
const id = source.getAttribute("data-sid") || source.getAttribute("data-slot-id");
|
|
if (!id) return;
|
|
const target = generatedTarget(scope, id);
|
|
if (target) {
|
|
target.innerHTML = source.innerHTML;
|
|
changed = true;
|
|
}
|
|
});
|
|
return changed;
|
|
}
|
|
|
|
function forEachElement(scope, visit) {
|
|
for (let node = scope && scope.firstElementChild; node; node = node.nextElementSibling) {
|
|
visit(node);
|
|
forEachElement(node, visit);
|
|
}
|
|
}
|
|
|
|
function generatedFormTarget(scope, id) {
|
|
if (scope && generatedForm(scope, id)) return scope;
|
|
return firstElement(scope, (el) => generatedForm(el, id));
|
|
}
|
|
|
|
function namedSlot(el, name) {
|
|
return attrEquals(el, "data-hemx-slot", name) || attrEquals(el, "data-slot", name);
|
|
}
|
|
|
|
function replaceSlot(scope, doc, name, fallback) {
|
|
const target = firstElement(scope, (el) => namedSlot(el, name));
|
|
if (!target) return false;
|
|
const source = firstElement(doc, (el) => namedSlot(el, name));
|
|
if (!source && fallback === undefined) return false;
|
|
target.innerHTML = source ? source.innerHTML : fallback;
|
|
return true;
|
|
}
|
|
|
|
function emit(root, name, detail) {
|
|
(root || document).dispatchEvent(new CustomEvent(name, { bubbles: true, detail }));
|
|
}
|
|
|
|
function defaultEvent(el) {
|
|
if (el.getAttribute("data-hemx-on")) return el.getAttribute("data-hemx-on").trim().split(/\s+/)[0];
|
|
if (el.tagName === "FORM") return "submit";
|
|
return "click";
|
|
}
|
|
|
|
function handlesEvent(el, name) {
|
|
const declared = el.getAttribute("data-hemx-on");
|
|
return declared ? declared.trim().split(/\s+/).includes(name) : defaultEvent(el) === name;
|
|
}
|
|
|
|
function bindRoot(root) {
|
|
["click", "submit", "input", "change", "keydown", "dragstart", "dragover", "drop"].forEach((name) => {
|
|
root.addEventListener(name, (event) => {
|
|
if (name === "keydown") {
|
|
const direct = closestInRoot(event.target, root, (el) => el.hasAttribute("data-hemx-client"));
|
|
if (direct && !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) return;
|
|
}
|
|
if (name === "dragstart") {
|
|
const item = closestInRoot(event.target, root, (el) => el.hasAttribute("data-key"));
|
|
if (item) {
|
|
dragKeys.set(root, item.getAttribute("data-key"));
|
|
if (event.dataTransfer) event.dataTransfer.setData("text/plain", item.getAttribute("data-key"));
|
|
}
|
|
return;
|
|
}
|
|
if (name === "dragover") {
|
|
const drop = closestInRoot(event.target, root, (el) => el.hasAttribute(HID) && el.getAttribute("data-hemx-on") === "drop");
|
|
if (drop) event.preventDefault();
|
|
return;
|
|
}
|
|
const nav = closestInRoot(event.target, root, (el) =>
|
|
(el.tagName === "A" && el.hasAttribute("data-hemx-nav")) ||
|
|
(el.tagName === "A" && el.hasAttribute("href") && closestInRoot(el.parentElement, root, (node) => node.hasAttribute("data-hemx-boost")))
|
|
);
|
|
if (name === "click" && nav && sameOriginNav(event, nav)) {
|
|
event.preventDefault();
|
|
navigate(nav, historyMode(nav, "push"));
|
|
return;
|
|
}
|
|
if (name === "click") {
|
|
const direct = closestInRoot(event.target, root, (el) => el.hasAttribute(HID));
|
|
const active = direct || closestInRoot(event.target, root, (el) => el.hasAttribute("data-hemx-client"));
|
|
if (active && handlesEvent(active, "click")) {
|
|
event.preventDefault();
|
|
if (active.hasAttribute("data-hemx-client")) {
|
|
runClient(active, event).catch((error) => emit(root, "hemx:client-error", {
|
|
handler: active.getAttribute("data-hemx-client"),
|
|
message: String(error),
|
|
fallback: false,
|
|
}));
|
|
} else {
|
|
schedule(active, name);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (name === "click") {
|
|
const submitter = closestInRoot(event.target, root, (el) =>
|
|
(el.tagName === "BUTTON" && (!el.hasAttribute("type") || el.getAttribute("type") === "submit")) ||
|
|
(el.tagName === "INPUT" && el.getAttribute("type") === "submit")
|
|
);
|
|
const form = formOwner(submitter);
|
|
if (form && root.contains(form) && (formHandleId(form) || pageFormHistoryMode(submitter, form))) {
|
|
if (form.reportValidity && !form.reportValidity()) return;
|
|
event.preventDefault();
|
|
schedule(form, "submit", submitter);
|
|
return;
|
|
}
|
|
}
|
|
let el = closestInRoot(event.target, root, (node) =>
|
|
node.hasAttribute(HID) || node.hasAttribute("data-hemx-client") ||
|
|
(node.tagName === "FORM" && (pageFormHistoryMode(event.submitter || node, node) || boostRoot(node)))
|
|
);
|
|
if (name === "submit" && !el && event.target && event.target.tagName === "FORM" && (formHandleId(event.target) || pageFormHistoryMode(event.submitter || event.target, event.target))) el = event.target;
|
|
if (!el || !handlesEvent(el, name)) return;
|
|
event.preventDefault();
|
|
if (el.hasAttribute("data-hemx-client")) {
|
|
runClient(el, event).catch((error) => emit(root, "hemx:client-error", {
|
|
handler: el.getAttribute("data-hemx-client"),
|
|
message: String(error),
|
|
fallback: false,
|
|
}));
|
|
} else {
|
|
schedule(el, name, event.submitter || el);
|
|
}
|
|
});
|
|
});
|
|
bindPolling(root);
|
|
bindRevealed(root);
|
|
}
|
|
|
|
function schedule(el, eventName, source = el) {
|
|
const debounce = duration(el.getAttribute("data-hemx-debounce"));
|
|
const delay = duration(el.getAttribute("data-hemx-delay"));
|
|
const throttle = duration(el.getAttribute("data-hemx-throttle"));
|
|
if (debounce) {
|
|
clearTimeout(timers.get(el));
|
|
timers.set(el, setTimeout(() => send(el, eventName, source), debounce));
|
|
} else if (delay) {
|
|
setTimeout(() => send(el, eventName, source), delay);
|
|
} else if (throttle) {
|
|
if (timers.get(el)) return;
|
|
send(el, eventName, source).finally(() => setTimeout(() => timers.delete(el), throttle));
|
|
} else {
|
|
send(el, eventName, source);
|
|
}
|
|
}
|
|
|
|
function bindPolling(root) {
|
|
forEachElement(root, (el) => {
|
|
if ((!el.hasAttribute("data-hemx-every") && !el.hasAttribute("data-hemx-interval")) || everyTimers.has(el)) return;
|
|
const eventName = el.hasAttribute("data-hemx-interval") ? "interval" : "every";
|
|
const ms = duration(el.getAttribute("data-hemx-interval") || el.getAttribute("data-hemx-every"));
|
|
if (!ms) return;
|
|
everyTimers.set(el, setInterval(() => document.contains(el) ? send(el, eventName) : stopPolling(el), ms));
|
|
});
|
|
}
|
|
|
|
function stopPolling(el) {
|
|
clearInterval(everyTimers.get(el));
|
|
everyTimers.delete(el);
|
|
}
|
|
|
|
function bindRevealed(root) {
|
|
let observer = revealObservers.get(root);
|
|
forEachElement(root, (el) => {
|
|
if (!el.hasAttribute("data-hemx-revealed") || revealed.has(el)) return;
|
|
if (typeof IntersectionObserver === "undefined") {
|
|
revealed.add(el);
|
|
schedule(el, "revealed");
|
|
return;
|
|
}
|
|
if (!observer) {
|
|
observer = new IntersectionObserver((entries) => {
|
|
entries.forEach((entry) => {
|
|
if (!entry.isIntersecting || revealed.has(entry.target)) return;
|
|
revealed.add(entry.target);
|
|
observer.unobserve(entry.target);
|
|
schedule(entry.target, "revealed");
|
|
});
|
|
});
|
|
revealObservers.set(root, observer);
|
|
}
|
|
observer.observe(el);
|
|
});
|
|
}
|
|
|
|
function bindSse(root) {
|
|
const url = root.getAttribute("data-hemx-sse");
|
|
if (!url || sseSources.has(root) || typeof EventSource === "undefined") return;
|
|
const href = new URL(url, location.href);
|
|
if (href.origin !== location.origin) {
|
|
emit(root, "hemx:sse-error", url);
|
|
return;
|
|
}
|
|
const source = new EventSource(href.href);
|
|
source.addEventListener("hemx", (event) => applySseMessage(root, event));
|
|
source.addEventListener("message", (event) => applySseMessage(root, event));
|
|
source.addEventListener("error", () => emit(root, "hemx:sse-error", url));
|
|
sseSources.set(root, source);
|
|
}
|
|
|
|
function applySseMessage(root, event) {
|
|
try {
|
|
const bytes = base64UrlBytes(event.data);
|
|
applyBatch(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), root);
|
|
} catch (error) {
|
|
emit(root, "hemx:error", String(error));
|
|
}
|
|
}
|
|
|
|
function duration(value) {
|
|
if (!value) return 0;
|
|
const match = String(value).trim().match(/^(\d+)(ms|s)?$/);
|
|
if (!match) return 0;
|
|
return Number(match[1]) * (match[2] === "s" ? 1000 : 1);
|
|
}
|
|
|
|
function bootstrapState(root) {
|
|
const encoded = root.getAttribute(STATE);
|
|
if (!encoded) return;
|
|
try {
|
|
const store = atomStore(root);
|
|
for (const atom of decodeAtomState(encoded)) store.set(String(atom.id), atom.bytes);
|
|
} catch (error) {
|
|
atomStores.delete(root);
|
|
emit(root, "hemx:state-error", String(error));
|
|
}
|
|
}
|
|
|
|
function decodeAtomState(encoded) {
|
|
const bytes = base64UrlBytes(encoded);
|
|
const d = postcardDecoder(bytes);
|
|
const atoms = d.vec(() => ({ id: d.varint(), bytes: d.bytes() }));
|
|
if (!d.done()) throw new Error("trailing hemx state bytes");
|
|
return atoms;
|
|
}
|
|
|
|
function base64UrlBytes(encoded) {
|
|
if (typeof encoded !== "string" || encoded.length > Math.ceil(MAX_WIRE_BYTES * 4 / 3) + 4) {
|
|
throw new Error(`encoded hemx state exceeds ${MAX_WIRE_BYTES} bytes`);
|
|
}
|
|
const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
|
|
const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
|
|
return Uint8Array.from(atob(padded), (ch) => ch.charCodeAt(0));
|
|
}
|
|
|
|
const MAX_WIRE_BYTES = 1024 * 1024;
|
|
const MAX_WIRE_ITEMS = 1024;
|
|
const MAX_WIRE_FIELD_BYTES = 256 * 1024;
|
|
|
|
function boundedLength(value, maximum, field) {
|
|
if (!Number.isSafeInteger(value) || value < 0 || value > maximum) {
|
|
throw new Error(`${field} length ${value} exceeds ${maximum}`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function postcardDecoder(bytes) {
|
|
if (bytes.length > MAX_WIRE_BYTES) throw new Error(`hemx state exceeds ${MAX_WIRE_BYTES} bytes`);
|
|
let offset = 0;
|
|
const need = (len) => {
|
|
boundedLength(len, bytes.length - offset, "hemx state field");
|
|
const end = offset + len;
|
|
if (end > bytes.length) throw new Error("truncated hemx state");
|
|
const slice = bytes.subarray(offset, end);
|
|
offset = end;
|
|
return slice;
|
|
};
|
|
const varint = () => {
|
|
let value = 0;
|
|
for (let index = 0; index < 5; index += 1) {
|
|
const byte = need(1)[0];
|
|
if (index === 4 && byte > 0x0f) throw new Error("oversized hemx state varint");
|
|
value += (byte & 0x7f) * (2 ** (index * 7));
|
|
if ((byte & 0x80) === 0) return value >>> 0;
|
|
}
|
|
throw new Error("oversized hemx state varint");
|
|
};
|
|
const bytesField = () => need(boundedLength(varint(), MAX_WIRE_FIELD_BYTES, "hemx state bytes"));
|
|
const vec = (read) => {
|
|
const length = boundedLength(varint(), MAX_WIRE_ITEMS, "hemx state vector");
|
|
const values = [];
|
|
for (let index = 0; index < length; index += 1) values.push(read());
|
|
return values;
|
|
};
|
|
return { varint, bytes: bytesField, vec, done: () => offset === bytes.length };
|
|
}
|
|
|
|
function decoder(buffer) {
|
|
const bytes = new Uint8Array(buffer);
|
|
if (bytes.length > MAX_WIRE_BYTES) throw new Error(`hemx batch exceeds ${MAX_WIRE_BYTES} bytes`);
|
|
let offset = 0;
|
|
const need = (len) => {
|
|
boundedLength(len, bytes.length - offset, "hemx batch field");
|
|
const end = offset + len;
|
|
if (end > bytes.length) throw new Error("truncated hemx batch");
|
|
const slice = bytes.subarray(offset, end);
|
|
offset = end;
|
|
return slice;
|
|
};
|
|
const u8 = () => need(1)[0];
|
|
const u32 = () => {
|
|
const b = need(4);
|
|
return (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0;
|
|
};
|
|
const u64 = () => {
|
|
const lo = BigInt(u32());
|
|
const hi = BigInt(u32());
|
|
return lo | (hi << 32n);
|
|
};
|
|
const str = () => new TextDecoder("utf-8", { fatal: true }).decode(
|
|
need(boundedLength(u32(), MAX_WIRE_FIELD_BYTES, "hemx string")),
|
|
);
|
|
const enumValue = (values, field) => {
|
|
const discriminant = u8();
|
|
if (discriminant >= values.length) throw new Error(`unknown ${field} ${discriminant}`);
|
|
return values[discriminant];
|
|
};
|
|
const option = (read) => {
|
|
const discriminant = u8();
|
|
if (discriminant === 0) return null;
|
|
if (discriminant === 1) return read();
|
|
throw new Error(`unknown hemx option ${discriminant}`);
|
|
};
|
|
const resource = () => ({ kind: enumValue(["slot", "atom", "handle", "form"], "hemx resource"), id: u32() });
|
|
const scope = () => {
|
|
const kind = u8();
|
|
if (kind === 0) return null;
|
|
if (kind === 1) return { kind: "key", value: str() };
|
|
if (kind === 2) return { kind: "field", value: str() };
|
|
throw new Error(`unknown hemx scope ${kind}`);
|
|
};
|
|
const ref = () => ({ resource: resource(), scope: scope() });
|
|
const payload = () => ({ kind: enumValue(["text", "html"], "hemx payload"), value: str() });
|
|
const scroll = () => {
|
|
const kind = u8();
|
|
if (kind === 0) return "preserve";
|
|
if (kind === 1) return "top";
|
|
if (kind === 2) return { kind: "element", target: ref() };
|
|
throw new Error(`unknown hemx scroll behavior ${kind}`);
|
|
};
|
|
const effect = () => {
|
|
const kind = u8();
|
|
if (kind === 0) return { kind: "put", target: ref(), payload: payload() };
|
|
if (kind === 1) return { kind: "insert", target: ref(), key: str(), payload: payload() };
|
|
if (kind === 2) return { kind: "prepend", target: ref(), key: str(), payload: payload() };
|
|
if (kind === 3) return { kind: "remove", target: ref(), key: option(str) };
|
|
if (kind === 4) return { kind: "move", target: ref(), key: str(), before: option(str) };
|
|
if (kind === 5) return { kind: "focus", target: ref() };
|
|
if (kind === 6) return { kind: "navigate", url: str(), mode: enumValue(["push", "replace", "redirect"], "hemx navigation mode"), scroll: scroll(), title: option(str) };
|
|
if (kind === 7) return { kind: "emit", name: str(), payload: str() };
|
|
throw new Error(`unknown hemx effect ${kind}`);
|
|
};
|
|
const vec = (read) => {
|
|
const length = boundedLength(u32(), MAX_WIRE_ITEMS, "hemx effect vector");
|
|
const values = [];
|
|
for (let index = 0; index < length; index += 1) values.push(read());
|
|
return values;
|
|
};
|
|
return { u8, u32, u64, vec, effect, done: () => offset === bytes.length };
|
|
}
|
|
|
|
function decodeBatch(buffer) {
|
|
const d = decoder(buffer);
|
|
if (String.fromCharCode(d.u8(), d.u8(), d.u8(), d.u8()) !== "HEMX") throw new Error("bad hemx batch magic");
|
|
const abiVersion = d.u32();
|
|
if (abiVersion !== runtimeAbiVersion) {
|
|
const error = new Error(`unsupported hemx batch ABI version ${abiVersion}; expected ${runtimeAbiVersion}`);
|
|
error.code = "HEMX_UNSUPPORTED_ABI";
|
|
throw error;
|
|
}
|
|
const batch = { abiVersion, fingerprint: d.u64(), ops: d.vec(d.effect) };
|
|
if (!d.done()) throw new Error("trailing hemx batch bytes");
|
|
return batch;
|
|
}
|
|
|
|
function sameOriginNav(event, anchor) {
|
|
return !event.defaultPrevented && event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey &&
|
|
anchor.origin === location.origin && !anchor.download && anchor.target !== "_blank";
|
|
}
|
|
|
|
function descendantRoots(node) {
|
|
const roots = [];
|
|
for (const child of node.children || []) {
|
|
if (child.hasAttribute(ROOT)) roots.push(child);
|
|
roots.push(...descendantRoots(child));
|
|
}
|
|
return roots;
|
|
}
|
|
|
|
function stopDescendantPolling(node) {
|
|
for (const child of node.children || []) {
|
|
if (child.hasAttribute("data-hemx-every") || child.hasAttribute("data-hemx-interval")) {
|
|
stopPolling(child);
|
|
}
|
|
stopDescendantPolling(child);
|
|
}
|
|
}
|
|
|
|
function cleanupRemovedRoot(root) {
|
|
clientRuns.delete(root);
|
|
const source = sseSources.get(root);
|
|
if (source) source.close();
|
|
sseSources.delete(root);
|
|
const observer = revealObservers.get(root);
|
|
if (observer) observer.disconnect();
|
|
revealObservers.delete(root);
|
|
stopDescendantPolling(root);
|
|
}
|
|
|
|
function restoreRevealed(event) {
|
|
if (!event.persisted) return;
|
|
roots().forEach((root) => {
|
|
const observer = revealObservers.get(root);
|
|
if (observer) observer.disconnect();
|
|
revealObservers.delete(root);
|
|
forEachElement(root, (el) => {
|
|
if (attrEquals(el, "data-hemx-on", "revealed") || el.hasAttribute("data-hemx-revealed")) revealed.delete(el);
|
|
});
|
|
bindRevealed(root);
|
|
});
|
|
}
|
|
|
|
function start() {
|
|
roots().forEach((root) => {
|
|
root.setAttribute("data-hemx-request-timeout-ms", String(REQUEST_TIMEOUT_MS));
|
|
try {
|
|
bootstrapState(root);
|
|
} catch (error) {
|
|
emit(root, "hemx:state-error", String(error));
|
|
}
|
|
try {
|
|
bindRoot(root);
|
|
} catch (error) {
|
|
emit(root, "hemx:bind-error", String(error));
|
|
}
|
|
try {
|
|
bindSse(root);
|
|
} catch (error) {
|
|
emit(root, "hemx:sse-error", String(error));
|
|
}
|
|
});
|
|
new MutationObserver((records) => {
|
|
records.forEach((record) => {
|
|
record.removedNodes.forEach((node) => {
|
|
if (!(node instanceof Element)) return;
|
|
if (node.hasAttribute(ROOT)) cleanupRemovedRoot(node);
|
|
descendantRoots(node).forEach(cleanupRemovedRoot);
|
|
});
|
|
record.addedNodes.forEach((node) => {
|
|
if (!(node instanceof Element)) return;
|
|
if (node.hasAttribute(ROOT)) bindRoot(node);
|
|
descendantRoots(node).forEach(bindRoot);
|
|
const owner = rootOf(node.parentElement);
|
|
if (owner) {
|
|
bindPolling(owner);
|
|
bindRevealed(owner);
|
|
}
|
|
});
|
|
});
|
|
}).observe(document.documentElement, { childList: true, subtree: true });
|
|
try {
|
|
history.replaceState(history.state || { hemx: true }, "", location.href);
|
|
} catch (error) {
|
|
const root = roots()[0];
|
|
if (root) emit(root, "hemx:history-error", String(error));
|
|
}
|
|
}
|
|
|
|
window.addEventListener("pageshow", restoreRevealed);
|
|
|
|
addEventListener("popstate", (event) => {
|
|
const root = roots()[0];
|
|
if (root && !restorePage(event.state, root)) {
|
|
if (root) navigateUrl(location.href, root, "none").catch((error) => emit(root, "hemx:error", String(error)));
|
|
}
|
|
});
|
|
|
|
window.hemx = Object.freeze({
|
|
runtimeAbiVersion,
|
|
roots,
|
|
rootOf,
|
|
applyHtml,
|
|
applyBatch,
|
|
decodeBatch,
|
|
atomValue,
|
|
decodeAtomState,
|
|
registerClientHandler(name, handler) {
|
|
if (!name || typeof handler !== "function") throw new Error("client handler registration requires a name and function");
|
|
const previous = clientHandlers.get(name);
|
|
clientHandlers.set(name, handler);
|
|
return previous;
|
|
},
|
|
});
|
|
|
|
if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", start);
|
|
else start();
|
|
})();
|