slick-table 1.0.18 → 1.1.1

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/DecoratorColumnFilter.test.ts

@@ -0,0 +1,216 @@
+import { SlickGrid } from "slickgrid";
+
+import { headerButtons } from "shared/lib/slickgrid";
+import { EColumnFilter, EColumnFiltersGroup } from "shared/model/enums";
+import { IFilter } from "shared/model/types";
+
+import { DecoratorColumnFilter } from "./DecoratorColumnFilter";
+import { filter } from "./Filter";
+
+jest.mock("app/store/store");
+
+describe("DecoratorColumnFilter", () => {
+	let decoratorColumnFilter: DecoratorColumnFilter;
+	let mockFilter: IFilter;
+
+	beforeEach(() => {
+		mockFilter = {
+			getFilterFn: jest.fn(),
+			reset: jest.fn(),
+			print: jest.fn(),
+			args: {},
+			grid: {} as SlickGrid,
+			tableId: "test-table",
+		} as unknown as IFilter;
+		decoratorColumnFilter = new DecoratorColumnFilter(mockFilter);
+	});
+
+	it("should return true when args.columnFilters is undefined", () => {
+		const item = { id: 1, name: "Test" };
+		const args: any = {};
+
+		const result = decoratorColumnFilter.filterFn(item, args);
+
+		expect(result).toBe(true);
+	});
+
+	it("should return true when the grid is not available", () => {
+		const item = { id: 1, name: "Test" };
+		const args = {
+			columnFilters: {
+				name: {
+					filterId: EColumnFilter.TextContain,
+					group: EColumnFiltersGroup.Text,
+					value: { 1: "Test", 2: "" },
+				},
+			},
+		};
+		decoratorColumnFilter.grid = null;
+
+		const result = decoratorColumnFilter.filterFn(item, args);
+
+		expect(result).toBe(true);
+	});
+
+	it("should correctly apply filters for boolean column types", () => {
+		const mockGrid = {
+			getColumns: jest.fn(() => [{ id: "isActive", field: "isActive" }]),
+			getColumnIndex: jest.fn(() => 0),
+		} as unknown as SlickGrid;
+		decoratorColumnFilter.grid = mockGrid;
+
+		const item = { isActive: true };
+		const args = {
+			columnFilters: {
+				isActive: {
+					filterId: EColumnFilter.Boolean,
+					group: EColumnFiltersGroup.Boolean,
+					value: { 1: "true", 2: "" },
+				},
+			},
+		};
+
+		const result = decoratorColumnFilter.filterFn(item, args);
+
+		expect(result).toBe(true);
+		expect(mockGrid.getColumns).toHaveBeenCalled();
+		expect(mockGrid.getColumnIndex).toHaveBeenCalledWith("isActive");
+	});
+
+	it("should return false if any column filter fails", () => {
+		const mockGrid = {
+			getColumns: jest.fn(() => [
+				{ id: "name", field: "name" },
+				{ id: "age", field: "age" },
+			]),
+			getColumnIndex: jest.fn((id) => (id === "name" ? 0 : 1)),
+		} as unknown as SlickGrid;
+		decoratorColumnFilter.grid = mockGrid;
+
+		const item = { name: "John", age: 30 };
+		const args = {
+			columnFilters: {
+				name: {
+					filterId: EColumnFilter.TextContain,
+					group: EColumnFiltersGroup.Text,
+					value: { 1: "John", 2: "" },
+				},
+				age: {
+					filterId: EColumnFilter.NumberFrom,
+					group: EColumnFiltersGroup.Number,
+					value: { 1: "40", 2: "" },
+				},
+			},
+		};
+
+		jest
+			.spyOn(filter, "passed")
+			.mockReturnValueOnce(true) // For name filter
+			.mockReturnValueOnce(false); // For age filter
+
+		const result = decoratorColumnFilter.filterFn(item, args);
+
+		expect(result).toBe(false);
+		expect(mockGrid.getColumns).toHaveBeenCalled();
+		expect(mockGrid.getColumnIndex).toHaveBeenCalledWith("name");
+		expect(mockGrid.getColumnIndex).toHaveBeenCalledWith("age");
+		expect(filter.passed).toHaveBeenCalledTimes(2);
+	});
+
+	it("should use the formatter function for non-boolean and non-number column types", () => {
+		const mockGrid = {
+			getColumns: jest.fn(() => [
+				{
+					id: "name",
+					field: "name",
+					formatter: (_row: number, _cell: number, value: string) =>
+						`Formatted: ${value}`,
+				},
+				{ id: "age", field: "age" },
+			]),
+			getColumnIndex: jest.fn((id) => (id === "name" ? 0 : 1)),
+		} as unknown as SlickGrid;
+		decoratorColumnFilter.grid = mockGrid;
+
+		const item = { name: "John", age: 30 };
+		const args = {
+			columnFilters: {
+				name: {
+					filterId: EColumnFilter.TextContain,
+					group: EColumnFiltersGroup.Text,
+					value: { 1: "Formatted: John", 2: "" },
+				},
+				age: {
+					filterId: EColumnFilter.NumberFrom,
+					group: EColumnFiltersGroup.Number,
+					value: { 1: "30", 2: "" },
+				},
+			},
+		};
+
+		jest.spyOn(filter, "passed").mockReturnValue(true);
+
+		decoratorColumnFilter.filterFn(item, args);
+
+		expect(filter.passed).toHaveBeenCalledWith(
+			"Formatted: John",
+			{ 1: "Formatted: John", 2: "" },
+			EColumnFilter.TextContain,
+		);
+		expect(filter.passed).toHaveBeenCalledWith(
+			30,
+			{ 1: "30", 2: "" },
+			EColumnFilter.NumberFrom,
+		);
+	});
+
+	it("should correctly reset filters and highlight all columns", () => {
+		const mockFilter = {
+			reset: jest.fn(),
+		};
+		const mockHeaderButtons = {
+			highlightAllColumns: jest.fn(),
+		};
+		const mockArgs = { someArg: "value" };
+		const mockTableId = "test-table";
+
+		jest
+			.spyOn(headerButtons, "highlightAllColumns")
+			.mockImplementation(mockHeaderButtons.highlightAllColumns);
+
+		const decoratorColumnFilter = new DecoratorColumnFilter(mockFilter as any);
+		decoratorColumnFilter.args = mockArgs;
+		decoratorColumnFilter.tableId = mockTableId;
+
+		decoratorColumnFilter.reset();
+
+		expect(mockFilter.reset).toHaveBeenCalled();
+		expect(mockHeaderButtons.highlightAllColumns).toHaveBeenCalledWith(
+			mockArgs,
+			mockTableId,
+		);
+	});
+	it("should correctly reset filters and highlight all columns", () => {
+		const mockFilter = {
+			reset: jest.fn(),
+		};
+		const mockHeaderButtons = {
+			highlightAllColumns: jest.fn(),
+		};
+		const mockArgs = { someArg: "value" };
+		const mockTableId = "";
+
+		jest
+			.spyOn(headerButtons, "highlightAllColumns")
+			.mockImplementation(mockHeaderButtons.highlightAllColumns);
+
+		const decoratorColumnFilter = new DecoratorColumnFilter(mockFilter as any);
+		decoratorColumnFilter.args = mockArgs;
+		decoratorColumnFilter.tableId = mockTableId;
+
+		decoratorColumnFilter.reset();
+
+		expect(mockFilter.reset).toHaveBeenCalled();
+		expect(mockHeaderButtons.highlightAllColumns).not.toHaveBeenCalled();
+	});
+});

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/DecoratorColumnFilter.ts

@@ -0,0 +1,53 @@
+import { EColumnFilter, EColumnFiltersGroup } from "shared/model/enums";
+import { IColumnFilterValue } from "shared/model/types";
+
+import { headerButtons } from "../../../../../ui";
+import { DecoratorFilter } from "../DecoratorFilter";
+import { filter } from "./Filter";
+
+const formatterNotNeeded: EColumnFiltersGroup[] = [
+	EColumnFiltersGroup.Date,
+	EColumnFiltersGroup.Boolean,
+	EColumnFiltersGroup.Number,
+];
+
+export class DecoratorColumnFilter extends DecoratorFilter {
+	public filterFn(item: Record<string, any>, args: IArgs) {
+		if (!args.columnFilters) return true;
+		const grid = this.grid;
+		if (!grid) return true;
+		const columns = grid.getColumns();
+		const columnIds = Object.keys(args.columnFilters);
+		for (let i = 0; i < columnIds.length; i++) {
+			const columnId = columnIds[i];
+			const column = columns[grid.getColumnIndex(columnId)];
+			const { filterId, group, value } = args.columnFilters[columnId];
+			let cellValue = item[column?.field];
+			if (!formatterNotNeeded.includes(group)) {
+				const formatter = column?.formatter;
+				if (formatter)
+					cellValue = formatter(0, 0, cellValue, column, item, grid);
+			}
+			if (!filter.passed(cellValue, value, filterId)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	public reset() {
+		this.filter.reset();
+		if (this.tableId)
+			headerButtons.highlightAllColumns(this.args, this.tableId);
+	}
+}
+
+interface IArgs {
+	columnFilters?: Record<
+		string,
+		{
+			filterId: EColumnFilter;
+			group: EColumnFiltersGroup;
+			value: IColumnFilterValue;
+		}
+	>;
+}

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/Filter.test.ts

@@ -0,0 +1,264 @@
+import { EColumnFilter } from "shared/model/enums";
+
+import { filter } from "./Filter";
+
+describe("Filter", () => {
+	const spring = "2024-03-20",
+		summer = "2024-06-21",
+		automn = "2024-09-23",
+		winter = "2024-12-21";
+
+	it("should filter EColumnFilter.Boolean", () => {
+		const trueResult = filter.passed(
+			"1",
+			{ 1: "true", 2: "" },
+			EColumnFilter.Boolean,
+		);
+		const falseResult = filter.passed(
+			"0",
+			{ 1: "", 2: "false" },
+			EColumnFilter.Boolean,
+		);
+		const falseResult_ = filter.passed(
+			"10",
+			{ 1: "", 2: "false" },
+			EColumnFilter.Boolean,
+		);
+		const emptyResult = filter.passed(
+			"",
+			{ 1: "", 2: "false" },
+			EColumnFilter.Boolean,
+		);
+		const defaultResult = filter.passed(
+			"0",
+			{ 1: "", 2: "" },
+			EColumnFilter.Boolean,
+		);
+
+		expect(trueResult).toBe(true);
+		expect(falseResult).toBe(true);
+		expect(falseResult_).toBe(false);
+		expect(emptyResult).toBe(true);
+		expect(defaultResult).toBe(true);
+	});
+
+	it("should filter EColumnFilter.DateBetween", () => {
+		const between = filter.passed(
+			summer,
+			{ 1: spring, 2: automn },
+			EColumnFilter.DateBetween,
+		);
+		const before = filter.passed(
+			summer,
+			{ 1: automn, 2: winter },
+			EColumnFilter.DateBetween,
+		);
+		const after = filter.passed(
+			winter,
+			{ 1: spring, 2: automn },
+			EColumnFilter.DateBetween,
+		);
+
+		const before2 = filter.passed(
+			winter,
+			{ 1: spring, 2: "" },
+			EColumnFilter.DateBetween,
+		);
+		const after2 = filter.passed(
+			winter,
+			{ 1: "", 2: automn },
+			EColumnFilter.DateBetween,
+		);
+
+		expect(between).toBe(true);
+		expect(before).toBe(false);
+		expect(after).toBe(false);
+		expect(before2).toBe(true);
+		expect(after2).toBe(false);
+	});
+
+	it("should filter EColumnFilter.DateEqual", () => {
+		const dateEqual = filter.passed(
+			summer,
+			{ 1: summer, 2: "" },
+			EColumnFilter.DateEqual,
+		);
+		const dateNotEqual = filter.passed(
+			summer,
+			{ 1: winter, 2: "" },
+			EColumnFilter.DateEqual,
+		);
+
+		expect(dateEqual).toBe(true);
+		expect(dateNotEqual).toBe(false);
+	});
+
+	it("should filter EColumnFilter.DateTo", () => {
+		const dateBefore = filter.passed(
+			spring,
+			{ 1: summer, 2: "" },
+			EColumnFilter.DateTo,
+		);
+		const sameDay = filter.passed(
+			summer,
+			{ 1: summer, 2: "" },
+			EColumnFilter.DateTo,
+		);
+		const dateAfter = filter.passed(
+			summer,
+			{ 1: spring, 2: "" },
+			EColumnFilter.DateTo,
+		);
+
+		expect(dateBefore).toBe(true);
+		expect(sameDay).toBe(true);
+		expect(dateAfter).toBe(false);
+	});
+
+	it("should filter EColumnFilter.DateFrom", () => {
+		const dateBefore = filter.passed(
+			spring,
+			{ 1: summer, 2: "" },
+			EColumnFilter.DateFrom,
+		);
+		const sameDay = filter.passed(
+			summer,
+			{ 1: summer, 2: "" },
+			EColumnFilter.DateFrom,
+		);
+		const dateAfter = filter.passed(
+			summer,
+			{ 1: spring, 2: "" },
+			EColumnFilter.DateFrom,
+		);
+
+		expect(dateBefore).toBe(false);
+		expect(sameDay).toBe(true);
+		expect(dateAfter).toBe(true);
+	});
+
+	it("should filter EColumnFilter.NumberBetween", () => {
+		const value = { 1: "25", 2: "75" };
+		const result1 = filter.passed("50", value, EColumnFilter.NumberBetween);
+		const result2 = filter.passed("20", value, EColumnFilter.NumberBetween);
+		const result3 = filter.passed("80", value, EColumnFilter.NumberBetween);
+
+		const result4 = filter.passed(
+			"20",
+			{ 1: "", 2: "50" },
+			EColumnFilter.NumberBetween,
+		);
+
+		const result5 = filter.passed(
+			"20",
+			{ 1: "10", 2: "" },
+			EColumnFilter.NumberBetween,
+		);
+
+		expect(result1).toBe(true);
+		expect(result2).toBe(false);
+		expect(result3).toBe(false);
+		expect(result4).toBe(true);
+		expect(result5).toBe(true);
+	});
+
+	it("should filter EColumnFilter.NumberFrom", () => {
+		const value = { 1: "25", 2: "" };
+		const result1 = filter.passed("50", value, EColumnFilter.NumberFrom);
+		const result2 = filter.passed("25", value, EColumnFilter.NumberFrom);
+		const result3 = filter.passed("20", value, EColumnFilter.NumberFrom);
+
+		expect(result1).toBe(true);
+		expect(result2).toBe(true);
+		expect(result3).toBe(false);
+	});
+
+	it("should filter EColumnFilter.NumberTo", () => {
+		const value = { 1: "25", 2: "" };
+		const result1 = filter.passed("50", value, EColumnFilter.NumberTo);
+		const result2 = filter.passed("25", value, EColumnFilter.NumberTo);
+		const result3 = filter.passed("20", value, EColumnFilter.NumberTo);
+
+		expect(result1).toBe(false);
+		expect(result2).toBe(true);
+		expect(result3).toBe(true);
+	});
+
+	it("should filter EColumnFilter.NumberEqual", () => {
+		const value = { 1: "25", 2: "" };
+		const result1 = filter.passed("50", value, EColumnFilter.NumberEqual);
+		const result2 = filter.passed("25", value, EColumnFilter.NumberEqual);
+		const result3 = filter.passed("20", value, EColumnFilter.NumberEqual);
+
+		expect(result1).toBe(false);
+		expect(result2).toBe(true);
+		expect(result3).toBe(false);
+	});
+
+	it("should filter EColumnFilter.TextEqual", () => {
+		const value = { 1: "hello world", 2: "" };
+		const result1 = filter.passed(
+			"Hello World",
+			value,
+			EColumnFilter.TextEqual,
+		);
+		const result2 = filter.passed(
+			"HELLO WORLD",
+			value,
+			EColumnFilter.TextEqual,
+		);
+		const result3 = filter.passed(
+			"Goodbye World",
+			value,
+			EColumnFilter.TextEqual,
+		);
+
+		expect(result1).toBe(true);
+		expect(result2).toBe(true);
+		expect(result3).toBe(false);
+	});
+
+	it("should filter EColumnFilter.TextNotEqual", () => {
+		const value = { 1: "hello world", 2: "" };
+		const result1 = filter.passed(
+			"Hello World",
+			value,
+			EColumnFilter.TextNotEqual,
+		);
+		const result2 = filter.passed(
+			"HELLO WORLD",
+			value,
+			EColumnFilter.TextNotEqual,
+		);
+		const result3 = filter.passed(
+			"Goodbye World",
+			value,
+			EColumnFilter.TextNotEqual,
+		);
+
+		expect(result1).toBe(false);
+		expect(result2).toBe(false);
+		expect(result3).toBe(true);
+	});
+
+	it("should filter EColumnFilter.TextContain (returns an array of matching string)", () => {
+		const string = "any value",
+			matching = "an";
+		const result = filter.passed(
+			string,
+			{ 1: matching, 2: "" },
+			EColumnFilter.TextContain,
+		);
+
+		expect(result).toBeTruthy();
+	});
+
+	it("should filter EColumnFilter.TextNotContain", () => {
+		const result = filter.passed(
+			"any value",
+			{ 1: " val", 2: "" },
+			EColumnFilter.TextNotContain,
+		);
+		expect(result).toBe(false);
+	});
+});

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/Filter.ts

@@ -0,0 +1,108 @@
+import { getTime } from "shared/lib/datetime";
+import { EColumnFilter } from "shared/model/enums";
+import { IColumnFilterValue } from "shared/model/types";
+
+class Filter {
+	passed(
+		cellValue: string,
+		value: IColumnFilterValue,
+		filterId: EColumnFilter,
+	) {
+		if (!value[1] && !value[2]) return true;
+		switch (filterId) {
+			case EColumnFilter.Boolean: {
+				return this.boolean(cellValue, value);
+			}
+			case EColumnFilter.DateBetween: {
+				return this.dateBetween(cellValue, value);
+			}
+			case EColumnFilter.DateEqual: {
+				return this.dateEqual(cellValue, value[1]);
+			}
+			case EColumnFilter.DateFrom: {
+				return this.dateFrom(cellValue, value[1]);
+			}
+			case EColumnFilter.DateTo: {
+				return this.dateTo(cellValue, value[1]);
+			}
+			case EColumnFilter.MultipleSelect: {
+				return this.multipleSelect(cellValue, value[1]);
+			}
+			case EColumnFilter.NumberBetween: {
+				return this.numberBetween(cellValue, value);
+			}
+			case EColumnFilter.NumberEqual: {
+				return this.numberEqual(cellValue, value[1]);
+			}
+			case EColumnFilter.NumberFrom: {
+				return this.numberFrom(cellValue, value[1]);
+			}
+			case EColumnFilter.NumberTo: {
+				return this.numberTo(cellValue, value[1]);
+			}
+			case EColumnFilter.TextContain: {
+				return this.textContain(cellValue, value[1]);
+			}
+			case EColumnFilter.TextEqual: {
+				return this.textEqual(cellValue, value[1]);
+			}
+			case EColumnFilter.TextNotContain: {
+				return !this.textContain(cellValue, value[1]);
+			}
+			case EColumnFilter.TextNotEqual: {
+				return !this.textEqual(cellValue, value[1]);
+			}
+		}
+	}
+
+	boolean(cellValue: string, value: IColumnFilterValue) {
+		if (value[1]) return Boolean(cellValue);
+		if (value[2]) return !cellValue;
+		return true;
+	}
+	dateBetween(cellValue: string, value: IColumnFilterValue) {
+		const from = value[1];
+		const to = value[2];
+		if (!from) return this.dateTo(cellValue, to);
+		if (!to) return this.dateFrom(cellValue, from);
+		return this.dateFrom(cellValue, from) && this.dateTo(cellValue, to);
+	}
+	dateEqual(cellValue: string, filter: string) {
+		return filter === cellValue;
+	}
+	dateFrom(cellValue: string, filter: string) {
+		return getTime(cellValue) >= getTime(filter);
+	}
+	dateTo(cellValue: string, filter: string) {
+		return getTime(cellValue) <= getTime(filter);
+	}
+	multipleSelect(cellValue: string, filter: string) {
+		const array = JSON.parse(filter) as (number | string)[];
+		if (array.includes("All")) return true;
+		return array.includes(cellValue);
+	}
+	numberBetween(cellValue: string, value: IColumnFilterValue) {
+		const from = value[1] || 0;
+		const to = value[2] || 0;
+		if (!from) return Number(cellValue) <= Number(to);
+		if (!to) return Number(cellValue) >= Number(from);
+		return this.numberFrom(cellValue, from) && this.numberTo(cellValue, to);
+	}
+	numberEqual(cellValue: string, filter: string) {
+		return Number(filter) === Number(cellValue);
+	}
+	numberFrom(cellValue: string, filter: string) {
+		return Number(cellValue) >= Number(filter);
+	}
+	numberTo(cellValue: string, filter: string) {
+		return Number(cellValue) <= Number(filter);
+	}
+	textEqual(cellValue: string, filter: string) {
+		return (cellValue || "").toLowerCase() === filter.toLowerCase();
+	}
+	textContain(cellValue: string, filter: string) {
+		return (cellValue || "").toLowerCase().match(filter.toLowerCase());
+	}
+}
+
+export const filter = new Filter();

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/ColumnFilter/index.ts

@@ -0,0 +1 @@
+export { DecoratorColumnFilter } from "./DecoratorColumnFilter";

package/src/shared/lib/slickgrid/model/SlickTable/filters/decorators/DecoratorEndingDate.ts

@@ -0,0 +1,16 @@
+import { getTime } from "shared/lib/datetime";
+import { ISlickRow } from "shared/model/types";
+
+import { DecoratorFilter } from "./DecoratorFilter";
+
+export class DecoratorEndingDate extends DecoratorFilter {
+	filterFn(row: ISlickRow, args: IArguments): boolean {
+		const { endingDate } = args;
+		if (!endingDate) return true;
+		return getTime(row.date) <= getTime(endingDate);
+	}
+}
+
+interface IArguments {
+	endingDate?: string;
+}