@vueye-table/core 3.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1207 @@
+//#region src/humanize.ts
+/**
+* Turn a column id into a readable header: `"name.first_name"` becomes `"Name first name"` and
+* `"createdAt"` becomes `"Created at"`.
+*/
+function humanize(id) {
+	const sentence = id.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").split(/[\s._-]+/u).filter((word) => word.length > 0).map((word) => word.toLowerCase()).join(" ");
+	return sentence.charAt(0).toUpperCase() + sentence.slice(1);
+}
+
+//#endregion
+//#region src/path.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Read the value at a dotted path, or `undefined` when a step is missing. */
+function getPath(source, path) {
+	let current = source;
+	for (const segment of path.split(".")) {
+		if (!isRecord$1(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+/**
+* Return a copy of `source` with `value` at `path`. Only the objects along the path are copied;
+* everything else is shared. Missing steps are created as plain objects.
+*/
+function setPath(source, path, value) {
+	const [head, ...rest] = path.split(".");
+	const base = isRecord$1(source) ? { ...source } : {};
+	if (head === void 0) return source;
+	base[head] = rest.length === 0 ? value : setPath(base[head], rest.join("."), value);
+	return base;
+}
+
+//#endregion
+//#region src/column.ts
+/** Declare columns for a row type with full inference, outside a table. */
+function defineColumns(columns) {
+	return Object.freeze([...columns]);
+}
+const collator = new Intl.Collator(void 0, {
+	numeric: true,
+	sensitivity: "base"
+});
+function isEmpty(value) {
+	return value === null || value === void 0 || value === "";
+}
+/** Order any two values: empty last, then numbers, dates, booleans, and text naturally. */
+function compareValues(left, right) {
+	const leftEmpty = isEmpty(left);
+	const rightEmpty = isEmpty(right);
+	if (leftEmpty || rightEmpty) return leftEmpty === rightEmpty ? 0 : leftEmpty ? 1 : -1;
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	if (typeof left === "bigint" && typeof right === "bigint") return left < right ? -1 : left > right ? 1 : 0;
+	if (left instanceof Date && right instanceof Date) return left.getTime() - right.getTime();
+	if (typeof left === "boolean" && typeof right === "boolean") return Number(left) - Number(right);
+	return collator.compare(formatValue(left), formatValue(right));
+}
+/**
+* Text for a value: empty for `null` and `undefined`, ISO for dates, comma-joined for arrays, and
+* JSON for other objects. The result never depends on the runtime's locale, so server and client
+* render the same text.
+*/
+function formatValue(value) {
+	if (value === null || value === void 0) return "";
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+	if (Array.isArray(value)) return value.map(formatValue).join(", ");
+	if (typeof value === "object") return JSON.stringify(value);
+	switch (typeof value) {
+		case "string": return value;
+		case "number":
+		case "bigint":
+		case "boolean": return String(value);
+		case "symbol": return value.toString();
+		default: return "";
+	}
+}
+function toComparable(value) {
+	if (value instanceof Date) {
+		const time = value.getTime();
+		return Number.isNaN(time) ? void 0 : time;
+	}
+	if (typeof value === "number") return Number.isNaN(value) ? void 0 : value;
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Read a range bound in the kind of the value it is compared with, so a bound typed into a text
+* box (`"10"`, `"2024-01-31"`) compares with numbers as a number and with dates as a time. An
+* empty or unreadable bound leaves that end of the range open.
+*/
+function toBound(bound, value) {
+	if (isEmpty(bound)) return;
+	if (typeof bound === "string" && typeof value === "number") {
+		const number = Number(bound.trim());
+		return bound.trim() === "" || Number.isNaN(number) ? void 0 : number;
+	}
+	if (typeof bound === "string" && value instanceof Date) return toComparable(new Date(bound));
+	if (bound instanceof Date && typeof value === "string") return Number.isNaN(bound.getTime()) ? void 0 : bound.toISOString().slice(0, value.length);
+	return toComparable(bound);
+}
+function isRangeFilter(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && ("min" in value || "max" in value);
+}
+/**
+* The default column filter:
+*
+* - an empty filter value (`undefined`, `null`, `""`, `[]`) lets every row through;
+* - an array keeps rows whose value is one of its items;
+* - `{ min, max }` keeps values inside the inclusive range; a bound given as text is read as a
+*   number or a date when the value is one, and an empty bound leaves that end open;
+* - text keeps rows whose shown text contains it, ignoring case;
+* - anything else keeps rows whose value is identical.
+*/
+function matchesFilter(value, filterValue, display) {
+	if (isEmpty(filterValue) || Array.isArray(filterValue) && filterValue.length === 0) return true;
+	if (Array.isArray(filterValue)) return filterValue.some((item) => Object.is(item, value) || compareValues(item, value) === 0);
+	if (isRangeFilter(filterValue)) {
+		const min = toBound(filterValue.min, value);
+		const max = toBound(filterValue.max, value);
+		if (min === void 0 && max === void 0) return true;
+		const comparable = toComparable(value);
+		if (comparable === void 0) return false;
+		return (min === void 0 || comparable >= min) && (max === void 0 || comparable <= max);
+	}
+	if (typeof filterValue === "string") return display.toLowerCase().includes(filterValue.toLowerCase());
+	return Object.is(value, filterValue);
+}
+const TRUE_WORDS = /* @__PURE__ */ new Set([
+	"true",
+	"1",
+	"yes",
+	"y",
+	"on"
+]);
+const FALSE_WORDS = /* @__PURE__ */ new Set([
+	"false",
+	"0",
+	"no",
+	"n",
+	"off"
+]);
+/** The column type a value suggests, or `undefined` for an empty value. */
+function typeOf(value) {
+	if (value === null || value === void 0) return;
+	if (typeof value === "number") return "number";
+	if (typeof value === "boolean") return "boolean";
+	return value instanceof Date ? "date" : "text";
+}
+/** Read text as a column type. Empty text is `null` for every type but text. */
+function parseAs(input, type) {
+	const text = input.trim();
+	if (type === "text") return {
+		ok: true,
+		value: input
+	};
+	if (text === "") return {
+		ok: true,
+		value: null
+	};
+	if (type === "number") {
+		const value = Number(text);
+		return Number.isFinite(value) ? {
+			ok: true,
+			value
+		} : {
+			ok: false,
+			message: `"${input}" is not a number`
+		};
+	}
+	if (type === "boolean") {
+		const word = text.toLowerCase();
+		if (TRUE_WORDS.has(word)) return {
+			ok: true,
+			value: true
+		};
+		if (FALSE_WORDS.has(word)) return {
+			ok: true,
+			value: false
+		};
+		return {
+			ok: false,
+			message: `"${input}" is not a yes or no value`
+		};
+	}
+	const value = new Date(text);
+	return Number.isNaN(value.getTime()) ? {
+		ok: false,
+		message: `"${input}" is not a date`
+	} : {
+		ok: true,
+		value
+	};
+}
+/** Resolve a definition against its defaults. */
+function resolveColumn(definition) {
+	const def = definition;
+	const { accessor } = def;
+	const getValue = accessor ?? ((row) => getPath(row, def.id));
+	const format = def.format ?? ((value) => formatValue(value));
+	const compare = def.compare ?? compareValues;
+	const customFilter = def.filter;
+	const customParse = def.parse;
+	const editable = def.editable ?? false;
+	const customSetValue = def.setValue;
+	const canWrite = accessor === void 0 || customSetValue !== void 0;
+	return Object.freeze({
+		id: def.id,
+		header: def.header ?? humanize(def.id),
+		align: def.align ?? "start",
+		width: def.width,
+		minWidth: def.minWidth,
+		sortable: def.sortable ?? true,
+		searchable: def.searchable ?? true,
+		initiallyHidden: def.hidden ?? false,
+		meta: Object.freeze({ ...def.meta }),
+		definition,
+		getValue,
+		format: (value, row) => format(value, row),
+		compare: (left, right) => compare(left, right),
+		matches(value, filterValue, row) {
+			return customFilter ? customFilter(value, filterValue, row) : matchesFilter(value, filterValue, format(value, row));
+		},
+		isEditable(row) {
+			if (!canWrite) return false;
+			return typeof editable === "function" ? editable(row) : editable;
+		},
+		parse(input, row, sample) {
+			if (customParse) try {
+				return {
+					ok: true,
+					value: customParse(input, row)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					message: error instanceof Error ? error.message : String(error)
+				};
+			}
+			return parseAs(input, def.type ?? typeOf(getValue(row)) ?? typeOf(sample) ?? "text");
+		},
+		setValue(row, value) {
+			if (customSetValue) return customSetValue(row, value);
+			return accessor === void 0 ? setPath(row, def.id, value) : void 0;
+		}
+	});
+}
+
+//#endregion
+//#region src/delimited.ts
+/**
+* Delimited text: tab-separated for the clipboard, comma-separated for export.
+*
+* A field is quoted when it holds the delimiter, a quote, or a line break, and quotes inside it
+* are doubled. This is what spreadsheet applications write and read.
+*/
+function quote(field, delimiter) {
+	return field.includes(delimiter) || field.includes("\"") || field.includes("\n") || field.includes("\r") ? `"${field.replaceAll("\"", "\"\"")}"` : field;
+}
+/** Write a matrix of text as delimited lines joined with `\n`. */
+function toDelimited(matrix, delimiter = "	") {
+	return matrix.map((line) => line.map((field) => quote(field, delimiter)).join(delimiter)).join("\n");
+}
+/**
+* Read delimited text into a matrix. Accepts `\n` and `\r\n`, quoted fields with doubled quotes
+* and embedded line breaks, and ignores one trailing line break.
+*/
+function parseDelimited(text, delimiter = "	") {
+	const rows = [];
+	let row = [];
+	let field = "";
+	let quoted = false;
+	let index = 0;
+	const endField = () => {
+		row.push(field);
+		field = "";
+	};
+	const endRow = () => {
+		endField();
+		rows.push(row);
+		row = [];
+	};
+	while (index < text.length) {
+		const char = text.charAt(index);
+		if (quoted) {
+			if (char === "\"") {
+				if (text.charAt(index + 1) === "\"") {
+					field += "\"";
+					index += 1;
+				} else quoted = false;
+			} else field += char;
+		} else if (char === "\"" && field === "") quoted = true;
+		else if (char === delimiter) endField();
+		else if (char === "\n" || char === "\r") {
+			if (char === "\r" && text.charAt(index + 1) === "\n") index += 1;
+			endRow();
+		} else field += char;
+		index += 1;
+	}
+	if (field !== "" || row.length > 0) endRow();
+	return rows;
+}
+
+//#endregion
+//#region src/grid.ts
+function clamp(value, max) {
+	return Math.min(Math.max(0, value), Math.max(0, max - 1));
+}
+function clampPosition(position, bounds) {
+	return {
+		row: clamp(position.row, bounds.rows),
+		column: clamp(position.column, bounds.columns)
+	};
+}
+/** A selection of one cell. */
+function selectCell(position) {
+	return {
+		anchor: position,
+		focus: position
+	};
+}
+/** Move the focus one step, or to the edge, staying inside the bounds. */
+function moveSelection(selection, direction, bounds, options = {}) {
+	const { row, column } = selection.focus;
+	const far = options.toEdge === true;
+	const next = clampPosition({
+		row: direction === "up" ? far ? 0 : row - 1 : direction === "down" ? far ? bounds.rows - 1 : row + 1 : row,
+		column: direction === "left" ? far ? 0 : column - 1 : direction === "right" ? far ? bounds.columns - 1 : column + 1 : column
+	}, bounds);
+	return options.extend === true ? {
+		anchor: selection.anchor,
+		focus: next
+	} : {
+		anchor: next,
+		focus: next
+	};
+}
+/** The rectangle a selection covers. */
+function selectionRange(selection) {
+	return {
+		top: Math.min(selection.anchor.row, selection.focus.row),
+		left: Math.min(selection.anchor.column, selection.focus.column),
+		bottom: Math.max(selection.anchor.row, selection.focus.row),
+		right: Math.max(selection.anchor.column, selection.focus.column)
+	};
+}
+function rangeContains(range, position) {
+	return position.row >= range.top && position.row <= range.bottom && position.column >= range.left && position.column <= range.right;
+}
+/** `0` is `"A"`, `25` is `"Z"`, `26` is `"AA"`. */
+function columnLabel(index) {
+	let label = "";
+	let rest = index + 1;
+	while (rest > 0) {
+		const remainder = (rest - 1) % 26;
+		label = String.fromCharCode(65 + remainder) + label;
+		rest = Math.floor((rest - 1) / 26);
+	}
+	return label;
+}
+/** `{ row: 2, column: 1 }` is `"B3"`. */
+function toA1(position) {
+	return `${columnLabel(position.column)}${position.row + 1}`;
+}
+/** `"B3"` is `{ row: 2, column: 1 }`. Returns `undefined` for anything else. */
+function fromA1(reference) {
+	const match = /^([A-Z]+)([1-9]\d*)$/u.exec(reference.trim().toUpperCase());
+	if (!match?.[1] || !match[2]) return;
+	let column = 0;
+	for (const char of match[1]) column = column * 26 + (char.charCodeAt(0) - 64);
+	return {
+		row: Number(match[2]) - 1,
+		column: column - 1
+	};
+}
+const ARROWS = {
+	ArrowUp: "up",
+	ArrowDown: "down",
+	ArrowLeft: "left",
+	ArrowRight: "right"
+};
+/**
+* Map a key press to a grid command, spreadsheet style: arrows move (Shift extends, Ctrl or Cmd
+* jumps to the edge), Tab moves across, Home and End reach the row's ends, Enter or F2 edit,
+* a printable character starts editing with that character, Delete and Backspace clear, Escape
+* collapses the selection, and Ctrl or Cmd with A, Z, Y select all, undo, and redo.
+*/
+function gridCommand(event) {
+	const mod = event.ctrlKey === true || event.metaKey === true;
+	const shift = event.shiftKey === true;
+	const direction = ARROWS[event.key];
+	if (direction) return {
+		type: "move",
+		direction,
+		options: {
+			extend: shift,
+			toEdge: mod
+		}
+	};
+	switch (event.key) {
+		case "Tab": return {
+			type: "move",
+			direction: shift ? "left" : "right",
+			options: {}
+		};
+		case "Home":
+		case "End": return {
+			type: "move",
+			direction: event.key === "Home" ? "left" : "right",
+			options: {
+				extend: shift,
+				toEdge: true
+			}
+		};
+		case "Enter":
+		case "F2": return { type: "edit" };
+		case "Delete":
+		case "Backspace": return { type: "clear" };
+		case "Escape": return { type: "cancel" };
+	}
+	if (mod) {
+		const key = event.key.toLowerCase();
+		if (key === "a") return { type: "selectAll" };
+		if (key === "z") return shift ? { type: "redo" } : { type: "undo" };
+		if (key === "y") return { type: "redo" };
+		return;
+	}
+	if (event.key.length === 1 && event.altKey !== true) return {
+		type: "edit",
+		initial: event.key
+	};
+}
+
+//#endregion
+//#region src/undo-stack.ts
+function createUndoStack(limit = 100) {
+	const past = [];
+	const future = [];
+	return {
+		get canUndo() {
+			return past.length > 0;
+		},
+		get canRedo() {
+			return future.length > 0;
+		},
+		record(entry) {
+			past.push(entry);
+			if (past.length > limit) past.shift();
+			future.length = 0;
+		},
+		undo() {
+			const entry = past.pop();
+			if (entry !== void 0) future.push(entry);
+			return entry;
+		},
+		redo() {
+			const entry = future.pop();
+			if (entry !== void 0) past.push(entry);
+			return entry;
+		},
+		clear() {
+			past.length = 0;
+			future.length = 0;
+		}
+	};
+}
+
+//#endregion
+//#region src/infer.ts
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function collect(value, prefix, depth, into) {
+	if (!isPlainObject(value)) return;
+	for (const [key, child] of Object.entries(value)) {
+		const path = prefix === "" ? key : `${prefix}.${key}`;
+		if (isPlainObject(child) && depth < 4) collect(child, path, depth + 1, into);
+		else into.add(path);
+	}
+}
+/**
+* Columns for data that has none declared: one path column per leaf of the first `sample` rows,
+* nested objects flattened into dotted paths, in first-seen order.
+*/
+function inferColumns(rows, sample = 20) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const row of rows.slice(0, sample)) collect(row, "", 1, paths);
+	return Object.freeze([...paths].map((id) => ({ id })));
+}
+
+//#endregion
+//#region src/pipeline.ts
+/**
+* The row pipeline: filter, then sort, then paginate. Each stage is a pure function, so a table
+* recomputes only the stages whose inputs changed, and a server can run the same stages.
+*/
+/** Split free text into lowercase terms. */
+function searchTerms(search) {
+	return search.toLowerCase().split(/\s+/u).filter((term) => term.length > 0);
+}
+/**
+* Keep rows that pass every column filter and contain every search term in at least one
+* searchable column.
+*/
+function filterRows(rows, columns, search, filters) {
+	const terms = searchTerms(search);
+	const byId = new Map(columns.map((column) => [column.id, column]));
+	const activeFilters = Object.entries(filters).flatMap(([id, value]) => {
+		const column = byId.get(id);
+		return column && value !== void 0 ? [{
+			column,
+			value
+		}] : [];
+	});
+	const searchable = columns.filter((column) => column.searchable);
+	if (terms.length === 0 && activeFilters.length === 0) return rows;
+	return rows.filter((row) => {
+		for (const { column, value } of activeFilters) if (!column.matches(row.getValue(column.id), value, row.original)) return false;
+		if (terms.length === 0) return true;
+		const haystack = searchable.map((column) => row.getDisplay(column.id).toLowerCase());
+		return terms.every((term) => haystack.some((text) => text.includes(term)));
+	});
+}
+/** Sort rows by each rule in turn. The sort is stable: ties keep their incoming order. */
+function sortRows(rows, columns, sorting) {
+	const byId = new Map(columns.map((column) => [column.id, column]));
+	const rules = sorting.flatMap((rule) => {
+		const column = byId.get(rule.column);
+		return column ? [{
+			column,
+			sign: rule.direction === "desc" ? -1 : 1
+		}] : [];
+	});
+	if (rules.length === 0) return rows;
+	return rows.toSorted((left, right) => {
+		for (const { column, sign } of rules) {
+			const leftValue = left.getValue(column.id);
+			const rightValue = right.getValue(column.id);
+			const leftEmpty = leftValue === null || leftValue === void 0 || leftValue === "";
+			if (leftEmpty !== (rightValue === null || rightValue === void 0 || rightValue === "")) return leftEmpty ? 1 : -1;
+			const order = column.compare(leftValue, rightValue) * sign;
+			if (order !== 0) return order;
+		}
+		return 0;
+	});
+}
+/** The number of pages for a row count. An empty table still has one page. */
+function countPages(rowCount, pageSize) {
+	return Math.max(1, Math.ceil(rowCount / pageSize));
+}
+/** Clamp a page into `1..pageCount`. */
+function clampPage(page, pageCount) {
+	return Math.min(Math.max(1, Math.trunc(page) || 1), pageCount);
+}
+/** The rows on one page. `pagination.page` must already be clamped. */
+function paginateRows(rows, pagination) {
+	const start = (pagination.page - 1) * pagination.pageSize;
+	return rows.slice(start, start + pagination.pageSize);
+}
+/**
+* The page buttons to show: always the first and last page, `siblings` pages on each side of the
+* current one, and a gap wherever pages are skipped. A gap never hides a single page.
+*/
+function paginationItems(page, pageCount, siblings = 1) {
+	const pages = /* @__PURE__ */ new Set([1, pageCount]);
+	for (let offset = -siblings; offset <= siblings; offset += 1) {
+		const candidate = page + offset;
+		if (candidate >= 1 && candidate <= pageCount) pages.add(candidate);
+	}
+	const sorted = [...pages].toSorted((left, right) => left - right);
+	const items = [];
+	let previous = 0;
+	for (const value of sorted) {
+		if (value - previous === 2) items.push({
+			type: "page",
+			page: value - 1,
+			current: value - 1 === page
+		});
+		else if (value - previous > 2) items.push({
+			type: "gap",
+			key: `gap-${previous}-${value}`
+		});
+		items.push({
+			type: "page",
+			page: value,
+			current: value === page
+		});
+		previous = value;
+	}
+	return items;
+}
+
+//#endregion
+//#region src/state.ts
+const DEFAULT_PAGE_SIZE = 10;
+function createInitialState(patch = {}) {
+	return freezeState({
+		sorting: patch.sorting ?? [],
+		search: patch.search ?? "",
+		filters: patch.filters ?? {},
+		pagination: patch.pagination ?? {
+			page: 1,
+			pageSize: 10
+		},
+		selection: patch.selection ?? [],
+		hiddenColumns: patch.hiddenColumns ?? [],
+		columnOrder: patch.columnOrder ?? []
+	});
+}
+function mergeState(state, patch) {
+	let changed = false;
+	const next = { ...state };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === void 0 || Object.is(next[key], value)) continue;
+		if (key === "pagination" && samePagination(next[key], value)) continue;
+		next[key] = value;
+		changed = true;
+	}
+	return changed ? freezeState(next) : state;
+}
+function samePagination(left, right) {
+	return left.page === right.page && left.pageSize === right.pageSize;
+}
+function freezeState(state) {
+	return Object.freeze({
+		sorting: Object.freeze(state.sorting.map((rule) => Object.freeze({ ...rule }))),
+		search: state.search,
+		filters: Object.freeze({ ...state.filters }),
+		pagination: Object.freeze({ ...state.pagination }),
+		selection: Object.freeze([...state.selection]),
+		hiddenColumns: Object.freeze([...state.hiddenColumns]),
+		columnOrder: Object.freeze([...state.columnOrder])
+	});
+}
+
+//#endregion
+//#region src/issues.ts
+function issue(code, message, details = {}) {
+	return Object.freeze({
+		code,
+		message,
+		...details
+	});
+}
+
+//#endregion
+//#region src/row.ts
+function createRow(original, key, index, columns) {
+	const values = /* @__PURE__ */ new Map();
+	const displays = /* @__PURE__ */ new Map();
+	const getValue = (columnId) => {
+		if (values.has(columnId)) return values.get(columnId);
+		const value = columns.get(columnId)?.getValue(original);
+		values.set(columnId, value);
+		return value;
+	};
+	return Object.freeze({
+		key,
+		index,
+		original,
+		getValue,
+		getDisplay(columnId) {
+			const cached = displays.get(columnId);
+			if (cached !== void 0) return cached;
+			const column = columns.get(columnId);
+			const display = column ? column.format(getValue(columnId), original) : "";
+			displays.set(columnId, display);
+			return display;
+		}
+	});
+}
+
+//#endregion
+//#region src/table.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function memo(compute) {
+	let last;
+	return (...deps) => {
+		if (last && last.deps.length === deps.length && last.deps.every((d, i) => Object.is(d, deps[i]))) return last.result;
+		const result = compute(...deps);
+		last = {
+			deps,
+			result
+		};
+		return result;
+	};
+}
+function isInputEdit(edit) {
+	return "input" in edit;
+}
+function coverage(selected, total) {
+	if (selected === 0 || total === 0) return "none";
+	return selected === total ? "all" : "some";
+}
+/** Create a data table. */
+function createTable(options) {
+	const selectionMode = options.selectionMode ?? "multiple";
+	const selectScope = options.selectScope ?? "all";
+	const manual = options.manual ?? false;
+	const undoStack = createUndoStack(options.historyLimit);
+	const listeners = /* @__PURE__ */ new Set();
+	let data = options.data;
+	let definitions = options.columns;
+	let rowCount = options.rowCount;
+	const initialState = createInitialState({
+		...options.initialState,
+		hiddenColumns: options.initialState?.hiddenColumns ?? options.columns.filter((column) => column.hidden === true).map((column) => column.id)
+	});
+	let state = initialState;
+	let snapshot;
+	const readKey = (row, index) => {
+		const { rowKey } = options;
+		if (typeof rowKey === "function") return rowKey(row, index);
+		const value = getPath(row, rowKey ?? "id");
+		if (typeof value === "string" || typeof value === "number") return value;
+		return rowKey === void 0 || !isRecord(row) ? index : String(value);
+	};
+	const resolveColumns = memo((defs) => {
+		const columns = defs.map((definition) => resolveColumn(definition));
+		return {
+			columns,
+			byId: new Map(columns.map((column) => [column.id, column]))
+		};
+	});
+	const indexRows = memo((rows, byId) => {
+		const byKey = /* @__PURE__ */ new Map();
+		const issues = [];
+		return {
+			rows: rows.map((original, index) => {
+				let key = readKey(original, index);
+				if (byKey.has(key)) {
+					issues.push(issue("duplicate_row_key", `Row ${index} repeats the key "${String(key)}"; it is keyed "${String(key)}#${index}" instead.`, { rowKey: key }));
+					key = `${String(key)}#${index}`;
+				}
+				const row = createRow(original, key, index, byId);
+				byKey.set(key, row);
+				return row;
+			}),
+			byKey,
+			issues
+		};
+	});
+	const orderColumns = memo((columns, columnOrder, hiddenColumns) => {
+		const position = new Map(columnOrder.map((id, index) => [id, index]));
+		const ordered = columns.map((column, index) => ({
+			column,
+			index
+		})).toSorted((left, right) => {
+			return (position.get(left.column.id) ?? columnOrder.length + left.index) - (position.get(right.column.id) ?? columnOrder.length + right.index);
+		}).map(({ column }) => column);
+		const hidden = new Set(hiddenColumns);
+		return {
+			all: ordered,
+			visible: ordered.filter((column) => !hidden.has(column.id))
+		};
+	});
+	const filterStage = memo(filterRows);
+	const sortStage = memo(sortRows);
+	const selectedSet = memo((selection) => new Set(selection));
+	function stateIssues(byId) {
+		const issues = [];
+		const referenced = /* @__PURE__ */ new Set([
+			...state.sorting.map((rule) => rule.column),
+			...Object.keys(state.filters),
+			...state.hiddenColumns,
+			...state.columnOrder
+		]);
+		for (const id of referenced) if (!byId.has(id)) issues.push(issue("unknown_column", `The state refers to a column "${id}" that is not defined.`, { column: id }));
+		const { pageSize } = state.pagination;
+		if (!Number.isInteger(pageSize) || pageSize < 1) issues.push(issue("invalid_page_size", `Page size ${String(pageSize)} is not a positive whole number; ${10} is used.`));
+		return issues;
+	}
+	function computeSnapshot() {
+		const { columns, byId } = resolveColumns(definitions);
+		const indexed = indexRows(data, byId);
+		const ordered = orderColumns(columns, state.columnOrder, state.hiddenColumns);
+		const issues = [...indexed.issues, ...stateIssues(byId)];
+		const requestedSize = state.pagination.pageSize;
+		const pageSize = Number.isInteger(requestedSize) && requestedSize >= 1 ? requestedSize : 10;
+		let processedRows;
+		let rows;
+		let filteredCount;
+		let page;
+		let pageCount;
+		if (manual) {
+			processedRows = indexed.rows;
+			rows = indexed.rows;
+			filteredCount = rowCount ?? indexed.rows.length;
+			pageCount = countPages(filteredCount, pageSize);
+			page = clampPage(state.pagination.page, pageCount);
+		} else {
+			const filtered = filterStage(indexed.rows, columns, state.search, state.filters);
+			processedRows = sortStage(filtered, columns, state.sorting);
+			filteredCount = processedRows.length;
+			pageCount = countPages(filteredCount, pageSize);
+			page = clampPage(state.pagination.page, pageCount);
+			rows = paginateRows(processedRows, {
+				page,
+				pageSize
+			});
+		}
+		const selected = selectedSet(state.selection);
+		const pageSelected = rows.filter((row) => selected.has(row.key)).length;
+		const scopeRows = selectScope === "page" || manual ? rows : processedRows;
+		const scopeSelected = scopeRows === rows ? pageSelected : scopeRows.filter((row) => selected.has(row.key)).length;
+		const pageStart = rows.length === 0 ? 0 : (page - 1) * pageSize + 1;
+		const sortIndex = new Map(state.sorting.map((rule, priority) => [rule.column, {
+			direction: rule.direction,
+			priority
+		}]));
+		return Object.freeze({
+			state,
+			columns: ordered.visible,
+			allColumns: ordered.all,
+			rows,
+			processedRows,
+			page,
+			pageSize,
+			pageCount,
+			rowCount: filteredCount,
+			totalRowCount: manual ? filteredCount : indexed.rows.length,
+			pageStart,
+			pageEnd: rows.length === 0 ? 0 : pageStart + rows.length - 1,
+			pageItems: paginationItems(page, pageCount),
+			canPreviousPage: page > 1,
+			canNextPage: page < pageCount,
+			selectionMode,
+			selectedCount: state.selection.length,
+			pageSelection: coverage(pageSelected, rows.length),
+			allSelection: coverage(scopeSelected, scopeRows.length),
+			canUndo: undoStack.canUndo,
+			canRedo: undoStack.canRedo,
+			issues: Object.freeze(issues),
+			isSelected: (key) => selected.has(key),
+			getSort: (columnId) => sortIndex.get(columnId),
+			getColumn: (columnId) => byId.get(columnId),
+			getRow: (key) => indexed.byKey.get(key)
+		});
+	}
+	function getSnapshot() {
+		snapshot ??= computeSnapshot();
+		return snapshot;
+	}
+	function notify() {
+		snapshot = void 0;
+		if (listeners.size === 0) return;
+		const next = getSnapshot();
+		for (const listener of listeners) listener(next);
+	}
+	/** Apply a change made by a table operation. */
+	function commit(patch) {
+		const previous = state;
+		const next = mergeState(state, patch);
+		if (next === previous) return;
+		state = next;
+		options.onStateChange?.(state, previous);
+		notify();
+	}
+	const firstPage = () => ({
+		page: 1,
+		pageSize: state.pagination.pageSize
+	});
+	function setSort(columnId, direction, multi) {
+		if (!getSnapshot().getColumn(columnId)?.sortable) return;
+		const others = multi ? state.sorting.filter((rule) => rule.column !== columnId) : [];
+		const existing = state.sorting.findIndex((rule) => rule.column === columnId);
+		let sorting = others;
+		if (direction) {
+			const rule = {
+				column: columnId,
+				direction
+			};
+			sorting = multi && existing !== -1 ? state.sorting.map((current) => current.column === columnId ? rule : current) : [...others, rule];
+		}
+		commit({
+			sorting,
+			pagination: firstPage()
+		});
+	}
+	function applySelection(next) {
+		if (selectionMode === "none") return;
+		const unique = [...new Set(next)];
+		const selection = selectionMode === "single" ? unique.slice(-1) : unique;
+		const current = state.selection;
+		if (selection.length === current.length && selection.every((key, i) => key === current[i])) return;
+		commit({ selection });
+	}
+	function applyChanges(edits, record) {
+		const current = getSnapshot();
+		const working = [...data];
+		const issues = [];
+		const changes = [];
+		const samples = /* @__PURE__ */ new Map();
+		const sampleOf = (columnId) => {
+			if (!samples.has(columnId)) {
+				const other = current.processedRows.find((candidate) => {
+					const value = candidate.getValue(columnId);
+					return value !== null && value !== void 0;
+				});
+				samples.set(columnId, other?.getValue(columnId));
+			}
+			return samples.get(columnId);
+		};
+		for (const edit of edits) {
+			const row = current.getRow(edit.rowKey);
+			const column = current.getColumn(edit.column);
+			if (!row) {
+				issues.push(issue("unknown_row", `No row has the key "${String(edit.rowKey)}".`, {
+					rowKey: edit.rowKey,
+					column: edit.column
+				}));
+				continue;
+			}
+			if (!column) {
+				issues.push(issue("unknown_column", `No column has the id "${edit.column}".`, {
+					rowKey: edit.rowKey,
+					column: edit.column
+				}));
+				continue;
+			}
+			const original = working[row.index];
+			if (record && !column.isEditable(original)) {
+				issues.push(issue("read_only_cell", `The "${column.id}" cell of row "${String(row.key)}" is read-only.`, {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
+			let value;
+			if (isInputEdit(edit)) {
+				const parsed = column.parse(edit.input, original, sampleOf(column.id));
+				if (!parsed.ok) {
+					issues.push(issue("invalid_value", parsed.message, {
+						rowKey: row.key,
+						column: column.id
+					}));
+					continue;
+				}
+				value = parsed.value;
+			} else value = edit.value;
+			const previous = column.getValue(original);
+			if (Object.is(previous, value)) continue;
+			const updated = column.setValue(original, value);
+			if (updated === void 0) {
+				issues.push(issue("read_only_cell", `The "${column.id}" column has no way to write a value.`, {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
+			working[row.index] = updated;
+			changes.push({
+				rowKey: row.key,
+				column: column.id,
+				previous,
+				value,
+				row: updated
+			});
+		}
+		let status;
+		if (changes.length === 0) status = issues.length > 0 ? "rejected" : "unchanged";
+		else {
+			status = issues.length > 0 ? "partial" : "applied";
+			data = working;
+			if (record) undoStack.record(changes);
+			options.onDataChange?.(data, changes);
+			notify();
+		}
+		if (issues.length > 0) options.onEditIssues?.(issues);
+		return Object.freeze({
+			status,
+			changes: Object.freeze(changes),
+			issues: Object.freeze(issues)
+		});
+	}
+	function rangeEdits(origin, matrix) {
+		const { rows, columns } = getSnapshot();
+		const edits = [];
+		matrix.forEach((line, rowOffset) => {
+			const row = rows[origin.row + rowOffset];
+			if (!row) return;
+			line.forEach((input, columnOffset) => {
+				const column = columns[origin.column + columnOffset];
+				if (column) edits.push({
+					rowKey: row.key,
+					column: column.id,
+					input
+				});
+			});
+		});
+		return edits;
+	}
+	function replay(changes, direction) {
+		applyChanges(changes.map((change) => ({
+			rowKey: change.rowKey,
+			column: change.column,
+			value: direction === "undo" ? change.previous : change.value
+		})), false);
+	}
+	const table = {
+		getSnapshot,
+		getState: () => state,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		setState(patch) {
+			const next = mergeState(state, patch);
+			if (next !== state) {
+				state = next;
+				notify();
+			}
+		},
+		setData(next) {
+			if (next === data) return;
+			data = next;
+			undoStack.clear();
+			notify();
+		},
+		setColumns(next) {
+			if (next === definitions) return;
+			definitions = next;
+			notify();
+		},
+		setRowCount(next) {
+			if (next === rowCount) return;
+			rowCount = next;
+			notify();
+		},
+		toggleSort(columnId, { multi = false } = {}) {
+			const current = state.sorting.find((rule) => rule.column === columnId)?.direction;
+			setSort(columnId, current === void 0 ? "asc" : current === "asc" ? "desc" : void 0, multi);
+		},
+		sort(columnId, direction, { multi = false } = {}) {
+			setSort(columnId, direction, multi);
+		},
+		clearSorting() {
+			commit({ sorting: [] });
+		},
+		search(text) {
+			if (text === state.search) return;
+			commit({
+				search: text,
+				pagination: firstPage()
+			});
+		},
+		filter(columnId, value) {
+			const filters = { ...state.filters };
+			const empty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+			if (empty ? !(columnId in filters) : Object.is(filters[columnId], value)) return;
+			if (empty) delete filters[columnId];
+			else filters[columnId] = value;
+			commit({
+				filters,
+				pagination: firstPage()
+			});
+		},
+		clearFilters() {
+			if (Object.keys(state.filters).length > 0) commit({
+				filters: {},
+				pagination: firstPage()
+			});
+		},
+		goToPage(page) {
+			const { pageCount, page: currentPage } = getSnapshot();
+			const next = clampPage(page, pageCount);
+			if (next !== currentPage || next !== state.pagination.page) commit({ pagination: {
+				page: next,
+				pageSize: state.pagination.pageSize
+			} });
+		},
+		nextPage() {
+			table.goToPage(getSnapshot().page + 1);
+		},
+		previousPage() {
+			table.goToPage(getSnapshot().page - 1);
+		},
+		setPageSize(pageSize) {
+			if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize === state.pagination.pageSize) return;
+			const { pageStart } = getSnapshot();
+			commit({ pagination: {
+				page: pageStart === 0 ? 1 : Math.floor((pageStart - 1) / pageSize) + 1,
+				pageSize
+			} });
+		},
+		select(keys) {
+			applySelection([...state.selection, ...keys]);
+		},
+		deselect(keys) {
+			const removed = new Set(keys);
+			applySelection(state.selection.filter((key) => !removed.has(key)));
+		},
+		toggleRow(key, selected) {
+			const isSelected = state.selection.includes(key);
+			const next = selected ?? !isSelected;
+			if (next === isSelected) return;
+			if (next) table.select([key]);
+			else table.deselect([key]);
+		},
+		toggleAll(scope = selectScope) {
+			if (selectionMode !== "multiple") return;
+			const current = getSnapshot();
+			const keys = (scope === "page" || manual ? current.rows : current.processedRows).map((row) => row.key);
+			if (keys.length > 0 && keys.every((key) => current.isSelected(key))) table.deselect(keys);
+			else table.select(keys);
+		},
+		clearSelection() {
+			applySelection([]);
+		},
+		getSelectedRows() {
+			const current = getSnapshot();
+			return state.selection.flatMap((key) => {
+				const row = current.getRow(key);
+				return row ? [row] : [];
+			});
+		},
+		toggleColumn(columnId, visible) {
+			if (!getSnapshot().getColumn(columnId)) return;
+			const hidden = state.hiddenColumns.includes(columnId);
+			const show = visible ?? hidden;
+			if (show === !hidden) return;
+			commit({ hiddenColumns: show ? state.hiddenColumns.filter((id) => id !== columnId) : [...state.hiddenColumns, columnId] });
+		},
+		moveColumn(columnId, toIndex) {
+			const order = getSnapshot().allColumns.map((column) => column.id);
+			const from = order.indexOf(columnId);
+			if (from === -1) return;
+			const target = Math.min(Math.max(0, Math.trunc(toIndex)), order.length - 1);
+			if (target === from) return;
+			order.splice(from, 1);
+			order.splice(target, 0, columnId);
+			commit({ columnOrder: order });
+		},
+		edit(edits) {
+			return applyChanges(Array.isArray(edits) ? edits : [edits], true);
+		},
+		undo() {
+			const changes = undoStack.undo();
+			if (!changes) return false;
+			replay(changes, "undo");
+			return true;
+		},
+		redo() {
+			const changes = undoStack.redo();
+			if (!changes) return false;
+			replay(changes, "redo");
+			return true;
+		},
+		copy(range) {
+			const { rows, columns } = getSnapshot();
+			const matrix = [];
+			rows.forEach((row, rowIndex) => {
+				const line = [];
+				columns.forEach((column, columnIndex) => {
+					if (rangeContains(range, {
+						row: rowIndex,
+						column: columnIndex
+					})) line.push(row.getDisplay(column.id));
+				});
+				if (line.length > 0) matrix.push(line);
+			});
+			return toDelimited(matrix);
+		},
+		paste(origin, text) {
+			return applyChanges(rangeEdits(origin, parseDelimited(text)), true);
+		},
+		clear(range) {
+			const matrix = Array.from({ length: range.bottom - range.top + 1 }, () => Array.from({ length: range.right - range.left + 1 }, () => ""));
+			const current = getSnapshot();
+			return applyChanges(rangeEdits({
+				row: range.top,
+				column: range.left
+			}, matrix).filter((edit) => {
+				const row = current.getRow(edit.rowKey);
+				return row !== void 0 && current.getColumn(edit.column)?.isEditable(row.original) === true;
+			}), true);
+		},
+		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true } = {}) {
+			const current = getSnapshot();
+			const columns = ids ? ids.flatMap((id) => {
+				const column = current.getColumn(id);
+				return column ? [column] : [];
+			}) : current.columns;
+			const matrix = (pageOnly ? current.rows : current.processedRows).map((row) => columns.map((column) => row.getDisplay(column.id)));
+			if (headers) matrix.unshift(columns.map((column) => column.header));
+			return toDelimited(matrix, format === "csv" ? "," : "	");
+		},
+		reset() {
+			commit(initialState);
+		},
+		destroy() {
+			listeners.clear();
+		}
+	};
+	return table;
+}
+
+//#endregion
+export { DEFAULT_PAGE_SIZE, clampPage, clampPosition, columnLabel, compareValues, countPages, createTable, createUndoStack, defineColumns, filterRows, formatValue, fromA1, getPath, gridCommand, humanize, inferColumns, matchesFilter, moveSelection, paginateRows, paginationItems, parseAs, parseDelimited, rangeContains, resolveColumn, selectCell, selectionRange, setPath, sortRows, toA1, toDelimited, typeOf };
+//# sourceMappingURL=index.js.map