@ixfx/components 0.15.5 → 0.16.1

package/dist/{list-native-drag-controller-O2Nruqpi.d.ts → list-native-drag-controller-D_UrXipS.d.ts}

@@ -1,4 +1,4 @@
-import { F as ListDragPreviewContext, I as ListDragPreviewRenderer, L as ListDragPreviewSourceResolver, N as ListDragEntry, R as ListDragSource, z as ListNativeDragStartDetail } from "./tree-component-C6UHO-w9.js";
+import { B as ListNativeDragStartDetail, I as ListDragPreviewContext, L as ListDragPreviewRenderer, P as ListDragEntry, R as ListDragPreviewSourceResolver, z as ListDragSource } from "./tree-component-DgfkxmVY.js";
 import { ReactiveController, ReactiveControllerHost } from "lit";
 //#region src/interaction/list-native-drag-controller.d.ts
 type ListNativeDragControllerConfig<T> = {

package/dist/{list-selection-controller-BeE70lbB.js → list-selection-controller-5L0Nj9tR.js}

@@ -1,3 +1,4 @@
+import { a as capKeys, d as partitionKeys, n as EMPTY_KEYS } from "./pending-BGidHppL.js";
 //#region src/interaction/list-drag-select-controller.ts
 const DEFAULT_POINTER_TYPES = [`mouse`, `pen`];
 const DEFAULT_THRESHOLD = 4;
@@ -331,6 +332,12 @@ var ListSelectionController = class {
 	#config;
 	#selected = /* @__PURE__ */ new Set();
 	#anchor;
+	/**
+	* Selected keys whose items are not currently present (restored view state,
+	* or items removed by a data reset). Re-selected by `resolvePending()` when
+	* a matching item appears; dropped by any explicit selection change.
+	*/
+	#pending = EMPTY_KEYS;
 	constructor(config) {
 		this.#config = config;
 	}
@@ -425,6 +432,7 @@ var ListSelectionController = class {
 	}
 	/** Clear the selection. No change event when the selection is already empty. */
 	clear() {
+		this.#pending = EMPTY_KEYS;
 		if (this.#selected.size === 0) return;
 		this.#apply(/* @__PURE__ */ new Set());
 	}
@@ -544,6 +552,79 @@ var ListSelectionController = class {
 		}
 		if (changed) this.#apply(next);
 	}
+	/** Selected keys waiting for their items to appear. */
+	get pendingKeys() {
+		return this.#pending;
+	}
+	/**
+	* Restore a selection by key: keys that resolve are selected now (one
+	* `onChange`), the rest are kept pending for `resolvePending()`. Replaces
+	* any previous selection and pending keys. Unlike `selectKeys`, this works
+	* in `selectionMode="none"` only to the extent of holding keys pending.
+	*/
+	restoreKeys(keys, resolve) {
+		const wanted = new Set(keys);
+		const { present, missing } = partitionKeys(wanted, (key) => this.#resolveSelectable(key, resolve) !== void 0);
+		let next = /* @__PURE__ */ new Set();
+		if (this.#config.getModes().selectionMode !== `none`) for (const key of present) next.add(this.#resolveSelectable(key, resolve));
+		if (!this.#effectiveMulti() && next.size > 1) next = new Set([...next].slice(-1));
+		this.#anchor = [...next].at(-1);
+		this.#pending = capKeys(missing);
+		if (next.size === 0 && this.#selected.size === 0) return;
+		this.#apply(next, true);
+	}
+	/**
+	* Select pending keys whose items now resolve (call after items are added
+	* or rebuilt). Fires `onChange` once when anything was selected; returns
+	* whether it did.
+	*/
+	resolvePending(resolve) {
+		if (this.#pending.size === 0 || this.#config.getModes().selectionMode === `none`) return false;
+		const { present, missing } = partitionKeys(this.#pending, (key) => this.#resolveSelectable(key, resolve) !== void 0);
+		if (present.length === 0) return false;
+		const found = present.map((key) => this.#resolveSelectable(key, resolve));
+		let next;
+		if (this.#effectiveMulti()) {
+			next = /* @__PURE__ */ new Set([...this.#selected, ...found]);
+			this.#pending = missing;
+		} else {
+			next = /* @__PURE__ */ new Set([found.at(-1)]);
+			this.#pending = EMPTY_KEYS;
+		}
+		this.#anchor ??= found.at(-1);
+		this.#apply(next, true);
+		return true;
+	}
+	/**
+	* Silently deselect `items` that left the data, keeping their keys pending
+	* so they are re-selected if the same keys come back (data reset, re-fetch).
+	* No `onChange`; returns whether the selection changed.
+	*/
+	demote(items) {
+		const getKey = this.#config.getKey;
+		const next = new Set(this.#selected);
+		const pending = new Set(this.#pending);
+		let changed = false;
+		for (const item of items) {
+			if (!next.delete(item)) continue;
+			changed = true;
+			const key = getKey?.(item);
+			if (key !== void 0) pending.add(key);
+			if (this.#anchor === item) this.#anchor = void 0;
+		}
+		if (!changed) return false;
+		this.#selected = next;
+		this.#pending = capKeys(pending);
+		return true;
+	}
+	/** Drop pending keys without touching the live selection. */
+	clearPending() {
+		this.#pending = EMPTY_KEYS;
+	}
+	#resolveSelectable(key, resolve) {
+		const item = resolve(key);
+		return item !== void 0 && this.#config.isSelectable(item) ? item : void 0;
+	}
 	/** Route a click on `item` according to the current interaction mode. */
 	handleClick(item, gesture) {
 		const { selectionMode, interactionMode: mode } = this.#config.getModes();
@@ -586,9 +667,11 @@ var ListSelectionController = class {
 	}
 	/**
 	* Hard reset: empty the selection and clear the anchor without firing
-	* `onChange` (e.g. when all items are removed).
+	* `onChange` (e.g. when all items are removed). Keyed selected items become
+	* pending, so a rebuilt item set re-selects them via `resolvePending()`.
 	*/
 	reset() {
+		this.demote([...this.#selected]);
 		this.#selected = /* @__PURE__ */ new Set();
 		this.#anchor = void 0;
 	}
@@ -615,7 +698,9 @@ var ListSelectionController = class {
 		const group = this.#groupOf(first);
 		return new Set([...items].filter((t) => this.#groupOf(t) === group));
 	}
-	#apply(next) {
+	/** Commit `next`. An explicit selection change supersedes pending keys unless `keepPending`. */
+	#apply(next, keepPending = false) {
+		if (!keepPending) this.#pending = EMPTY_KEYS;
 		const previous = this.#selected;
 		this.#selected = next;
 		this.#config.onChange(next, previous);