@geajs/ui 0.2.4 → 0.2.10

package/dist/keyed-list.mjs

@@ -0,0 +1,538 @@
+import { a as subscribe, i as withTracking, u as GEA_PROXY_RAW } from "./bind.mjs";
+import { n as _DIRTY_PROPS, t as _DIRTY } from "./dirty-symbols.mjs";
+//#region ../gea/src/runtime/keyed-list/lis.ts
+/**
+* Longest Increasing Subsequence — O(n log n). Input is `newToOld[]`
+* (index in new array → index in old array, or `-1` for new items). Output
+* is the set of new-indices that form the longest increasing run of old
+* indices, i.e. the set of entries that can stay put during a reorder.
+*/
+function lis(arr) {
+	const n = arr.length;
+	if (n === 0) return [];
+	const vals = [];
+	const idxs = [];
+	for (let i = 0; i < n; i++) if (arr[i] >= 0) {
+		vals.push(arr[i]);
+		idxs.push(i);
+	}
+	const m = vals.length;
+	if (m === 0) return [];
+	const tails = [];
+	const tIdx = [];
+	const pred = new Array(m).fill(-1);
+	for (let i = 0; i < m; i++) {
+		const v = vals[i];
+		let lo = 0, hi = tails.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (tails[mid] < v) lo = mid + 1;
+			else hi = mid;
+		}
+		if (lo === tails.length) {
+			tails.push(v);
+			tIdx.push(i);
+		} else {
+			tails[lo] = v;
+			tIdx[lo] = i;
+		}
+		if (lo > 0) pred[i] = tIdx[lo - 1];
+	}
+	const out = new Array(tails.length);
+	let k = tIdx[tails.length - 1];
+	for (let i = tails.length - 1; i >= 0; i--) {
+		out[i] = idxs[k];
+		k = pred[k];
+	}
+	return out;
+}
+//#endregion
+//#region ../gea/src/runtime/keyed-list/rescue.ts
+const _toFlush = /* @__PURE__ */ new Set();
+const _live = /* @__PURE__ */ new WeakMap();
+const _claimed = /* @__PURE__ */ new WeakSet();
+const _claimable = /* @__PURE__ */ new WeakSet();
+let _pendingBulkMaps = [];
+let _pendingBulkEntries = [];
+let _flushQueued = false;
+function _unwrap(v) {
+	return v && typeof v === "object" && v[GEA_PROXY_RAW] || v;
+}
+function _liveFor(pending) {
+	let live = _live.get(pending);
+	if (!live) {
+		live = /* @__PURE__ */ new Map();
+		_live.set(pending, live);
+	}
+	return live;
+}
+function _trackLive(pending, e) {
+	const key = String(e.key);
+	const live = _liveFor(pending);
+	let bucket = live.get(key);
+	if (!bucket) live.set(key, bucket = /* @__PURE__ */ new Set());
+	bucket.add(e);
+}
+function _untrackLive(pending, e) {
+	_claimable.delete(e);
+	const bucket = _live.get(pending)?.get(String(e.key));
+	if (!bucket) return;
+	bucket.delete(e);
+	if (bucket.size === 0) _live.get(pending)?.delete(String(e.key));
+}
+function _markClaimable(e, claimable) {
+	if (claimable) _claimable.add(e);
+	else _claimable.delete(e);
+}
+function _consumeClaim(e) {
+	if (!_claimed.has(e)) return false;
+	_claimed.delete(e);
+	_claimable.delete(e);
+	return true;
+}
+function _schedule() {
+	if (_flushQueued) return;
+	_flushQueued = true;
+	queueMicrotask(() => {
+		_flushQueued = false;
+		const drainMaps = Array.from(_toFlush);
+		const bulkEntries = _pendingBulkEntries;
+		_toFlush.clear();
+		_pendingBulkMaps = [];
+		_pendingBulkEntries = [];
+		for (let i = 0; i < drainMaps.length; i++) {
+			const m = drainMaps[i];
+			for (const e of m.values()) try {
+				e.disposer.dispose();
+			} catch {}
+			m.clear();
+		}
+		for (let i = 0; i < bulkEntries.length; i++) try {
+			bulkEntries[i].disposer.dispose();
+		} catch {}
+	});
+}
+function _defer(pending, e) {
+	_untrackLive(pending, e);
+	pending.set(String(e.key), e);
+	_toFlush.add(pending);
+	_schedule();
+}
+/**
+* Queue a full batch of removed entries for deferred disposal. Cheaper than
+* per-row `_defer` for whole-list ops (clear, disjoint replace): no
+* `Map.set` per row. If a `_rescue` call arrives before the microtask
+* drains, the batch is materialized into its target `pending` map first.
+*/
+function _deferBulk(pending, entries) {
+	if (entries.length === 0) return;
+	const next = [];
+	for (let i = 0; i < entries.length; i++) {
+		const e = entries[i];
+		if (_consumeClaim(e)) continue;
+		_untrackLive(pending, e);
+		next.push(e);
+	}
+	if (next.length === 0) return;
+	for (let i = 0; i < next.length; i++) {
+		_pendingBulkMaps.push(pending);
+		_pendingBulkEntries.push(next[i]);
+	}
+	_schedule();
+}
+function _rescue(pending, key, item) {
+	const e = pending.get(key);
+	if (e) {
+		pending.delete(key);
+		return e;
+	}
+	if (_pendingBulkMaps.length > 0) {
+		for (let i = 0; i < _pendingBulkMaps.length; i++) {
+			const target = _pendingBulkMaps[i];
+			const bulkItem = _pendingBulkEntries[i];
+			target.set(String(bulkItem.key), bulkItem);
+			_toFlush.add(target);
+		}
+		_pendingBulkMaps = [];
+		_pendingBulkEntries = [];
+		const r = pending.get(key);
+		if (r) {
+			pending.delete(key);
+			return r;
+		}
+	}
+	if (arguments.length >= 3) {
+		const raw = _unwrap(item);
+		const bucket = _live.get(pending)?.get(key);
+		if (bucket) {
+			for (const live of bucket) if (_claimable.has(live) && live.item === raw) {
+				_claimed.add(live);
+				_claimable.delete(live);
+				return live;
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+//#region ../gea/src/runtime/keyed-list.ts
+/** Unwrap a proxy value to its raw target. */
+function unwrap(v) {
+	return v && typeof v === "object" && v[GEA_PROXY_RAW] || v;
+}
+function keyedList(cfg) {
+	const container = cfg.container;
+	const anchor = cfg.anchor;
+	const disposer = cfg.disposer;
+	const root = cfg.root;
+	const path = cfg.path;
+	const keyFn = cfg.key;
+	const createEntry = cfg.createEntry;
+	const patchEntry = cfg.patchEntry;
+	const onItemRemove = cfg.onItemRemove;
+	const pending = cfg.pending ?? /* @__PURE__ */ new Map();
+	let entries = [];
+	const byKey = /* @__PURE__ */ new Map();
+	if (cfg.onByKeyCreated) cfg.onByKeyCreated(byKey);
+	const resolveArr = () => {
+		if (typeof path === "function") {
+			const v = path();
+			return Array.isArray(v) ? v : [];
+		}
+		let v = root;
+		for (let i = 0; i < path.length; i++) {
+			if (v == null) return [];
+			v = v[path[i]];
+		}
+		return Array.isArray(v) ? v : [];
+	};
+	const removeEntry = (e) => {
+		if (onItemRemove) onItemRemove(e);
+		byKey.delete(e.key);
+		if (_consumeClaim(e)) return;
+		if (e.element.parentNode) e.element.parentNode.removeChild(e.element);
+		_defer(pending, e);
+	};
+	const markEntriesLeaving = (next) => {
+		if (entries.length === 0) return;
+		const nextByKey = /* @__PURE__ */ new Map();
+		for (let i = 0; i < next.length; i++) {
+			const k = keyFn(next[i], i);
+			let bucket = nextByKey.get(k);
+			if (!bucket) nextByKey.set(k, bucket = /* @__PURE__ */ new Set());
+			bucket.add(unwrap(next[i]));
+		}
+		for (let i = 0; i < entries.length; i++) {
+			const e = entries[i];
+			_markClaimable(e, !nextByKey.get(e.key)?.has(e.item));
+		}
+	};
+	const firstArr = resolveArr();
+	if (firstArr.length > 0) {
+		const frag = container.ownerDocument.createDocumentFragment();
+		for (let i = 0; i < firstArr.length; i++) {
+			const item = firstArr[i];
+			const e = createEntry(item, i);
+			entries.push(e);
+			byKey.set(e.key, e);
+			_trackLive(pending, e);
+			frag.appendChild(e.element);
+			if (item && typeof item === "object") {
+				item[_DIRTY] = false;
+				item[_DIRTY_PROPS]?.clear();
+			}
+		}
+		container.insertBefore(frag, anchor);
+	}
+	let prevArrRef = firstArr;
+	const patchDirtyItems = (arr) => {
+		let patched = false;
+		const raw = arr[GEA_PROXY_RAW] || arr;
+		for (let i = 0; i < raw.length; i++) {
+			const item = raw[i];
+			if (item && typeof item === "object" && item[_DIRTY]) {
+				patchEntry(entries[i], item, i);
+				item[_DIRTY] = false;
+				item[_DIRTY_PROPS]?.clear();
+				entries[i].item = item;
+				patched = true;
+			}
+		}
+		return patched;
+	};
+	const reconcile = (arr, changes) => {
+		if (arr === prevArrRef && entries.length === arr.length) {
+			let structural = false;
+			let aipuOnly = changes && changes.length > 0;
+			let itemDirtyOnly = changes && changes.length > 0;
+			if (changes && changes.length > 0) for (let i = 0; i < changes.length; i++) {
+				const c = changes[i];
+				if (c.type === "append" || c.type === "remove" || c.type === "delete" || c.type === "reorder") {
+					structural = true;
+					aipuOnly = false;
+					itemDirtyOnly = false;
+					break;
+				}
+				if (!c.aipu) {
+					aipuOnly = false;
+					itemDirtyOnly = false;
+				} else {
+					structural = true;
+					if (!c.itemDirty) itemDirtyOnly = false;
+				}
+			}
+			if (itemDirtyOnly) {
+				const raw = arr[GEA_PROXY_RAW] || arr;
+				let stableKeys = true;
+				for (let i = 0; i < changes.length; i++) {
+					const idx = changes[i].arix;
+					if (idx < 0 || idx >= entries.length || entries[idx].key !== keyFn(raw[idx], idx)) {
+						stableKeys = false;
+						break;
+					}
+				}
+				if (stableKeys) {
+					patchDirtyItems(arr);
+					return;
+				}
+			}
+			if (aipuOnly && changes.length > 1 && changes.length < 3) {
+				const a = changes[0].arix;
+				const b = changes[1].arix;
+				if (a >= 0 && b >= 0 && a < entries.length && b < entries.length && a !== b) {
+					const eA = entries[a];
+					const eB = entries[b];
+					const newAKey = keyFn(arr[a], a);
+					const newBKey = keyFn(arr[b], b);
+					if (eA.key === newBKey && eB.key === newAKey) {
+						const refB = eB.element.nextSibling;
+						container.insertBefore(eB.element, eA.element);
+						if (refB) container.insertBefore(eA.element, refB);
+						else container.appendChild(eA.element);
+						entries[a] = eB;
+						entries[b] = eA;
+						if (unwrap(arr[a]) !== eB.item) patchEntry(eB, arr[a], a);
+						if (unwrap(arr[b]) !== eA.item) patchEntry(eA, arr[b], b);
+						prevArrRef = arr;
+						return;
+					}
+				}
+			}
+			if (!structural) {
+				patchDirtyItems(arr);
+				return;
+			}
+		}
+		if (entries.length === arr.length && changes && changes.length > 0) {
+			let structural = false;
+			for (let i = 0; i < changes.length; i++) {
+				const c = changes[i];
+				if (c.type === "append" || c.type === "remove" || c.type === "delete" || c.type === "reorder" || c.aipu) {
+					structural = true;
+					break;
+				}
+			}
+			if (!structural && patchDirtyItems(arr)) {
+				prevArrRef = arr;
+				return;
+			}
+		}
+		if (changes && changes.length > 0 && entries.length < arr.length) {
+			let onlyAppends = true;
+			let appendCount = 0;
+			for (let i = 0; i < changes.length; i++) {
+				if (changes[i].type !== "append") {
+					onlyAppends = false;
+					break;
+				}
+				appendCount += changes[i].count || 0;
+			}
+			if (onlyAppends && appendCount === arr.length - entries.length) {
+				const startIdx = entries.length;
+				const frag = container.ownerDocument.createDocumentFragment();
+				for (let i = startIdx; i < arr.length; i++) {
+					const e = createEntry(arr[i], i);
+					entries.push(e);
+					byKey.set(e.key, e);
+					_trackLive(pending, e);
+					frag.appendChild(e.element);
+				}
+				container.insertBefore(frag, anchor);
+				prevArrRef = arr;
+				return;
+			}
+		}
+		if (changes && changes.length > 0 && entries.length > arr.length) {
+			let onlyRemoves = true;
+			let totalRemoved = 0;
+			for (let i = 0; i < changes.length; i++) {
+				const c = changes[i];
+				if (c.type !== "remove") {
+					onlyRemoves = false;
+					break;
+				}
+				totalRemoved += c.count || 0;
+			}
+			if (onlyRemoves && entries.length - arr.length === totalRemoved) {
+				if (changes.length < 2 && changes[0].count === 1) {
+					const idx = changes[0].start;
+					if (idx >= 0 && idx < entries.length) {
+						removeEntry(entries[idx]);
+						entries.splice(idx, 1);
+					}
+					prevArrRef = arr;
+					return;
+				}
+				const rmIdx = [];
+				for (const c of changes) {
+					const s = c.start;
+					const ct = c.count;
+					for (let k = 0; k < ct; k++) rmIdx.push(s + k);
+				}
+				rmIdx.sort((a, b) => b - a);
+				for (let i = 0; i < rmIdx.length; i++) {
+					const j = rmIdx[i];
+					if (j >= 0 && j < entries.length) {
+						removeEntry(entries[j]);
+						entries.splice(j, 1);
+					}
+				}
+				prevArrRef = arr;
+				return;
+			}
+		}
+		const newLen = arr.length;
+		const oldLen = entries.length;
+		if (oldLen === 0 && newLen > 0) {
+			const freshEntries = new Array(newLen);
+			const frag = container.ownerDocument.createDocumentFragment();
+			for (let i = 0; i < newLen; i++) {
+				const e = createEntry(arr[i], i);
+				freshEntries[i] = e;
+				byKey.set(e.key, e);
+				_trackLive(pending, e);
+				frag.appendChild(e.element);
+			}
+			container.insertBefore(frag, anchor);
+			entries = freshEntries;
+			prevArrRef = arr;
+			return;
+		}
+		const newKeys = new Array(newLen);
+		for (let i = 0; i < newLen; i++) newKeys[i] = keyFn(arr[i], i);
+		if (newLen === 0) {
+			if (container.childNodes.length === oldLen + 1) {
+				if (onItemRemove) {
+					for (let i = 0; i < oldLen; i++) onItemRemove(entries[i]);
+					_deferBulk(pending, entries);
+				} else _deferBulk(pending, entries);
+				container.textContent = "";
+				container.appendChild(anchor);
+			} else for (let i = oldLen - 1; i >= 0; i--) removeEntry(entries[i]);
+			entries = [];
+			byKey.clear();
+			prevArrRef = arr;
+			return;
+		}
+		if (newLen === oldLen) {
+			let diffA = -1, diffB = -1, diffCount = 0;
+			for (let i = 0; i < newLen; i++) if (entries[i].key !== newKeys[i]) {
+				if (diffCount === 0) diffA = i;
+				else if (diffCount === 1) diffB = i;
+				diffCount++;
+				if (diffCount > 2) break;
+			}
+			if (diffCount === 2 && entries[diffA].key === newKeys[diffB] && entries[diffB].key === newKeys[diffA]) {
+				const eA = entries[diffA], eB = entries[diffB];
+				const refB = eB.element.nextSibling;
+				container.insertBefore(eB.element, eA.element);
+				if (refB) container.insertBefore(eA.element, refB);
+				else container.appendChild(eA.element);
+				entries[diffA] = eB;
+				entries[diffB] = eA;
+				if (unwrap(arr[diffA]) !== eB.item) patchEntry(eB, arr[diffA], diffA);
+				if (unwrap(arr[diffB]) !== eA.item) patchEntry(eA, arr[diffB], diffB);
+				prevArrRef = arr;
+				return;
+			}
+		}
+		if (oldLen > 0 && newLen > 0 && container.childNodes.length === oldLen + 1) {
+			let disjoint = true;
+			for (let i = 0; i < newLen; i++) if (byKey.has(newKeys[i])) {
+				disjoint = false;
+				break;
+			}
+			if (disjoint) {
+				if (onItemRemove) {
+					for (let i = 0; i < oldLen; i++) onItemRemove(entries[i]);
+					_deferBulk(pending, entries);
+				} else _deferBulk(pending, entries);
+				byKey.clear();
+				const newEntries = new Array(newLen);
+				const newEls = new Array(newLen + 1);
+				for (let i = 0; i < newLen; i++) {
+					const e = createEntry(arr[i], i);
+					newEntries[i] = e;
+					newEls[i] = e.element;
+					byKey.set(e.key, e);
+					_trackLive(pending, e);
+				}
+				newEls[newLen] = anchor;
+				container.replaceChildren(...newEls);
+				entries = newEntries;
+				prevArrRef = arr;
+				return;
+			}
+		}
+		for (let i = 0; i < oldLen; i++) entries[i]._i = i;
+		const newToOld = new Array(newLen);
+		const seenOld = new Array(oldLen).fill(false);
+		for (let i = 0; i < newLen; i++) {
+			const existing = byKey.get(newKeys[i]);
+			if (existing) {
+				const oldIdx = existing._i;
+				newToOld[i] = oldIdx;
+				seenOld[oldIdx] = true;
+			} else newToOld[i] = -1;
+		}
+		for (let i = oldLen - 1; i >= 0; i--) if (!seenOld[i]) removeEntry(entries[i]);
+		const stable = new Set(lis(newToOld));
+		const next = new Array(newLen);
+		let nextRef = anchor;
+		for (let i = newLen - 1; i >= 0; i--) {
+			const oldIdx = newToOld[i];
+			let e;
+			if (oldIdx === -1) {
+				e = createEntry(arr[i], i);
+				byKey.set(e.key, e);
+				_trackLive(pending, e);
+				container.insertBefore(e.element, nextRef);
+			} else {
+				e = entries[oldIdx];
+				if (e.item !== unwrap(arr[i])) patchEntry(e, arr[i], i);
+				if (e.element.parentNode !== container) container.insertBefore(e.element, nextRef);
+				else if (!stable.has(i)) container.insertBefore(e.element, nextRef);
+			}
+			next[i] = e;
+			nextRef = e.element;
+		}
+		entries = next;
+		prevArrRef = arr;
+	};
+	if (typeof path === "function") withTracking(disposer, root, () => {
+		const arr = path();
+		const next = Array.isArray(arr) ? arr : [];
+		markEntriesLeaving(next);
+		queueMicrotask(() => reconcile(next));
+	});
+	else {
+		const off = subscribe(root, path, (_v, changes) => {
+			reconcile(resolveArr(), changes);
+		});
+		disposer.add(off);
+	}
+}
+//#endregion
+export { _rescue as n, keyedList as t };
+
+//# sourceMappingURL=keyed-list.mjs.map

package/dist/keyed-list.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-list.mjs","names":["GEA_DIRTY","GEA_DIRTY_PROPS"],"sources":["../../gea/src/runtime/keyed-list/lis.ts","../../gea/src/runtime/keyed-list/rescue.ts","../../gea/src/runtime/keyed-list.ts"],"sourcesContent":["/**\n * Longest Increasing Subsequence — O(n log n). Input is `newToOld[]`\n * (index in new array → index in old array, or `-1` for new items). Output\n * is the set of new-indices that form the longest increasing run of old\n * indices, i.e. the set of entries that can stay put during a reorder.\n */\nexport function lis(arr: number[]): number[] {\n  const n = arr.length\n  if (n === 0) return []\n  const vals: number[] = []\n  const idxs: number[] = []\n  for (let i = 0; i < n; i++) {\n    if (arr[i] >= 0) {\n      vals.push(arr[i])\n      idxs.push(i)\n    }\n  }\n  const m = vals.length\n  if (m === 0) return []\n  const tails: number[] = []\n  const tIdx: number[] = []\n  const pred = new Array(m).fill(-1)\n  for (let i = 0; i < m; i++) {\n    const v = vals[i]\n    let lo = 0,\n      hi = tails.length\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1\n      if (tails[mid] < v) lo = mid + 1\n      else hi = mid\n    }\n    if (lo === tails.length) {\n      tails.push(v)\n      tIdx.push(i)\n    } else {\n      tails[lo] = v\n      tIdx[lo] = i\n    }\n    if (lo > 0) pred[i] = tIdx[lo - 1]\n  }\n  const out = new Array(tails.length)\n  let k = tIdx[tails.length - 1]\n  for (let i = tails.length - 1; i >= 0; i--) {\n    out[i] = idxs[k]\n    k = pred[k]\n  }\n  return out\n}\n","/**\n * Cross-list rescue. `removeEntry` queues `disposer.dispose()` to a microtask\n * instead of firing it synchronously. If the same `.map()` site's\n * `createEntry` sees the matching key before that microtask runs, it pulls\n * the entry back out — DOM + disposer + subscriptions transfer intact.\n *\n * The `pending` map is **per-site**: the compiler emits one `Map<string, Entry<T>>`\n * literal per `.map()` site at module scope and threads it into every\n * `_defer` / `_deferBulk` / `_rescue` call. Two unrelated `.map()` sites\n * can't collide because they literally don't share a Map.\n */\nimport type { Entry } from './types'\nimport { GEA_PROXY_RAW } from '../symbols'\n\ntype Pending<T> = Map<string, Entry<T>>\ntype LiveEntries<T> = Map<string, Set<Entry<T>>>\n\n// Two parallel FLAT arrays instead of a `{ pending, entries }[]`. A record field\n// typed as a `Map` has no geatsc Representation (\"representation-plan coverage\n// gap for record field __gea_type_PendingBulkBatch.pending\"), and an `Entry[][]`\n// of per-batch lists has no frozen record shape either (\"missing-record-shape\n// [__gea_type_Entry] ... Entry[][]\"). One entry per index, with its target map\n// repeated alongside, keeps both vectors flat and exact.\n//\n// This module-level state is shared across EVERY `.map()` site in the app at\n// once, each with its own item type — no single `T` describes it (TypeScript\n// has no existential/wildcard generics for a registry instantiated\n// differently by each caller). So the registries below are declared once\n// against the erased `Pending<unknown>`/`Entry<unknown>`, and every EXPORTED\n// function is what actually carries each call's real `T` — the standard\n// type-erasure-at-the-registry-boundary shape for a shared heterogeneous\n// cache (the same idea as a global cache keyed by branded IDs across many\n// unrelated generic instantiations). `Entry<T>` is structurally covariant in\n// `T` here (a widening store, never narrowed back out except through the\n// exact `Pending<T>` the caller already holds), so storing/retrieving\n// through the erased type doesn't lose safety at the real, generic call\n// sites below — only this module-private cache itself is untyped in `T`.\nconst _toFlush: Set<Pending<unknown>> = new Set()\nconst _live: WeakMap<Pending<unknown>, LiveEntries<unknown>> = new WeakMap()\nconst _claimed: WeakSet<Entry<unknown>> = new WeakSet()\nconst _claimable: WeakSet<Entry<unknown>> = new WeakSet()\nlet _pendingBulkMaps: Pending<unknown>[] = []\nlet _pendingBulkEntries: Entry<unknown>[] = []\nlet _flushQueued = false\n\n// A top-level FUNCTION DECLARATION, not a `const` holding an arrow: an\n// unannotated module-scope callable const has no sealed binding subject\n// under geatsc (`representation-plan coverage gap for\n// VariableDeclaration`) because its `any -> any` signature admits no exact\n// ABI. A function declaration is its own emitted callable and needs no\n// value carrier. Body is unchanged.\nfunction _unwrap<V>(v: V): V {\n  const rawTarget = v && typeof v === 'object' && (v as Record<symbol, unknown>)[GEA_PROXY_RAW]\n  return (rawTarget as V) || v\n}\n\nfunction _liveFor(pending: Pending<unknown>): LiveEntries<unknown> {\n  let live = _live.get(pending)\n  if (!live) {\n    live = new Map()\n    _live.set(pending, live)\n  }\n  return live\n}\n\nexport function _trackLive<T>(pending: Pending<T>, e: Entry<T>): void {\n  const key = String(e.key)\n  const live = _liveFor(pending as Pending<unknown>)\n  let bucket = live.get(key)\n  if (!bucket) live.set(key, (bucket = new Set()))\n  bucket.add(e as Entry<unknown>)\n}\n\nfunction _untrackLive<T>(pending: Pending<T>, e: Entry<T>): void {\n  _claimable.delete(e as Entry<unknown>)\n  const bucket = _live.get(pending as Pending<unknown>)?.get(String(e.key))\n  if (!bucket) return\n  bucket.delete(e as Entry<unknown>)\n  if (bucket.size === 0) _live.get(pending as Pending<unknown>)?.delete(String(e.key))\n}\n\nexport function _markClaimable<T>(e: Entry<T>, claimable: boolean): void {\n  if (claimable) _claimable.add(e as Entry<unknown>)\n  else _claimable.delete(e as Entry<unknown>)\n}\n\nexport function _consumeClaim<T>(e: Entry<T>): boolean {\n  if (!_claimed.has(e as Entry<unknown>)) return false\n  _claimed.delete(e as Entry<unknown>)\n  _claimable.delete(e as Entry<unknown>)\n  return true\n}\n\nfunction _schedule(): void {\n  if (_flushQueued) return\n  _flushQueued = true\n  queueMicrotask(() => {\n    _flushQueued = false\n    const drainMaps = Array.from(_toFlush)\n    const bulkEntries = _pendingBulkEntries\n    _toFlush.clear()\n    _pendingBulkMaps = []\n    _pendingBulkEntries = []\n    for (let i = 0; i < drainMaps.length; i++) {\n      const m = drainMaps[i]\n      for (const e of m.values()) {\n        try {\n          e.disposer.dispose()\n        } catch {\n          /* isolated */\n        }\n      }\n      m.clear()\n    }\n    for (let i = 0; i < bulkEntries.length; i++) {\n      try {\n        bulkEntries[i].disposer.dispose()\n      } catch {\n        /* isolated */\n      }\n    }\n  })\n}\n\nexport function _defer<T>(pending: Pending<T>, e: Entry<T>): void {\n  _untrackLive(pending, e)\n  pending.set(String(e.key), e)\n  _toFlush.add(pending as Pending<unknown>)\n  _schedule()\n}\n\n/**\n * Queue a full batch of removed entries for deferred disposal. Cheaper than\n * per-row `_defer` for whole-list ops (clear, disjoint replace): no\n * `Map.set` per row. If a `_rescue` call arrives before the microtask\n * drains, the batch is materialized into its target `pending` map first.\n */\nexport function _deferBulk<T>(pending: Pending<T>, entries: Entry<T>[]): void {\n  if (entries.length === 0) return\n  const next: Entry<T>[] = []\n  for (let i = 0; i < entries.length; i++) {\n    const e = entries[i]\n    if (_consumeClaim(e)) continue\n    _untrackLive(pending, e)\n    next.push(e)\n  }\n  if (next.length === 0) return\n  for (let i = 0; i < next.length; i++) {\n    _pendingBulkMaps.push(pending as Pending<unknown>)\n    _pendingBulkEntries.push(next[i] as Entry<unknown>)\n  }\n  _schedule()\n}\n\nexport function _rescue<T>(pending: Pending<T>, key: string, item?: T): Entry<T> | null {\n  const e = pending.get(key)\n  if (e) {\n    pending.delete(key)\n    return e\n  }\n\n  // Lazy fallback: materialize any pending bulk batches into their target\n  // pending maps so cross-site rescue still works without paying per-row\n  // Map.set on the common no-rescue-needed bulk path.\n  if (_pendingBulkMaps.length > 0) {\n    for (let i = 0; i < _pendingBulkMaps.length; i++) {\n      const target = _pendingBulkMaps[i]\n      const bulkItem = _pendingBulkEntries[i]\n      target.set(String(bulkItem.key), bulkItem)\n      _toFlush.add(target)\n    }\n    _pendingBulkMaps = []\n    _pendingBulkEntries = []\n    const r = pending.get(key)\n    if (r) {\n      pending.delete(key)\n      return r\n    }\n  }\n\n  if (arguments.length >= 3) {\n    const raw = _unwrap(item)\n    const bucket = _live.get(pending as Pending<unknown>)?.get(key)\n    if (bucket) {\n      for (const live of bucket) {\n        if (_claimable.has(live) && live.item === raw) {\n          _claimed.add(live)\n          _claimable.delete(live)\n          return live as Entry<T>\n        }\n      }\n    }\n  }\n  return null\n}\n","/**\n * keyedList — compile-time-specialized keyed list reconciler.\n *\n * This module is the **diff kernel only**. It does not know about:\n *   - item proxies (`ItemObs`, `createItemProxy`)\n *   - row disposers (allocated or shared no-op)\n *   - compiler analysis flags (`noItemProxy`, `skipInitialPatch`, etc.)\n *   - the `createItem` / `patchRow` pair\n *   - owner lifecycle hooks (`registerListState`, `onItemSync`)\n *\n * All that logic is inlined by the compiler at each `.map()` site via\n * three specialized closures:\n *\n *   - `createEntry(item, idx) => Entry`:\n *       Full per-row work — `_rescue` lookup, disposer allocation (or\n *       not), `ItemObs` construction (or not), template clone + walks +\n *       bindings + stamps, initial patch writes. Opaque to the kernel.\n *   - `patchEntry(e, newItem, newIdx)`:\n *       Per-row identity-change work — `e.item` update, `obs.fire` (if\n *       proxied), direct DOM writes on dirty bindings, dirty-bit clear.\n *   - `onItemRemove?(e)` (optional):\n *       User-level cleanup on removal (relational-class map delete, etc.).\n *       Omit entirely for rows with no cleanup.\n *\n * Apps whose sites never need item-proxies end up with zero references\n * to `ItemObs` / `createItemProxy` through the kernel's import graph\n * → tree-shaker drops them → bundle shrinks.\n */\n\nimport type { Disposer } from './disposer'\nimport { subscribe } from './subscribe'\nimport { withTracking } from './with-tracking'\nimport type { Change } from '../store'\nimport { GEA_DIRTY, GEA_DIRTY_PROPS } from './dirty-symbols'\nimport { GEA_PROXY_RAW } from './symbols'\nimport { lis } from './keyed-list/lis'\nimport type { Entry } from './keyed-list/types'\nimport { _consumeClaim, _defer, _deferBulk, _markClaimable, _trackLive } from './keyed-list/rescue'\nimport { GEA_DOM_ITEM, GEA_DOM_KEY } from './keyed-list-symbols'\n\n/** Unwrap a proxy value to its raw target. */\n// A top-level FUNCTION DECLARATION, not a `const` holding an arrow: an\n// unannotated module-scope callable const has no sealed binding subject\n// under geatsc (`representation-plan coverage gap for\n// VariableDeclaration`) because its `any -> any` signature admits no exact\n// ABI. A function declaration is its own emitted callable and needs no\n// value carrier. Body is unchanged.\nfunction unwrap<V>(v: V): V {\n  const rawTarget = v && typeof v === 'object' && (v as Record<symbol, unknown>)[GEA_PROXY_RAW]\n  return (rawTarget as V) || v\n}\n\nexport { GEA_DOM_ITEM, GEA_DOM_KEY } from './keyed-list-symbols'\n\nexport type { Entry, ItemObservable } from './keyed-list/types'\n\n/**\n * `T` is the list item's type — knowable at each `.map()` call site (the\n * compiler emits one `keyedList()` invocation per site, closed over the\n * source array's real element type). `root` stays a structural `any`: it's\n * whatever object `path`/getter reads through (a component instance, a\n * nested store, ...), and — unlike the item — resolving it further would\n * need the same path-typed machinery `subscribe()` documents as a genuine\n * dynamic boundary.\n */\nexport interface KeyedListConfig<T> {\n  container: Element\n  anchor: Comment\n  disposer: Disposer\n  root: any\n  /**\n   * Per-site rescue queue. The compiler emits one `Map<string, Entry<T>>`\n   * literal per `.map()` site at module scope and threads it through here so\n   * two unrelated sites can't collide. Optional for hand-written callers (a\n   * fresh map is allocated when omitted, disabling cross-render rescue but\n   * keeping the disposer microtask intact).\n   */\n  pending?: Map<string, Entry<T>>\n  /** Either a static path on `root` (`['items']`) OR a getter returning the array. */\n  path: readonly string[] | (() => T[])\n  key: (item: T, idx: number) => string\n  /** Compiler-specialized: create a new entry for this item at index `idx`. */\n  createEntry: (item: T, idx: number) => Entry<T>\n  /** Compiler-specialized: apply a new item identity to an existing entry. */\n  patchEntry: (e: Entry<T>, newItem: T, newIdx: number) => void\n  /** Optional: user-level cleanup on row removal (relational-class map delete). */\n  onItemRemove?: (e: Entry<T>) => void\n  /** Optional: gives relational-class setup access to the kernel's byKey Map. */\n  onByKeyCreated?: (byKey: Map<string, Entry<T>>) => void\n}\n\nexport function keyedList<T>(cfg: KeyedListConfig<T>): void {\n  const container = cfg.container\n  const anchor = cfg.anchor\n  const disposer = cfg.disposer\n  const root = cfg.root\n  const path = cfg.path\n  const keyFn = cfg.key\n  const createEntry = cfg.createEntry\n  const patchEntry = cfg.patchEntry\n  const onItemRemove = cfg.onItemRemove\n  const pending: Map<string, Entry<T>> = cfg.pending ?? new Map()\n\n  let entries: Entry<T>[] = []\n  const byKey = new Map<string, Entry<T>>()\n  if (cfg.onByKeyCreated) cfg.onByKeyCreated(byKey)\n\n  const resolveArr = (): T[] => {\n    if (typeof path === 'function') {\n      const v = (path as () => T[])()\n      return Array.isArray(v) ? v : []\n    }\n    let v: any = root\n    for (let i = 0; i < (path as readonly string[]).length; i++) {\n      if (v == null) return []\n      v = v[(path as readonly string[])[i]]\n    }\n    return Array.isArray(v) ? v : []\n  }\n\n  const removeEntry = (e: Entry<T>): void => {\n    if (onItemRemove) onItemRemove(e)\n    byKey.delete(e.key)\n    if (_consumeClaim(e)) return\n    if (e.element.parentNode) e.element.parentNode.removeChild(e.element)\n    _defer(pending, e)\n  }\n\n  const markEntriesLeaving = (next: T[]): void => {\n    if (entries.length === 0) return\n    const nextByKey = new Map<string, Set<T>>()\n    for (let i = 0; i < next.length; i++) {\n      const k = keyFn(next[i], i)\n      let bucket = nextByKey.get(k)\n      if (!bucket) nextByKey.set(k, (bucket = new Set()))\n      bucket.add(unwrap(next[i]))\n    }\n    for (let i = 0; i < entries.length; i++) {\n      const e = entries[i]\n      _markClaimable(e, !nextByKey.get(e.key)?.has(e.item))\n    }\n  }\n\n  // ── First render ──────────────────────────────────────────────────────\n  const firstArr = resolveArr()\n  if (firstArr.length > 0) {\n    const frag = container.ownerDocument!.createDocumentFragment()\n    for (let i = 0; i < firstArr.length; i++) {\n      const item = firstArr[i]\n      const e = createEntry(item, i)\n      entries.push(e)\n      byKey.set(e.key, e)\n      _trackLive(pending, e)\n      frag.appendChild(e.element)\n      if (item && typeof item === 'object') {\n        ;(item as any)[GEA_DIRTY] = false\n        ;(item as any)[GEA_DIRTY_PROPS]?.clear()\n      }\n    }\n    container.insertBefore(frag, anchor)\n  }\n\n  let prevArrRef: T[] = firstArr\n\n  const patchDirtyItems = (arr: T[]): boolean => {\n    let patched = false\n    const raw = (arr as any)[GEA_PROXY_RAW] || arr\n    for (let i = 0; i < raw.length; i++) {\n      const item = raw[i]\n      if (item && typeof item === 'object' && item[GEA_DIRTY]) {\n        patchEntry(entries[i], item, i)\n        item[GEA_DIRTY] = false\n        item[GEA_DIRTY_PROPS]?.clear()\n        entries[i].item = item\n        patched = true\n      }\n    }\n    return patched\n  }\n\n  // ── Reconciliation ────────────────────────────────────────────────────\n  const reconcile = (arr: T[], changes?: Change[]): void => {\n    // Same array ref + same length → structural no-op. Dirty-bit scan\n    // picks up in-place item writes.\n    if (arr === prevArrRef && entries.length === arr.length) {\n      let structural = false\n      let aipuOnly = changes && changes.length > 0\n      let itemDirtyOnly = changes && changes.length > 0\n      if (changes && changes.length > 0) {\n        for (let i = 0; i < changes.length; i++) {\n          const c = changes[i]\n          if (c.type === 'append' || c.type === 'remove' || c.type === 'delete' || c.type === 'reorder') {\n            structural = true\n            aipuOnly = false\n            itemDirtyOnly = false\n            break\n          }\n          if (!c.aipu) {\n            aipuOnly = false\n            itemDirtyOnly = false\n          } else {\n            structural = true\n            if (!c.itemDirty) itemDirtyOnly = false\n          }\n        }\n      }\n      if (itemDirtyOnly) {\n        const raw = (arr as any)[GEA_PROXY_RAW] || arr\n        let stableKeys = true\n        for (let i = 0; i < changes!.length; i++) {\n          const idx = changes![i].arix as number\n          if (idx < 0 || idx >= entries.length || entries[idx].key !== keyFn(raw[idx], idx)) {\n            stableKeys = false\n            break\n          }\n        }\n        if (stableKeys) {\n          patchDirtyItems(arr)\n          return\n        }\n      }\n      // aipu-only 2-swap: items[i]↔items[j] via two symmetric aipu records.\n      if (aipuOnly && changes!.length > 1 && changes!.length < 3) {\n        const a = changes![0].arix as number\n        const b = changes![1].arix as number\n        if (a >= 0 && b >= 0 && a < entries.length && b < entries.length && a !== b) {\n          const eA = entries[a]\n          const eB = entries[b]\n          const newAKey = keyFn(arr[a], a)\n          const newBKey = keyFn(arr[b], b)\n          if (eA.key === newBKey && eB.key === newAKey) {\n            const refB = eB.element.nextSibling\n            container.insertBefore(eB.element, eA.element)\n            if (refB) container.insertBefore(eA.element, refB)\n            else container.appendChild(eA.element)\n            entries[a] = eB\n            entries[b] = eA\n            if (unwrap(arr[a]) !== eB.item) patchEntry(eB, arr[a], a)\n            if (unwrap(arr[b]) !== eA.item) patchEntry(eA, arr[b], b)\n            prevArrRef = arr\n            return\n          }\n        }\n      }\n      if (!structural) {\n        // Dirty-aware patch pass. Same array ref + no structural change →\n        // in-place item mutations (e.g. `store.items[i].label = 'X'`) only.\n        // The store's nested-proxy set trap stamped `item[GEA_DIRTY]=true`;\n        // walk the raw array and patch marked items. Runtime owns the\n        // dirty-bit protocol — compiler-emitted patchEntry doesn't see it.\n        patchDirtyItems(arr)\n        return\n      }\n    }\n\n    if (entries.length === arr.length && changes && changes.length > 0) {\n      let structural = false\n      for (let i = 0; i < changes.length; i++) {\n        const c = changes[i]\n        if (c.type === 'append' || c.type === 'remove' || c.type === 'delete' || c.type === 'reorder' || c.aipu) {\n          structural = true\n          break\n        }\n      }\n      if (!structural && patchDirtyItems(arr)) {\n        prevArrRef = arr\n        return\n      }\n    }\n\n    // Append-only.\n    if (changes && changes.length > 0 && entries.length < arr.length) {\n      let onlyAppends = true\n      let appendCount = 0\n      for (let i = 0; i < changes.length; i++) {\n        if (changes[i].type !== 'append') {\n          onlyAppends = false\n          break\n        }\n        appendCount += (changes[i].count as number) || 0\n      }\n      if (onlyAppends && appendCount === arr.length - entries.length) {\n        const startIdx = entries.length\n        const frag = container.ownerDocument!.createDocumentFragment()\n        for (let i = startIdx; i < arr.length; i++) {\n          const e = createEntry(arr[i], i)\n          entries.push(e)\n          byKey.set(e.key, e)\n          _trackLive(pending, e)\n          frag.appendChild(e.element)\n        }\n        container.insertBefore(frag, anchor)\n        prevArrRef = arr\n        return\n      }\n    }\n\n    // Remove-only.\n    if (changes && changes.length > 0 && entries.length > arr.length) {\n      let onlyRemoves = true\n      let totalRemoved = 0\n      for (let i = 0; i < changes.length; i++) {\n        const c = changes[i]\n        if (c.type !== 'remove') {\n          onlyRemoves = false\n          break\n        }\n        totalRemoved += (c.count as number) || 0\n      }\n      if (onlyRemoves && entries.length - arr.length === totalRemoved) {\n        if (changes.length < 2 && (changes[0].count as number) === 1) {\n          const idx = changes[0].start as number\n          if (idx >= 0 && idx < entries.length) {\n            removeEntry(entries[idx])\n            entries.splice(idx, 1)\n          }\n          prevArrRef = arr\n          return\n        }\n        const rmIdx: number[] = []\n        for (const c of changes) {\n          const s = c.start as number\n          const ct = c.count as number\n          for (let k = 0; k < ct; k++) rmIdx.push(s + k)\n        }\n        rmIdx.sort((a, b) => b - a)\n        for (let i = 0; i < rmIdx.length; i++) {\n          const j = rmIdx[i]\n          if (j >= 0 && j < entries.length) {\n            removeEntry(entries[j])\n            entries.splice(j, 1)\n          }\n        }\n        prevArrRef = arr\n        return\n      }\n    }\n\n    // ── General keyed reconciliation ─────────────────────────────────\n    const newLen = arr.length\n    const oldLen = entries.length\n\n    // Fresh-create fast path (09_clear1k_x8 per-cycle).\n    if (oldLen === 0 && newLen > 0) {\n      const freshEntries: Entry<T>[] = new Array(newLen)\n      const frag = container.ownerDocument!.createDocumentFragment()\n      for (let i = 0; i < newLen; i++) {\n        const e = createEntry(arr[i], i)\n        freshEntries[i] = e\n        byKey.set(e.key, e)\n        _trackLive(pending, e)\n        frag.appendChild(e.element)\n      }\n      container.insertBefore(frag, anchor)\n      entries = freshEntries\n      prevArrRef = arr\n      return\n    }\n\n    const newKeys: string[] = new Array(newLen)\n    for (let i = 0; i < newLen; i++) newKeys[i] = keyFn(arr[i], i)\n\n    if (newLen === 0) {\n      // Bulk clear.\n      if (container.childNodes.length === oldLen + 1) {\n        if (onItemRemove) {\n          for (let i = 0; i < oldLen; i++) onItemRemove(entries[i])\n          _deferBulk(pending, entries)\n        } else {\n          _deferBulk(pending, entries)\n        }\n        container.textContent = ''\n        container.appendChild(anchor)\n      } else {\n        for (let i = oldLen - 1; i >= 0; i--) removeEntry(entries[i])\n      }\n      entries = []\n      byKey.clear()\n      prevArrRef = arr\n      return\n    }\n\n    // Swap fast path (05_swap).\n    if (newLen === oldLen) {\n      let diffA = -1,\n        diffB = -1,\n        diffCount = 0\n      for (let i = 0; i < newLen; i++) {\n        if (entries[i].key !== newKeys[i]) {\n          if (diffCount === 0) diffA = i\n          else if (diffCount === 1) diffB = i\n          diffCount++\n          if (diffCount > 2) break\n        }\n      }\n      if (diffCount === 2 && entries[diffA].key === newKeys[diffB] && entries[diffB].key === newKeys[diffA]) {\n        const eA = entries[diffA],\n          eB = entries[diffB]\n        const refB = eB.element.nextSibling\n        container.insertBefore(eB.element, eA.element)\n        if (refB) container.insertBefore(eA.element, refB)\n        else container.appendChild(eA.element)\n        entries[diffA] = eB\n        entries[diffB] = eA\n        if (unwrap(arr[diffA]) !== eB.item) patchEntry(eB, arr[diffA], diffA)\n        if (unwrap(arr[diffB]) !== eA.item) patchEntry(eA, arr[diffB], diffB)\n        prevArrRef = arr\n        return\n      }\n    }\n\n    // Disjoint-replace (02_replace1k).\n    if (oldLen > 0 && newLen > 0 && container.childNodes.length === oldLen + 1) {\n      let disjoint = true\n      for (let i = 0; i < newLen; i++) {\n        if (byKey.has(newKeys[i])) {\n          disjoint = false\n          break\n        }\n      }\n      if (disjoint) {\n        if (onItemRemove) {\n          for (let i = 0; i < oldLen; i++) onItemRemove(entries[i])\n          _deferBulk(pending, entries)\n        } else {\n          _deferBulk(pending, entries)\n        }\n        byKey.clear()\n        const newEntries: Entry<T>[] = new Array(newLen)\n        const newEls: Node[] = new Array(newLen + 1)\n        for (let i = 0; i < newLen; i++) {\n          const e = createEntry(arr[i], i)\n          newEntries[i] = e\n          newEls[i] = e.element\n          byKey.set(e.key, e)\n          _trackLive(pending, e)\n        }\n        newEls[newLen] = anchor\n        ;(container as any).replaceChildren(...newEls)\n        entries = newEntries\n        prevArrRef = arr\n        return\n      }\n    }\n\n    // General LIS reconcile.\n    for (let i = 0; i < oldLen; i++) (entries[i] as any)._i = i\n    const newToOld = new Array(newLen)\n    const seenOld = new Array(oldLen).fill(false)\n    for (let i = 0; i < newLen; i++) {\n      const existing = byKey.get(newKeys[i])\n      if (existing) {\n        const oldIdx = (existing as any)._i as number\n        newToOld[i] = oldIdx\n        seenOld[oldIdx] = true\n      } else {\n        newToOld[i] = -1\n      }\n    }\n\n    for (let i = oldLen - 1; i >= 0; i--) {\n      if (!seenOld[i]) removeEntry(entries[i])\n    }\n\n    const stable = new Set(lis(newToOld))\n\n    const next: Entry<T>[] = new Array(newLen)\n    let nextRef: Node = anchor\n    for (let i = newLen - 1; i >= 0; i--) {\n      const oldIdx = newToOld[i]\n      let e: Entry<T>\n      if (oldIdx === -1) {\n        e = createEntry(arr[i], i)\n        byKey.set(e.key, e)\n        _trackLive(pending, e)\n        container.insertBefore(e.element, nextRef)\n      } else {\n        e = entries[oldIdx]\n        if (e.item !== unwrap(arr[i])) patchEntry(e, arr[i], i)\n        if (e.element.parentNode !== container) container.insertBefore(e.element, nextRef)\n        else if (!stable.has(i)) container.insertBefore(e.element, nextRef)\n      }\n      next[i] = e\n      nextRef = e.element\n    }\n\n    entries = next\n    prevArrRef = arr\n  }\n\n  // ── Subscribe for array updates ──────────────────────────────────────\n  if (typeof path === 'function') {\n    withTracking(disposer, root, () => {\n      const arr = (path as () => T[])()\n      const next: T[] = Array.isArray(arr) ? arr : []\n      markEntriesLeaving(next)\n      queueMicrotask(() => reconcile(next))\n    })\n  } else {\n    const off = subscribe(root, path as readonly string[], (_v: any, changes?: Change[]) => {\n      reconcile(resolveArr(), changes)\n    })\n    disposer.add(off)\n  }\n}\n"],"mappings":"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"}

package/dist/label.d.mts

@@ -2,7 +2,7 @@ import { Component } from "@geajs/core";
 
 //#region src/components/label.d.ts
 declare class Label extends Component {
-  template(props: any): string;
+  template(props: any): any;
 }
 //#endregion
 export { Label as default };