@sprawlify/primitives 0.0.1

package/dist/collection-8XqaNHs_.mjs

@@ -0,0 +1,1279 @@
+import { t as _defineProperty } from "./defineProperty-DrXfyjd4.mjs";
+import { Ot as prevIndex, Tt as nextIndex, dt as isEqual, et as hasProp, mt as chunk, st as isObject } from "./utils-BZyrxWWR.mjs";
+
+//#region src/shared/collection/list-collection.ts
+let _Symbol$iterator;
+const fallback = {
+	itemToValue(item) {
+		if (typeof item === "string") return item;
+		if (isObject(item) && hasProp(item, "value")) return item.value;
+		return "";
+	},
+	itemToString(item) {
+		if (typeof item === "string") return item;
+		if (isObject(item) && hasProp(item, "label")) return item.label;
+		return fallback.itemToValue(item);
+	},
+	isItemDisabled(item) {
+		if (isObject(item) && hasProp(item, "disabled")) return !!item.disabled;
+		return false;
+	}
+};
+_Symbol$iterator = Symbol.iterator;
+var ListCollection = class ListCollection {
+	constructor(options) {
+		this.options = options;
+		_defineProperty(this, "items", void 0);
+		_defineProperty(this, "indexMap", null);
+		_defineProperty(this, "copy", (items) => {
+			return new ListCollection({
+				...this.options,
+				items: items ?? [...this.items]
+			});
+		});
+		_defineProperty(this, "isEqual", (other) => {
+			return isEqual(this.items, other.items);
+		});
+		_defineProperty(this, "setItems", (items) => {
+			return this.copy(items);
+		});
+		_defineProperty(this, "getValues", (items = this.items) => {
+			const values = [];
+			for (const item of items) {
+				const value = this.getItemValue(item);
+				if (value != null) values.push(value);
+			}
+			return values;
+		});
+		_defineProperty(this, "find", (value) => {
+			if (value == null) return null;
+			const index = this.indexOf(value);
+			return index !== -1 ? this.at(index) : null;
+		});
+		_defineProperty(this, "findMany", (values) => {
+			const result = [];
+			for (const value of values) {
+				const item = this.find(value);
+				if (item != null) result.push(item);
+			}
+			return result;
+		});
+		_defineProperty(this, "at", (index) => {
+			if (!this.options.groupBy && !this.options.groupSort) return this.items[index] ?? null;
+			let idx = 0;
+			const groups = this.group();
+			for (const [, items] of groups) for (const item of items) {
+				if (idx === index) return item;
+				idx++;
+			}
+			return null;
+		});
+		_defineProperty(this, "sortFn", (valueA, valueB) => {
+			const indexA = this.indexOf(valueA);
+			const indexB = this.indexOf(valueB);
+			return (indexA ?? 0) - (indexB ?? 0);
+		});
+		_defineProperty(this, "sort", (values) => {
+			return [...values].sort(this.sortFn.bind(this));
+		});
+		_defineProperty(this, "getItemValue", (item) => {
+			if (item == null) return null;
+			return this.options.itemToValue?.(item) ?? fallback.itemToValue(item);
+		});
+		_defineProperty(this, "getItemDisabled", (item) => {
+			if (item == null) return false;
+			return this.options.isItemDisabled?.(item) ?? fallback.isItemDisabled(item);
+		});
+		_defineProperty(this, "stringifyItem", (item) => {
+			if (item == null) return null;
+			return this.options.itemToString?.(item) ?? fallback.itemToString(item);
+		});
+		_defineProperty(this, "stringify", (value) => {
+			if (value == null) return null;
+			return this.stringifyItem(this.find(value));
+		});
+		_defineProperty(this, "stringifyItems", (items, separator = ", ") => {
+			const strs = [];
+			for (const item of items) {
+				const str = this.stringifyItem(item);
+				if (str != null) strs.push(str);
+			}
+			return strs.join(separator);
+		});
+		_defineProperty(this, "stringifyMany", (value, separator) => {
+			return this.stringifyItems(this.findMany(value), separator);
+		});
+		_defineProperty(this, "has", (value) => {
+			return this.indexOf(value) !== -1;
+		});
+		_defineProperty(this, "hasItem", (item) => {
+			if (item == null) return false;
+			return this.has(this.getItemValue(item));
+		});
+		_defineProperty(this, "group", () => {
+			const { groupBy, groupSort } = this.options;
+			if (!groupBy) return [["", [...this.items]]];
+			const groups = /* @__PURE__ */ new Map();
+			this.items.forEach((item, index) => {
+				const groupKey = groupBy(item, index);
+				if (!groups.has(groupKey)) groups.set(groupKey, []);
+				groups.get(groupKey).push(item);
+			});
+			let entries = Array.from(groups.entries());
+			if (groupSort) entries.sort(([a], [b]) => {
+				if (typeof groupSort === "function") return groupSort(a, b);
+				if (Array.isArray(groupSort)) {
+					const indexA = groupSort.indexOf(a);
+					const indexB = groupSort.indexOf(b);
+					if (indexA === -1) return 1;
+					if (indexB === -1) return -1;
+					return indexA - indexB;
+				}
+				if (groupSort === "asc") return a.localeCompare(b);
+				if (groupSort === "desc") return b.localeCompare(a);
+				return 0;
+			});
+			return entries;
+		});
+		_defineProperty(this, "getNextValue", (value, step = 1, clamp = false) => {
+			let index = this.indexOf(value);
+			if (index === -1) return null;
+			index = clamp ? Math.min(index + step, this.size - 1) : index + step;
+			while (index <= this.size && this.getItemDisabled(this.at(index))) index++;
+			return this.getItemValue(this.at(index));
+		});
+		_defineProperty(this, "getPreviousValue", (value, step = 1, clamp = false) => {
+			let index = this.indexOf(value);
+			if (index === -1) return null;
+			index = clamp ? Math.max(index - step, 0) : index - step;
+			while (index >= 0 && this.getItemDisabled(this.at(index))) index--;
+			return this.getItemValue(this.at(index));
+		});
+		_defineProperty(this, "indexOf", (value) => {
+			if (value == null) return -1;
+			if (!this.options.groupBy && !this.options.groupSort) return this.items.findIndex((item) => this.getItemValue(item) === value);
+			if (!this.indexMap) {
+				this.indexMap = /* @__PURE__ */ new Map();
+				let idx = 0;
+				const groups = this.group();
+				for (const [, items] of groups) for (const item of items) {
+					const itemValue = this.getItemValue(item);
+					if (itemValue != null) this.indexMap.set(itemValue, idx);
+					idx++;
+				}
+			}
+			return this.indexMap.get(value) ?? -1;
+		});
+		_defineProperty(this, "getByText", (text, current) => {
+			const currentIndex = current != null ? this.indexOf(current) : -1;
+			const isSingleKey = text.length === 1;
+			for (let i = 0; i < this.items.length; i++) {
+				const item = this.items[(currentIndex + i + 1) % this.items.length];
+				if (isSingleKey && this.getItemValue(item) === current) continue;
+				if (this.getItemDisabled(item)) continue;
+				if (match(this.stringifyItem(item), text)) return item;
+			}
+		});
+		_defineProperty(this, "search", (queryString, options$1) => {
+			const { state, currentValue, timeout = 350 } = options$1;
+			const search = state.keysSoFar + queryString;
+			const query = search.length > 1 && Array.from(search).every((char) => char === search[0]) ? search[0] : search;
+			const item = this.getByText(query, currentValue);
+			const value = this.getItemValue(item);
+			function cleanup() {
+				clearTimeout(state.timer);
+				state.timer = -1;
+			}
+			function update(value$1) {
+				state.keysSoFar = value$1;
+				cleanup();
+				if (value$1 !== "") state.timer = +setTimeout(() => {
+					update("");
+					cleanup();
+				}, timeout);
+			}
+			update(search);
+			return value;
+		});
+		_defineProperty(this, "update", (value, item) => {
+			let index = this.indexOf(value);
+			if (index === -1) return this;
+			return this.copy([
+				...this.items.slice(0, index),
+				item,
+				...this.items.slice(index + 1)
+			]);
+		});
+		_defineProperty(this, "upsert", (value, item, mode = "append") => {
+			let index = this.indexOf(value);
+			if (index === -1) return (mode === "append" ? this.append : this.prepend)(item);
+			return this.copy([
+				...this.items.slice(0, index),
+				item,
+				...this.items.slice(index + 1)
+			]);
+		});
+		_defineProperty(this, "insert", (index, ...items) => {
+			return this.copy(insert$1(this.items, index, ...items));
+		});
+		_defineProperty(this, "insertBefore", (value, ...items) => {
+			let toIndex = this.indexOf(value);
+			if (toIndex === -1) if (this.items.length === 0) toIndex = 0;
+			else return this;
+			return this.copy(insert$1(this.items, toIndex, ...items));
+		});
+		_defineProperty(this, "insertAfter", (value, ...items) => {
+			let toIndex = this.indexOf(value);
+			if (toIndex === -1) if (this.items.length === 0) toIndex = 0;
+			else return this;
+			return this.copy(insert$1(this.items, toIndex + 1, ...items));
+		});
+		_defineProperty(this, "prepend", (...items) => {
+			return this.copy(insert$1(this.items, 0, ...items));
+		});
+		_defineProperty(this, "append", (...items) => {
+			return this.copy(insert$1(this.items, this.items.length, ...items));
+		});
+		_defineProperty(this, "filter", (fn) => {
+			const filteredItems = this.items.filter((item, index) => fn(this.stringifyItem(item), index, item));
+			return this.copy(filteredItems);
+		});
+		_defineProperty(this, "remove", (...itemsOrValues) => {
+			const values = itemsOrValues.map((itemOrValue) => typeof itemOrValue === "string" ? itemOrValue : this.getItemValue(itemOrValue));
+			return this.copy(this.items.filter((item) => {
+				const value = this.getItemValue(item);
+				if (value == null) return false;
+				return !values.includes(value);
+			}));
+		});
+		_defineProperty(this, "move", (value, toIndex) => {
+			const fromIndex = this.indexOf(value);
+			if (fromIndex === -1) return this;
+			return this.copy(move$1(this.items, [fromIndex], toIndex));
+		});
+		_defineProperty(this, "moveBefore", (value, ...values) => {
+			let toIndex = this.items.findIndex((item) => this.getItemValue(item) === value);
+			if (toIndex === -1) return this;
+			let indices = values.map((value$1) => this.items.findIndex((item) => this.getItemValue(item) === value$1)).sort((a, b) => a - b);
+			return this.copy(move$1(this.items, indices, toIndex));
+		});
+		_defineProperty(this, "moveAfter", (value, ...values) => {
+			let toIndex = this.items.findIndex((item) => this.getItemValue(item) === value);
+			if (toIndex === -1) return this;
+			let indices = values.map((value$1) => this.items.findIndex((item) => this.getItemValue(item) === value$1)).sort((a, b) => a - b);
+			return this.copy(move$1(this.items, indices, toIndex + 1));
+		});
+		_defineProperty(this, "reorder", (fromIndex, toIndex) => {
+			return this.copy(move$1(this.items, [fromIndex], toIndex));
+		});
+		_defineProperty(this, "compareValue", (a, b) => {
+			const indexA = this.indexOf(a);
+			const indexB = this.indexOf(b);
+			if (indexA < indexB) return -1;
+			if (indexA > indexB) return 1;
+			return 0;
+		});
+		_defineProperty(this, "range", (from, to) => {
+			let keys = [];
+			let key = from;
+			while (key != null) {
+				if (this.find(key)) keys.push(key);
+				if (key === to) return keys;
+				key = this.getNextValue(key);
+			}
+			return [];
+		});
+		_defineProperty(this, "getValueRange", (from, to) => {
+			if (from && to) {
+				if (this.compareValue(from, to) <= 0) return this.range(from, to);
+				return this.range(to, from);
+			}
+			return [];
+		});
+		_defineProperty(this, "toString", () => {
+			let result = "";
+			for (const item of this.items) {
+				const itemString = [
+					this.getItemValue(item),
+					this.stringifyItem(item),
+					this.getItemDisabled(item)
+				].filter(Boolean).join(":");
+				result += itemString + ",";
+			}
+			return result;
+		});
+		_defineProperty(this, "toJSON", () => {
+			return {
+				size: this.size,
+				first: this.firstValue,
+				last: this.lastValue
+			};
+		});
+		this.items = [...options.items];
+	}
+	get size() {
+		return this.items.length;
+	}
+	get firstValue() {
+		let index = 0;
+		while (this.getItemDisabled(this.at(index))) index++;
+		return this.getItemValue(this.at(index));
+	}
+	get lastValue() {
+		let index = this.size - 1;
+		while (this.getItemDisabled(this.at(index))) index--;
+		return this.getItemValue(this.at(index));
+	}
+	*[_Symbol$iterator]() {
+		yield* this.items;
+	}
+};
+const match = (label, query) => {
+	return !!label?.toLowerCase().startsWith(query.toLowerCase());
+};
+function isListCollection(v) {
+	return v instanceof ListCollection;
+}
+function insert$1(items, index, ...values) {
+	return [
+		...items.slice(0, index),
+		...values,
+		...items.slice(index)
+	];
+}
+function move$1(items, indices, toIndex) {
+	indices = [...indices].sort((a, b) => a - b);
+	const itemsToMove = indices.map((i) => items[i]);
+	for (let i = indices.length - 1; i >= 0; i--) items = [...items.slice(0, indices[i]), ...items.slice(indices[i] + 1)];
+	toIndex = Math.max(0, toIndex - indices.filter((i) => i < toIndex).length);
+	return [
+		...items.slice(0, toIndex),
+		...itemsToMove,
+		...items.slice(toIndex)
+	];
+}
+
+//#endregion
+//#region src/shared/collection/grid-collection.ts
+var GridCollection = class extends ListCollection {
+	constructor(options) {
+		const { columnCount } = options;
+		super(options);
+		_defineProperty(this, "columnCount", void 0);
+		_defineProperty(this, "rows", null);
+		_defineProperty(this, "getRows", () => {
+			if (!this.rows) this.rows = chunk([...this.items], this.columnCount);
+			return this.rows;
+		});
+		_defineProperty(this, "getRowCount", () => {
+			return Math.ceil(this.items.length / this.columnCount);
+		});
+		_defineProperty(this, "getCellIndex", (row, column) => {
+			return row * this.columnCount + column;
+		});
+		_defineProperty(this, "getCell", (row, column) => {
+			return this.at(this.getCellIndex(row, column));
+		});
+		_defineProperty(this, "getValueCell", (value) => {
+			const index = this.indexOf(value);
+			if (index === -1) return null;
+			return {
+				row: Math.floor(index / this.columnCount),
+				column: index % this.columnCount
+			};
+		});
+		_defineProperty(this, "getLastEnabledColumnIndex", (row) => {
+			for (let col = this.columnCount - 1; col >= 0; col--) {
+				const cell = this.getCell(row, col);
+				if (cell && !this.getItemDisabled(cell)) return col;
+			}
+			return null;
+		});
+		_defineProperty(this, "getFirstEnabledColumnIndex", (row) => {
+			for (let col = 0; col < this.columnCount; col++) {
+				const cell = this.getCell(row, col);
+				if (cell && !this.getItemDisabled(cell)) return col;
+			}
+			return null;
+		});
+		_defineProperty(this, "getPreviousRowValue", (value, loop = false) => {
+			const currentCell = this.getValueCell(value);
+			if (currentCell === null) return null;
+			const rows = this.getRows();
+			const rowCount = rows.length;
+			let prevRowIndex = currentCell.row;
+			let prevColumnIndex = currentCell.column;
+			for (let i = 1; i <= rowCount; i++) {
+				prevRowIndex = prevIndex(rows, prevRowIndex, { loop });
+				const prevRow = rows[prevRowIndex];
+				if (!prevRow) continue;
+				if (!prevRow[prevColumnIndex]) {
+					const lastColumnIndex = this.getLastEnabledColumnIndex(prevRowIndex);
+					if (lastColumnIndex != null) prevColumnIndex = lastColumnIndex;
+				}
+				const cell = this.getCell(prevRowIndex, prevColumnIndex);
+				if (!this.getItemDisabled(cell)) return this.getItemValue(cell);
+			}
+			return this.firstValue;
+		});
+		_defineProperty(this, "getNextRowValue", (value, loop = false) => {
+			const currentCell = this.getValueCell(value);
+			if (currentCell === null) return null;
+			const rows = this.getRows();
+			const rowCount = rows.length;
+			let nextRowIndex = currentCell.row;
+			let nextColumnIndex = currentCell.column;
+			for (let i = 1; i <= rowCount; i++) {
+				nextRowIndex = nextIndex(rows, nextRowIndex, { loop });
+				const nextRow = rows[nextRowIndex];
+				if (!nextRow) continue;
+				if (!nextRow[nextColumnIndex]) {
+					const lastColumnIndex = this.getLastEnabledColumnIndex(nextRowIndex);
+					if (lastColumnIndex != null) nextColumnIndex = lastColumnIndex;
+				}
+				const cell = this.getCell(nextRowIndex, nextColumnIndex);
+				if (!this.getItemDisabled(cell)) return this.getItemValue(cell);
+			}
+			return this.lastValue;
+		});
+		this.columnCount = columnCount;
+	}
+};
+function isGridCollection(v) {
+	return hasProp(v, "columnCount") && hasProp(v, "getRows");
+}
+
+//#endregion
+//#region src/shared/collection/selection.ts
+var Selection = class Selection extends Set {
+	constructor(values = []) {
+		super(values);
+		_defineProperty(this, "selectionMode", "single");
+		_defineProperty(this, "deselectable", true);
+		_defineProperty(this, "copy", () => {
+			const clone = new Selection([...this]);
+			return this.sync(clone);
+		});
+		_defineProperty(this, "sync", (other) => {
+			other.selectionMode = this.selectionMode;
+			other.deselectable = this.deselectable;
+			return other;
+		});
+		_defineProperty(this, "isEmpty", () => {
+			return this.size === 0;
+		});
+		_defineProperty(this, "isSelected", (value) => {
+			if (this.selectionMode === "none" || value == null) return false;
+			return this.has(value);
+		});
+		_defineProperty(this, "canSelect", (collection, value) => {
+			return this.selectionMode !== "none" || !collection.getItemDisabled(collection.find(value));
+		});
+		_defineProperty(this, "firstSelectedValue", (collection) => {
+			let firstValue = null;
+			for (let value of this) if (!firstValue || collection.compareValue(value, firstValue) < 0) firstValue = value;
+			return firstValue;
+		});
+		_defineProperty(this, "lastSelectedValue", (collection) => {
+			let lastValue = null;
+			for (let value of this) if (!lastValue || collection.compareValue(value, lastValue) > 0) lastValue = value;
+			return lastValue;
+		});
+		_defineProperty(this, "extendSelection", (collection, anchorValue, targetValue) => {
+			if (this.selectionMode === "none") return this;
+			if (this.selectionMode === "single") return this.replaceSelection(collection, targetValue);
+			const selection = this.copy();
+			const lastSelected = Array.from(this).pop();
+			for (let key of collection.getValueRange(anchorValue, lastSelected ?? targetValue)) selection.delete(key);
+			for (let key of collection.getValueRange(targetValue, anchorValue)) if (this.canSelect(collection, key)) selection.add(key);
+			return selection;
+		});
+		_defineProperty(this, "toggleSelection", (collection, value) => {
+			if (this.selectionMode === "none") return this;
+			if (this.selectionMode === "single" && !this.isSelected(value)) return this.replaceSelection(collection, value);
+			const selection = this.copy();
+			if (selection.has(value)) selection.delete(value);
+			else if (selection.canSelect(collection, value)) selection.add(value);
+			return selection;
+		});
+		_defineProperty(this, "replaceSelection", (collection, value) => {
+			if (this.selectionMode === "none") return this;
+			if (value == null) return this;
+			if (!this.canSelect(collection, value)) return this;
+			const selection = new Selection([value]);
+			return this.sync(selection);
+		});
+		_defineProperty(this, "setSelection", (values$1) => {
+			if (this.selectionMode === "none") return this;
+			let selection = new Selection();
+			for (let value of values$1) if (value != null) {
+				selection.add(value);
+				if (this.selectionMode === "single") break;
+			}
+			return this.sync(selection);
+		});
+		_defineProperty(this, "clearSelection", () => {
+			const selection = this.copy();
+			if (selection.deselectable && selection.size > 0) selection.clear();
+			return selection;
+		});
+		_defineProperty(this, "select", (collection, value, forceToggle) => {
+			if (this.selectionMode === "none") return this;
+			if (this.selectionMode === "single") if (this.isSelected(value) && this.deselectable) return this.toggleSelection(collection, value);
+			else return this.replaceSelection(collection, value);
+			else if (this.selectionMode === "multiple" || forceToggle) return this.toggleSelection(collection, value);
+			else return this.replaceSelection(collection, value);
+		});
+		_defineProperty(this, "deselect", (value) => {
+			const selection = this.copy();
+			selection.delete(value);
+			return selection;
+		});
+		_defineProperty(this, "isEqual", (other) => {
+			return isEqual(Array.from(this), Array.from(other));
+		});
+	}
+};
+
+//#endregion
+//#region src/shared/collection/tree-visit.ts
+function access(node, indexPath, options) {
+	for (let i = 0; i < indexPath.length; i++) node = options.getChildren(node, indexPath.slice(i + 1))[indexPath[i]];
+	return node;
+}
+function ancestorIndexPaths(indexPaths) {
+	const sortedPaths = sortIndexPaths(indexPaths);
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const indexPath of sortedPaths) {
+		const key = indexPath.join();
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(indexPath);
+		}
+	}
+	return result;
+}
+function compareIndexPaths(a, b) {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) {
+		if (a[i] < b[i]) return -1;
+		if (a[i] > b[i]) return 1;
+	}
+	return a.length - b.length;
+}
+function sortIndexPaths(indexPaths) {
+	return indexPaths.sort(compareIndexPaths);
+}
+function find(node, options) {
+	let found;
+	visit(node, {
+		...options,
+		onEnter: (child, indexPath) => {
+			if (options.predicate(child, indexPath)) {
+				found = child;
+				return "stop";
+			}
+		}
+	});
+	return found;
+}
+function findAll(node, options) {
+	const found = [];
+	visit(node, {
+		onEnter: (child, indexPath) => {
+			if (options.predicate(child, indexPath)) found.push(child);
+		},
+		getChildren: options.getChildren
+	});
+	return found;
+}
+function findIndexPath(node, options) {
+	let found;
+	visit(node, {
+		onEnter: (child, indexPath) => {
+			if (options.predicate(child, indexPath)) {
+				found = [...indexPath];
+				return "stop";
+			}
+		},
+		getChildren: options.getChildren
+	});
+	return found;
+}
+function reduce(node, options) {
+	let result = options.initialResult;
+	visit(node, {
+		...options,
+		onEnter: (child, indexPath) => {
+			result = options.nextResult(result, child, indexPath);
+		}
+	});
+	return result;
+}
+function flatMap(node, options) {
+	return reduce(node, {
+		...options,
+		initialResult: [],
+		nextResult: (result, child, indexPath) => {
+			result.push(...options.transform(child, indexPath));
+			return result;
+		}
+	});
+}
+function filter(node, options) {
+	const { predicate, create, getChildren } = options;
+	const filterRecursive = (node$1, indexPath) => {
+		const children = getChildren(node$1, indexPath);
+		const filteredChildren = [];
+		children.forEach((child, index) => {
+			const filteredChild = filterRecursive(child, [...indexPath, index]);
+			if (filteredChild) filteredChildren.push(filteredChild);
+		});
+		const isRoot = indexPath.length === 0;
+		const nodeMatches = predicate(node$1, indexPath);
+		const hasFilteredChildren = filteredChildren.length > 0;
+		if (isRoot || nodeMatches || hasFilteredChildren) return create(node$1, filteredChildren, indexPath);
+		return null;
+	};
+	return filterRecursive(node, []) || create(node, [], []);
+}
+function flatten(rootNode, options) {
+	const nodes = [];
+	let idx = 0;
+	const idxMap = /* @__PURE__ */ new Map();
+	const parentMap = /* @__PURE__ */ new Map();
+	visit(rootNode, {
+		getChildren: options.getChildren,
+		onEnter: (node, indexPath) => {
+			if (!idxMap.has(node)) idxMap.set(node, idx++);
+			const children = options.getChildren(node, indexPath);
+			children.forEach((child) => {
+				if (!parentMap.has(child)) parentMap.set(child, node);
+				if (!idxMap.has(child)) idxMap.set(child, idx++);
+			});
+			const _children = children.length > 0 ? children.map((child) => idxMap.get(child)) : void 0;
+			const parent = parentMap.get(node);
+			const _parent = parent ? idxMap.get(parent) : void 0;
+			const _index = idxMap.get(node);
+			nodes.push({
+				...node,
+				_children,
+				_parent,
+				_index
+			});
+		}
+	});
+	return nodes;
+}
+function insertOperation(index, nodes) {
+	return {
+		type: "insert",
+		index,
+		nodes
+	};
+}
+function removeOperation(indexes) {
+	return {
+		type: "remove",
+		indexes
+	};
+}
+function replaceOperation() {
+	return { type: "replace" };
+}
+function splitIndexPath(indexPath) {
+	return [indexPath.slice(0, -1), indexPath[indexPath.length - 1]];
+}
+function getInsertionOperations(indexPath, nodes, operations = /* @__PURE__ */ new Map()) {
+	const [parentIndexPath, index] = splitIndexPath(indexPath);
+	for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+		const parentKey = parentIndexPath.slice(0, i).join();
+		switch (operations.get(parentKey)?.type) {
+			case "remove": continue;
+		}
+		operations.set(parentKey, replaceOperation());
+	}
+	const operation = operations.get(parentIndexPath.join());
+	switch (operation?.type) {
+		case "remove":
+			operations.set(parentIndexPath.join(), {
+				type: "removeThenInsert",
+				removeIndexes: operation.indexes,
+				insertIndex: index,
+				insertNodes: nodes
+			});
+			break;
+		default: operations.set(parentIndexPath.join(), insertOperation(index, nodes));
+	}
+	return operations;
+}
+function getRemovalOperations(indexPaths) {
+	const operations = /* @__PURE__ */ new Map();
+	const indexesToRemove = /* @__PURE__ */ new Map();
+	for (const indexPath of indexPaths) {
+		const parentKey = indexPath.slice(0, -1).join();
+		const value = indexesToRemove.get(parentKey) ?? [];
+		value.push(indexPath[indexPath.length - 1]);
+		indexesToRemove.set(parentKey, value.sort((a, b) => a - b));
+	}
+	for (const indexPath of indexPaths) for (let i = indexPath.length - 2; i >= 0; i--) {
+		const parentKey = indexPath.slice(0, i).join();
+		if (!operations.has(parentKey)) operations.set(parentKey, replaceOperation());
+	}
+	for (const [parentKey, indexes] of indexesToRemove) operations.set(parentKey, removeOperation(indexes));
+	return operations;
+}
+function getReplaceOperations(indexPath, node) {
+	const operations = /* @__PURE__ */ new Map();
+	const [parentIndexPath, index] = splitIndexPath(indexPath);
+	for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+		const parentKey = parentIndexPath.slice(0, i).join();
+		operations.set(parentKey, replaceOperation());
+	}
+	operations.set(parentIndexPath.join(), {
+		type: "removeThenInsert",
+		removeIndexes: [index],
+		insertIndex: index,
+		insertNodes: [node]
+	});
+	return operations;
+}
+function mutate(node, operations, options) {
+	return map(node, {
+		...options,
+		getChildren: (node$1, indexPath) => {
+			const key = indexPath.join();
+			switch (operations.get(key)?.type) {
+				case "replace":
+				case "remove":
+				case "removeThenInsert":
+				case "insert": return options.getChildren(node$1, indexPath);
+				default: return [];
+			}
+		},
+		transform: (node$1, children, indexPath) => {
+			const key = indexPath.join();
+			const operation = operations.get(key);
+			switch (operation?.type) {
+				case "remove": return options.create(node$1, children.filter((_, index) => !operation.indexes.includes(index)), indexPath);
+				case "removeThenInsert":
+					const updatedChildren = children.filter((_, index) => !operation.removeIndexes.includes(index));
+					const adjustedIndex = operation.removeIndexes.reduce((index, removedIndex) => removedIndex < index ? index - 1 : index, operation.insertIndex);
+					return options.create(node$1, splice(updatedChildren, adjustedIndex, 0, ...operation.insertNodes), indexPath);
+				case "insert": return options.create(node$1, splice(children, operation.index, 0, ...operation.nodes), indexPath);
+				case "replace": return options.create(node$1, children, indexPath);
+				default: return node$1;
+			}
+		}
+	});
+}
+function splice(array, start, deleteCount, ...items) {
+	return [
+		...array.slice(0, start),
+		...items,
+		...array.slice(start + deleteCount)
+	];
+}
+function map(node, options) {
+	const childrenMap = {};
+	visit(node, {
+		...options,
+		onLeave: (child, indexPath) => {
+			const keyIndexPath = [0, ...indexPath];
+			const key = keyIndexPath.join();
+			const transformed = options.transform(child, childrenMap[key] ?? [], indexPath);
+			const parentKey = keyIndexPath.slice(0, -1).join();
+			const parentChildren = childrenMap[parentKey] ?? [];
+			parentChildren.push(transformed);
+			childrenMap[parentKey] = parentChildren;
+		}
+	});
+	return childrenMap[""][0];
+}
+function insert(node, options) {
+	const { nodes, at } = options;
+	if (at.length === 0) throw new Error(`Can't insert nodes at the root`);
+	return mutate(node, getInsertionOperations(at, nodes), options);
+}
+function replace(node, options) {
+	if (options.at.length === 0) return options.node;
+	return mutate(node, getReplaceOperations(options.at, options.node), options);
+}
+function remove(node, options) {
+	if (options.indexPaths.length === 0) return node;
+	for (const indexPath of options.indexPaths) if (indexPath.length === 0) throw new Error(`Can't remove the root node`);
+	return mutate(node, getRemovalOperations(options.indexPaths), options);
+}
+function move(node, options) {
+	if (options.indexPaths.length === 0) return node;
+	for (const indexPath of options.indexPaths) if (indexPath.length === 0) throw new Error(`Can't move the root node`);
+	if (options.to.length === 0) throw new Error(`Can't move nodes to the root`);
+	const _ancestorIndexPaths = ancestorIndexPaths(options.indexPaths);
+	const nodesToInsert = _ancestorIndexPaths.map((indexPath) => access(node, indexPath, options));
+	return mutate(node, getInsertionOperations(options.to, nodesToInsert, getRemovalOperations(_ancestorIndexPaths)), options);
+}
+function visit(node, options) {
+	const { onEnter, onLeave, getChildren } = options;
+	let indexPath = [];
+	let stack = [{ node }];
+	const getIndexPath = options.reuseIndexPath ? () => indexPath : () => indexPath.slice();
+	while (stack.length > 0) {
+		let wrapper = stack[stack.length - 1];
+		if (wrapper.state === void 0) {
+			const enterResult = onEnter?.(wrapper.node, getIndexPath());
+			if (enterResult === "stop") return;
+			wrapper.state = enterResult === "skip" ? -1 : 0;
+		}
+		const children = wrapper.children || getChildren(wrapper.node, getIndexPath());
+		wrapper.children || (wrapper.children = children);
+		if (wrapper.state !== -1) {
+			if (wrapper.state < children.length) {
+				let currentIndex = wrapper.state;
+				indexPath.push(currentIndex);
+				stack.push({ node: children[currentIndex] });
+				wrapper.state = currentIndex + 1;
+				continue;
+			}
+			if (onLeave?.(wrapper.node, getIndexPath()) === "stop") return;
+		}
+		indexPath.pop();
+		stack.pop();
+	}
+}
+
+//#endregion
+//#region src/shared/collection/tree-collection.ts
+var TreeCollection = class TreeCollection {
+	constructor(options) {
+		this.options = options;
+		_defineProperty(this, "rootNode", void 0);
+		_defineProperty(this, "isEqual", (other) => {
+			return isEqual(this.rootNode, other.rootNode);
+		});
+		_defineProperty(this, "getNodeChildren", (node) => {
+			return this.options.nodeToChildren?.(node) ?? fallbackMethods.nodeToChildren(node) ?? [];
+		});
+		_defineProperty(this, "resolveIndexPath", (valueOrIndexPath) => {
+			return typeof valueOrIndexPath === "string" ? this.getIndexPath(valueOrIndexPath) : valueOrIndexPath;
+		});
+		_defineProperty(this, "resolveNode", (valueOrIndexPath) => {
+			const indexPath = this.resolveIndexPath(valueOrIndexPath);
+			return indexPath ? this.at(indexPath) : void 0;
+		});
+		_defineProperty(this, "getNodeChildrenCount", (node) => {
+			return this.options.nodeToChildrenCount?.(node) ?? fallbackMethods.nodeToChildrenCount(node);
+		});
+		_defineProperty(this, "getNodeValue", (node) => {
+			return this.options.nodeToValue?.(node) ?? fallbackMethods.nodeToValue(node);
+		});
+		_defineProperty(this, "getNodeDisabled", (node) => {
+			return this.options.isNodeDisabled?.(node) ?? fallbackMethods.isNodeDisabled(node);
+		});
+		_defineProperty(this, "stringify", (value) => {
+			const node = this.findNode(value);
+			if (!node) return null;
+			return this.stringifyNode(node);
+		});
+		_defineProperty(this, "stringifyNode", (node) => {
+			return this.options.nodeToString?.(node) ?? fallbackMethods.nodeToString(node);
+		});
+		_defineProperty(this, "getFirstNode", (rootNode = this.rootNode) => {
+			let firstChild;
+			visit(rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (!firstChild && indexPath.length > 0 && !this.getNodeDisabled(node)) {
+						firstChild = node;
+						return "stop";
+					}
+				}
+			});
+			return firstChild;
+		});
+		_defineProperty(this, "getLastNode", (rootNode = this.rootNode, opts = {}) => {
+			let lastChild;
+			visit(rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (this.isSameNode(node, rootNode)) return;
+					if (opts.skip?.({
+						value: this.getNodeValue(node),
+						node,
+						indexPath
+					})) return "skip";
+					if (indexPath.length > 0 && !this.getNodeDisabled(node)) lastChild = node;
+				}
+			});
+			return lastChild;
+		});
+		_defineProperty(this, "at", (indexPath) => {
+			return access(this.rootNode, indexPath, { getChildren: this.getNodeChildren });
+		});
+		_defineProperty(this, "findNode", (value, rootNode = this.rootNode) => {
+			return find(rootNode, {
+				getChildren: this.getNodeChildren,
+				predicate: (node) => this.getNodeValue(node) === value
+			});
+		});
+		_defineProperty(this, "findNodes", (values, rootNode = this.rootNode) => {
+			const v = new Set(values.filter((v$1) => v$1 != null));
+			return findAll(rootNode, {
+				getChildren: this.getNodeChildren,
+				predicate: (node) => v.has(this.getNodeValue(node))
+			});
+		});
+		_defineProperty(this, "sort", (values) => {
+			return values.reduce((acc, value) => {
+				const indexPath = this.getIndexPath(value);
+				if (indexPath) acc.push({
+					value,
+					indexPath
+				});
+				return acc;
+			}, []).sort((a, b) => compareIndexPaths(a.indexPath, b.indexPath)).map(({ value }) => value);
+		});
+		_defineProperty(this, "getIndexPath", (value) => {
+			return findIndexPath(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				predicate: (node) => this.getNodeValue(node) === value
+			});
+		});
+		_defineProperty(this, "getValue", (indexPath) => {
+			const node = this.at(indexPath);
+			return node ? this.getNodeValue(node) : void 0;
+		});
+		_defineProperty(this, "getValuePath", (indexPath) => {
+			if (!indexPath) return [];
+			const valuePath = [];
+			let currentPath = [...indexPath];
+			while (currentPath.length > 0) {
+				const node = this.at(currentPath);
+				if (node) valuePath.unshift(this.getNodeValue(node));
+				currentPath.pop();
+			}
+			return valuePath;
+		});
+		_defineProperty(this, "getDepth", (value) => {
+			return findIndexPath(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				predicate: (node) => this.getNodeValue(node) === value
+			})?.length ?? 0;
+		});
+		_defineProperty(this, "isSameNode", (node, other) => {
+			return this.getNodeValue(node) === this.getNodeValue(other);
+		});
+		_defineProperty(this, "isRootNode", (node) => {
+			return this.isSameNode(node, this.rootNode);
+		});
+		_defineProperty(this, "contains", (parentIndexPath, valueIndexPath) => {
+			if (!parentIndexPath || !valueIndexPath) return false;
+			return valueIndexPath.slice(0, parentIndexPath.length).every((_, i) => parentIndexPath[i] === valueIndexPath[i]);
+		});
+		_defineProperty(this, "getNextNode", (value, opts = {}) => {
+			let found = false;
+			let nextNode;
+			visit(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (this.isRootNode(node)) return;
+					const nodeValue = this.getNodeValue(node);
+					if (opts.skip?.({
+						value: nodeValue,
+						node,
+						indexPath
+					})) {
+						if (nodeValue === value) found = true;
+						return "skip";
+					}
+					if (found && !this.getNodeDisabled(node)) {
+						nextNode = node;
+						return "stop";
+					}
+					if (nodeValue === value) found = true;
+				}
+			});
+			return nextNode;
+		});
+		_defineProperty(this, "getPreviousNode", (value, opts = {}) => {
+			let previousNode;
+			let found = false;
+			visit(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (this.isRootNode(node)) return;
+					const nodeValue = this.getNodeValue(node);
+					if (opts.skip?.({
+						value: nodeValue,
+						node,
+						indexPath
+					})) return "skip";
+					if (nodeValue === value) {
+						found = true;
+						return "stop";
+					}
+					if (!this.getNodeDisabled(node)) previousNode = node;
+				}
+			});
+			return found ? previousNode : void 0;
+		});
+		_defineProperty(this, "getParentNodes", (valueOrIndexPath) => {
+			const indexPath = this.resolveIndexPath(valueOrIndexPath)?.slice();
+			if (!indexPath) return [];
+			const result = [];
+			while (indexPath.length > 0) {
+				indexPath.pop();
+				const parentNode = this.at(indexPath);
+				if (parentNode && !this.isRootNode(parentNode)) result.unshift(parentNode);
+			}
+			return result;
+		});
+		_defineProperty(this, "getDescendantNodes", (valueOrIndexPath, options$1) => {
+			const parentNode = this.resolveNode(valueOrIndexPath);
+			if (!parentNode) return [];
+			const result = [];
+			visit(parentNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, nodeIndexPath) => {
+					if (nodeIndexPath.length === 0) return;
+					if (!options$1?.withBranch && this.isBranchNode(node)) return;
+					result.push(node);
+				}
+			});
+			return result;
+		});
+		_defineProperty(this, "getDescendantValues", (valueOrIndexPath, options$1) => {
+			return this.getDescendantNodes(valueOrIndexPath, options$1).map((child) => this.getNodeValue(child));
+		});
+		_defineProperty(this, "getParentIndexPath", (indexPath) => {
+			return indexPath.slice(0, -1);
+		});
+		_defineProperty(this, "getParentNode", (valueOrIndexPath) => {
+			const indexPath = this.resolveIndexPath(valueOrIndexPath);
+			return indexPath ? this.at(this.getParentIndexPath(indexPath)) : void 0;
+		});
+		_defineProperty(this, "visit", (opts) => {
+			const { skip, ...rest } = opts;
+			visit(this.rootNode, {
+				...rest,
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (this.isRootNode(node)) return;
+					if (skip?.({
+						value: this.getNodeValue(node),
+						node,
+						indexPath
+					})) return "skip";
+					return rest.onEnter?.(node, indexPath);
+				}
+			});
+		});
+		_defineProperty(this, "getPreviousSibling", (indexPath) => {
+			const parentNode = this.getParentNode(indexPath);
+			if (!parentNode) return;
+			const siblings = this.getNodeChildren(parentNode);
+			let idx = indexPath[indexPath.length - 1];
+			while (--idx >= 0) {
+				const sibling = siblings[idx];
+				if (!this.getNodeDisabled(sibling)) return sibling;
+			}
+		});
+		_defineProperty(this, "getNextSibling", (indexPath) => {
+			const parentNode = this.getParentNode(indexPath);
+			if (!parentNode) return;
+			const siblings = this.getNodeChildren(parentNode);
+			let idx = indexPath[indexPath.length - 1];
+			while (++idx < siblings.length) {
+				const sibling = siblings[idx];
+				if (!this.getNodeDisabled(sibling)) return sibling;
+			}
+		});
+		_defineProperty(this, "getSiblingNodes", (indexPath) => {
+			const parentNode = this.getParentNode(indexPath);
+			return parentNode ? this.getNodeChildren(parentNode) : [];
+		});
+		_defineProperty(this, "getValues", (rootNode = this.rootNode) => {
+			return flatMap(rootNode, {
+				getChildren: this.getNodeChildren,
+				transform: (node) => [this.getNodeValue(node)]
+			}).slice(1);
+		});
+		_defineProperty(this, "isValidDepth", (indexPath, depth) => {
+			if (depth == null) return true;
+			if (typeof depth === "function") return depth(indexPath.length);
+			return indexPath.length === depth;
+		});
+		_defineProperty(this, "isBranchNode", (node) => {
+			return this.getNodeChildren(node).length > 0 || this.getNodeChildrenCount(node) != null;
+		});
+		_defineProperty(this, "getBranchValues", (rootNode = this.rootNode, opts = {}) => {
+			let values = [];
+			visit(rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (node, indexPath) => {
+					if (indexPath.length === 0) return;
+					const nodeValue = this.getNodeValue(node);
+					if (opts.skip?.({
+						value: nodeValue,
+						node,
+						indexPath
+					})) return "skip";
+					if (this.isBranchNode(node) && this.isValidDepth(indexPath, opts.depth)) values.push(this.getNodeValue(node));
+				}
+			});
+			return values;
+		});
+		_defineProperty(this, "flatten", (rootNode = this.rootNode) => {
+			return flatten(rootNode, { getChildren: this.getNodeChildren });
+		});
+		_defineProperty(this, "_create", (node, children) => {
+			if (this.getNodeChildren(node).length > 0 || children.length > 0) return {
+				...node,
+				children
+			};
+			return { ...node };
+		});
+		_defineProperty(this, "_insert", (rootNode, indexPath, nodes) => {
+			return this.copy(insert(rootNode, {
+				at: indexPath,
+				nodes,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			}));
+		});
+		_defineProperty(this, "copy", (rootNode) => {
+			return new TreeCollection({
+				...this.options,
+				rootNode
+			});
+		});
+		_defineProperty(this, "_replace", (rootNode, indexPath, node) => {
+			return this.copy(replace(rootNode, {
+				at: indexPath,
+				node,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			}));
+		});
+		_defineProperty(this, "_move", (rootNode, indexPaths, to) => {
+			return this.copy(move(rootNode, {
+				indexPaths,
+				to,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			}));
+		});
+		_defineProperty(this, "_remove", (rootNode, indexPaths) => {
+			return this.copy(remove(rootNode, {
+				indexPaths,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			}));
+		});
+		_defineProperty(this, "replace", (indexPath, node) => {
+			return this._replace(this.rootNode, indexPath, node);
+		});
+		_defineProperty(this, "remove", (indexPaths) => {
+			return this._remove(this.rootNode, indexPaths);
+		});
+		_defineProperty(this, "insertBefore", (indexPath, nodes) => {
+			return this.getParentNode(indexPath) ? this._insert(this.rootNode, indexPath, nodes) : void 0;
+		});
+		_defineProperty(this, "insertAfter", (indexPath, nodes) => {
+			if (!this.getParentNode(indexPath)) return;
+			const nextIndex$1 = [...indexPath.slice(0, -1), indexPath[indexPath.length - 1] + 1];
+			return this._insert(this.rootNode, nextIndex$1, nodes);
+		});
+		_defineProperty(this, "move", (fromIndexPaths, toIndexPath) => {
+			return this._move(this.rootNode, fromIndexPaths, toIndexPath);
+		});
+		_defineProperty(this, "filter", (predicate) => {
+			const filteredRoot = filter(this.rootNode, {
+				predicate,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			});
+			return this.copy(filteredRoot);
+		});
+		_defineProperty(this, "toJSON", () => {
+			return this.getValues(this.rootNode);
+		});
+		this.rootNode = options.rootNode;
+	}
+};
+function flattenedToTree(nodes, options = fallbackMethods) {
+	if (nodes.length === 0) throw new Error("[sprawlify-js/tree] Cannot create tree from empty flattened array");
+	const rootFlatNode = nodes.find((node) => node._parent === void 0);
+	if (!rootFlatNode) throw new Error("[sprawlify-js/tree] No root node found in flattened data");
+	const nodeMap = /* @__PURE__ */ new Map();
+	nodes.forEach((node) => {
+		nodeMap.set(node._index, node);
+	});
+	const buildNode = (idx) => {
+		const flatNode = nodeMap.get(idx);
+		if (!flatNode) return {};
+		const { _children, ...cleanNode } = flatNode;
+		const children = [];
+		_children?.forEach((childIndex) => {
+			children.push(buildNode(childIndex));
+		});
+		return {
+			...cleanNode,
+			...children.length > 0 && { children }
+		};
+	};
+	const rootNode = buildNode(rootFlatNode._index);
+	return new TreeCollection({
+		...options,
+		rootNode
+	});
+}
+function filePathToTree(paths) {
+	const rootNode = {
+		label: "",
+		value: "ROOT",
+		children: []
+	};
+	paths.forEach((path) => {
+		const parts = path.split("/");
+		let currentNode = rootNode;
+		parts.forEach((part, index) => {
+			let childNode = currentNode.children?.find((child) => child.label === part);
+			if (!childNode) {
+				var _currentNode;
+				childNode = {
+					value: parts.slice(0, index + 1).join("/"),
+					label: part
+				};
+				(_currentNode = currentNode).children || (_currentNode.children = []);
+				currentNode.children.push(childNode);
+			}
+			currentNode = childNode;
+		});
+	});
+	return new TreeCollection({ rootNode });
+}
+const fallbackMethods = {
+	nodeToValue(node) {
+		if (typeof node === "string") return node;
+		if (isObject(node) && hasProp(node, "value")) return node.value;
+		return "";
+	},
+	nodeToString(node) {
+		if (typeof node === "string") return node;
+		if (isObject(node) && hasProp(node, "label")) return node.label;
+		return fallbackMethods.nodeToValue(node);
+	},
+	isNodeDisabled(node) {
+		if (isObject(node) && hasProp(node, "disabled")) return !!node.disabled;
+		return false;
+	},
+	nodeToChildren(node) {
+		return node.children;
+	},
+	nodeToChildrenCount(node) {
+		if (isObject(node) && hasProp(node, "childrenCount")) return node.childrenCount;
+	}
+};
+
+//#endregion
+export { GridCollection as a, isListCollection as c, Selection as i, filePathToTree as n, isGridCollection as o, flattenedToTree as r, ListCollection as s, TreeCollection as t };