@ixfx/components 0.17.0 → 0.18.0

package/dist/{grid-list-BHo9TBxX.js → grid-list-DYU_z2K9.js}

@@ -2,9 +2,9 @@ import { n as appearanceColor, t as appearanceAbsent } from "./item-appearance-F
 import { n as tickledStyles, t as tickledItemStyles } from "./tickled-styles-pnieYweS.js";
 import { c as createElementListSearchAdapter, f as createDataListSearchAdapter, i as ListSearchController, n as listSearchStyles, o as registerListSearchCommands, r as LIST_SEARCH_MODES, u as keyForElement } from "./incr-search-C5114RxZ.js";
 import { i as resolveGroupKey, r as partitionByGroup } from "./grouping-kENdqzSV.js";
-import "./interaction-8Kbbf6xN.js";
+import "./interaction-BEcBIY0d.js";
 import { i as ListDragSelectController, n as gestureOf, t as ListSelectionController } from "./list-selection-controller-Dkh3m3hX.js";
-import { a as listItemFadeKeyframes, t as ListNativeDragController } from "./list-native-drag-controller-ByftBooJ.js";
+import { a as listItemFadeKeyframes, t as ListNativeDragController } from "./list-native-drag-controller-Brk30s5d.js";
 import { i as sameKeySet, r as isPartialKey, t as PARTIAL_DESCRIPTION } from "./partial-keys-D4l_ede_.js";
 import { c as keysAsFlags, f as withoutFlag, i as capFlags, l as keysToArray, o as flagsFromRecord, s as flagsToRecord, t as EMPTY_FLAGS } from "./pending-Afl4LT64.js";
 import { n as createScrollHoverGuard } from "./scroll-hover-guard-BGAjtyXT.js";
@@ -19,7 +19,104 @@ import { LitElement, css, html, nothing } from "lit";
 import { property, state } from "lit/decorators.js";
 import { createCommandRegistry } from "@clinth/ui-commands";
 import { repeat } from "lit/directives/repeat.js";
+import { keyed } from "lit/directives/keyed.js";
 import { createRef, ref } from "lit/directives/ref.js";
+// src/grid-list/grid-list-key-index.ts
+var KeyIndex = class {
+	/** Key → raw index. The first occurrence of a key wins. */
+	#map = /* @__PURE__ */ new Map();
+	/** The items array the map was built from. */
+	#source = void 0;
+	/** The adapter the map was built with. */
+	#adapter = void 0;
+	/**
+	* Rebuild the map if `items` or `adapter` changed since it was built.
+	*
+	* The map is keyed on the identity of the array / adapter it was built from,
+	* so it stays correct even when the items are replaced between Lit update
+	* cycles (a host may assign `items` and then call `updateItem` before the
+	* update flushes).
+	*
+	* One pass — the adapter's `key` is called once per item.
+	*/
+	ensure(items, adapter) {
+		if (this.#source === items && this.#adapter === adapter) return;
+		if (!adapter) {
+			this.#map = /* @__PURE__ */ new Map();
+			this.#source = items;
+			this.#adapter = void 0;
+			return;
+		}
+		const map = /* @__PURE__ */ new Map();
+		for (let i = 0; i < items.length; i++) {
+			const key = adapter.key(items[i], i);
+			if (!map.has(key)) map.set(key, i);
+		}
+		this.#map = map;
+		this.#source = items;
+		this.#adapter = adapter;
+	}
+	/** Raw index of `key`, or `-1`. O(1). */
+	get(key) {
+		return this.#map.get(key) ?? -1;
+	}
+	/** Whether `key` is known. */
+	has(key) {
+		return this.#map.has(key);
+	}
+	/**
+	* Record that `items` is now `next`, after `patch` updated the map.
+	*
+	* `patch` receives the live map so a mutation can adjust only the entries
+	* it touched. The map's "built from" pointer is updated to `next`, so the
+	* next {@link ensure} does not rebuild it.
+	*/
+	commit(next, patch) {
+		if (patch) patch(this.#map);
+		this.#source = next;
+	}
+	/**
+	* Update the map after the item at `idx` changed.
+	*
+	* `next` is the new array; `oldKey` is the key the item had before the
+	* change, and the new key is derived from the item. If the item kept its key
+	* the map is untouched. If it was re-keyed, the old entry is dropped and the
+	* new one added — but only when no *earlier* item already claims the new
+	* key, so "the first occurrence wins" still holds.
+	*/
+	rekey(next, idx, oldKey, item, adapter) {
+		const newKey = adapter.key(item, idx);
+		if (newKey === oldKey) return;
+		this.#map.delete(oldKey);
+		if (!this.#map.has(oldKey)) {
+			for (let i = idx + 1; i < next.length; i++) if (adapter.key(next[i], i) === oldKey) {
+				this.#map.set(oldKey, i);
+				break;
+			}
+		}
+		if (!this.#map.has(newKey)) this.#map.set(newKey, idx);
+	}
+	/**
+	* Rebuild the map from `items` — used after a removal, which shifts every
+	* later item down.
+	*/
+	rebuild(items, adapter) {
+		const map = /* @__PURE__ */ new Map();
+		for (let i = 0; i < items.length; i++) {
+			const key = adapter.key(items[i], i);
+			if (!map.has(key)) map.set(key, i);
+		}
+		this.#map = map;
+		this.#source = items;
+	}
+	/** Add the keys of `items`, which were appended at `base`. */
+	addAppended(items, base, adapter) {
+		for (let i = 0; i < items.length; i++) {
+			const key = adapter.key(items[i], base + i);
+			if (!this.#map.has(key)) this.#map.set(key, base + i);
+		}
+	}
+};
 // src/grid-list/grid-list-layout.ts
 /**
 * `itemWidth` is the square's width; `rowHeight` is the full cell height
@@ -393,15 +490,25 @@ const SYNTHETIC_PREFIX = `gl-auto-`;
 function isSyntheticKey(key) {
 	return key.startsWith(SYNTHETIC_PREFIX);
 }
-function warnDuplicateKeys(keys) {
-	const seen = /* @__PURE__ */ new Set();
+/**
+* Warn about duplicate keys while building the key → raw index map, in a single
+* pass. Avoids the throwaway key array `items.map(adapter.key)` used to build.
+* The map keeps the **first** occurrence of each key, matching the
+* "first occurrence wins" contract the warning states.
+*/
+function rawIndexByKey(items, keyOf) {
+	const index = /* @__PURE__ */ new Map();
 	const dupes = /* @__PURE__ */ new Set();
-	for (const k of keys) {
-		if (isSyntheticKey(k)) continue;
-		if (seen.has(k)) dupes.add(k);
-		else seen.add(k);
+	for (let i = 0; i < items.length; i++) {
+		const key = keyOf(items[i], i);
+		if (index.has(key)) {
+			if (!isSyntheticKey(key)) dupes.add(key);
+			continue;
+		}
+		index.set(key, i);
 	}
 	if (dupes.size > 0) console.warn(`ixfx-grid-list: duplicate item key(s) ${[...dupes].map((k) => `"${k}"`).join(`, `)} — the first occurrence wins for key-based operations.`);
+	return index;
 }
 /** Key → first effective index, built from `keys` (first occurrence wins on duplicates). */
 function indexByKey(keys) {
@@ -421,6 +528,8 @@ var ElementGridListSource = class {
 	#effectiveIndices = [];
 	#keysCache;
 	#indexCache;
+	/** Key → raw index, rebuilt with the items (first occurrence wins). */
+	#rawIndexByKey = /* @__PURE__ */ new Map();
 	#grouping;
 	#groups = [];
 	#groupByKey = /* @__PURE__ */ new Map();
@@ -442,6 +551,9 @@ var ElementGridListSource = class {
 		this.#indexCache ??= indexByKey(this.keys());
 		return this.#indexCache.get(key) ?? -1;
 	}
+	rawIndexOfKey(key) {
+		return this.#rawIndexByKey.get(key) ?? -1;
+	}
 	keys() {
 		this.#keysCache ??= this.#effectiveIndices.map((i) => this.#itemKey(this.#items[i]));
 		return this.#keysCache;
@@ -489,7 +601,7 @@ var ElementGridListSource = class {
 	}
 	refresh() {
 		this.#items = Array.from(this.#host.querySelectorAll(ITEM_SELECTOR$1)).filter((el) => !el.hidden);
-		warnDuplicateKeys(this.#items.map((el) => this.#itemKey(el)));
+		this.#rawIndexByKey = rawIndexByKey(this.#items, (el) => this.#itemKey(el));
 		this.#recomputeEffective();
 	}
 	/** Effective-order elements — the array `GridListElement` renders and slices. */
@@ -554,13 +666,20 @@ var DataGridListSource = class {
 	#effectiveIndices = [];
 	#keysCache;
 	#indexCache;
+	/**
+	* Key → **raw** index, built in one pass over the items. The first
+	* occurrence of a key wins (same contract as the duplicate-key warning).
+	* Lets `resolveKeyToData` and the host's `updateItem` find an item without
+	* an O(n) scan per call.
+	*/
+	#rawIndexByKey;
 	#grouping;
 	#groups = [];
 	#groupByKey = /* @__PURE__ */ new Map();
 	constructor(items, adapter) {
 		this.#items = items;
 		this.#adapter = adapter;
-		warnDuplicateKeys(items.map((it, i) => adapter.key(it, i)));
+		this.#rawIndexByKey = rawIndexByKey(items, (it, i) => adapter.key(it, i));
 		this.#recomputeEffective();
 	}
 	get count() {
@@ -647,8 +766,16 @@ var DataGridListSource = class {
 	}
 	resolveKeyToElement(_key) {}
 	resolveKeyToData(key) {
-		const idx = this.#items.findIndex((item, i) => this.#adapter.key(item, i) === key);
-		return idx >= 0 ? this.#items[idx] : void 0;
+		const idx = this.#rawIndexByKey.get(key);
+		return idx === void 0 ? void 0 : this.#items[idx];
+	}
+	/**
+	* Raw (unfiltered) index of `key`, or `-1`. O(1) — the key → raw index map
+	* is built in one pass over the items. The first occurrence of a duplicate
+	* key wins.
+	*/
+	rawIndexOfKey(key) {
+		return this.#rawIndexByKey.get(key) ?? -1;
 	}
 	#recomputeEffective() {
 		const effective = [];
@@ -964,6 +1091,8 @@ let GridListElement = class GridListElement extends LitElement {
 			}
 		});
 		this.#groupByChanged = false;
+		this.#keyIndex = new KeyIndex();
+		this.#cellRevisions = /* @__PURE__ */ new Map();
 		this.#resolveKey = (key) => this.#source.indexOfKey(key) >= 0 ? key : void 0;
 		this.#markedTickled = /* @__PURE__ */ new Set();
 		this.#markedSelected = /* @__PURE__ */ new Set();
@@ -1893,13 +2022,17 @@ let GridListElement = class GridListElement extends LitElement {
 		const dataModeChanged = changed.has(`items`) || changed.has(`itemAdapter`);
 		if (dataModeChanged) {
 			this.#zoomAnchor = void 0;
+			this.#ensureRawIndex();
 			const prevKeys = this.#source?.keys() ?? [];
 			const modeFlipped = this.itemAdapter !== void 0 !== this.#source instanceof DataGridListSource;
 			this.#rebuildSource();
 			const nextKeys = this.#source.keys();
 			const nextKeySet = new Set(nextKeys);
 			const removedKeys = prevKeys.filter((k) => !nextKeySet.has(k));
-			if (removedKeys.length > 0) this.#demoteGone(removedKeys);
+			if (removedKeys.length > 0) {
+				this.#demoteGone(removedKeys);
+				for (const key of removedKeys) this.#cellRevisions.delete(key);
+			}
 			const tickledId = this.tickled.tickledId;
 			if (tickledId && !nextKeySet.has(tickledId)) this.#demoteFocus(tickledId);
 			this._syncItemStates();
@@ -2199,11 +2332,19 @@ let GridListElement = class GridListElement extends LitElement {
 	/**
 	* Data mode only: raw index of `key` in `this.items`, or `-1`. Data-mode keys
 	* come straight from the adapter, so this is exact even under a filter/search.
+	*
+	* O(1) — backed by {@link #keyIndex}, a key → raw index map kept in sync
+	* with `items`.
 	*/
 	#rawIndexOfKey(key) {
-		const adapter = this.itemAdapter;
-		if (!adapter) return -1;
-		return this.items.findIndex((it, i) => adapter.key(it, i) === key);
+		this.#ensureRawIndex();
+		return this.#keyIndex.get(key);
+	}
+	/** Key → raw index for the current `items`. See `grid-list-key-index.ts`. */
+	#keyIndex;
+	/** Rebuild the key → raw index map if `items` / `itemAdapter` changed. */
+	#ensureRawIndex() {
+		this.#keyIndex.ensure(this.items, this.itemAdapter);
 	}
 	/**
 	* Data mode: replace the whole item array. Selection and cursor keep any key
@@ -2220,23 +2361,104 @@ let GridListElement = class GridListElement extends LitElement {
 	* A no-op in element mode.
 	*/
 	appendItems(items) {
-		if (this.itemAdapter && items.length > 0) this.items = [...this.items, ...items];
+		if (this.itemAdapter && items.length > 0) {
+			const base = this.items.length;
+			const next = [...this.items, ...items];
+			this.#ensureRawIndex();
+			this.#keyIndex.addAppended(items, base, this.itemAdapter);
+			this.#keyIndex.commit(next);
+			this.items = next;
+		}
 	}
 	/**
 	* Data mode: replace the item carrying `key`. A visible cell re-renders in
 	* place (the keyed subtree is kept); an offscreen item shows its new content
 	* when scrolled into view. Scroll and selection are untouched. Unknown keys
 	* are ignored.
+	*
+	* Passing the **same object** that is already at `key` is a no-op: the
+	* `items` array is left untouched (same identity) and nothing is emitted.
+	* Use {@link refreshItem} to re-render a cell without changing the data.
+	*
+	* Updating many items one by one? Use {@link updateItems} — it applies them
+	* with a single array copy and a single rebuild.
 	*/
 	updateItem(key, item) {
 		if (!this.itemAdapter) return;
 		const idx = this.#rawIndexOfKey(key);
 		if (idx < 0) return;
+		if (this.items[idx] === item) return;
 		const next = [...this.items];
 		next[idx] = item;
+		this.#ensureRawIndex();
+		this.#keyIndex.rekey(next, idx, key, item, this.itemAdapter);
+		this.#keyIndex.commit(next);
 		this.items = next;
 	}
 	/**
+	* Data mode: replace several items at once — the batched form of
+	* {@link updateItem}.
+	*
+	* `entries` is an array of `{ key, item }` pairs (a `Map<key, item>` is
+	* accepted too). All the replacements are applied with **one** array copy
+	* and **one** source rebuild, so a host that must refresh n rows does not
+	* pay n copies and n scans.
+	*
+	* Semantics match n sequential {@link updateItem} calls:
+	* - unknown keys are ignored;
+	* - an entry whose `item` is the identical object already at that key is
+	*   skipped (it cannot change anything);
+	* - selection, cursor and scroll are untouched;
+	* - if no entry changes anything, `items` is left untouched (same identity)
+	*   and nothing is emitted.
+	*/
+	updateItems(entries) {
+		if (!this.itemAdapter) return;
+		const pairs = [];
+		for (const entry of entries) if (Array.isArray(entry)) pairs.push([entry[0], entry[1]]);
+		else pairs.push([entry.key, entry.item]);
+		if (pairs.length === 0) return;
+		this.#ensureRawIndex();
+		const next = [...this.items];
+		const touched = [];
+		for (const [key, item] of pairs) {
+			const idx = this.#keyIndex.get(key);
+			if (idx < 0) continue;
+			if (next[idx] === item) continue;
+			next[idx] = item;
+			touched.push([
+				idx,
+				key,
+				item
+			]);
+		}
+		if (touched.length === 0) return;
+		for (const [idx, key, item] of touched) this.#keyIndex.rekey(next, idx, key, item, this.itemAdapter);
+		this.#keyIndex.commit(next);
+		this.items = next;
+	}
+	/**
+	* Data mode: re-render the cell for `key` without touching `items`.
+	*
+	* Use this when the *data* is unchanged but the cell should be redrawn — for
+	* example after mutating something the adapter reads from outside the item
+	* (a thumbnail's load state). The `items` array keeps its identity, so the
+	* collection is not copied and no source rebuild is triggered.
+	*
+	* The adapter's `render` is called again for that cell on the next render,
+	* so the cell picks up the new state. Other cells are left alone.
+	*
+	* Unknown keys are ignored. A no-op in element mode.
+	*/
+	refreshItem(key) {
+		if (!this.itemAdapter) return;
+		if (this.#rawIndexOfKey(key) < 0) return;
+		this.#cellRevisions.set(key, (this.#cellRevisions.get(key) ?? 0) + 1);
+		this.requestUpdate();
+	}
+	/** Per-key revision, bumped by {@link refreshItem}. */
+	#cellRevisions;
+	/**
 	* Data mode: remove the items carrying these keys. Removed keys leave the
 	* selection and cursor silently (via the `items` change) and are held as
 	* pending view state. A no-op in element mode.
@@ -2245,7 +2467,12 @@ let GridListElement = class GridListElement extends LitElement {
 		if (!this.itemAdapter) return;
 		const adapter = this.itemAdapter;
 		const keySet = new Set(keys);
-		this.items = this.items.filter((it, i) => !keySet.has(adapter.key(it, i)));
+		const kept = this.items.filter((it, i) => !keySet.has(adapter.key(it, i)));
+		if (kept.length === this.items.length) return;
+		this.#ensureRawIndex();
+		this.#keyIndex.rebuild(kept, adapter);
+		this.#keyIndex.commit(kept);
+		this.items = kept;
 	}
 	/**
 	* Data mode: drop every item. Selection and cursor are reset and one
@@ -2708,13 +2935,24 @@ let GridListElement = class GridListElement extends LitElement {
       >
         <div class="content${icon === void 0 ? `` : ` has-icon`}" part="content">
           ${icon === void 0 ? nothing : html`<span class="cell-icon" part="icon" style=${this.#colorStyle(this.#source.iconColorAt(index))}>${icon}</span>`}
-          ${this.#source.renderCellContent(index)}
+          ${this.#renderCellBody(index, key)}
         </div>
         ${showCaption ? this.#renderCaption(caption, captionCss, tickled, this.#source.badgeAt(index), this.#source.textColorAt(index)) : ``}
       </div>
     `;
 	}
 	/**
+	* The cell's content, keyed by the cell's revision so {@link refreshItem}
+	* can force it to be re-evaluated (and its DOM re-created) even though
+	* `items` did not change. Without a revision change the content is bound
+	* normally, so Lit keeps it in place.
+	*/
+	#renderCellBody(index, key) {
+		const revision = this.#cellRevisions.get(key);
+		if (revision === void 0) return this.#source.renderCellContent(index);
+		return keyed(revision, this.#source.renderCellContent(index));
+	}
+	/**
 	* A tickled cell swaps its plain label for an `ixfx-pan-text` in loop mode
 	* so a truncated label scrolls instead of staying an ellipsis. Unticked
 	* cells keep the cheap plain-text caption.
@@ -3008,6 +3246,7 @@ __decorate([property({
 	reflect: true
 })], GridListElement.prototype, "marqueeFromCellBlank", void 0);
 __decorate([property({ attribute: false })], GridListElement.prototype, "dragPreviewRenderer", void 0);
+__decorate([property({ attribute: false })], GridListElement.prototype, "writeDataTransfer", void 0);
 __decorate([property({ attribute: false })], GridListElement.prototype, "dragPreviewSource", void 0);
 __decorate([property({
 	type: String,

package/dist/grid-list.d.ts

@@ -1,5 +1,5 @@
-import { B as ListNativeDragStartDetail, F as ListDragPreview, I as ListDragPreviewContext, L as ListDragPreviewRenderer, P as ListDragEntry, V as ListNativeDragStartEvent, z as ListDragSource } from "./tree-component-DNuzfo6R.js";
-import { _ as GridListSelectEvent, a as GridListCaptionAlign, b as GridListViewportChangeDetail, c as GridListCaptionStyle, d as GridListFullElementEventMap, f as GridListItemClickDetail, g as GridListSelectDetail, h as GridListOrientation, i as GridListActivateEvent, l as GridListDataAdapter, m as GridListItemEventDetail, n as GridListViewState, o as GridListCaptionBackdrop, p as GridListItemClickEvent, r as GridListActivateDetail, s as GridListCaptionPosition, t as GridListElement, u as GridListElementEventMap, v as GridListTickleDetail, x as GridListViewportChangeEvent, y as GridListTickleEvent } from "./grid-list-Dg8hIiKO.js";
+import { B as ListDragSource, F as ListDragEntry, H as ListNativeDragStartEvent, I as ListDragPreview, L as ListDragPreviewContext, R as ListDragPreviewRenderer, V as ListNativeDragStartDetail } from "./tree-component-BE7OEIiH.js";
+import { S as GridListViewportChangeEvent, _ as GridListSelectDetail, a as GridListCaptionAlign, b as GridListTickleEvent, c as GridListCaptionStyle, d as GridListFullElementEventMap, f as GridListItemClickDetail, g as GridListOrientation, h as GridListItemUpdate, i as GridListActivateEvent, l as GridListDataAdapter, m as GridListItemEventDetail, n as GridListViewState, o as GridListCaptionBackdrop, p as GridListItemClickEvent, r as GridListActivateDetail, s as GridListCaptionPosition, t as GridListElement, u as GridListElementEventMap, v as GridListSelectEvent, x as GridListViewportChangeDetail, y as GridListTickleDetail } from "./grid-list-Crv-hFJL.js";
 import { h as ListSelectionMode, i as ListInteractionMode } from "./list-selection-types-CKTt7Rrw.js";
 import { i as ListGroupChangeEvent, l as ListGroupToggleDetail, n as ListGroupBy, o as ListGroupInfo, r as ListGroupChangeDetail, s as ListGroupLabel, u as ListGroupToggleEvent } from "./grouping-OoQ8WaKc.js";
-export { type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewState, type GridListViewportChangeDetail, type GridListViewportChangeEvent, type ListDragEntry, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragSource, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupInfo, type ListGroupLabel, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSelectionMode };
+export { type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListItemUpdate, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewState, type GridListViewportChangeDetail, type GridListViewportChangeEvent, type ListDragEntry, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragSource, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupInfo, type ListGroupLabel, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSelectionMode };

package/dist/grid-list.js

@@ -1,2 +1,2 @@
 import "./list-group-header.js";
-export { t as GridListElement } from "./grid-list-BHo9TBxX.js";
+export { t as GridListElement } from "./grid-list-DYU_z2K9.js";

package/dist/incr-search.d.ts

@@ -1,2 +1,2 @@
-import { A as FuzzySearch, C as ListSearchControllerOptions, D as IncrSearchTreeOptions, E as IncrSearchTreeController, F as IncrSearchChangeCallback, I as IncrSearchOptions, L as IncrSearchResult, M as HighlightOptions, N as HighlightTarget, O as createAcCompletionProvider, P as IncrSearch, R as IncrSearchState, S as ListSearchController, T as ListSearchMode, _ as DataListSearchAdapterOptions, a as RegisterListSearchCommandsOptions, b as LIST_SEARCH_MODES, c as applyHighlights, d as createFuzzySearch, f as ElementIncrSearch, g as createElementListSearchAdapter, h as ElementListSearchHost, i as LIST_SEARCH_COMMAND_IDS, j as FuzzySearchOptions, k as ElementIncrSearchOptions, l as buildHighlightTargets, m as ElementListSearchAdapterOptions, n as createTreeListSearchAdapter, o as registerListSearchCommands, p as createElementIncrSearch, r as listSearchStyles, s as createIncrSearch, t as TreeListSearchAdapterOptions, u as clearHighlights, v as DataListSearchItem, w as ListSearchHost, x as ListSearchAdapter, y as createDataListSearchAdapter } from "./index-CRLTVAyt.js";
+import { A as FuzzySearch, C as ListSearchControllerOptions, D as IncrSearchTreeOptions, E as IncrSearchTreeController, F as IncrSearchChangeCallback, I as IncrSearchOptions, L as IncrSearchResult, M as HighlightOptions, N as HighlightTarget, O as createAcCompletionProvider, P as IncrSearch, R as IncrSearchState, S as ListSearchController, T as ListSearchMode, _ as DataListSearchAdapterOptions, a as RegisterListSearchCommandsOptions, b as LIST_SEARCH_MODES, c as applyHighlights, d as createFuzzySearch, f as ElementIncrSearch, g as createElementListSearchAdapter, h as ElementListSearchHost, i as LIST_SEARCH_COMMAND_IDS, j as FuzzySearchOptions, k as ElementIncrSearchOptions, l as buildHighlightTargets, m as ElementListSearchAdapterOptions, n as createTreeListSearchAdapter, o as registerListSearchCommands, p as createElementIncrSearch, r as listSearchStyles, s as createIncrSearch, t as TreeListSearchAdapterOptions, u as clearHighlights, v as DataListSearchItem, w as ListSearchHost, x as ListSearchAdapter, y as createDataListSearchAdapter } from "./index-Db5VGFR1.js";
 export { type DataListSearchAdapterOptions, type DataListSearchItem, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, type FuzzySearch, type FuzzySearchOptions, type HighlightOptions, type HighlightTarget, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, LIST_SEARCH_COMMAND_IDS, LIST_SEARCH_MODES, type ListSearchAdapter, ListSearchController, type ListSearchControllerOptions, type ListSearchHost, type ListSearchMode, type RegisterListSearchCommandsOptions, type TreeListSearchAdapterOptions, applyHighlights, buildHighlightTargets, clearHighlights, createAcCompletionProvider, createDataListSearchAdapter, createElementIncrSearch, createElementListSearchAdapter, createFuzzySearch, createIncrSearch, createTreeListSearchAdapter, listSearchStyles, registerListSearchCommands };

package/dist/{index-CzhYJJsx.d.ts → index-BE0hk8xS.d.ts}

@@ -1,9 +1,9 @@
-import { E as TreeSearchHost, M as TreeDataModel, a as TreeComponent, i as TreeCollapseEvent, j as TreeTickleEvent, k as TreeSelectEvent, n as TreeActivateEvent, o as TreeComponentEventMap, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-DNuzfo6R.js";
+import { E as TreeSearchHost, M as TreeDataModel, a as TreeComponent, i as TreeCollapseEvent, j as TreeTickleEvent, k as TreeSelectEvent, n as TreeActivateEvent, o as TreeComponentEventMap, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-BE7OEIiH.js";
 import { a as TreeItem, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-6hpXRKt7.js";
 import { a as ViewStateBase, n as ScrollState, t as GetViewStateOptions } from "./types-16GC5k1z.js";
 import { m as ListSelectKeysDetail, u as ListSelectIntentDetail } from "./list-selection-types-CKTt7Rrw.js";
 import "./index-Cdcek1Oj.js";
-import { S as ListSearchController } from "./index-CRLTVAyt.js";
+import { S as ListSearchController } from "./index-Db5VGFR1.js";
 import { n as TickledController } from "./tickled-controller-DSPoG551.js";
 import { LitElement, PropertyValues, TemplateResult, nothing } from "lit";
 import { CommandRegistry } from "@clinth/ui-commands";

package/dist/{index-88ra6YHP.d.ts → index-BymYKGY-.d.ts}

@@ -1,10 +1,10 @@
-import { B as ListNativeDragStartDetail, C as TreeItemDblClickEvent, D as TreeSelectAllOptions, E as TreeSearchHost, L as ListDragPreviewRenderer, M as TreeDataModel, R as ListDragPreviewSourceResolver, _ as TreeDropTarget, a as TreeComponent, c as TreeDragContext, d as TreeDragStartEvent, h as TreeDropEvent, i as TreeCollapseEvent, j as TreeTickleEvent, k as TreeSelectEvent, l as TreeDragEndEvent, m as TreeDropDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeDropContext, s as TreeDndMode, u as TreeDragOverEvent, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-DNuzfo6R.js";
+import { C as TreeItemDblClickEvent, D as TreeSelectAllOptions, E as TreeSearchHost, M as TreeDataModel, R as ListDragPreviewRenderer, V as ListNativeDragStartDetail, _ as TreeDropTarget, a as TreeComponent, c as TreeDragContext, d as TreeDragStartEvent, h as TreeDropEvent, i as TreeCollapseEvent, j as TreeTickleEvent, k as TreeSelectEvent, l as TreeDragEndEvent, m as TreeDropDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeDropContext, s as TreeDndMode, u as TreeDragOverEvent, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent, z as ListDragPreviewSourceResolver } from "./tree-component-BE7OEIiH.js";
 import { a as TreeItem, i as TreeInteractionMode, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-6hpXRKt7.js";
 import { a as ViewStateBase, t as GetViewStateOptions } from "./types-16GC5k1z.js";
 import { m as ListSelectKeysDetail, p as ListSelectIntentSource, u as ListSelectIntentDetail } from "./list-selection-types-CKTt7Rrw.js";
 import "./index-Cdcek1Oj.js";
-import { S as ListSearchController } from "./index-CRLTVAyt.js";
-import { t as ListNativeDragController } from "./list-native-drag-controller-CgXKdmjr.js";
+import { S as ListSearchController } from "./index-Db5VGFR1.js";
+import { t as ListNativeDragController } from "./list-native-drag-controller-Cs-Tmtaa.js";
 import { n as TickledController } from "./tickled-controller-DSPoG551.js";
 import { LitElement, PropertyValues, ReactiveController, ReactiveControllerHost, TemplateResult, nothing } from "lit";
 import { CommandRegistry } from "@clinth/ui-commands";

package/dist/{index-CRLTVAyt.d.ts → index-Db5VGFR1.d.ts}

@@ -1,4 +1,4 @@
-import { E as TreeSearchHost } from "./tree-component-DNuzfo6R.js";
+import { E as TreeSearchHost } from "./tree-component-BE7OEIiH.js";
 import { o as TreeNode } from "./types-6hpXRKt7.js";
 import { p as ListSelectIntentSource } from "./list-selection-types-CKTt7Rrw.js";
 import "./icon-Bhz0c6Yf.js";