@oscarpalmer/tabela 0.13.0 → 0.15.0

package/dist/managers/data.manager.mjs

@@ -1,4 +1,7 @@
+import { EVENT_DATA_ADD, EVENT_DATA_CLEAR, EVENT_DATA_REMOVE, EVENT_DATA_SYNCHRONIZE, EVENT_DATA_UPDATE, EVENT_GROUP_ADD, EVENT_GROUP_REMOVE, EVENT_GROUP_UPDATE } from "../models/event.model.mjs";
 import { GroupComponent, updateGroup } from "../components/group.component.mjs";
+import { getGroup, isGroupKey } from "../helpers/misc.helpers.mjs";
+import { SORT_ASCENDING } from "../models/sort.model.mjs";
 import { sortWithGroups } from "./sort.manager.mjs";
 import { chunk, select, sort } from "@oscarpalmer/atoms/array";
 import { toMap } from "@oscarpalmer/atoms/array/to-map";
@@ -8,25 +11,25 @@ import { delay } from "@oscarpalmer/atoms/promise/delay";
 import { getValue } from "@oscarpalmer/atoms/value/handle";
 //#region src/managers/data.manager.ts
 var DataManager = class {
-	handlers = Object.freeze({
-		add: (data) => void this.add(data, true),
-		clear: () => void this.clear(),
+	handlers = {
+		add: (data) => this.add(data, true),
+		clear: () => this.clear(),
 		get: (active) => this.get(active),
-		remove: (items) => void this.remove(items, true),
-		synchronize: (data, remove) => void this.synchronize(data, remove),
-		update: (data) => void this.update(data)
-	});
+		remove: (items) => this.remove(items, true),
+		synchronize: (data, remove) => this.synchronize(data, remove === true),
+		update: (data) => this.update(data, true)
+	};
 	state;
-	get items() {
-		return this.state.items.active ?? this.state.items.original;
+	get keys() {
+		return this.state.keys.active ?? this.state.keys.original;
 	}
 	get size() {
-		return this.items.length;
+		return this.keys.length;
 	}
 	constructor(state) {
 		this.state = {
 			...state,
-			items: { original: [] },
+			keys: { original: [] },
 			values: {
 				array: [],
 				mapped: /* @__PURE__ */ new Map()
@@ -35,125 +38,151 @@ var DataManager = class {
 	}
 	async add(data, render) {
 		const { state } = this;
-		const groups = [];
-		const updates = [];
+		const addedData = [];
+		const updatedData = [];
+		const addedGroups = [];
+		const updatedGroups = [];
 		let groupColumn;
 		let { length } = data;
 		for (let index = 0; index < length; index += 1) {
 			const item = data[index];
 			const key = getValue(item, state.key);
 			if (state.values.mapped.has(key)) {
-				updates.push(item);
+				updatedData.push(item);
 				continue;
 			}
+			addedData.push(item);
 			state.values.array.push(item);
 			state.values.mapped.set(key, item);
 			if (!state.managers.group.enabled) continue;
-			const groupValue = getValue(item, state.managers.group.field);
-			let group = state.managers.group.get(groupValue);
+			const groupValue = getValue(item, state.managers.group.key);
+			let group = state.managers.group.getForValue(groupValue);
 			if (group == null) {
-				groupColumn ??= state.managers.column.get(state.managers.group.field);
-				group = new GroupComponent(`${groupColumn?.options.title ?? state.managers.group.field}: ${groupValue}`, groupValue);
-				state.values.array.push(group);
-				state.managers.group.add(group);
-			}
+				groupColumn ??= state.managers.column.get(state.managers.group.key);
+				group = new GroupComponent(`${groupColumn?.options.label ?? state.managers.group.key}: ${groupValue}`, groupValue);
+				state.values.array.push(group.key);
+				state.managers.group.add(group, false);
+				addedGroups.push(group);
+			} else if (!addedGroups.includes(group) && !updatedGroups.includes(group)) updatedGroups.push(group);
 			if (!group.expanded) state.managers.group.collapsed.add(key);
 			group.total += 1;
-			groups.push(group);
 		}
-		length = groups.length;
-		for (let index = 0; index < length; index += 1) updateGroup(state, groups[index]);
-		if (updates.length > 0) this.update(updates);
-		else if (render) this.render();
+		length = addedGroups.length;
+		if (length > 0) {
+			state.managers.event.emit(EVENT_GROUP_ADD, addedGroups.map(getGroup));
+			for (let index = 0; index < length; index += 1) updateGroup(state, addedGroups[index], false);
+		}
+		length = updatedGroups.length;
+		if (length > 0) {
+			for (let index = 0; index < length; index += 1) updateGroup(state, updatedGroups[index], false);
+			state.managers.event.emit(EVENT_GROUP_UPDATE, updatedGroups.map(getGroup));
+		}
+		await this.update(updatedData, addedData.length === 0);
+		if (addedData.length === 0) return;
+		state.managers.event.emit(EVENT_DATA_ADD, addedData);
+		if (render) this.render();
 	}
-	clear() {
-		if (this.state.values.array.length > 0) this.removeItems([], true, true);
+	async clear() {
+		if (this.state.values.array.length > 0) return this.removeItems([], true, true).then(() => void 0);
 	}
 	destroy() {
 		const { state } = this;
 		state.values.mapped.clear();
-		state.items.active = void 0;
-		state.items.original.length = 0;
+		state.keys.active = void 0;
+		state.keys.original.length = 0;
 		state.values.array.length = 0;
 		this.handlers = void 0;
 		this.state = void 0;
 	}
 	get(active) {
 		const { state } = this;
-		return active ?? false ? select(state.items.active ?? [], (key) => !(key instanceof GroupComponent), (key) => state.values.mapped.get(key)) : state.values.array.filter((item) => !(item instanceof GroupComponent));
+		return (active ?? false) && state.keys.active != null ? select(state.keys.active, (key) => !isGroupKey(key), (key) => state.values.mapped.get(key)) : state.values.array.filter((item) => !isGroupKey(item));
 	}
 	getIndex(item) {
-		if (item instanceof GroupComponent) return this.items.indexOf(item);
-		return this.items.findIndex((value) => value instanceof GroupComponent ? value.key === item : value === item);
+		return this.keys.indexOf(item);
 	}
 	async remove(items, render) {
 		const { state } = this;
-		const keys = items.map((value) => isPlainObject(value) ? getValue(value, state.key) : value);
+		const keys = items.map((value) => isPlainObject(value) ? getValue(value, state.key) : value).filter((key) => !isGroupKey(key));
 		const { length } = keys;
-		if (length > 0) return this.removeItems(keys, false, render === true);
+		return length === 0 ? render ? void 0 : [] : this.removeItems(keys, false, render);
 	}
-	async removeItems(items, clear, render) {
+	async removeItems(keys, clear, render) {
 		const { state } = this;
 		if (clear) {
-			state.items.active = void 0;
-			state.items.original = [];
+			state.keys.active = void 0;
+			state.keys.original = [];
 			state.values.array = [];
 			state.values.mapped.clear();
 			state.managers.row.clear();
 			if (state.managers.group.enabled) state.managers.group.clear();
-			return this.render();
+			state.managers.event.emit(EVENT_DATA_CLEAR);
+			this.render();
+			return render ? void 0 : [];
 		}
-		const groups = [];
-		const chunked = chunk(items);
+		const removedGroups = [];
+		const updatedGroups = [];
+		const removedData = [];
+		const chunked = chunk(keys);
 		const chunkedLength = chunked.length;
 		for (let chunkedIndex = 0; chunkedIndex < chunkedLength; chunkedIndex += 1) {
 			const chunk = chunked[chunkedIndex];
 			const chunkLength = chunk.length;
-			for (let itemIndex = 0; itemIndex < chunkLength; itemIndex += 1) {
-				const item = chunk[itemIndex];
-				const dataIndex = state.items.original.indexOf(item);
+			for (let keyIndex = 0; keyIndex < chunkLength; keyIndex += 1) {
+				const key = chunk[keyIndex];
+				const dataIndex = state.keys.original.indexOf(key);
 				let dataValue;
 				[dataValue] = state.values.array.splice(dataIndex, 1);
-				state.items.original.splice(dataIndex, 1);
-				state.managers.row.remove(item);
-				state.values.mapped.delete(item);
-				if (!state.managers.group.enabled || item instanceof GroupComponent) continue;
-				state.managers.group.collapsed.delete(item);
-				const groupKey = getValue(dataValue, state.managers.group.field);
-				const group = state.managers.group.get(groupKey);
+				removedData.push(dataValue);
+				state.keys.original.splice(dataIndex, 1);
+				state.managers.row.remove(key);
+				state.values.mapped.delete(key);
+				if (!state.managers.group.enabled || isGroupKey(key)) continue;
+				state.managers.group.collapsed.delete(key);
+				const groupValue = getValue(dataValue, state.managers.group.key);
+				const group = state.managers.group.getForValue(groupValue);
 				if (group == null) continue;
 				group.total -= 1;
 				if (group.total > 0) {
-					groups.push(group);
+					updatedGroups.push(group);
 					continue;
 				}
-				let groupIndex = groups.indexOf(group);
-				if (groupIndex > -1) groups.splice(groupIndex, 1);
-				groupIndex = state.values.array.indexOf(group);
+				let groupIndex = updatedGroups.indexOf(group);
+				if (groupIndex > -1) updatedGroups.splice(groupIndex, 1);
+				groupIndex = state.values.array.indexOf(group.key);
 				if (groupIndex > -1) {
-					state.items.original.splice(groupIndex, 1);
+					state.keys.original.splice(groupIndex, 1);
 					state.values.array.splice(groupIndex, 1);
 				}
-				state.managers.group.remove(group);
-				if (items.length >= 1e4) await delay(25);
+				removedGroups.push(group);
+				state.managers.group.remove(group, false);
+				if (keys.length >= 1e4) await delay(25);
 			}
 		}
-		const { length } = groups;
-		for (let index = 0; index < length; index += 1) updateGroup(state, groups[index]);
-		if (render) return this.render();
+		let { length } = updatedGroups;
+		if (length > 0) {
+			for (let index = 0; index < length; index += 1) updateGroup(state, updatedGroups[index], false);
+			state.managers.event.emit(EVENT_GROUP_UPDATE, updatedGroups.map(getGroup));
+		}
+		length = removedGroups.length;
+		if (length > 0) state.managers.event.emit(EVENT_GROUP_REMOVE, removedGroups.map(getGroup));
+		state.managers.event.emit(EVENT_DATA_REMOVE, removedData);
+		if (render) this.render();
+		return render ? void 0 : removedData;
 	}
 	render() {
 		const { state } = this;
 		if (state.managers.group.enabled) sortWithGroups(state, state.values.array, [{
-			direction: "ascending",
+			direction: SORT_ASCENDING,
 			key: state.key
 		}]);
 		else sort(state.values.array, [{
-			direction: "ascending",
+			direction: SORT_ASCENDING,
 			key: state.key
 		}]);
-		state.items.original = state.values.array.map((item) => item instanceof GroupComponent ? item : getValue(item, state.key));
-		state.values.mapped = toMap(state.values.array.filter((item) => !(item instanceof GroupComponent)), (item) => getValue(item, state.key));
+		state.keys.active = void 0;
+		state.keys.original = state.values.array.map((item) => typeof item === "string" ? item : getValue(item, state.key));
+		state.values.mapped = toMap(state.values.array.filter((item) => !isGroupKey(item)), (item) => getValue(item, state.key));
 		if (Object.keys(state.managers.filter.items).length > 0) state.managers.filter.filter();
 		else if (state.managers.sort.items.length > 0) state.managers.sort.sort();
 		else state.managers.render.update(true, true);
@@ -162,17 +191,17 @@ var DataManager = class {
 		const { state } = this;
 		const array = data.slice();
 		if (state.managers.group.enabled) {
-			const column = state.managers.column.get(state.managers.group.field);
-			const grouped = toRecord.arrays(data, state.managers.group.field);
+			const column = state.managers.column.get(state.managers.group.key);
+			const grouped = toRecord.arrays(data, state.managers.group.key);
 			const entries = Object.entries(grouped);
 			const { length } = entries;
 			const groups = [];
 			for (let index = 0; index < length; index += 1) {
 				const [value, items] = entries[index];
-				const group = new GroupComponent(`${column?.options.title ?? state.managers.group.field}: ${value}`, value);
+				const group = new GroupComponent(`${column?.options.label ?? state.managers.group.key}: ${value}`, value);
 				group.total = items.length;
 				groups.push(group);
-				array.push(group);
+				array.push(group.key);
 			}
 			state.managers.group.set(groups);
 		}
@@ -181,7 +210,7 @@ var DataManager = class {
 	}
 	async synchronize(data, remove) {
 		const { state } = this;
-		const add = [];
+		const added = [];
 		const updated = [];
 		const keys = /* @__PURE__ */ new Set([]);
 		const { length } = data;
@@ -189,33 +218,38 @@ var DataManager = class {
 			const object = data[index];
 			const key = getValue(object, state.key);
 			if (state.values.mapped.has(key)) updated.push(object);
-			else add.push(object);
+			else added.push(object);
 			keys.add(key);
 		}
 		if (keys.size === 0) return;
-		if (remove ?? false) {
-			const toRemove = state.items.original.filter((key) => !(key instanceof GroupComponent) && !keys.has(key));
-			if (toRemove.length > 0) await this.remove(toRemove, false);
+		let removed = [];
+		if (remove) {
+			const toRemove = state.keys.original.filter((key) => !isGroupKey(key) && !keys.has(key));
+			if (toRemove.length > 0) removed = await this.remove(toRemove, false);
 		}
-		await this.update(updated);
-		if (add.length > 0) await this.add(add, false);
-		if (add.length > 0 || (remove ?? false)) this.render();
+		await this.update(updated, added.length === 0);
+		await this.add(added, false);
+		state.managers.event.emit(EVENT_DATA_SYNCHRONIZE, {
+			added,
+			removed,
+			updated
+		});
+		if (added.length > 0 || remove) this.render();
 	}
-	async update(data) {
+	async update(data, render) {
 		const { state } = this;
 		const { length } = data;
+		const updated = [];
 		for (let index = 0; index < length; index += 1) {
-			const object = data[index];
-			const key = getValue(object, state.key);
-			const value = state.values.mapped.get(key);
-			if (value != null) {
-				state.values.mapped.set(key, {
-					...value,
-					...object
-				});
-				state.managers.row.update(key);
-			}
+			const item = data[index];
+			const key = getValue(item, state.key);
+			const existing = state.keys.original.indexOf(key);
+			if (existing === -1) continue;
+			Object.assign(state.values.array[existing], item);
+			updated.push(state.values.array[existing]);
+			if (render && state.managers.render.visible.keys.has(key)) state.managers.row.update(key);
 		}
+		if (updated.length > 0) state.managers.event.emit(EVENT_DATA_UPDATE, updated);
 	}
 };
 //#endregion

package/dist/managers/event.manager.d.mts

@@ -1,2 +1,18 @@
-import { C as EventManager } from "../group.component-Cq1YYbfJ.mjs";
+import { EventMap, EventName, Events, TabelaEvents } from "../models/event.model.mjs";
+import { State } from "../models/tabela.model.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/managers/event.manager.d.ts
+declare class EventManager {
+  state: State;
+  events: Events;
+  handlers: TabelaEvents;
+  constructor(state: State);
+  emit<Name extends EventName>(name: Name, ...parameters: Parameters<EventMap[Name]>): void;
+  destroy(): void;
+  onSort(event: MouseEvent, target: HTMLElement): void;
+  subscribe(name: string, callback: GenericCallback): void;
+  unsubscribe(name: string, callback: GenericCallback): void;
+}
+//#endregion
 export { EventManager };

package/dist/managers/event.manager.mjs

@@ -1,32 +1,55 @@
+import { ATTRIBUTE_DATA_EVENT, ATTRIBUTE_DATA_KEY, ATTRIBUTE_DATA_SORT_DIRECTION } from "../models/dom.model.mjs";
+import { CSS_TABLE } from "../models/style.model.mjs";
+import { EVENT_GROUP, EVENT_HEADING } from "../models/event.model.mjs";
+import { isEvent } from "../helpers/misc.helpers.mjs";
 import { on } from "@oscarpalmer/toretto/event";
 import { findAncestor } from "@oscarpalmer/toretto/find";
 //#region src/managers/event.manager.ts
 var EventManager = class {
+	events = {};
+	handlers = {
+		subscribe: (name, callback) => this.subscribe(name, callback),
+		unsubscribe: (name, callback) => this.unsubscribe(name, callback)
+	};
 	constructor(state) {
 		this.state = state;
 		mapped.set(state.element, this);
 	}
+	emit(name, ...parameters) {
+		if (this.events[name] == null) return;
+		const handlers = [...this.events[name]];
+		const { length } = handlers;
+		for (let index = 0; index < length; index += 1) handlers[index](...parameters);
+	}
 	destroy() {
 		mapped.delete(this.state.element);
 		this.state = void 0;
 	}
 	onSort(event, target) {
-		const direction = target.getAttribute("data-sort-direction");
-		const field = target.getAttribute("data-field");
-		if (field != null) this.state.managers.sort.toggle(event, field, direction);
+		const direction = target.getAttribute(ATTRIBUTE_DATA_SORT_DIRECTION);
+		const key = target.getAttribute(ATTRIBUTE_DATA_KEY);
+		if (key != null) this.state.managers.sort.toggle(event, key, direction);
+	}
+	subscribe(name, callback) {
+		if (!isEvent(name) || typeof callback !== "function") return;
+		this.events[name] ??= /* @__PURE__ */ new Set();
+		this.events[name].add(callback);
+	}
+	unsubscribe(name, callback) {
+		if (isEvent(name) && typeof callback === "function") this.events[name]?.delete(callback);
 	}
 };
 function onClick(event) {
-	const target = findAncestor(event, "[data-event]");
-	const table = findAncestor(event, ".tabela__table");
+	const target = findAncestor(event, eventAttribute);
+	const table = findAncestor(event, tableClassName);
 	if (!(target instanceof HTMLElement) || !(table instanceof HTMLElement)) return;
 	const manager = mapped.get(table);
 	if (manager == null) return;
-	switch (target?.getAttribute("data-event")) {
-		case "group":
+	switch (target?.getAttribute(ATTRIBUTE_DATA_EVENT)) {
+		case EVENT_GROUP:
 			manager.state.managers.group.handle(target);
 			break;
-		case "heading":
+		case EVENT_HEADING:
 			manager.onSort(event, target);
 			break;
 		case "row":
@@ -36,8 +59,8 @@ function onClick(event) {
 	}
 }
 function onKeydown(event) {
-	const target = findAncestor(event, "[data-event]");
-	const table = findAncestor(event, ".tabela__table");
+	const target = findAncestor(event, eventAttribute);
+	const table = findAncestor(event, tableClassName);
 	if (!(target instanceof HTMLElement) || !(table instanceof HTMLElement)) return;
 	const manager = mapped.get(table);
 	if (manager == null) return;
@@ -47,7 +70,9 @@ function onKeydown(event) {
 	}
 	manager.state.managers.navigation.handle(event);
 }
+const eventAttribute = `[${ATTRIBUTE_DATA_EVENT}]`;
 const mapped = /* @__PURE__ */ new WeakMap();
+const tableClassName = `.${CSS_TABLE}`;
 on(document, "click", onClick);
 on(document, "keydown", onKeydown, { passive: false });
 //#endregion

package/dist/managers/filter.manager.d.mts

@@ -1,2 +1,18 @@
-import { S as FilterManager } from "../group.component-Cq1YYbfJ.mjs";
+import { TabelaFilter, TabelaFilterItem } from "../models/filter.model.mjs";
+import { State } from "../models/tabela.model.mjs";
+
+//#region src/managers/filter.manager.d.ts
+declare class FilterManager {
+  state: State;
+  handlers: TabelaFilter;
+  items: Record<string, TabelaFilterItem[]>;
+  constructor(state: State);
+  add(item: TabelaFilterItem): void;
+  clear(): void;
+  destroy(): void;
+  filter(): void;
+  remove(value: string | TabelaFilterItem): void;
+  set(items: TabelaFilterItem[]): void;
+}
+//#endregion
 export { FilterManager };

package/dist/managers/filter.manager.mjs

@@ -1,31 +1,34 @@
-import { GroupComponent } from "../components/group.component.mjs";
+import { isGroupKey } from "../helpers/misc.helpers.mjs";
+import { FILTER_CONTAINS, FILTER_ENDS_WITH, FILTER_EQUALS, FILTER_GREATER_THAN, FILTER_GREATER_THAN_OR_EQUAL, FILTER_LESS_THAN, FILTER_LESS_THAN_OR_EQUAL, FILTER_NOT_CONTAINS, FILTER_NOT_EQUALS, FILTER_STARTS_WITH } from "../models/filter.model.mjs";
 import { getString } from "@oscarpalmer/atoms/string";
 import { getNumber } from "@oscarpalmer/atoms/number";
 import { endsWith, includes, startsWith } from "@oscarpalmer/atoms/string/match";
 import { equal } from "@oscarpalmer/atoms/value/equal";
 //#region src/managers/filter.manager.ts
 var FilterManager = class {
-	handlers = Object.freeze({
+	handlers = {
 		add: (item) => this.add(item),
 		clear: () => this.clear(),
 		remove: (value) => this.remove(value),
 		set: (items) => this.set(items)
-	});
+	};
 	items = {};
 	constructor(state) {
 		this.state = state;
 	}
 	add(item) {
-		if (this.items[item.field] == null) this.items[item.field] = [];
-		else if (this.items[item.field].findIndex((existing) => equal(existing, item)) > -1) return;
-		this.items[item.field].push(item);
+		const { items, state } = this;
+		if (items[item.key] == null) items[item.key] = [];
+		else if (items[item.key].findIndex((existing) => equal(existing, item)) > -1) return;
+		items[item.key].push(item);
+		state.managers.event.emit("filter:add", [item]);
 		this.filter();
 	}
 	clear() {
-		if (Object.keys(this.items).length > 0) {
-			this.items = {};
-			this.filter();
-		}
+		if (Object.keys(this.items).length === 0) return;
+		this.items = {};
+		this.state.managers.event.emit("filter:clear");
+		this.filter();
 	}
 	destroy() {
 		this.handlers = void 0;
@@ -36,18 +39,18 @@ var FilterManager = class {
 		const { state } = this;
 		const filtered = [];
 		const filters = Object.entries(this.items);
-		const itemsLength = state.managers.data.state.items.original.length;
+		const itemsLength = state.managers.data.state.keys.original.length;
 		rowLoop: for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
-			const item = state.managers.data.state.items.original[itemIndex];
-			if (item instanceof GroupComponent) {
+			const item = state.managers.data.state.keys.original[itemIndex];
+			if (isGroupKey(item)) {
 				filtered.push(item);
 				continue;
 			}
 			const row = state.managers.data.state.values.mapped.get(item);
 			if (row == null) continue;
 			filterLoop: for (let filterIndex = 0; filterIndex < filters.length; filterIndex += 1) {
-				const [field, items] = filters[filterIndex];
-				const value = row[field];
+				const [key, items] = filters[filterIndex];
+				const value = row[key];
 				for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
 					const filter = items[itemIndex];
 					if (comparators[filter.comparison](value, filter.value)) continue filterLoop;
@@ -56,26 +59,31 @@ var FilterManager = class {
 			}
 			filtered.push(item);
 		}
-		state.managers.data.state.items.active = filtered;
+		state.managers.data.state.keys.active = filtered;
 		if (state.managers.sort.items.length > 0) state.managers.sort.sort();
 		else state.managers.render.update(true, true);
 	}
 	remove(value) {
+		const removed = [];
 		if (typeof value === "string") {
 			if (this.items[value] == null) return;
 			const keyed = {};
-			const filters = Object.keys(this.items);
-			const { length } = filters;
+			const keys = Object.keys(this.items);
+			const { length } = keys;
 			for (let index = 0; index < length; index += 1) {
-				const field = filters[index];
-				if (field !== value) keyed[field] = this.items[field];
+				const key = keys[index];
+				if (key === value) removed.push(...this.items[key]);
+				else keyed[key] = this.items[key];
 			}
 			this.items = keyed;
 		} else {
-			const { field } = value;
-			if (this.items[field] == null) return;
-			if (this.items[field].findIndex((item) => equal(item, value)) === -1) return;
+			const { key } = value;
+			if (this.items[key] == null) return;
+			const index = this.items[key].findIndex((item) => equal(item, value));
+			if (index === -1) return;
+			removed.push(this.items[key][index]);
 		}
+		this.state.managers.event.emit("filter:remove", removed);
 		this.filter();
 	}
 	set(items) {
@@ -83,24 +91,24 @@ var FilterManager = class {
 		const { length } = items;
 		for (let index = 0; index < length; index += 1) {
 			const item = items[index];
-			keyed[item.field] ??= [];
-			keyed[item.field].push(item);
+			keyed[item.key] ??= [];
+			keyed[item.key].push(item);
 		}
 		this.items = keyed;
 		this.filter();
 	}
 };
 const comparators = {
-	contains: (row, filter) => includes(getString(row), getString(filter), true),
-	"ends-with": (row, filter) => endsWith(getString(row), getString(filter), true),
-	equals: (row, filter) => equalizer(row, filter),
-	"greater-than": (row, filter) => getNumber(row) > getNumber(filter),
-	"greater-than-or-equal": (row, filter) => getNumber(row) >= getNumber(filter),
-	"less-than": (row, filter) => getNumber(row) < getNumber(filter),
-	"less-than-or-equal": (row, filter) => getNumber(row) <= getNumber(filter),
-	"not-contains": (row, filter) => !includes(getString(row), getString(filter), true),
-	"not-equals": (row, filter) => !equalizer(row, filter),
-	"starts-with": (row, filter) => startsWith(getString(row), getString(filter), true)
+	[FILTER_CONTAINS]: (row, filter) => includes(getString(row), getString(filter), true),
+	[FILTER_ENDS_WITH]: (row, filter) => endsWith(getString(row), getString(filter), true),
+	[FILTER_EQUALS]: (row, filter) => equalizer(row, filter),
+	[FILTER_GREATER_THAN]: (row, filter) => getNumber(row) > getNumber(filter),
+	[FILTER_GREATER_THAN_OR_EQUAL]: (row, filter) => getNumber(row) >= getNumber(filter),
+	[FILTER_LESS_THAN]: (row, filter) => getNumber(row) < getNumber(filter),
+	[FILTER_LESS_THAN_OR_EQUAL]: (row, filter) => getNumber(row) <= getNumber(filter),
+	[FILTER_NOT_CONTAINS]: (row, filter) => !includes(getString(row), getString(filter), true),
+	[FILTER_NOT_EQUALS]: (row, filter) => !equalizer(row, filter),
+	[FILTER_STARTS_WITH]: (row, filter) => startsWith(getString(row), getString(filter), true)
 };
 const equalizer = equal.initialize({ ignoreCase: true });
 //#endregion

package/dist/managers/group.manager.d.mts

@@ -1,2 +1,27 @@
-import { x as GroupManager } from "../group.component-Cq1YYbfJ.mjs";
+import { TabelaGroupHandlers } from "../models/group.model.mjs";
+import { GroupComponent } from "../components/group.component.mjs";
+import { State } from "../models/tabela.model.mjs";
+import { Key } from "@oscarpalmer/atoms/models";
+
+//#region src/managers/group.manager.d.ts
+declare class GroupManager {
+  state: State;
+  collapsed: Set<Key>;
+  enabled: boolean;
+  key: string;
+  handlers: TabelaGroupHandlers;
+  items: GroupComponent[];
+  mapped: Map<string, GroupComponent>;
+  order: Record<never, number>;
+  constructor(state: State);
+  add(group: GroupComponent, emit: boolean): void;
+  clear(): void;
+  destroy(): void;
+  getForKey(key: string): GroupComponent | undefined;
+  getForValue(value: unknown): GroupComponent | undefined;
+  handle(button: HTMLElement): void;
+  remove(group: GroupComponent, update: boolean): void;
+  set(items: GroupComponent[]): void;
+}
+//#endregion
 export { GroupManager };