@geajs/ui 0.2.3 → 0.2.9

package/dist/keyed-list.mjs

@@ -0,0 +1,487 @@
+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] !== -1) {
+		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 _pendingBulk = null;
+let _flushQueued = false;
+const _unwrap = (v) => 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 bulk = _pendingBulk;
+		_toFlush.clear();
+		_pendingBulk = null;
+		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();
+		}
+		if (bulk) for (let i = 0; i < bulk.length; i++) {
+			const batch = bulk[i].entries;
+			for (let j = 0; j < batch.length; j++) try {
+				batch[j].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;
+	const batch = {
+		pending,
+		entries: next
+	};
+	if (_pendingBulk) _pendingBulk.push(batch);
+	else _pendingBulk = [batch];
+	_schedule();
+}
+function _rescue(pending, key, item) {
+	const e = pending.get(key);
+	if (e) {
+		pending.delete(key);
+		return e;
+	}
+	if (_pendingBulk) {
+		for (let i = 0; i < _pendingBulk.length; i++) {
+			const batch = _pendingBulk[i];
+			const target = batch.pending;
+			const items = batch.entries;
+			for (let j = 0; j < items.length; j++) target.set(String(items[j].key), items[j]);
+			_toFlush.add(target);
+		}
+		_pendingBulk = null;
+		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. */
+const unwrap = (v) => v && typeof v === "object" && v[GEA_PROXY_RAW] || v;
+function keyedList(cfg) {
+	const { container, anchor, disposer, root, path, key: keyFn, createEntry, patchEntry, onItemRemove } = cfg;
+	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 reconcile = (arr, changes) => {
+		if (arr === prevArrRef && entries.length === arr.length) {
+			let structural = false;
+			let aipuOnly = 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;
+					break;
+				}
+				if (!c.aipu) aipuOnly = false;
+				else structural = true;
+			}
+			if (aipuOnly && changes.length === 2) {
+				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) {
+				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;
+					}
+				}
+				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 === 1 && 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] !== -1) {\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>`\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 = Map<string, Entry>\ntype LiveEntries = Map<string, Set<Entry>>\n\ninterface PendingBulkBatch {\n  pending: Pending\n  entries: Entry[]\n}\n\nconst _toFlush = new Set<Pending>()\nconst _live = new WeakMap<Pending, LiveEntries>()\nconst _claimed = new WeakSet<Entry>()\nconst _claimable = new WeakSet<Entry>()\nlet _pendingBulk: PendingBulkBatch[] | null = null\nlet _flushQueued = false\n\nconst _unwrap = (v: any): any => (v && typeof v === 'object' && v[GEA_PROXY_RAW]) || v\n\nfunction _liveFor(pending: Pending): LiveEntries {\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(pending: Pending, e: Entry): void {\n  const key = String(e.key)\n  const live = _liveFor(pending)\n  let bucket = live.get(key)\n  if (!bucket) live.set(key, (bucket = new Set()))\n  bucket.add(e)\n}\n\nfunction _untrackLive(pending: Pending, e: Entry): void {\n  _claimable.delete(e)\n  const bucket = _live.get(pending)?.get(String(e.key))\n  if (!bucket) return\n  bucket.delete(e)\n  if (bucket.size === 0) _live.get(pending)?.delete(String(e.key))\n}\n\nexport function _markClaimable(e: Entry, claimable: boolean): void {\n  if (claimable) _claimable.add(e)\n  else _claimable.delete(e)\n}\n\nexport function _consumeClaim(e: Entry): boolean {\n  if (!_claimed.has(e)) return false\n  _claimed.delete(e)\n  _claimable.delete(e)\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 bulk = _pendingBulk\n    _toFlush.clear()\n    _pendingBulk = null\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    if (bulk) {\n      for (let i = 0; i < bulk.length; i++) {\n        const batch = bulk[i].entries\n        for (let j = 0; j < batch.length; j++) {\n          try {\n            batch[j].disposer.dispose()\n          } catch {\n            /* isolated */\n          }\n        }\n      }\n    }\n  })\n}\n\nexport function _defer(pending: Pending, e: Entry): void {\n  _untrackLive(pending, e)\n  pending.set(String(e.key), e)\n  _toFlush.add(pending)\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(pending: Pending, entries: Entry[]): void {\n  if (entries.length === 0) return\n  const next: Entry[] = []\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  const batch: PendingBulkBatch = { pending, entries: next }\n  if (_pendingBulk) _pendingBulk.push(batch)\n  else _pendingBulk = [batch]\n  _schedule()\n}\n\nexport function _rescue(pending: Pending, key: string, item?: any): Entry | 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 (_pendingBulk) {\n    for (let i = 0; i < _pendingBulk.length; i++) {\n      const batch = _pendingBulk[i]\n      const target = batch.pending\n      const items = batch.entries\n      for (let j = 0; j < items.length; j++) target.set(String(items[j].key), items[j])\n      _toFlush.add(target)\n    }\n    _pendingBulk = null\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)?.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\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. */\nconst unwrap = (v: any): any => (v && typeof v === 'object' && v[GEA_PROXY_RAW]) || v\n\nexport { GEA_DOM_ITEM, GEA_DOM_KEY } from './keyed-list-symbols'\n\nexport type { Entry, ItemObservable } from './keyed-list/types'\n\nexport interface KeyedListConfig {\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>` literal\n   * per `.map()` site at module scope and threads it through here so two\n   * unrelated sites can't collide. Optional for hand-written callers (a fresh\n   * map is allocated when omitted, disabling cross-render rescue but keeping\n   * the disposer microtask intact).\n   */\n  pending?: Map<string, Entry>\n  /** Either a static path on `root` (`['items']`) OR a getter returning the array. */\n  path: readonly string[] | (() => any[])\n  key: (item: any, idx: number) => string\n  /** Compiler-specialized: create a new entry for this item at index `idx`. */\n  createEntry: (item: any, idx: number) => Entry\n  /** Compiler-specialized: apply a new item identity to an existing entry. */\n  patchEntry: (e: Entry, newItem: any, newIdx: number) => void\n  /** Optional: user-level cleanup on row removal (relational-class map delete). */\n  onItemRemove?: (e: Entry) => void\n  /** Optional: gives relational-class setup access to the kernel's byKey Map. */\n  onByKeyCreated?: (byKey: Map<string, Entry>) => void\n}\n\nexport function keyedList(cfg: KeyedListConfig): void {\n  const { container, anchor, disposer, root, path, key: keyFn, createEntry, patchEntry, onItemRemove } = cfg\n  const pending: Map<string, Entry> = cfg.pending ?? new Map()\n\n  let entries: Entry[] = []\n  const byKey = new Map<string, Entry>()\n  if (cfg.onByKeyCreated) cfg.onByKeyCreated(byKey)\n\n  const resolveArr = (): any[] => {\n    if (typeof path === 'function') {\n      const v = (path as () => any[])()\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): 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: any[]): void => {\n    if (entries.length === 0) return\n    const nextByKey = new Map<string, Set<any>>()\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: any = firstArr\n\n  // ── Reconciliation ────────────────────────────────────────────────────\n  const reconcile = (arr: any[], 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      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            break\n          }\n          if (!c.aipu) aipuOnly = false\n          else structural = true\n        }\n      }\n      // aipu-only 2-swap: items[i]↔items[j] via two symmetric aipu records.\n      if (aipuOnly && changes!.length === 2) {\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        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          }\n        }\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 === 1 && (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[] = 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[] = 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[] = 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\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 () => any[])()\n      const next = 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 };

package/dist/label.mjs

@@ -1,49 +1,24 @@
-import { t as cn } from "./cn.mjs";
-import { Component, GEA_ELEMENT, GEA_INSTANTIATE_CHILD_COMPONENTS, GEA_MOUNT_COMPILED_CHILD_COMPONENTS, GEA_ON_PROP_CHANGE, GEA_PATCH_NODE } from "@geajs/core";
+import { n as cn, t as CompiledComponent } from "./compiled-component.mjs";
+import { o as GEA_CREATE_TEMPLATE } from "./bind.mjs";
+import { t as reactiveText } from "./reactive-text.mjs";
+import { t as reactiveAttr } from "./reactive-attr.mjs";
+import { t as reactiveClass } from "./reactive-class.mjs";
 //#region src/components/label.tsx
-var Label = class extends Component {
-	static {
-		this.__geaTagName = "gea-label";
-	}
-	template(props) {
-		return `<label id="${this.id}"${cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", props.class) == null || cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", props.class) === false ? "" : ` class="${(cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", props.class) != null ? String(cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", props.class)) : "").trim()}"`}${props.htmlFor == null || props.htmlFor === false ? "" : ` for="${props.htmlFor}"`}>${props.children}</label>`;
-	}
-	[GEA_ON_PROP_CHANGE](key, value) {
-		if (key === "class") {
-			const __el = this[GEA_ELEMENT];
-			this.props;
-			const __boundValue = cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", value);
-			if (__el) {
-				const __newClass = String(__boundValue ?? "").trim().replace(/\s+/g, " ");
-				if (__el.className !== __newClass) __el.className = __newClass;
-			}
-		}
-		if (key === "htmlFor") {
-			const __el = this[GEA_ELEMENT];
-			if (__el) {
-				var __av = value;
-				if (__av == null || __av === false) __el.removeAttribute("for");
-				else {
-					const __newAttr = String(__av);
-					if (__el.getAttribute("for") !== __newAttr) __el.setAttribute("for", __newAttr);
-				}
-			}
-		}
-		if (key === "children") {
-			const __el = this[GEA_ELEMENT];
-			if (__el) {
-				const __tw = document.createElement("template");
-				__tw.innerHTML = value;
-				const __newEl = __tw.content.firstElementChild;
-				const __existEl = __el.firstElementChild;
-				if (__newEl && __existEl && __tw.content.childNodes.length === 1) this.constructor[GEA_PATCH_NODE](__existEl, __newEl, true);
-				else if (__el.innerHTML !== value) {
-					__el.innerHTML = value;
-					this[GEA_INSTANTIATE_CHILD_COMPONENTS]();
-					if (this.parentComponent) this.parentComponent[GEA_MOUNT_COMPILED_CHILD_COMPONENTS]();
-				}
-			}
-		}
+function _tpl0_create() {
+	const e = document.createElement("label");
+	e.textContent = "0";
+	return e;
+}
+var Label = class extends CompiledComponent {
+	[GEA_CREATE_TEMPLATE](d) {
+		const root = _tpl0_create();
+		const el0 = root;
+		const el1 = el0;
+		const marker2 = root.firstChild;
+		reactiveClass(el0, d, this, () => cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", this.props.class));
+		reactiveAttr(el1, d, this, "for", () => this.props.htmlFor);
+		reactiveText(marker2, d, this, () => this.props.children);
+		return root;
 	}
 };
 //#endregion

package/dist/label.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"label.mjs","names":["Component","GEA_ON_PROP_CHANGE","GEA_ELEMENT","GEA_PATCH_NODE","GEA_INSTANTIATE_CHILD_COMPONENTS","GEA_MOUNT_COMPILED_CHILD_COMPONENTS","cn","Label","__geaTagName","template","props","__id","id","class","String","trim","htmlFor","children","key","value","__el","__boundValue","__newClass","replace","className","__av","removeAttribute","__newAttr","getAttribute","setAttribute","__tw","document","createElement","innerHTML","__newEl","content","firstElementChild","__existEl","childNodes","length","constructor","parentComponent"],"sources":["../src/components/label.tsx"],"sourcesContent":["import { Component } from '@geajs/core'\nimport { cn } from '../utils/cn'\n\nexport default class Label extends Component {\n  template(props: any) {\n    return (\n      <label\n        class={cn(\n          'text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70',\n          props.class,\n        )}\n        for={props.htmlFor}\n      >\n        {props.children}\n      </label>\n    )\n  }\n}\n"],"mappings":";;;AAGA,IAAqBO,QAArB,cAAmCP,UAAU;;sBAAA;;CAC3CS,SAASC,OAAY;AACnB,SAAA,cADmB,KAAAE,GACnB,GAEWN,GACL,8FACAI,MAAMG,MACP,IAAA,QAHMP,GACL,8FACAI,MAAMG,MACP,KAAA,QAAA,KAAA,YAHMP,GACL,8FACAI,MAAMG,MACP,IAAA,OAAAC,OAHMR,GACL,8FACAI,MAAMG,MACP,CAAA,GAAA,IAAAE,MAAA,CAAA,KACIL,MAAMM,WAAO,QAAbN,MAAMM,YAAO,QAAA,KAAA,SAAbN,MAAMM,QAAO,GAAA,GAEjBN,MAAMO,SAAQ;;CAZvB,CAAAhB,oBAAwBiB,KAAKC,OAAK;AAAA,MAAAD,QAAA,SAAA;GAAA,MAAAE,OAAA,KAAAlB;AAGb,QAAAQ;GAAA,MAAAW,eAGNf,GACL,8FAA4Fa,MAE7F;AAAA,OAAAC,MATT;IACM,MAAME,aADXR,OAAOO,gBAAyB,GAAG,CAAEN,MAAM,CAACQ,QAAQ,QAAQ,IACf;AACxC,QAAIH,KAAsBI,cAAcF,WAAYF,MAAsBI,YAAYF;;;AACvF,MAAAJ,QAAA,WAAA;GAAA,MAAAE,OAAA,KAAAlB;AAAA,OAAAkB,MAAA;IAFC,IAAIK,OAAIN;AACR,QAAIM,QAAQ,QAAQA,SAAS,MAC3BL,MAAsBM,gBAAgB,MAAM;SACvC;KACL,MAAMC,YAAYb,OAAOW,KAAK;AAC9B,SAAIL,KAAsBQ,aAAa,MAAM,KAAKD,UAChDP,MAAsBS,aAAa,OAAOF,UAAU;;;;AACvD,MAAAT,QAAA,YAAA;GAAA,MAAAE,OAAA,KAAAlB;AAAA,OAAAkB,MARP;IACI,MAAMU,OAAOC,SAASC,cAAc,WAAW;AAC/CF,SAAKG,YAASd;IACd,MAAMe,UAAUJ,KAAKK,QAAQC;IAC7B,MAAMC,YAAYjB,KAAsBgB;AACxC,QAAIF,WAAWG,aAAaP,KAAKK,QAAQG,WAAWC,WAAW,EAC7D,MAAKC,YAAWrC,gBAAwBkC,WAAWH,SAAS,KAAK;aACxDd,KAAsBa,cAASd,OAA4B;AACpEC,UAAsBa,YAASd;AAC/B,UAAIf,mCAAyB;AAC7B,SAAI,KAAKqC,gBAAiB,MAAKA,gBAAepC,sCAAyB"}
+{"version":3,"file":"label.mjs","names":["GEA_CREATE_TEMPLATE","reactiveClass","reactiveAttr","reactiveText","CompiledComponent","Component","cn","_tpl0_create","e","document","createElement","textContent","Label","d","root","el0","el1","marker2","firstChild","props","class","htmlFor","t2","children"],"sources":["../src/components/label.tsx"],"sourcesContent":["import { Component } from '@geajs/core'\nimport { cn } from '../utils/cn'\n\nexport default class Label extends Component {\n  template(props: any) {\n    return (\n      <label\n        class={cn(\n          'text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70',\n          props.class,\n        )}\n        for={props.htmlFor}\n      >\n        {props.children}\n      </label>\n    )\n  }\n}\n"],"mappings":";;;;;;AAGA,SAASO,eAAe;CACtB,MAAMC,IAAIC,SAASC,cAAc,QAAQ;AACzCF,GAAEG,cAAc;AAChB,QAAOH;;AAET,IAAqBI,QAArB,cAAmCR,kBAAkB;CACnD,CAACJ,qBAAqBa,GAAG;EACvB,MAAMC,OAAOP,cAAc;EAC3B,MAAMQ,MAAMD;EACZ,MAAME,MAAMD;EACZ,MAAME,UAAUH,KAAKI;AACrBjB,gBAAcc,KAAKF,GAAG,YAAYP,GAAG,8FAA8F,KAAKa,MAAMC,MAAM,CAAC;AACrJlB,eAAac,KAAKH,GAAG,MAAM,aAAa,KAAKM,MAAME,QAAQ;AAE3DlB,eAAamB,SAAIT,GAAG,YAAY,KAAKM,MAAMI,SAAS;AACpD,SAAOT"}

package/dist/menu.d.mts

@@ -7,7 +7,7 @@ declare class Menu extends ZagComponent {
   open: boolean;
   createMachine(_props: any): any;
   getMachineProps(props: any): {
-    id: any;
+    id: string;
     open: any;
     defaultOpen: any;
     closeOnSelect: any;
@@ -29,7 +29,7 @@ declare class Menu extends ZagComponent {
     '[data-part="item-group-label"]': (api: any, el: any) => any;
   };
   syncState(api: any): void;
-  template(props: any): string;
+  template(props: any): any;
 }
 //#endregion
 export { Menu as default };