@rivinia/table 0.0.0-stage → 1.0.0

package/fesm2022/rivinia-table.mjs

@@ -0,0 +1,813 @@
+import { computed, isDevMode, linkedSignal, signal } from "@angular/core";
+function readCellValue(column, row) {
+	const accessor = column.accessor;
+	if (accessor === void 0) return void 0;
+	if (typeof accessor === "string") return row.data[accessor];
+	return accessor(row.data);
+}
+const COLLATORS = /* @__PURE__ */ new Map();
+function collatorFor(locale) {
+	const key = locale === "" ? "en" : locale;
+	const cached = COLLATORS.get(key);
+	if (cached !== void 0) return cached;
+	let collator;
+	try {
+		collator = new Intl.Collator(key, {
+			numeric: true,
+			sensitivity: "base"
+		});
+	} catch {
+		collator = new Intl.Collator(void 0, {
+			numeric: true,
+			sensitivity: "base"
+		});
+	}
+	COLLATORS.set(key, collator);
+	return collator;
+}
+function normalizeSearchText(value) {
+	return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[\u064B-\u065F\u0670]/g, "").replace(/\u0640/g, "").replace(/[أإآٱ]/g, "ا").replace(/ى/g, "ي").replace(/ؤ/g, "و").replace(/ئ/g, "ي").replace(/ة/g, "ه").toLowerCase();
+}
+function isNullish$1(value) {
+	return value === null || value === void 0;
+}
+function isActiveFilter(value) {
+	if (value === null || value === void 0 || value === "") return false;
+	return !Array.isArray(value) || value.length > 0;
+}
+function toNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "string" && value.trim() !== "") {
+		const numeric = Number(value);
+		return Number.isFinite(numeric) ? numeric : null;
+	}
+	return null;
+}
+function toTime(value) {
+	if (value instanceof Date) {
+		const time = value.getTime();
+		return Number.isNaN(time) ? null : time;
+	}
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") return null;
+		const numeric = Number(trimmed);
+		if (Number.isFinite(numeric)) return numeric;
+		const parsed = Date.parse(trimmed);
+		return Number.isNaN(parsed) ? null : parsed;
+	}
+	return null;
+}
+function isRange(value) {
+	return typeof value === "object" && value !== null && ("min" in value || "max" in value);
+}
+function matchesRange(cell, range) {
+	const min = range.min === null || range.min === void 0 ? null : toTime(range.min);
+	const max = range.max === null || range.max === void 0 ? null : toTime(range.max);
+	if (min === null && max === null) return true;
+	const time = toTime(cell);
+	if (time === null) return false;
+	return (min === null || time >= min) && (max === null || time <= max);
+}
+function matchesFilter(cell, filter) {
+	if (Array.isArray(filter)) return filter.some((item) => Object.is(item, cell));
+	if (typeof filter === "boolean") return Boolean(cell) === filter;
+	if (filter instanceof Date) {
+		const time = toTime(cell);
+		return time !== null && time === filter.getTime();
+	}
+	if (typeof filter === "number") {
+		const numeric = toNumber(cell);
+		return numeric !== null && numeric === filter;
+	}
+	if (typeof filter === "bigint") {
+		const numeric = toNumber(cell);
+		return numeric !== null && numeric === Number(filter);
+	}
+	if (isRange(filter)) return matchesRange(cell, filter);
+	if (typeof filter === "string") return normalizeSearchText(String(cell ?? "")).includes(normalizeSearchText(filter));
+	return Object.is(cell, filter);
+}
+function applyFilters(rows, columns, filters) {
+	if (filters.length === 0) return rows;
+	const byId = new Map(columns.map((column) => [column.id, column]));
+	const plan = [];
+	for (const filter of filters) {
+		if (!isActiveFilter(filter.value)) continue;
+		const column = byId.get(filter.column);
+		if (column === void 0 || column.accessor === void 0) continue;
+		plan.push({
+			column,
+			value: filter.value
+		});
+	}
+	if (plan.length === 0) return rows;
+	return rows.filter((row) => {
+		for (const entry of plan) if (!matchesFilter(readCellValue(entry.column, row), entry.value)) return false;
+		return true;
+	});
+}
+function applySearch(rows, columns, search) {
+	const needle = normalizeSearchText(search.trim());
+	if (needle === "") return rows;
+	const searchable = columns.filter((column) => column.accessor !== void 0);
+	if (searchable.length === 0) return [];
+	return rows.filter((row) => {
+		for (const column of searchable) {
+			const value = readCellValue(column, row);
+			if (value === null || value === void 0) continue;
+			if (normalizeSearchText(String(value)).includes(needle)) return true;
+		}
+		return false;
+	});
+}
+function comparePresent(left, right, comparator, collator) {
+	if (comparator !== void 0) return comparator(left, right);
+	if (left instanceof Date && right instanceof Date) {
+		const a = left.getTime();
+		const b = right.getTime();
+		if (!Number.isNaN(a) && !Number.isNaN(b)) return a < b ? -1 : a > b ? 1 : 0;
+	}
+	if (typeof left === "number" && typeof right === "number") return left < right ? -1 : left > right ? 1 : 0;
+	if (typeof left === "bigint" && typeof right === "bigint") return left < right ? -1 : left > right ? 1 : 0;
+	if (typeof left === "boolean" && typeof right === "boolean") return left === right ? 0 : left ? 1 : -1;
+	return collator.compare(String(left), String(right));
+}
+function applySort(rows, columns, sorting, locale = "en") {
+	if (sorting.length === 0) return rows;
+	const byId = new Map(columns.map((column) => [column.id, column]));
+	const plan = [];
+	for (const state of sorting) {
+		const column = byId.get(state.column);
+		if (column === void 0 || column.accessor === void 0) continue;
+		plan.push({
+			state,
+			column
+		});
+	}
+	if (plan.length === 0) return rows;
+	const collator = collatorFor(locale);
+	const keyed = rows.map((row) => ({
+		row,
+		keys: plan.map((entry) => readCellValue(entry.column, row))
+	}));
+	keyed.sort((a, b) => {
+		for (let index = 0; index < plan.length; index++) {
+			const left = a.keys[index];
+			const right = b.keys[index];
+			const leftMissing = isNullish$1(left);
+			const rightMissing = isNullish$1(right);
+			if (leftMissing || rightMissing) {
+				if (leftMissing && rightMissing) continue;
+				return leftMissing ? 1 : -1;
+			}
+			const entry = plan[index];
+			const result = comparePresent(left, right, entry.column.comparator, collator);
+			if (result !== 0) return entry.state.direction === "desc" ? -result : result;
+		}
+		return a.row.index - b.row.index;
+	});
+	return keyed.map((entry) => entry.row);
+}
+function paginate(rows, page, pageSize) {
+	const total = rows.length;
+	const size = Number.isFinite(pageSize) ? Math.floor(pageSize) : 0;
+	const currentPage = Number.isFinite(page) ? Math.max(0, Math.floor(page)) : 0;
+	if (size <= 0) return {
+		pageRows: rows,
+		total,
+		pageCount: total > 0 ? 1 : 0,
+		start: total > 0 ? 1 : 0,
+		end: total
+	};
+	const pageCount = Math.ceil(total / size);
+	const offset = currentPage * size;
+	const pageRows = offset >= total ? [] : rows.slice(offset, offset + size);
+	return {
+		pageRows,
+		total,
+		pageCount,
+		start: pageRows.length === 0 ? 0 : offset + 1,
+		end: pageRows.length === 0 ? 0 : offset + pageRows.length
+	};
+}
+const NO_CELLS = Object.freeze([]);
+function defaultWarn(message) {
+	if (isDevMode()) console.warn(`[rivinia/table] ${message}`);
+}
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+function clamp(value, min, max) {
+	if (!Number.isFinite(value)) return min;
+	return value < min ? min : value > max ? max : value;
+}
+function checkColumns(columns, warn, strict) {
+	for (const column of columns) {
+		const conflicting = column.merge !== void 0 ? "merge" : column.colSpan !== void 0 ? "colSpan" : null;
+		if (column.span !== void 0 && conflicting !== null) {
+			const message = `column "${column.id}" declares both span and ${conflicting}; use span alone for full control, or merge/colSpan for the simple path`;
+			if (strict) throw new Error(`[rivinia/table] ${message}`);
+			warn(`${message}; span wins`);
+		}
+		if (column.merge !== void 0 && column.accessor === void 0) warn(`column "${column.id}" declares merge but has no accessor; merge is ignored`);
+	}
+}
+function assertSpanColumns(columns, options) {
+	checkColumns(columns, options?.warn ?? defaultWarn, true);
+}
+function buildSpanModel(rows, columns, options) {
+	const warn = options?.warn ?? defaultWarn;
+	checkColumns(columns, warn, options?.strict ?? true);
+	const rowCount = rows.length;
+	const columnCount = columns.length;
+	if (!columns.some((column) => column.span !== void 0 || column.colSpan !== void 0 || column.merge !== void 0 && column.accessor !== void 0) || rowCount === 0 || columnCount === 0) return plainSpanModel(rowCount, columnCount);
+	const claimed = new Uint8Array(rowCount * columnCount);
+	const owners = new Int32Array(rowCount * columnCount).fill(-1);
+	const cells = [];
+	const resolve = (definition, row, column) => {
+		const current = rows[row];
+		const value = readCellValue(definition, current);
+		const spanResolver = definition.span;
+		if (spanResolver !== void 0) {
+			const explicit = spanResolver(contextOf(current, definition, value, row, column));
+			if (explicit !== null && explicit !== void 0) return {
+				rowSpan: explicit.rowSpan ?? 1,
+				colSpan: explicit.colSpan ?? 1
+			};
+		}
+		let rowSpan = 1;
+		let colSpan = 1;
+		const merge = definition.merge;
+		if (merge !== void 0 && definition.accessor !== void 0) {
+			if (merge === "equal") {
+				if (!isNullish(value)) {
+					let end = row;
+					while (end + 1 < rowCount) {
+						const candidate = readCellValue(definition, rows[end + 1]);
+						if (isNullish(candidate) || !Object.is(candidate, value)) break;
+						end++;
+					}
+					rowSpan = end - row + 1;
+				}
+			} else {
+				const anchor = current.data;
+				let end = row;
+				while (end + 1 < rowCount && merge(rows[end + 1].data, anchor)) end++;
+				rowSpan = end - row + 1;
+			}
+		}
+		const colSpanDefinition = definition.colSpan;
+		if (colSpanDefinition !== void 0) colSpan = typeof colSpanDefinition === "function" ? colSpanDefinition(contextOf(current, definition, value, row, column)) : colSpanDefinition;
+		return {
+			rowSpan,
+			colSpan
+		};
+	};
+	for (let row = 0; row < rowCount; row++) for (let column = 0; column < columnCount; column++) {
+		if (claimed[row * columnCount + column] !== 0) continue;
+		const definition = columns[column];
+		const requested = resolve(definition, row, column);
+		let rowSpan = requested.rowSpan ?? 1;
+		let colSpan = requested.colSpan ?? 1;
+		if (colSpan === Number.POSITIVE_INFINITY) colSpan = columnCount - column;
+		if (!Number.isInteger(rowSpan) || rowSpan < 1) {
+			warn(`column "${definition.id}" returned rowSpan ${rowSpan}; clamped to 1`);
+			rowSpan = 1;
+		}
+		if (!Number.isInteger(colSpan) || colSpan < 1) {
+			warn(`column "${definition.id}" returned colSpan ${colSpan}; clamped to 1`);
+			colSpan = 1;
+		}
+		rowSpan = Math.min(rowSpan, rowCount - row);
+		colSpan = Math.min(colSpan, columnCount - column);
+		const pinning = definition.pinned ?? null;
+		for (let step = 1; step < colSpan; step++) if ((columns[column + step].pinned ?? null) !== pinning) {
+			colSpan = step;
+			break;
+		}
+		const wantedRowSpan = rowSpan;
+		const wantedColSpan = colSpan;
+		while (colSpan > 1 && !isFree(claimed, columnCount, row, column, rowSpan, colSpan)) colSpan--;
+		while (rowSpan > 1 && !isFree(claimed, columnCount, row, column, rowSpan, colSpan)) rowSpan--;
+		if (rowSpan !== wantedRowSpan || colSpan !== wantedColSpan) warn(`column "${definition.id}" at row ${row} overlaps an existing span; shrunk from ${wantedRowSpan}x${wantedColSpan} to ${rowSpan}x${colSpan}`);
+		const anchor = cells.length;
+		cells.push({
+			row,
+			column,
+			rowSpan,
+			colSpan
+		});
+		for (let r = row; r < row + rowSpan; r++) for (let c = column; c < column + colSpan; c++) {
+			claimed[r * columnCount + c] = 1;
+			owners[r * columnCount + c] = anchor;
+		}
+	}
+	if (cells.length === rowCount * columnCount) return plainSpanModel(rowCount, columnCount);
+	const ownerAt = (row, column) => {
+		if (row < 0 || row >= rowCount || column < 0 || column >= columnCount) return null;
+		const index = owners[row * columnCount + column];
+		return index < 0 ? null : cells[index];
+	};
+	return {
+		cells,
+		at(row, column) {
+			const cell = ownerAt(row, column);
+			return cell !== null && cell.row === row && cell.column === column ? cell : null;
+		},
+		owner: ownerAt,
+		move(row, column, dRow, dColumn) {
+			if (dRow === 0 && dColumn === 0) return {
+				row: clamp(row, 0, rowCount - 1),
+				column: clamp(column, 0, columnCount - 1)
+			};
+			let currentRow = clamp(row, 0, rowCount - 1);
+			let currentColumn = clamp(column, 0, columnCount - 1);
+			for (;;) {
+				const nextRow = currentRow + dRow;
+				const nextColumn = currentColumn + dColumn;
+				if (nextRow < 0 || nextRow >= rowCount || nextColumn < 0 || nextColumn >= columnCount) return {
+					row: currentRow,
+					column: currentColumn
+				};
+				const span = ownerAt(nextRow, nextColumn);
+				if (span === null) return {
+					row: nextRow,
+					column: nextColumn
+				};
+				if (!(currentRow >= span.row && currentRow < span.row + span.rowSpan && currentColumn >= span.column && currentColumn < span.column + span.colSpan)) return {
+					row: span.row,
+					column: span.column
+				};
+				const jumpRow = dRow === 0 ? nextRow : dRow > 0 ? span.row + span.rowSpan : span.row - 1;
+				const jumpColumn = dColumn === 0 ? nextColumn : dColumn > 0 ? span.column + span.colSpan : span.column - 1;
+				if (jumpRow < 0 || jumpRow >= rowCount || jumpColumn < 0 || jumpColumn >= columnCount) return {
+					row: currentRow,
+					column: currentColumn
+				};
+				const jumped = ownerAt(jumpRow, jumpColumn);
+				if (jumped === null || jumped.row === jumpRow && jumped.column === jumpColumn) return {
+					row: jumpRow,
+					column: jumpColumn
+				};
+				currentRow = jumpRow;
+				currentColumn = jumpColumn;
+			}
+		}
+	};
+}
+function contextOf(row, column, value, rowIndex, columnIndex) {
+	return {
+		row,
+		column,
+		value,
+		rowIndex,
+		columnIndex
+	};
+}
+function isFree(claimed, columnCount, row, column, rowSpan, colSpan) {
+	for (let r = row; r < row + rowSpan; r++) for (let c = column; c < column + colSpan; c++) {
+		if (r === row && c === column) continue;
+		if (claimed[r * columnCount + c] !== 0) return false;
+	}
+	return true;
+}
+function plainSpanModel(rowCount, columnCount) {
+	return {
+		cells: NO_CELLS,
+		at: () => null,
+		owner: () => null,
+		move(row, column, dRow, dColumn) {
+			if (rowCount === 0 || columnCount === 0) return {
+				row: 0,
+				column: 0
+			};
+			return {
+				row: clamp(row + dRow, 0, rowCount - 1),
+				column: clamp(column + dColumn, 0, columnCount - 1)
+			};
+		}
+	};
+}
+function tableColumn() {
+	return Object.freeze({
+		accessor(key, definition) {
+			return Object.freeze({
+				header: key,
+				...definition,
+				id: key,
+				accessor: (row) => row[key]
+			});
+		},
+		display(id, definition) {
+			return Object.freeze({
+				header: id,
+				...definition,
+				id
+			});
+		}
+	});
+}
+const DEFAULT_PAGE_SIZE = 25;
+const NO_IDS = /* @__PURE__ */ new Set();
+const EMPTY_SELECTION = {
+	mode: "include",
+	ids: NO_IDS
+};
+function pruneSelection(state, rows) {
+	if (state.ids.size === 0) return state;
+	const present = /* @__PURE__ */ new Set();
+	for (const row of rows) if (row.identityValid !== false) present.add(row.id);
+	let dropped = false;
+	const next = /* @__PURE__ */ new Set();
+	for (const id of state.ids) if (present.has(id)) next.add(id);
+	else dropped = true;
+	return dropped ? {
+		mode: state.mode,
+		ids: next
+	} : state;
+}
+function withId(ids, id) {
+	if (ids.has(id)) return ids;
+	const next = new Set(ids);
+	next.add(id);
+	return next;
+}
+function withoutId(ids, id) {
+	if (!ids.has(id)) return ids;
+	const next = new Set(ids);
+	next.delete(id);
+	return next;
+}
+var RiviniaSelection = class {
+	enabled;
+	multiple;
+	mode;
+	ids;
+	count;
+	rows;
+	pageRows;
+	defaultScope;
+	initial;
+	state;
+	constructor(config) {
+		this.rows = config.rows;
+		this.pageRows = config.pageRows;
+		this.defaultScope = config.defaultScope;
+		this.initial = {
+			mode: config.initial.mode,
+			ids: new Set(config.initial.ids)
+		};
+		this.enabled = config.kind !== "none";
+		this.multiple = config.kind === "multi";
+		this.state = linkedSignal({
+			...ngDevMode ? { debugName: "state" } : /* istanbul ignore next */ {},
+			source: config.rows,
+			computation: (rows, previous) => pruneSelection(previous?.value ?? this.initial, rows)
+		});
+		this.mode = computed(() => this.state().mode, ...ngDevMode ? [{ debugName: "mode" }] : /* istanbul ignore next */ []);
+		this.ids = computed(() => this.selectedIds(), ...ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []);
+		this.count = computed(() => this.ids().length, ...ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []);
+	}
+	select(id) {
+		if (!this.enabled || !this.isUnambiguous(id)) return;
+		const state = this.state();
+		if (!this.multiple) {
+			if (state.mode === "include" && state.ids.size === 1 && state.ids.has(id)) return;
+			this.state.set({
+				mode: "include",
+				ids: /* @__PURE__ */ new Set([id])
+			});
+			return;
+		}
+		if (state.mode === "include") {
+			const ids = withId(state.ids, id);
+			if (ids !== state.ids) this.state.set({
+				mode: "include",
+				ids
+			});
+			return;
+		}
+		const ids = withoutId(state.ids, id);
+		if (ids !== state.ids) this.state.set({
+			mode: "exclude",
+			ids
+		});
+	}
+	deselect(id) {
+		if (!this.enabled || !this.isUnambiguous(id)) return;
+		const state = this.state();
+		if (state.mode === "include") {
+			const ids = withoutId(state.ids, id);
+			if (ids !== state.ids) this.state.set({
+				mode: "include",
+				ids
+			});
+			return;
+		}
+		const ids = withId(state.ids, id);
+		if (ids !== state.ids) this.state.set({
+			mode: "exclude",
+			ids
+		});
+	}
+	toggle(id) {
+		if (this.isSelected(id)) this.deselect(id);
+		else this.select(id);
+	}
+	clear() {
+		if (!this.enabled) return;
+		this.state.set(EMPTY_SELECTION);
+	}
+	isSelected(id) {
+		if (!this.enabled || !this.isUnambiguous(id)) return false;
+		const state = this.state();
+		return state.mode === "include" ? state.ids.has(id) : !state.ids.has(id);
+	}
+	selectAllOnPage() {
+		if (!this.enabled || !this.multiple) return;
+		const page = this.pageRows();
+		if (page.length === 0) return;
+		const state = this.state();
+		if (state.mode === "include") {
+			let ids = state.ids;
+			for (const row of page) if (row.identityValid !== false) ids = withId(ids, row.id);
+			if (ids !== state.ids) this.state.set({
+				mode: "include",
+				ids
+			});
+			return;
+		}
+		let ids = state.ids;
+		for (const row of page) if (row.identityValid !== false) ids = withoutId(ids, row.id);
+		if (ids !== state.ids) this.state.set({
+			mode: "exclude",
+			ids
+		});
+	}
+	selectAll(scope) {
+		if (!this.enabled || !this.multiple) return;
+		if ((scope ?? this.defaultScope) === "page") {
+			this.selectAllOnPage();
+			return;
+		}
+		if (this.rows().length === 0) return;
+		this.state.set({
+			mode: "exclude",
+			ids: NO_IDS
+		});
+	}
+	toState() {
+		const state = this.state();
+		if (state.mode === "exclude") return {
+			selected: [],
+			excluded: [...state.ids]
+		};
+		return {
+			selected: [...state.ids],
+			excluded: []
+		};
+	}
+	restore(selection) {
+		if (!this.enabled) return;
+		this.state.set(pruneSelection({
+			mode: selection.mode,
+			ids: new Set(selection.ids)
+		}, this.rows()));
+	}
+	selectedIds() {
+		const state = this.state();
+		const ids = [];
+		for (const row of this.rows()) {
+			if (row.identityValid === false) continue;
+			const listed = state.ids.has(row.id);
+			if (state.mode === "include" ? listed : !listed) ids.push(row.id);
+		}
+		return ids;
+	}
+	isUnambiguous(id) {
+		let matches = 0;
+		for (const row of this.rows()) {
+			if (row.identityValid !== false && row.id === id) matches++;
+			if (matches > 1) return false;
+		}
+		return matches === 1;
+	}
+};
+function isValidRowId(id) {
+	return typeof id === "string" && id.trim().length > 0 || typeof id === "number" && Number.isFinite(id);
+}
+function buildRows(data, getId) {
+	const ids = /* @__PURE__ */ new Map();
+	const invalid = /* @__PURE__ */ new Set();
+	const rows = new Array(data.length);
+	for (let index = 0; index < data.length; index++) {
+		const item = data[index];
+		const id = getId(item);
+		if (!isValidRowId(id)) {
+			invalid.add(index);
+			if (isDevMode()) throw new Error(`[rivinia/table] Invalid row ID ${String(id)} at row index ${index}; IDs must be non-empty strings or finite numbers.`);
+		} else {
+			const positions = ids.get(id) ?? [];
+			positions.push(index);
+			ids.set(id, positions);
+		}
+		rows[index] = {
+			id,
+			data: item,
+			index
+		};
+	}
+	for (const [id, positions] of ids) {
+		if (positions.length < 2) continue;
+		for (const index of positions) invalid.add(index);
+		if (isDevMode()) throw new Error(`[rivinia/table] Duplicate row ID ${JSON.stringify(id)} at row indices ${positions.join(", ")}; IDs must be unique and stable within the active data set.`);
+	}
+	return rows.map((row, index) => invalid.has(index) ? {
+		...row,
+		identityValid: false
+	} : row);
+}
+function reindex(rows) {
+	for (let index = 0; index < rows.length; index++) if (rows[index].index !== index) return rows.map((row, position) => ({
+		...row,
+		index: position
+	}));
+	return rows;
+}
+function normalizePage(value) {
+	return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function normalizePageSize(value) {
+	return Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_PAGE_SIZE;
+}
+var RiviniaTable = class {
+	columns;
+	visibleColumns;
+	rows;
+	pageRows;
+	spans;
+	total;
+	pageCount;
+	sorting;
+	filters;
+	globalSearch;
+	page;
+	pageSize;
+	selection;
+	request;
+	state;
+	options;
+	initialState;
+	defaultPageSize;
+	warn;
+	warned = /* @__PURE__ */ new Set();
+	generatedIds = /* @__PURE__ */ new WeakMap();
+	selectionImpl;
+	generatedIdSeq = 0;
+	constructor(options) {
+		this.options = options;
+		this.initialState = options().initialState ?? {};
+		const warnOption = options().warn;
+		this.warn = (message) => {
+			if (this.warned.has(message)) return;
+			this.warned.add(message);
+			if (warnOption !== void 0) warnOption(message);
+			else if (isDevMode()) console.warn(`[rivinia/table] ${message}`);
+		};
+		if (options().server !== void 0) this.warn("server mode is not implemented yet; nothing will be fetched. Pass `data` and let the app own the request for now");
+		assertSpanColumns(options().columns(), { warn: this.warn });
+		const initial = this.initialState;
+		const selectionOptions = options().selection;
+		this.columns = computed(() => this.options().columns(), ...ngDevMode ? [{ debugName: "columns" }] : /* istanbul ignore next */ []);
+		this.visibleColumns = computed(() => this.columns().filter((column) => column.hidden !== true), ...ngDevMode ? [{ debugName: "visibleColumns" }] : /* istanbul ignore next */ []);
+		this.sorting = signal(initial.sort ?? [], ...ngDevMode ? [{ debugName: "sorting" }] : /* istanbul ignore next */ []);
+		this.filters = signal(initial.filters ?? [], ...ngDevMode ? [{ debugName: "filters" }] : /* istanbul ignore next */ []);
+		this.globalSearch = signal(initial.search ?? "", ...ngDevMode ? [{ debugName: "globalSearch" }] : /* istanbul ignore next */ []);
+		this.defaultPageSize = normalizePageSize(initial.pageSize ?? options().pageSize ?? DEFAULT_PAGE_SIZE);
+		this.pageSize = signal(this.defaultPageSize, ...ngDevMode ? [{ debugName: "pageSize" }] : /* istanbul ignore next */ []);
+		this.page = linkedSignal({
+			...ngDevMode ? { debugName: "page" } : /* istanbul ignore next */ {},
+			source: () => JSON.stringify([
+				this.filters(),
+				this.sorting(),
+				this.globalSearch()
+			]),
+			computation: (_signature, previous) => previous === void 0 ? normalizePage(initial.page ?? 0) : 0
+		});
+		this.rows = computed(() => {
+			const current = this.options();
+			const data = current.data?.() ?? [];
+			const getId = current.getRowId ?? this.defaultRowId;
+			const columns = this.visibleColumns();
+			const all = buildRows(data, getId);
+			const filtered = current.manualFiltering ? all : applySearch(applyFilters(all, columns, this.filters()), columns, this.globalSearch());
+			return reindex(current.manualSorting ? filtered : applySort(filtered, columns, this.sorting(), current.locale?.() ?? "en"));
+		}, ...ngDevMode ? [{ debugName: "rows" }] : /* istanbul ignore next */ []);
+		this.total = computed(() => this.options().rowCount?.() ?? this.rows().length, ...ngDevMode ? [{ debugName: "total" }] : /* istanbul ignore next */ []);
+		this.pageRows = computed(() => {
+			if (this.options().manualPagination) return this.rows();
+			return paginate(this.rows(), this.page(), this.pageSize()).pageRows;
+		}, ...ngDevMode ? [{ debugName: "pageRows" }] : /* istanbul ignore next */ []);
+		this.pageCount = computed(() => {
+			const total = this.total();
+			const size = this.pageSize();
+			return size > 0 ? Math.ceil(total / size) : total > 0 ? 1 : 0;
+		}, ...ngDevMode ? [{ debugName: "pageCount" }] : /* istanbul ignore next */ []);
+		const selection = new RiviniaSelection({
+			rows: this.rows,
+			pageRows: this.pageRows,
+			kind: selectionOptions?.mode ?? "none",
+			defaultScope: selectionOptions?.selectAllScope ?? "filtered",
+			initial: {
+				mode: (initial.excluded?.length ?? 0) > 0 ? "exclude" : "include",
+				ids: (initial.excluded?.length ?? 0) > 0 ? initial.excluded ?? [] : initial.selected ?? []
+			}
+		});
+		this.selection = selection;
+		this.selectionImpl = selection;
+		this.spans = computed(() => buildSpanModel(this.pageRows(), this.visibleColumns(), {
+			warn: this.warn,
+			strict: false
+		}), ...ngDevMode ? [{ debugName: "spans" }] : /* istanbul ignore next */ []);
+		this.request = computed(() => ({
+			page: this.page(),
+			pageSize: this.pageSize(),
+			sort: this.sorting(),
+			filters: this.filters(),
+			search: this.globalSearch()
+		}), ...ngDevMode ? [{ debugName: "request" }] : /* istanbul ignore next */ []);
+		this.state = computed(() => {
+			const columns = this.columns();
+			const selected = selection.toState();
+			return {
+				sort: this.sorting(),
+				filters: this.filters(),
+				search: this.globalSearch(),
+				page: this.page(),
+				pageSize: this.pageSize(),
+				order: columns.map((column) => column.id),
+				hidden: columns.filter((column) => column.hidden === true).map((column) => column.id),
+				pinnedStart: columns.filter((column) => column.pinned === "start").map((column) => column.id),
+				pinnedEnd: columns.filter((column) => column.pinned === "end").map((column) => column.id),
+				selected: selected.selected,
+				excluded: selected.excluded
+			};
+		}, ...ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []);
+	}
+	setState(patch) {
+		if (patch.sort !== void 0) this.sorting.set(patch.sort);
+		if (patch.filters !== void 0) this.filters.set(patch.filters);
+		if (patch.search !== void 0) this.globalSearch.set(patch.search);
+		if (patch.pageSize !== void 0) this.pageSize.set(normalizePageSize(patch.pageSize));
+		if (patch.page !== void 0) this.page.set(normalizePage(patch.page));
+		if (patch.selected !== void 0 || patch.excluded !== void 0) {
+			const excluded = patch.excluded ?? [];
+			this.selectionImpl.restore(excluded.length > 0 ? {
+				mode: "exclude",
+				ids: excluded
+			} : {
+				mode: "include",
+				ids: patch.selected ?? []
+			});
+		}
+	}
+	resetState() {
+		const initial = this.initialState;
+		this.sorting.set(initial.sort ?? []);
+		this.filters.set(initial.filters ?? []);
+		this.globalSearch.set(initial.search ?? "");
+		this.pageSize.set(this.defaultPageSize);
+		this.page.set(normalizePage(initial.page ?? 0));
+		const excluded = initial.excluded ?? [];
+		this.selectionImpl.restore(excluded.length > 0 ? {
+			mode: "exclude",
+			ids: excluded
+		} : {
+			mode: "include",
+			ids: initial.selected ?? []
+		});
+	}
+	defaultRowId = (row) => {
+		if (typeof row === "object" && row !== null) {
+			const candidate = row.id;
+			if (typeof candidate === "string" || typeof candidate === "number") return candidate;
+			let generated = this.generatedIds.get(row);
+			if (generated === void 0) {
+				generated = `rv-row-${++this.generatedIdSeq}`;
+				this.generatedIds.set(row, generated);
+			}
+			return generated;
+		}
+		return String(row);
+	};
+};
+function createTable(options) {
+	return new RiviniaTable(options);
+}
+export { RiviniaTable, applyFilters, applySearch, applySort, assertSpanColumns, buildSpanModel, createTable, paginate, readCellValue, tableColumn };
+
+//# sourceMappingURL=rivinia-table.mjs.map