@oscarpalmer/tabela 0.13.0 → 0.15.0

package/dist/managers/sort.manager.mjs

@@ -1,67 +1,86 @@
-import { GroupComponent } from "../components/group.component.mjs";
+import { ARIA_SORT, ATTRIBUTE_DATA_SORT_DIRECTION, ATTRIBUTE_DATA_SORT_POSITION } from "../models/dom.model.mjs";
+import { EVENT_DATA_SORTED, EVENT_SORT_ADD, EVENT_SORT_CLEAR, EVENT_SORT_FLIP, EVENT_SORT_REMOVE, EVENT_SORT_SET } from "../models/event.model.mjs";
+import { isGroupKey } from "../helpers/misc.helpers.mjs";
+import { SORT_ASCENDING, SORT_DESCENDING } from "../models/sort.model.mjs";
 import { setAttribute, setAttributes } from "@oscarpalmer/toretto/attribute";
 import { sort } from "@oscarpalmer/atoms/array";
 import { getValue } from "@oscarpalmer/atoms/value/handle";
 import { compare } from "@oscarpalmer/atoms/value/compare";
 //#region src/managers/sort.manager.ts
 var SortManager = class {
-	handlers = Object.freeze({
+	handlers = {
 		add: (field, direction) => this.add(field, direction),
 		flip: (field) => this.flip(field),
 		clear: () => this.clear(),
 		remove: (field) => this.remove(field),
-		set: (items) => this.set(items)
-	});
+		set: (items) => this.set(items, true)
+	};
 	items = [];
 	constructor(state) {
 		this.state = state;
 	}
-	add(field, direction) {
-		if (this.items.findIndex((item) => item.key === field) > -1) return;
+	add(key, direction) {
+		if (this.items.findIndex((item) => item.key === key) > -1) return;
 		this.items.push({
-			key: field,
+			key,
 			direction: direction ?? "ascending"
 		});
+		this.state.managers.event.emit(EVENT_SORT_ADD, [{
+			key,
+			direction: direction ?? "ascending"
+		}]);
 		this.sort();
 	}
-	addOrSet(event, field) {
-		if (event.ctrlKey || event.metaKey) this.add(field);
+	addOrSet(event, key) {
+		if (event.ctrlKey || event.metaKey) this.add(key);
 		else this.set([{
-			field,
-			direction: "ascending"
-		}]);
+			key,
+			direction: SORT_ASCENDING
+		}], false);
 	}
 	clear() {
-		if (this.items.length > 0) {
-			this.items.length = 0;
-			this.sort();
-		}
+		if (this.items.length === 0) return;
+		this.items.length = 0;
+		this.state.managers.event.emit(EVENT_SORT_CLEAR);
+		this.sort();
 	}
 	destroy() {
 		this.handlers = void 0;
 		this.items = void 0;
 		this.state = void 0;
 	}
-	flip(field) {
-		const item = this.items.find((item) => item.key === field);
+	flip(key) {
+		const item = this.items.find((item) => item.key === key);
 		if (item == null) return;
-		item.direction = item.direction === "ascending" ? "descending" : "ascending";
+		item.direction = item.direction === "ascending" ? SORT_DESCENDING : SORT_ASCENDING;
+		this.state.managers.event.emit(EVENT_SORT_FLIP, [{
+			key,
+			direction: item.direction
+		}]);
 		this.sort();
 	}
-	remove(field) {
-		const index = this.items.findIndex((item) => item.key === field);
-		if (index > -1) {
-			this.items.splice(index, 1);
-			this.sort();
-		}
-	}
-	removeOrClear(event, field) {
-		if (event.ctrlKey || event.metaKey) this.remove(field);
-		else this.clear();
+	remove(key) {
+		const index = this.items.findIndex((item) => item.key === key);
+		if (index === -1) return;
+		const spliced = this.items.splice(index, 1);
+		this.state.managers.event.emit(EVENT_SORT_REMOVE, spliced);
+		if (this.items.length === 0) this.state.managers.event.emit(EVENT_SORT_CLEAR);
+		this.sort();
 	}
-	set(items) {
-		this.items.splice(0, this.items.length, ...items.map((item) => ({
-			key: item.field,
+	set(items, set) {
+		const removed = this.items.splice(0, this.items.length, ...items.map((item) => ({
+			key: item.key,
+			direction: item.direction
+		})));
+		if (set) this.state.managers.event.emit(EVENT_SORT_SET, {
+			removed,
+			added: items.map((item) => ({
+				key: item.key,
+				direction: item.direction
+			}))
+		});
+		else this.state.managers.event.emit(EVENT_SORT_ADD, items.map((item) => ({
+			key: item.key,
 			direction: item.direction
 		})));
 		this.sort();
@@ -71,47 +90,48 @@ var SortManager = class {
 		const { length } = state.managers.column.items;
 		for (let index = 0; index < length; index += 1) {
 			const column = state.managers.column.items[index];
-			const sorterIndex = items.findIndex((item) => item.key === column.options.field);
+			const sorterIndex = items.findIndex((item) => item.key === column.options.key);
 			const sorterItem = items[sorterIndex];
 			setAttributes(column.elements.wrapper, {
-				"aria-sort": sorterItem == null ? "none" : items.length > 1 ? "other" : sorterItem.direction,
-				"data-sort-direction": sorterItem == null ? void 0 : sorterItem.direction
+				[ARIA_SORT]: sorterItem == null ? SORT_NONE : items.length > 1 ? SORT_OTHER : sorterItem.direction,
+				[ATTRIBUTE_DATA_SORT_DIRECTION]: sorterItem == null ? void 0 : sorterItem.direction
 			});
-			setAttribute(column.elements.sorter, "data-sort-position", sorterIndex > -1 && items.length > 1 ? sorterIndex + 1 : void 0);
+			setAttribute(column.elements.sorter, ATTRIBUTE_DATA_SORT_POSITION, sorterIndex > -1 && items.length > 1 ? sorterIndex + 1 : void 0);
 		}
-		state.managers.data.state.items.active = items.length === 0 ? void 0 : getSortedItems(state, items);
+		state.managers.data.state.keys.active = items.length === 0 ? void 0 : getSortedItems(state, items);
+		state.managers.event.emit(EVENT_DATA_SORTED, state.managers.data.get(true));
 		state.managers.render.update(true, true);
 	}
-	toggle(event, field, direction) {
+	toggle(event, key, direction) {
 		switch (direction) {
-			case "ascending":
-				this.flip(field);
+			case SORT_ASCENDING:
+				this.flip(key);
 				return;
-			case "descending":
-				this.removeOrClear(event, field);
+			case SORT_DESCENDING:
+				this.remove(key);
 				return;
 			default:
-				this.addOrSet(event, field);
+				this.addOrSet(event, key);
 				return;
 		}
 	}
 };
 function getSortedItems(state, sorters) {
-	const data = state.managers.data.state.items.active?.map((key) => key instanceof GroupComponent ? key : state.managers.data.state.values.mapped.get(key)) ?? state.managers.data.state.values.array.slice();
+	const data = state.managers.data.state.keys.active?.map((key) => isGroupKey(key) ? key : state.managers.data.state.values.mapped.get(key)) ?? state.managers.data.state.values.array;
 	if (!state.managers.group.enabled) return sort(data, sorters).map((item) => getValue(item, state.key));
-	return sortWithGroups(state, data, sorters).map((item) => item instanceof GroupComponent ? item : getValue(item, state.key));
+	return sortWithGroups(state, data, sorters).map((item) => isGroupKey(item) ? item : getValue(item, state.key));
 }
 function sortWithGroups(state, data, sorters) {
 	const { length } = sorters;
 	return data.sort((first, second) => {
-		const firstValue = first instanceof GroupComponent ? first.value.stringified : getValue(first, state.managers.group.field);
-		const secondValue = second instanceof GroupComponent ? second.value.stringified : getValue(second, state.managers.group.field);
+		const firstIsGroup = isGroupKey(first);
+		const secondIsGroup = isGroupKey(second);
+		const firstValue = firstIsGroup ? state.managers.group.getForKey(first).value.stringified : getValue(first, state.managers.group.key);
+		const secondValue = secondIsGroup ? state.managers.group.getForKey(second).value.stringified : getValue(second, state.managers.group.key);
 		const firstOrder = state.managers.group.order[firstValue];
 		const secondOrder = state.managers.group.order[secondValue];
 		const groupComparison = compare(firstOrder, secondOrder);
 		if (groupComparison !== 0) return groupComparison;
-		const firstIsGroup = first instanceof GroupComponent;
-		const secondIsGroup = second instanceof GroupComponent;
 		if (firstIsGroup || secondIsGroup) return firstIsGroup && secondIsGroup ? 0 : firstIsGroup ? -1 : 1;
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
@@ -121,5 +141,7 @@ function sortWithGroups(state, data, sorters) {
 		return 0;
 	});
 }
+const SORT_NONE = "none";
+const SORT_OTHER = "other";
 //#endregion
 export { SortManager, sortWithGroups };

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

@@ -1,2 +1,9 @@
-import { c as StyleManager } from "../group.component-Cq1YYbfJ.mjs";
+import { State } from "../models/tabela.model.mjs";
+
+//#region src/managers/style.manager.d.ts
+declare class StyleManager {
+  readonly state: State;
+  constructor(state: State);
+}
+//#endregion
 export { StyleManager };

package/dist/managers/style.manager.mjs

@@ -1,3 +1,4 @@
+import { CSS_BUTTON, CSS_CELL, CSS_CELL_FOOTER, CSS_CELL_GROUP, CSS_HEADING, CSS_HEADING_CONTENT, CSS_HEADING_SORTER, CSS_ROW, CSS_ROWGROUP_BODY, CSS_ROWGROUP_FOOTER, CSS_ROWGROUP_HEADER, CSS_ROW_SELECTED, CSS_SELECTION, CSS_TABLE, CSS_WRAPPER } from "../models/style.model.mjs";
 //#region src/managers/style.manager.ts
 var StyleManager = class {
 	constructor(state) {
@@ -11,14 +12,14 @@ var StyleManager = class {
 };
 const styling = `/** Table */
 
-:where(.tabela) {
+:where(.${CSS_WRAPPER}) {
 	flex: 1;
 	position: relative;
 	background-color: var(--oui-absolute);
 	border: 1px solid grey;
 }
 
-:where(.tabela__table) {
+:where(.${CSS_TABLE}) {
 	min-height: 24em;
 	display: flex;
 	flex-flow: column nowrap;
@@ -30,69 +31,69 @@ const styling = `/** Table */
 
 /** Row group */
 
-:where(.tabela__rowgroup--header),
-:where(.tabela__rowgroup--footer) {
+:where(.${CSS_ROWGROUP_HEADER}),
+:where(.${CSS_ROWGROUP_FOOTER}) {
 	background-color: white;
 	position: sticky;
 	left: 0;
 	z-index: 10;
 }
 
-:where(.tabela__rowgroup--header) {
+:where(.${CSS_ROWGROUP_HEADER}) {
 	top: 0;
 }
 
-:where(.tabela__rowgroup--footer) {
+:where(.${CSS_ROWGROUP_FOOTER}) {
 	bottom: 0;
 }
 
-:where(.tabela__rowgroup--body) {
+:where(.${CSS_ROWGROUP_BODY}) {
 	display: flex;
 	flex-flow: column nowrap;
 	flex: 1;
 }
 
-:where(.tabela__rowgroup--body:focus) {
+:where(.${CSS_ROWGROUP_BODY}:focus) {
 	outline: none;
 }
 
-:where(.tabela:has(.tabela__rowgroup--body:focus-visible)) {
+:where(.${CSS_WRAPPER}:has(.${CSS_ROWGROUP_BODY}:focus-visible)) {
 	outline: 2px solid var(--oui-blue-6);
 	outline-offset: 2px;
 }
 
 /** Row */
 
-:where(.tabela__row) {
+:where(.${CSS_ROW}) {
 	width: 100%;
 	display: flex;
 	flex-flow: row nowrap;
 }
 
-:where(.tabela__row:last-child .tabela__cell) {
+:where(.${CSS_ROW}:last-child .${CSS_CELL}) {
 	border-bottom-width: 0;
 }
 
-:where(.tabela__row--body),
-:where(.tabela__row--group) {
+:where(.${CSS_ROW}--body),
+:where(.${CSS_ROW}--group) {
 	flex: 1;
 	position: absolute;
 }
 
-:where(.tabela__row--selected) {
+:where(.${CSS_ROW_SELECTED}) {
 	background-color: var(--oui-blue-1);
 	color: var(--oui-blue-9);
 }
 
-:where(.tabela:has(.tabela__rowgroup--body:focus-visible) .tabela__row[data-active="true"]) {
+:where(.${CSS_WRAPPER}:has(.${CSS_ROWGROUP_BODY}:focus-visible) .${CSS_ROW}[data-active="true"]) {
 	outline: 2px solid var(--oui-blue-6);
 	outline-offset: 2px;
 }
 
 /** Cells */
 
-:where(.tabela__cell),
-:where(.tabela__heading) {
+:where(.${CSS_CELL}),
+:where(.${CSS_HEADING}) {
 	padding: 0.5em;
 	border-color: gray;
 	border-style: solid;
@@ -100,24 +101,55 @@ const styling = `/** Table */
 	line-height: 1;
 }
 
-:where(.tabela__row .tabela__cell:last-child),
-:where(.tabela__row .tabela__heading:last-child) {
+:where(.${CSS_WRAPPER} .${CSS_CELL}:last-child),
+:where(.${CSS_ROW} .${CSS_HEADING}:last-child) {
 	flex: 1;
 	border-right-width: 0;
 }
 
-:where(.tabela__cell) {
+:where(.${CSS_CELL}) {
 	overflow: hidden;
 	text-overflow: ellipsis;
 	white-space: nowrap;
 }
 
-:where(.tabela__cell--footer) {
+:where(.${CSS_HEADING}) {
+	display: flex;
+	flex-flow: row nowrap;
+	align-items: center;
+	justify-content: space-between;
+	gap: 0.5em;
+	cursor: pointer;
+}
+
+:where(.${CSS_HEADING_CONTENT}) {
+	overflow: hidden;
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+:where(.${CSS_HEADING}[data-sort-direction] .${CSS_HEADING_SORTER})::after {
+	width: 1em;
+	height: 1em;
+	display: inline-flex;
+	font-size: .75em;
+	font-weight: bold;
+}
+
+:where(.${CSS_HEADING}[data-sort-direction="ascending"] .${CSS_HEADING_SORTER})::after {
+	content: '\\21C8';
+}
+
+:where(.${CSS_HEADING}[data-sort-direction="descending"] .${CSS_HEADING_SORTER})::after {
+	content: '\\21CA';
+}
+
+:where(.${CSS_CELL_FOOTER}) {
 	border-top-width: 1px;
 	border-bottom-width: 0;
 }
 
-:where(.tabela__cell--group) {
+:where(.${CSS_CELL_GROUP}) {
 	padding: 0;
 	display: flex;
 	flex-flow: row nowrap;
@@ -125,18 +157,18 @@ const styling = `/** Table */
 	gap: 0.5em;
 }
 
-:where(.tabela__cell--group .tabela__button) {
+:where(.${CSS_CELL_GROUP} .${CSS_BUTTON}) {
 	margin: 0 0 0 .25rem;
 }
 
 /** Misc. */
 
-:where(.tabela__button) {
+:where(.${CSS_BUTTON}) {
 	font-size: .75rem;
 	font-weight: bold;
 }
 
-:where(.tabela__selection) {
+:where(.${CSS_SELECTION}) {
 	background-color: color-mix(in oklch, var(--oui-blue-6), transparent);
 	border: 1px solid var(--oui-blue-6);
 	border-radius: .25rem;

package/dist/models/body.model.d.mts

@@ -1,2 +1,7 @@
-import { t as BodyElements } from "../body.model-2iwsovAV.mjs";
+//#region src/models/body.model.d.ts
+type BodyElements = {
+  faker: HTMLDivElement;
+  group: HTMLDivElement;
+};
+//#endregion
 export { BodyElements };

package/dist/models/column.model.d.mts

@@ -1,2 +1,13 @@
-import { n as TabelaColumn, r as TabelaColumnType, t as Column } from "../column.model-D-aw4EU4.mjs";
-export { Column, TabelaColumn, TabelaColumnType };
+//#region src/models/column.model.d.ts
+type Column = {
+  key: string;
+  label: string;
+  width: number;
+};
+type TabelaColumn = {
+  key: string;
+  label: string;
+  width?: number;
+};
+//#endregion
+export { Column, TabelaColumn };

package/dist/models/data.model.d.mts

@@ -1,2 +1,28 @@
-import { D as TabelaData, E as DataState, T as DataItem } from "../group.component-Cq1YYbfJ.mjs";
-export { DataItem, DataState, TabelaData };
+import { State } from "./tabela.model.mjs";
+import { Key, PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/models/data.model.d.ts
+type DataKeys = {
+  active?: Key[];
+  original: Key[];
+};
+type DataState = {
+  keys: DataKeys;
+  values: DataValues;
+} & State;
+type DataValue = string | PlainObject;
+type DataValues = {
+  array: DataValue[];
+  mapped: Map<Key, PlainObject>;
+};
+type TabelaData = {
+  add(data: PlainObject[]): Promise<void>;
+  clear(): Promise<void>;
+  get(active?: boolean): PlainObject[];
+  remove(keys: Key[]): Promise<void>;
+  remove(data: PlainObject[]): Promise<void>;
+  synchronize(data: PlainObject[], remove?: boolean): Promise<void>;
+  update(data: PlainObject[]): Promise<void>;
+};
+//#endregion
+export { DataState, DataValue, TabelaData };

package/dist/models/dom.model.d.mts

@@ -0,0 +1,19 @@
+//#region src/models/dom.model.d.ts
+declare const ARIA_ACTIVEDESCENDANT = "aria-activedescendant";
+declare const ARIA_LABEL = "aria-label";
+declare const ARIA_SELECTED = "aria-selected";
+declare const ARIA_SORT = "aria-sort";
+declare const ATTRIBUTE_DATA_ACTIVE = "data-active";
+declare const ATTRIBUTE_DATA_EVENT = "data-event";
+declare const ATTRIBUTE_DATA_KEY = "data-key";
+declare const ATTRIBUTE_DATA_SORT_DIRECTION = "data-sort-direction";
+declare const ATTRIBUTE_DATA_SORT_POSITION = "data-sort-position";
+declare const ATTRIBUTE_ROLE = "role";
+declare const ELEMENT_DIV = "div";
+declare const ROLE_CELL = "cell";
+declare const ROLE_COLUMNHEADER = "columnheader";
+declare const ROLE_ROW = "row";
+declare const ROLE_ROWGROUP = "rowgroup";
+declare const ROLE_TABLE = "table";
+//#endregion
+export { ARIA_ACTIVEDESCENDANT, ARIA_LABEL, ARIA_SELECTED, ARIA_SORT, ATTRIBUTE_DATA_ACTIVE, ATTRIBUTE_DATA_EVENT, ATTRIBUTE_DATA_KEY, ATTRIBUTE_DATA_SORT_DIRECTION, ATTRIBUTE_DATA_SORT_POSITION, ATTRIBUTE_ROLE, ELEMENT_DIV, ROLE_CELL, ROLE_COLUMNHEADER, ROLE_ROW, ROLE_ROWGROUP, ROLE_TABLE };

package/dist/models/dom.model.mjs

@@ -0,0 +1,19 @@
+//#region src/models/dom.model.ts
+const ARIA_ACTIVEDESCENDANT = "aria-activedescendant";
+const ARIA_LABEL = "aria-label";
+const ARIA_SELECTED = "aria-selected";
+const ARIA_SORT = "aria-sort";
+const ATTRIBUTE_DATA_ACTIVE = "data-active";
+const ATTRIBUTE_DATA_EVENT = "data-event";
+const ATTRIBUTE_DATA_KEY = "data-key";
+const ATTRIBUTE_DATA_SORT_DIRECTION = "data-sort-direction";
+const ATTRIBUTE_DATA_SORT_POSITION = "data-sort-position";
+const ATTRIBUTE_ROLE = "role";
+const ELEMENT_DIV = "div";
+const ROLE_CELL = "cell";
+const ROLE_COLUMNHEADER = "columnheader";
+const ROLE_ROW = "row";
+const ROLE_ROWGROUP = "rowgroup";
+const ROLE_TABLE = "table";
+//#endregion
+export { ARIA_ACTIVEDESCENDANT, ARIA_LABEL, ARIA_SELECTED, ARIA_SORT, ATTRIBUTE_DATA_ACTIVE, ATTRIBUTE_DATA_EVENT, ATTRIBUTE_DATA_KEY, ATTRIBUTE_DATA_SORT_DIRECTION, ATTRIBUTE_DATA_SORT_POSITION, ATTRIBUTE_ROLE, ELEMENT_DIV, ROLE_CELL, ROLE_COLUMNHEADER, ROLE_ROW, ROLE_ROWGROUP, ROLE_TABLE };

package/dist/models/event.model.d.mts

@@ -0,0 +1,99 @@
+import { TabelaFilterItem } from "./filter.model.mjs";
+import { TabelaGroup, TabelaGroupToggle } from "./group.model.mjs";
+import { TabelaSortItem } from "./sort.model.mjs";
+import { Key, PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/models/event.model.d.ts
+type EventDataAdd = (data: PlainObject[]) => void;
+type EventDataClear = () => void;
+type EventDataFiltered = (data: PlainObject[]) => void;
+type EventDataRemove = (data: PlainObject[]) => void;
+type EventDataSorted = (data: PlainObject[]) => void;
+type EventDataSynchronize = (data: {
+  added: PlainObject[];
+  removed: PlainObject[];
+  updated: PlainObject[];
+}) => void;
+type EventDataUpdate = (data: PlainObject[]) => void;
+type EventFilterAdd = (filters: TabelaFilterItem[]) => void;
+type EventFilterClear = () => void;
+type EventFilterRemove = (filters: TabelaFilterItem[]) => void;
+type EventGroupAdd = (groups: TabelaGroup[]) => void;
+type EventGroupClear = () => void;
+type EventGroupRemove = (groups: TabelaGroup[]) => void;
+type EventGroupToggle = (event: TabelaGroupToggle) => void;
+type EventGroupUpdate = (groups: TabelaGroup[]) => void;
+type EventMap = {
+  'data:add': EventDataAdd;
+  'data:clear': EventDataClear;
+  'data:filtered': EventDataFiltered;
+  'data:remove': EventDataRemove;
+  'data:sorted': EventDataSorted;
+  'data:synchronize': EventDataSynchronize;
+  'data:update': EventDataUpdate;
+  'filter:add': EventFilterAdd;
+  'filter:clear': EventFilterClear;
+  'filter:remove': EventFilterRemove;
+  'group:add': EventGroupAdd;
+  'group:clear': EventGroupClear;
+  'group:remove': EventGroupRemove;
+  'group:toggle': EventGroupToggle;
+  'group:update': EventGroupUpdate;
+  'navigation:active': EventNavigationActive;
+  'render:begin': EventRenderBegin;
+  'render:end': EventRenderEnd;
+  'selection:add': EventSelectionAdd;
+  'selection:clear': EventSelectionClear;
+  'selection:remove': EventSelectionRemove;
+  'selection:toggle': EventSelectionToggle;
+  'sort:add': EventSortAdd;
+  'sort:clear': EventSortClear;
+  'sort:flip': EventSortFlip;
+  'sort:remove': EventSortRemove;
+  'sort:set': EventSortSet;
+};
+type EventName = keyof EventMap;
+type EventNavigationActive = (active: Key | null) => void;
+type EventRenderBegin = () => void;
+type EventRenderEnd = () => void;
+type EventSelectionAdd = (keys: Key[]) => void;
+type EventSelectionClear = () => void;
+type EventSelectionRemove = (keys: Key[]) => void;
+type EventSelectionToggle = (keys: Key[]) => void;
+type EventSortAdd = (sorters: TabelaSortItem[]) => void;
+type EventSortClear = () => void;
+type EventSortFlip = (sorters: TabelaSortItem[]) => void;
+type EventSortRemove = (sorters: TabelaSortItem[]) => void;
+type EventSortSet = (sorters: {
+  added: TabelaSortItem[];
+  removed: TabelaSortItem[];
+}) => void;
+type Events = Partial<{ [Name in EventName]: Set<EventMap[Name]> }>;
+type TabelaEvents = {
+  subscribe<Name extends EventName>(name: Name, callback: EventMap[Name]): void;
+  unsubscribe<Name extends EventName>(name: Name, callback: EventMap[Name]): void;
+};
+declare const EVENT_BODY = "body";
+declare const EVENT_DATA_ADD = "data:add";
+declare const EVENT_DATA_CLEAR = "data:clear";
+declare const EVENT_DATA_FILTERED = "data:filtered";
+declare const EVENT_DATA_REMOVE = "data:remove";
+declare const EVENT_DATA_SORTED = "data:sorted";
+declare const EVENT_DATA_SYNCHRONIZE = "data:synchronize";
+declare const EVENT_DATA_UPDATE = "data:update";
+declare const EVENT_GROUP = "group";
+declare const EVENT_GROUP_ADD = "group:add";
+declare const EVENT_GROUP_CLEAR = "group:clear";
+declare const EVENT_GROUP_REMOVE = "group:remove";
+declare const EVENT_GROUP_TOGGLE = "group:toggle";
+declare const EVENT_GROUP_UPDATE = "group:update";
+declare const EVENT_HEADING = "heading";
+declare const EVENT_ROW = "row";
+declare const EVENT_SORT_ADD = "sort:add";
+declare const EVENT_SORT_CLEAR = "sort:clear";
+declare const EVENT_SORT_FLIP = "sort:flip";
+declare const EVENT_SORT_REMOVE = "sort:remove";
+declare const EVENT_SORT_SET = "sort:set";
+declare const EVENTS_NAMES: Set<keyof EventMap>;
+//#endregion
+export { EVENTS_NAMES, EVENT_BODY, EVENT_DATA_ADD, EVENT_DATA_CLEAR, EVENT_DATA_FILTERED, EVENT_DATA_REMOVE, EVENT_DATA_SORTED, EVENT_DATA_SYNCHRONIZE, EVENT_DATA_UPDATE, EVENT_GROUP, EVENT_GROUP_ADD, EVENT_GROUP_CLEAR, EVENT_GROUP_REMOVE, EVENT_GROUP_TOGGLE, EVENT_GROUP_UPDATE, EVENT_HEADING, EVENT_ROW, EVENT_SORT_ADD, EVENT_SORT_CLEAR, EVENT_SORT_FLIP, EVENT_SORT_REMOVE, EVENT_SORT_SET, EventDataAdd, EventDataClear, EventDataFiltered, EventDataRemove, EventDataSorted, EventDataSynchronize, EventDataUpdate, EventFilterAdd, EventFilterClear, EventFilterRemove, EventGroupAdd, EventGroupClear, EventGroupRemove, EventGroupToggle, EventGroupUpdate, EventMap, EventName, EventNavigationActive, EventRenderBegin, EventRenderEnd, EventSelectionAdd, EventSelectionClear, EventSelectionRemove, EventSelectionToggle, EventSortAdd, EventSortClear, EventSortFlip, EventSortRemove, EventSortSet, Events, TabelaEvents };

package/dist/models/event.model.mjs

@@ -0,0 +1,53 @@
+//#region src/models/event.model.ts
+const EVENT_BODY = "body";
+const EVENT_DATA_ADD = "data:add";
+const EVENT_DATA_CLEAR = "data:clear";
+const EVENT_DATA_FILTERED = "data:filtered";
+const EVENT_DATA_REMOVE = "data:remove";
+const EVENT_DATA_SORTED = "data:sorted";
+const EVENT_DATA_SYNCHRONIZE = "data:synchronize";
+const EVENT_DATA_UPDATE = "data:update";
+const EVENT_GROUP = "group";
+const EVENT_GROUP_ADD = "group:add";
+const EVENT_GROUP_CLEAR = "group:clear";
+const EVENT_GROUP_REMOVE = "group:remove";
+const EVENT_GROUP_TOGGLE = "group:toggle";
+const EVENT_GROUP_UPDATE = "group:update";
+const EVENT_HEADING = "heading";
+const EVENT_ROW = "row";
+const EVENT_SORT_ADD = "sort:add";
+const EVENT_SORT_CLEAR = "sort:clear";
+const EVENT_SORT_FLIP = "sort:flip";
+const EVENT_SORT_REMOVE = "sort:remove";
+const EVENT_SORT_SET = "sort:set";
+const EVENTS_NAMES = new Set([
+	EVENT_DATA_ADD,
+	EVENT_DATA_CLEAR,
+	EVENT_DATA_FILTERED,
+	EVENT_DATA_REMOVE,
+	EVENT_DATA_SORTED,
+	EVENT_DATA_SYNCHRONIZE,
+	EVENT_DATA_UPDATE,
+	"filter:add",
+	"filter:clear",
+	"filter:remove",
+	EVENT_GROUP_ADD,
+	EVENT_GROUP_CLEAR,
+	EVENT_GROUP_REMOVE,
+	EVENT_GROUP_TOGGLE,
+	EVENT_GROUP_UPDATE,
+	"navigation:active",
+	"render:begin",
+	"render:end",
+	"selection:add",
+	"selection:clear",
+	"selection:remove",
+	"selection:toggle",
+	EVENT_SORT_ADD,
+	EVENT_SORT_CLEAR,
+	EVENT_SORT_FLIP,
+	EVENT_SORT_REMOVE,
+	EVENT_SORT_SET
+]);
+//#endregion
+export { EVENTS_NAMES, EVENT_BODY, EVENT_DATA_ADD, EVENT_DATA_CLEAR, EVENT_DATA_FILTERED, EVENT_DATA_REMOVE, EVENT_DATA_SORTED, EVENT_DATA_SYNCHRONIZE, EVENT_DATA_UPDATE, EVENT_GROUP, EVENT_GROUP_ADD, EVENT_GROUP_CLEAR, EVENT_GROUP_REMOVE, EVENT_GROUP_TOGGLE, EVENT_GROUP_UPDATE, EVENT_HEADING, EVENT_ROW, EVENT_SORT_ADD, EVENT_SORT_CLEAR, EVENT_SORT_FLIP, EVENT_SORT_REMOVE, EVENT_SORT_SET };

package/dist/models/filter.model.d.mts

@@ -1,2 +1,26 @@
-import { n as TabelaFilterComparison, r as TabelaFilterItem, t as TabelaFilter } from "../filter.model-7ukJrtil.mjs";
-export { TabelaFilter, TabelaFilterComparison, TabelaFilterItem };
+//#region src/models/filter.model.d.ts
+type TabelaFilter = {
+  add(item: TabelaFilterItem): void;
+  clear(): void;
+  remove(key: string): void;
+  remove(item: TabelaFilterItem): void;
+  set(items: TabelaFilterItem[]): void;
+};
+type TabelaFilterComparison = 'contains' | 'ends-with' | 'equals' | 'greater-than' | 'greater-than-or-equal' | 'less-than' | 'less-than-or-equal' | 'not-contains' | 'not-equals' | 'starts-with';
+type TabelaFilterItem = {
+  comparison: TabelaFilterComparison;
+  key: string;
+  value: unknown;
+};
+declare const FILTER_CONTAINS: TabelaFilterComparison;
+declare const FILTER_ENDS_WITH: TabelaFilterComparison;
+declare const FILTER_EQUALS: TabelaFilterComparison;
+declare const FILTER_GREATER_THAN: TabelaFilterComparison;
+declare const FILTER_GREATER_THAN_OR_EQUAL: TabelaFilterComparison;
+declare const FILTER_LESS_THAN: TabelaFilterComparison;
+declare const FILTER_LESS_THAN_OR_EQUAL: TabelaFilterComparison;
+declare const FILTER_NOT_CONTAINS: TabelaFilterComparison;
+declare const FILTER_NOT_EQUALS: TabelaFilterComparison;
+declare const FILTER_STARTS_WITH: TabelaFilterComparison;
+//#endregion
+export { 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, TabelaFilter, TabelaFilterComparison, TabelaFilterItem };