@oscarpalmer/tabela 0.8.0 → 0.9.0

package/dist/managers/column.manager.js

@@ -7,6 +7,8 @@ var ColumnManager = class {
 		this.set(columns);
 	}
 	destroy() {
+		const { length } = this.items;
+		for (let index = 0; index < length; index += 1) this.items[index].destroy();
 		this.items.length = 0;
 	}
 	remove(value) {
@@ -16,7 +18,10 @@ var ColumnManager = class {
 		if (length === 0) return;
 		for (let fieldIndex = 0; fieldIndex < length; fieldIndex += 1) {
 			const itemIndex = items.findIndex((component) => component.options.field === fields[fieldIndex]);
-			if (itemIndex > -1) items.splice(itemIndex, 1);
+			if (itemIndex > -1) {
+				items[itemIndex].destroy();
+				items.splice(itemIndex, 1);
+			}
 		}
 		components.header.update(items);
 		components.footer.update(items);

package/dist/managers/data.manager.js

@@ -1,4 +1,4 @@
-import { sort } from "@oscarpalmer/atoms/array";
+import { push, sort } from "@oscarpalmer/atoms/array";
 import { toMap } from "@oscarpalmer/atoms/array/to-map";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 var DataManager = class {
@@ -27,7 +27,7 @@ var DataManager = class {
 	}
 	async add(data, render) {
 		const { field, values } = this;
-		values.objects.array.push(...data);
+		push(values.objects.array, data);
 		values.objects.mapped = toMap(values.objects.array, field);
 		if (render) this.render();
 	}
@@ -40,6 +40,7 @@ var DataManager = class {
 		values.keys.active = void 0;
 		values.keys.original.length = 0;
 		values.objects.array.length = 0;
+		this.handlers = void 0;
 	}
 	get(active) {
 		const { values } = this;
@@ -63,7 +64,8 @@ var DataManager = class {
 	render() {
 		const { field, managers, values } = this;
 		values.keys.original = sort(values.objects.array.map((item) => item[field]));
-		if (managers.sort.items.length > 0) managers.sort.sort();
+		if (Object.keys(managers.filter.items).length > 0) managers.filter.filter();
+		else if (managers.sort.items.length > 0) managers.sort.sort();
 		else managers.virtualization.update(true);
 	}
 	set(data) {

package/dist/managers/event.manager.js

@@ -4,7 +4,7 @@ var EventManager = class {
 	listener;
 	constructor(managers, element) {
 		this.managers = managers;
-		on(element, "click", (event) => {
+		this.listener = on(element, "click", (event) => {
 			this.onClick(event);
 		}, { passive: false });
 	}

package/dist/managers/filter.manager.js

@@ -0,0 +1,92 @@
+import { getNumber } from "@oscarpalmer/atoms/number";
+import { getString } from "@oscarpalmer/atoms/string";
+import { endsWith, includes, startsWith } from "@oscarpalmer/atoms/string/match";
+import { equal } from "@oscarpalmer/atoms/value/equal";
+var FilterManager = class {
+	handlers = Object.freeze({
+		add: (item) => this.add(item),
+		clear: () => this.clear(),
+		remove: (value) => this.remove(value),
+		set: (items) => this.set(items)
+	});
+	items = {};
+	constructor(managers) {
+		this.managers = managers;
+	}
+	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);
+		this.filter();
+	}
+	clear() {
+		if (Object.keys(this.items).length > 0) {
+			this.items = {};
+			this.filter();
+		}
+	}
+	destroy() {
+		this.handlers = void 0;
+		this.items = {};
+	}
+	filter() {
+		const { managers } = this;
+		const filtered = [];
+		const filters = Object.entries(this.items);
+		const keysLength = managers.data.values.keys.original.length;
+		rowLoop: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+			const key = managers.data.values.keys.original[keyIndex];
+			const row = managers.data.values.objects.mapped.get(key);
+			if (row == null) continue;
+			filterLoop: for (let filterIndex = 0; filterIndex < filters.length; filterIndex += 1) {
+				const [field, items] = filters[filterIndex];
+				const value = row[field];
+				for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+					const filter = items[itemIndex];
+					if (comparators[filter.comparison](value, filter.value)) continue filterLoop;
+				}
+				continue rowLoop;
+			}
+			filtered.push(key);
+		}
+		managers.data.values.keys.active = filtered;
+		if (managers.sort.items.length > 0) managers.sort.sort();
+		else managers.virtualization.update(true, true);
+	}
+	remove(value) {
+		if (typeof value === "string") {
+			if (this.items[value] == null) return;
+			this.items = {};
+		} else {
+			const { field } = value;
+			if (this.items[field] == null) return;
+			if (this.items[field].findIndex((item) => equal(item, value)) === -1) return;
+		}
+		this.filter();
+	}
+	set(items) {
+		const keyed = {};
+		const { length } = items;
+		for (let index = 0; index < length; index += 1) {
+			const item = items[index];
+			keyed[item.field] ??= [];
+			keyed[item.field].push(item);
+		}
+		this.items = keyed;
+		this.filter();
+	}
+};
+var 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)
+};
+var equalizer = equal.initialize({ ignoreCase: true });
+export { FilterManager };

package/dist/managers/row.manager.js

@@ -1,4 +1,4 @@
-import { RowComponent, renderRow } from "../components/row.component.js";
+import { RowComponent, removeRow, renderRow } from "../components/row.component.js";
 var RowManager = class {
 	components = /* @__PURE__ */ new Map();
 	height;
@@ -7,6 +7,9 @@ var RowManager = class {
 		this.height = rowHeight;
 	}
 	destroy() {
+		const components = [...this.components.values()];
+		const { length } = components;
+		for (let index = 0; index < length; index += 1) removeRow(this.managers.virtualization.pool, components[index]);
 		this.components.clear();
 	}
 	get(key) {
@@ -21,7 +24,11 @@ var RowManager = class {
 		return this.components.has(key);
 	}
 	remove(key) {
-		this.components.delete(key);
+		const row = this.components.get(key);
+		if (row != null) {
+			removeRow(this.managers.virtualization.pool, row);
+			this.components.delete(key);
+		}
 	}
 	update(key) {
 		const row = this.components.get(key);

package/dist/managers/sort.manager.js

@@ -23,13 +23,19 @@ var SortManager = class {
 	addOrSet(event, field) {
 		if (event.ctrlKey || event.metaKey) this.add(field);
 		else this.set([{
-			key: field,
+			field,
 			direction: "ascending"
 		}]);
 	}
 	clear() {
+		if (this.items.length > 0) {
+			this.items.length = 0;
+			this.sort();
+		}
+	}
+	destroy() {
+		this.handlers = void 0;
 		this.items.length = 0;
-		this.sort();
 	}
 	flip(field) {
 		const item = this.items.find((item) => item.key === field);
@@ -49,14 +55,17 @@ var SortManager = class {
 		else this.clear();
 	}
 	set(items) {
-		this.items.splice(0, this.items.length, ...items);
+		this.items.splice(0, this.items.length, ...items.map((item) => ({
+			key: item.field,
+			direction: item.direction
+		})));
 		this.sort();
 	}
 	sort() {
 		const { items, managers } = this;
-		managers.data.values.keys.active = items.length === 0 ? void 0 : sort(managers.data.values.objects.array, items).map((row) => row[managers.data.field]);
-		managers.virtualization.update(true, true);
-		for (const column of managers.column.items) {
+		const { length } = managers.column.items;
+		for (let index = 0; index < length; index += 1) {
+			const column = managers.column.items[index];
 			const sorterIndex = items.findIndex((item) => item.key === column.options.field);
 			const sorterItem = items[sorterIndex];
 			setAttributes(column.elements.wrapper, {
@@ -65,6 +74,8 @@ var SortManager = class {
 			});
 			setAttribute(column.elements.sorter, "data-sort-position", sorterIndex > -1 && items.length > 1 ? sorterIndex + 1 : void 0);
 		}
+		managers.data.values.keys.active = items.length === 0 ? void 0 : sort(managers.data.values.keys.active?.map((key) => managers.data.values.objects.mapped.get(key)) ?? managers.data.values.objects.array, items).map((row) => row[managers.data.field]);
+		managers.virtualization.update(true, true);
 	}
 	toggle(event, field, direction) {
 		switch (direction) {

package/dist/managers/virtualization.manager.js

@@ -49,6 +49,8 @@ var VirtualizationManager = class {
 		}
 		this.pool.cells = {};
 		this.pool.rows = [];
+		this.listener = void 0;
+		this.visible = void 0;
 	}
 	removeCells(fields) {
 		const { length } = fields;