slick-table 1.0.18 → 1.1.1

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

@@ -0,0 +1,139 @@
+import { SlickGrid } from "slickgrid";
+
+import { ISlickRow } from "shared/model/types";
+import { IFilter } from "shared/model/types";
+
+import { SlickTable } from "../../table";
+import { DecoratorFilter } from "./DecoratorFilter";
+
+class TestDecoratorFilter extends DecoratorFilter {
+	filterFn(): boolean {
+		return true;
+	}
+}
+
+describe("DecoratorFilter", () => {
+	let decoratorFilter: TestDecoratorFilter;
+	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;
+
+		decoratorFilter = new TestDecoratorFilter(mockFilter);
+	});
+
+	it("should combine the decorator's filterFn with the wrapped filter's filterFn", () => {
+		jest
+			.spyOn(mockFilter, "getFilterFn")
+			.mockReturnValue((row) => row.id % 2 === 0);
+
+		jest
+			.spyOn(decoratorFilter, "filterFn")
+			.mockImplementation((row: ISlickRow) => row.value > 10);
+
+		const combinedFilterFn = decoratorFilter.getFilterFn();
+
+		const row1 = { id: 1, value: 15 };
+		const row2 = { id: 2, value: 5 };
+		const row3 = { id: 3, value: 20 };
+		const row4 = { id: 4, value: 25 };
+
+		expect(combinedFilterFn(row1, {})).toBe(false);
+		expect(combinedFilterFn(row2, {})).toBe(false);
+		expect(combinedFilterFn(row3, {})).toBe(false);
+		expect(combinedFilterFn(row4, {})).toBe(true);
+
+		expect(mockFilter.getFilterFn).toHaveBeenCalledTimes(1);
+	});
+
+	it("should set and get args through the decorator", () => {
+		const testArgs = { key: "value" };
+
+		decoratorFilter.args = testArgs;
+		expect(decoratorFilter.args).toEqual(testArgs);
+		expect(mockFilter.args).toEqual(testArgs);
+
+		const retrievedArgs = decoratorFilter.args;
+
+		expect(retrievedArgs).toEqual(testArgs);
+	});
+
+	it("should set and get grid through the decorator", () => {
+		mockFilter.grid = null;
+		decoratorFilter = new TestDecoratorFilter(mockFilter);
+		const testGrid = {} as SlickGrid;
+		decoratorFilter.grid = testGrid;
+
+		expect(decoratorFilter.grid).toBe(testGrid);
+		expect(mockFilter.grid).toBe(testGrid);
+
+		const retrievedGrid = decoratorFilter.grid;
+
+		expect(retrievedGrid).toBe(testGrid);
+	});
+
+	it("should set and get tableId through the decorator", () => {
+		const testTableId = "test-table-id";
+
+		mockFilter.tableId = "";
+		decoratorFilter.tableId = testTableId;
+
+		expect(decoratorFilter.tableId).toBe(testTableId);
+		expect(mockFilter.tableId).toBe(testTableId);
+
+		const retrievedTableId = decoratorFilter.tableId;
+		expect(retrievedTableId).toBe(testTableId);
+	});
+
+	it("should register the filter with the grid and apply it to the data view", () => {
+		mockFilter.args = { testArg: "value" };
+		mockFilter.grid = null;
+		jest.spyOn(mockFilter, "getFilterFn").mockReturnValue(() => true);
+
+		const mockDataView = {
+			setFilter: jest.fn(),
+			setFilterArgs: jest.fn(),
+			refresh: jest.fn(),
+		};
+
+		const mockGrid = {
+			getData: jest.fn().mockReturnValue(mockDataView),
+		} as unknown as SlickGrid;
+
+		decoratorFilter.register(mockGrid, "test-table-id");
+
+		expect(decoratorFilter.tableId).toBe("test-table-id");
+		expect(decoratorFilter.grid).toBe(mockGrid);
+		expect(mockGrid.getData).toHaveBeenCalled();
+		expect(mockDataView.setFilter).toHaveBeenCalledWith(expect.any(Function));
+		expect(mockDataView.setFilterArgs).toHaveBeenCalledWith(mockFilter.args);
+		expect(mockDataView.refresh).toHaveBeenCalled();
+	});
+
+	it("should return the wrapped filter's print result when print is called", () => {
+		const mockTable = {} as SlickTable;
+		const mockPrintResult = [
+			document.createElement("tr"),
+			document.createElement("tr"),
+		];
+
+		jest.spyOn(mockFilter, "print").mockReturnValue(mockPrintResult);
+		const result = decoratorFilter.print(mockTable);
+
+		expect(mockFilter.print).toHaveBeenCalledWith(mockTable);
+		expect(result).toBe(mockPrintResult);
+	});
+
+	it("should reset both the decorator and the wrapped filter when reset is called", () => {
+		decoratorFilter.reset();
+
+		expect(mockFilter.reset).toHaveBeenCalledTimes(1);
+	});
+});

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

@@ -0,0 +1,55 @@
+import { FilterFn, SlickDataView, SlickGrid } from "slickgrid";
+
+import {
+	IFilter,
+	IFilterArguments,
+	ISlickRow,
+	ISlickTable,
+} from "shared/model/types";
+
+export abstract class DecoratorFilter implements IFilter {
+	protected filter: IFilter;
+	constructor(filter: IFilter) {
+		this.filter = filter;
+	}
+
+	abstract filterFn(row: ISlickRow, args: IFilterArguments): boolean;
+	public getFilterFn(): FilterFn<ISlickRow> {
+		const filterFn = this.filter.getFilterFn();
+		return (row, args): boolean => {
+			return this.filterFn(row, args) && filterFn(row, args);
+		};
+	}
+	public register(grid: SlickGrid, tableId: string): void {
+		this.tableId = tableId;
+		this.grid = grid;
+		const dataView: SlickDataView = grid.getData();
+		dataView.setFilter(this.getFilterFn());
+		dataView.setFilterArgs(this.args);
+		dataView.refresh();
+	}
+	public reset() {
+		this.filter.reset();
+	}
+	public print(table: ISlickTable): HTMLTableRowElement[] {
+		return this.filter.print(table);
+	}
+	set args(args) {
+		this.filter.args = args;
+	}
+	set grid(grid) {
+		this.filter.grid = grid;
+	}
+	set tableId(table) {
+		this.filter.tableId = table;
+	}
+	get args() {
+		return this.filter.args;
+	}
+	get grid() {
+		return this.filter.grid;
+	}
+	get tableId() {
+		return this.filter.tableId;
+	}
+}

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

@@ -0,0 +1,24 @@
+import moment from "moment/moment";
+
+import { dateFormats } from "shared/model/consts";
+
+import { DecoratorFilter } from "./DecoratorFilter";
+
+export class DecoratorPeriod extends DecoratorFilter {
+	public filterFn(row: Record<string, any>, filterArgs: IFilterArgs): boolean {
+		const { endDate, startDate } = filterArgs;
+		if (endDate && startDate) {
+			const start = moment(startDate);
+			const end = moment(endDate);
+			const recordDate = moment(row.date, dateFormats);
+			return recordDate.isBetween(start, end, undefined, "[]");
+		} else {
+			return true;
+		}
+	}
+}
+
+interface IFilterArgs {
+	endDate: string;
+	startDate: string;
+}

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

@@ -0,0 +1,4 @@
+export { DecoratorEndingDate } from "./DecoratorEndingDate";
+export { DecoratorFilter } from "./DecoratorFilter";
+export { DecoratorColumnFilter } from "./ColumnFilter";
+export { DecoratorPeriod } from "./DecoratorPeriod";

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

@@ -0,0 +1,9 @@
+export { DeletedRowsFilter } from "./DeletedRowsFilter";
+export { Filter } from "./Filter";
+export { WithoutFilter } from "./WithoutFilter";
+export {
+	DecoratorEndingDate,
+	DecoratorFilter,
+	DecoratorColumnFilter,
+	DecoratorPeriod,
+} from "./decorators";

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/DefaultHotKeys.ts

@@ -0,0 +1,116 @@
+import {
+	OnKeyDownEventArgs,
+	SlickDataView,
+	SlickEventData,
+	SlickGrid,
+} from "slickgrid";
+
+import {
+	IExternalVariables,
+	IHotKeysBehavior,
+	ISlickRow,
+	ISlickTable,
+	TGridRow,
+} from "shared/model/types";
+
+import {
+	copySelectedRows,
+	hotKeysCopy,
+	hotKeysDelete,
+	hotKeysRedo,
+	hotKeysUndo,
+	nothingToCopy,
+} from "../../../lib";
+
+export class DefaultHotKeys implements IHotKeysBehavior {
+	private externalVariables: IExternalVariables = {};
+	private commandQueue: ISlickRow[][] = [];
+	private queueIndex = -1;
+
+	private getQueueIndex(): number {
+		return this.queueIndex;
+	}
+	private setQueueIndex(queueIndex: number): void {
+		this.queueIndex = queueIndex;
+	}
+
+	public handleKeyboardEvent(
+		event: SlickEventData<OnKeyDownEventArgs>,
+		table: ISlickTable,
+	): void {
+		const grid = table.grid;
+		if (!table.isActive) return;
+		if (!grid) return;
+		const dataView: SlickDataView = grid.getData();
+		if (hotKeysCopy(event)) {
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			if (nothingToCopy(grid)) return;
+			if (this.externalVariables.editingAllowed === false) return;
+			copySelectedRows(grid);
+			grid.invalidate();
+			this.pushToCommandQueue(grid);
+			table.isEdited = true;
+		} else if (hotKeysDelete(event)) {
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			const selectedRows = grid.getSelectedRows();
+			if (!selectedRows.length) return;
+			selectedRows.forEach((rowNumber): void => {
+				const row = dataView.getItem<TGridRow>(rowNumber);
+				row.isDeleted = true;
+			});
+			grid.setSelectedRows([]);
+			dataView.refresh();
+			grid.invalidate();
+			this.pushToCommandQueue(grid);
+			table.isEdited = true;
+		} else if (hotKeysUndo(event)) {
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			const queueIndex = this.getQueueIndex();
+			if (queueIndex < 1) {
+				return;
+			}
+			const newQueueIndex = queueIndex - 1;
+			this.setQueueIndex(newQueueIndex);
+			dataView.setItems(copy(this.commandQueue[newQueueIndex]));
+			grid.invalidate();
+			table.isEdited = newQueueIndex !== 0;
+		} else if (hotKeysRedo(event)) {
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			const queueIndex = this.getQueueIndex();
+			if (queueIndex === this.commandQueue.length - 1) return;
+			const newQueueIndex = queueIndex + 1;
+			this.setQueueIndex(newQueueIndex);
+			dataView.setItems(copy(this.commandQueue[newQueueIndex]));
+			grid.invalidate();
+			table.isEdited = true;
+		}
+	}
+	public pushToCommandQueue(grid: SlickGrid | null): void {
+		if (!grid) return;
+		const dataView: SlickDataView = grid.getData();
+		const rows = dataView.getItems();
+		const queueIndex = this.getQueueIndex();
+		const newQueueIndex = queueIndex + 1;
+		this.commandQueue.length = newQueueIndex;
+		this.commandQueue.push(copy(rows));
+		this.setQueueIndex(newQueueIndex);
+	}
+	public resetQueue(): void {
+		this.commandQueue.length = 0;
+		this.queueIndex = -1;
+	}
+	public setExternalVariables(variables: IExternalVariables): void {
+		this.externalVariables = { ...this.externalVariables, ...variables };
+	}
+	public getExternalVariables(): IExternalVariables {
+		return this.externalVariables;
+	}
+}
+
+function copy(rows: ISlickRow[]): ISlickRow[] {
+	return rows.map((row) => ({ ...row }));
+}

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/WithoutHotKeys.ts

@@ -0,0 +1,20 @@
+import { IExternalVariables, IHotKeysBehavior } from "shared/model/types";
+
+export class WithoutHotKeys implements IHotKeysBehavior {
+	handleKeyboardEvent(): void {
+		// does nothing
+	}
+	pushToCommandQueue(): void {
+		// does nothing
+	}
+	resetQueue(): void {
+		// does nothing
+	}
+	setExternalVariables(_variables: IExternalVariables): void {
+		// does nothing
+	}
+
+	getExternalVariables(): IExternalVariables {
+		return {};
+	}
+}

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/decorators/HotKeysDecorator.ts

@@ -0,0 +1,32 @@
+import { OnKeyDownEventArgs, SlickEventData, SlickGrid } from "slickgrid";
+
+import {
+	IExternalVariables,
+	IHotKeysBehavior,
+	ISlickTable,
+} from "shared/model/types";
+
+export class HotKeysDecorator implements IHotKeysBehavior {
+	protected hotKeysBehaviour: IHotKeysBehavior;
+	constructor(hotKeysBehaviour: IHotKeysBehavior) {
+		this.hotKeysBehaviour = hotKeysBehaviour;
+	}
+	public handleKeyboardEvent(
+		event: SlickEventData<OnKeyDownEventArgs>,
+		table: ISlickTable,
+	): void {
+		this.hotKeysBehaviour.handleKeyboardEvent(event, table);
+	}
+	public pushToCommandQueue(grid: SlickGrid | null): void {
+		this.hotKeysBehaviour.pushToCommandQueue(grid);
+	}
+	public resetQueue(): void {
+		this.hotKeysBehaviour.resetQueue();
+	}
+	public setExternalVariables(variables: IExternalVariables): void {
+		this.hotKeysBehaviour.setExternalVariables(variables);
+	}
+	public getExternalVariables(): IExternalVariables {
+		return this.hotKeysBehaviour.getExternalVariables();
+	}
+}

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/decorators/PreventCopying.ts

@@ -0,0 +1,18 @@
+import { OnKeyDownEventArgs, SlickEventData } from "slickgrid";
+
+import { ISlickTable } from "shared/model/types";
+
+import { hotKeysCopy } from "../../../../lib";
+import { HotKeysDecorator } from "./HotKeysDecorator";
+
+export class PreventCopying extends HotKeysDecorator {
+	public handleKeyboardEvent(
+		event: SlickEventData<OnKeyDownEventArgs>,
+		table: ISlickTable,
+	): void {
+		if (!table.isActive) return;
+		if (!hotKeysCopy(event)) {
+			super.handleKeyboardEvent.call(this, event, table);
+		}
+	}
+}

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/decorators/RedoUndoOnly.ts

@@ -0,0 +1,18 @@
+import { OnKeyDownEventArgs, SlickEventData } from "slickgrid";
+
+import { ISlickTable } from "shared/model/types";
+
+import { hotKeysRedo, hotKeysUndo } from "../../../../lib";
+import { HotKeysDecorator } from "./HotKeysDecorator";
+
+export class RedoUndoOnly extends HotKeysDecorator {
+	public handleKeyboardEvent(
+		event: SlickEventData<OnKeyDownEventArgs>,
+		table: ISlickTable,
+	): void {
+		if (!table.isActive) return;
+		if (hotKeysRedo(event) || hotKeysUndo(event)) {
+			super.handleKeyboardEvent.call(this, event, table);
+		}
+	}
+}

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/decorators/WithConfirmationOfDeletion.ts

@@ -0,0 +1,33 @@
+import { OnKeyDownEventArgs, SlickEventData } from "slickgrid";
+
+import { NO_PRIVILEGES_MESSAGE } from "shared/model/consts";
+import { ISlickTable } from "shared/model/types";
+import { showNotification } from "shared/ui/notification";
+
+import { hotKeysDelete, isDeletionDangerous } from "../../../../lib";
+import { HotKeysDecorator } from "./HotKeysDecorator";
+
+export class WithConfirmationOfDeletion extends HotKeysDecorator {
+	public handleKeyboardEvent(
+		event: SlickEventData<OnKeyDownEventArgs>,
+		table: ISlickTable,
+	): void {
+		if (!table.isActive) return;
+		if (hotKeysDelete(event)) {
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			// if (clientIsLocked()) return;
+			if (isDeletionDangerous(table)) {
+				if (this.getExternalVariables().isAllowed === false) {
+					showNotification(NO_PRIVILEGES_MESSAGE, "info");
+					return;
+				}
+				this.getExternalVariables().setIsDialogOpened(true);
+			} else {
+				super.handleKeyboardEvent.call(this, event, table);
+			}
+		} else {
+			super.handleKeyboardEvent.call(this, event, table);
+		}
+	}
+}

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

@@ -0,0 +1,4 @@
+export { HotKeysDecorator } from "./HotKeysDecorator";
+export { PreventCopying } from "./PreventCopying";
+export { RedoUndoOnly } from "./RedoUndoOnly";
+export { WithConfirmationOfDeletion } from "./WithConfirmationOfDeletion";

package/src/shared/lib/slickgrid/model/SlickTable/hotKeys/index.ts

@@ -0,0 +1,8 @@
+export { DefaultHotKeys } from "./DefaultHotKeys";
+export { WithoutHotKeys } from "./WithoutHotKeys";
+export {
+	HotKeysDecorator,
+	PreventCopying,
+	RedoUndoOnly,
+	WithConfirmationOfDeletion,
+} from "./decorators";

package/src/shared/lib/slickgrid/model/SlickTable/index.ts

@@ -0,0 +1,19 @@
+export { DownloadManager } from "./csvDownloadManager";
+export {
+	DefaultHotKeys,
+	HotKeysDecorator,
+	PreventCopying,
+	RedoUndoOnly,
+	WithConfirmationOfDeletion,
+	WithoutHotKeys,
+} from "./hotKeys";
+export {
+	DecoratorEndingDate,
+	DecoratorFilter,
+	DecoratorColumnFilter,
+	DecoratorPeriod,
+	DeletedRowsFilter,
+	Filter,
+} from "./filters";
+export { DefaultPrinter } from "./printer";
+export { SlickTable } from "./table";