slick-table 0.0.1

package/dist/shared/lib/slickgrid/index.js

@@ -0,0 +1,3 @@
+export { Autocomplete, ColumnSorter, DateFormatter, DateValidator, EditorAmount, EditorAutocomplete, EditorDate, EditorSelectString, EditorSelectNumber, EditorSelectWithSearch, EmptyStringValidator, FORMATTER_NUMBER, FormatterCheck, getFormatterNumber, LengthValidator, PercentFormatter, FormatterCheckPrinter, StringFormatter, columnSorter, commitCurrentEdit, deleteRows, getDisplayedRows, getLastRow, getMaxId, highlightCell, highlightColumns, isDeletionDangerous, onCellChange, onRowCountChanged, onRowsChanged, selectedRows, sumTotalsFormatter, totalAmountOf, updateTotals, useHotKeys, getUpdates, useListenIfTablesWereEdited, useUpdateTotal, wereEdited, } from "./lib";
+export { DownloadManager, DecoratorEndingDate, DecoratorFilter, DecoratorColumnFilter, DecoratorPeriod, DefaultHotKeys, DefaultPrinter, DeletedRowsFilter, Filter, PreventCopying, RedoUndoOnly, SlickTable, WithConfirmationOfDeletion, WithoutHotKeys, eventContextMenu, } from "./model";
+export { SlickgridTable, WithTableStyles, columnCheckboxSelector, columnIsEdited, eventOpenColumnFilters, handleHeaderButtons, headerButtons, openColumnFilter, } from "./ui";

package/dist/shared/lib/slickgrid/lib/callbacks/getOnKeyDownCallback.js

@@ -0,0 +1,7 @@
+import { EKeyCode } from "shared/model/enums";
+export const getOnKeyDownCallback = (grid) => (event) => {
+    if (event.keyCode === EKeyCode.KeyEnter) {
+        event.stopImmediatePropagation();
+        grid.navigateNext();
+    }
+};

package/dist/shared/lib/slickgrid/lib/callbacks/index.js

@@ -0,0 +1,4 @@
+export { getOnKeyDownCallback } from "./getOnKeyDownCallback";
+export { onCellChange } from "./onCellChange";
+export { onRowsChanged } from "./onRowsChanged";
+export { onRowCountChanged } from "./onRowCountChanged";

package/dist/shared/lib/slickgrid/lib/callbacks/onCellChange.js

@@ -0,0 +1,8 @@
+export const onCellChange = (table) => (_e, args) => {
+    const { grid, item } = args;
+    item.isEdited = true;
+    const dataView = grid.getData();
+    dataView.updateItem(item.id, item);
+    table.isEdited = true;
+    table.hotKeysBehavior.pushToCommandQueue(grid);
+};

package/dist/shared/lib/slickgrid/lib/callbacks/onRowCountChanged.js

@@ -0,0 +1,7 @@
+export const onRowCountChanged = (table) => () => {
+    const grid = table.grid;
+    if (!grid)
+        return;
+    grid.updateRowCount();
+    grid.render();
+};

package/dist/shared/lib/slickgrid/lib/callbacks/onRowsChanged.js

@@ -0,0 +1,4 @@
+export const onRowsChanged = (grid) => (_e, args) => {
+    grid.invalidateRows(args.rows);
+    grid.render();
+};

package/dist/shared/lib/slickgrid/lib/contextMenu/index.js

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

package/dist/shared/lib/slickgrid/lib/contextMenu/openContextMenu.js

@@ -0,0 +1,12 @@
+import { eventContextMenu } from "../../model";
+import { commitCurrentEdit } from "../functions";
+export function openContextMenu(table) {
+    return function (e) {
+        e.preventDefault();
+        commitCurrentEdit();
+        eventContextMenu.table = table;
+        eventContextMenu.x = e.pageX || 0;
+        eventContextMenu.y = e.pageY || 0;
+        eventContextMenu.notify();
+    };
+}

package/dist/shared/lib/slickgrid/lib/editors/Autocomplete/Autocomplete.js

@@ -0,0 +1,141 @@
+import { keyCode, } from "slickgrid";
+import { EKey } from "shared/model/enums";
+export class Autocomplete {
+    constructor() {
+        this.currentFocus = -1;
+        this.defaultValue = "";
+        this.id = "autocomplete";
+        this.input = document.createElement("input");
+        this.keyCaptureList = [keyCode.UP, keyCode.DOWN, keyCode.ENTER];
+    }
+    applyValue(item, state) {
+        item[this.args.column.field] = state;
+    }
+    closeAllList() {
+        this.list?.remove();
+        this.list = undefined;
+        this.currentFocus = -1;
+    }
+    destroy() {
+        this.input.removeEventListener("input", this.onInput.bind(this));
+        this.input.removeEventListener("keydown", this.onKeydown.bind(this));
+        this.closeAllList();
+        this.input.remove();
+    }
+    focus() {
+        this.input.focus();
+    }
+    init() {
+        this.navOnLR = this.args.grid.getOptions().editorCellNavOnLRKeys;
+        this.input.setAttribute("type", "text");
+        this.input.classList.add("editor-text");
+        this.args.container.append(this.input);
+        this.input.addEventListener("input", this.onInput.bind(this));
+        this.input.addEventListener("keydown", this.onKeydown.bind(this));
+        this.input.focus();
+        this.input.select();
+    }
+    isValueChanged() {
+        return (!(this.input.value == "" && this.defaultValue == null) &&
+            this.input.value != this.defaultValue);
+    }
+    loadValue(item) {
+        this.defaultValue = item[this.args.column.field] || "";
+        this.input.value = this.defaultValue;
+        this.input.defaultValue = this.defaultValue;
+        this.input.focus();
+        this.input.select();
+    }
+    makeVisible(list) {
+        const canvas = list.closest(".grid-canvas");
+        if (!canvas)
+            return;
+        const { bottom: listBottom, right: listRigth } = list.getBoundingClientRect();
+        const { bottom: canvasBottom, right: canvasRight } = canvas.getBoundingClientRect();
+        if (listBottom >= canvasBottom) {
+            const rowHeight = this.args.grid.getOptions().rowHeight;
+            list.style.position = "absolute";
+            list.style.bottom = `${rowHeight}px`;
+        }
+        if (listRigth >= canvasRight) {
+            list.style.position = "absolute";
+            list.style.right = "0";
+        }
+    }
+    onKeydown(event) {
+        if (event.key === EKey.ArrowLeft) {
+            this.navOnLR && this.args.grid.navigatePrev();
+            event.stopImmediatePropagation();
+            return;
+        }
+        else if (event.key === EKey.ArrowRight) {
+            this.navOnLR && this.args.grid.navigateNext();
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (!this.list)
+            return;
+        const items = this.list.getElementsByTagName("div");
+        if (event.key === EKey.ArrowDown) {
+            this.currentFocus++;
+            this.setActive(items);
+        }
+        else if (event.key === EKey.ArrowUp) {
+            this.currentFocus--;
+            this.setActive(items);
+        }
+        else if (event.key === EKey.Enter) {
+            event.preventDefault();
+            if (this.currentFocus > -1) {
+                /* simulate a click on the "active" item */
+                if (items)
+                    items[this.currentFocus].click();
+            }
+        }
+    }
+    removeActive(x) {
+        for (let i = 0; i < x.length; i++) {
+            x[i].classList.remove("active");
+        }
+    }
+    scrollToElement(child) {
+        const parent = child.parentElement;
+        if (!parent)
+            return;
+        const { clientHeight: childClientHeight, offsetTop } = child;
+        const { clientHeight: parentClientHeight, scrollTop } = parent;
+        if (offsetTop >= scrollTop + parentClientHeight) {
+            parent.scrollTop = offsetTop - childClientHeight * 1.5;
+        }
+        else if (offsetTop - childClientHeight <= scrollTop) {
+            parent.scrollTop = offsetTop - parentClientHeight;
+        }
+    }
+    serializeValue() {
+        return this.input.value;
+    }
+    setActive(list) {
+        if (!list.length)
+            return;
+        this.removeActive(list);
+        if (this.currentFocus >= list.length)
+            this.currentFocus = 0;
+        if (this.currentFocus < 0)
+            this.currentFocus = list.length - 1;
+        const activeElement = list[this.currentFocus];
+        activeElement.classList.add("active");
+        this.scrollToElement(activeElement);
+    }
+    validate() {
+        if (this.args.column.validator) {
+            const validationResults = this.args.column.validator(this.input.value, this.args);
+            if (!validationResults.valid) {
+                return validationResults;
+            }
+        }
+        return {
+            valid: true,
+            msg: null,
+        };
+    }
+}

package/dist/shared/lib/slickgrid/lib/editors/Autocomplete/EditorAutocomplete.js

@@ -0,0 +1,57 @@
+import { escapeSpecialChar } from "shared/lib/regexp";
+import { Autocomplete } from "./Autocomplete";
+export class EditorAutocomplete extends Autocomplete {
+    constructor(args) {
+        super();
+        this.args = args;
+        const column = this.args.column;
+        const optionsList = column.optionsList;
+        if (optionsList) {
+            this.suggestionsList = new Set(optionsList);
+        }
+        else {
+            this.suggestionsList = new Set();
+            const columnId = column.id;
+            const dataView = this.args.grid.getData();
+            const data = dataView.getItems();
+            data.forEach((el) => {
+                if (el[columnId])
+                    this.suggestionsList.add(el[columnId]);
+            });
+        }
+        this.init();
+        const item = this.args.item;
+        const initialValue = item[column.field];
+        if (!initialValue) {
+            this.showOptions("");
+        }
+    }
+    onInput(event) {
+        this.closeAllList();
+        this.currentFocus = -1;
+        this.showOptions(event.target.value);
+    }
+    onClick(event) {
+        const div = event.target;
+        this.input.value = div.getElementsByTagName("input")[0].value;
+        this.closeAllList();
+    }
+    showOptions(search) {
+        this.list = document.createElement("div");
+        this.list.setAttribute("id", this.id);
+        this.args.container.appendChild(this.list);
+        this.suggestionsList.forEach((name) => {
+            const hasOverlap = name.match(new RegExp(escapeSpecialChar(search), "i"));
+            if (hasOverlap) {
+                const overlap = hasOverlap[0];
+                const listItem = document.createElement("div");
+                listItem.innerHTML = `${name.replaceAll(overlap, `<strong>${overlap}</strong>`)}`;
+                /*insert an input field that will hold the current array item's value:*/
+                listItem.innerHTML += `<input type="hidden" value="${name}">`;
+                listItem.addEventListener("click", this.onClick.bind(this));
+                this.list?.appendChild(listItem);
+            }
+        });
+        this.makeVisible(this.list);
+    }
+}

package/dist/shared/lib/slickgrid/lib/editors/Autocomplete/EditorSelectWithSearch.js

@@ -0,0 +1,60 @@
+import { escapeSpecialChar } from "shared/lib/regexp";
+import { Autocomplete } from "./Autocomplete";
+export class EditorSelectWithSearch extends Autocomplete {
+    constructor(args) {
+        super();
+        this.args = args;
+        const column = this.args.column;
+        this.hash = column.selectOptions;
+        this.reversedHash = Object.entries(this.hash).reduce((acc, [key, value]) => {
+            acc[value] = key;
+            return acc;
+        }, {});
+        this.init();
+        const item = this.args.item;
+        const initialValue = item[column.field];
+        if (!initialValue) {
+            this.showOptions("");
+        }
+    }
+    applyValue(item, state) {
+        item[this.args.column.field] = this.reversedHash[state];
+    }
+    loadValue(item) {
+        this.defaultValue = this.hash[item[this.args.column.id]] || "";
+        this.input.value = this.defaultValue;
+        this.input.defaultValue = this.defaultValue;
+        this.input.focus();
+        this.input.select();
+    }
+    onInput(event) {
+        this.closeAllList();
+        this.currentFocus = -1;
+        this.showOptions(event.target.value);
+    }
+    onClick(event) {
+        const div = event.target.closest("div");
+        this.input.value = this.hash[div.getElementsByTagName("input")[0].value];
+        this.closeAllList();
+    }
+    showOptions(search) {
+        this.list = document.createElement("div");
+        this.list.setAttribute("id", this.id);
+        this.list.style.width = "fit-content";
+        this.list.style.textAlign = "left";
+        this.args.container.appendChild(this.list);
+        Object.entries(this.hash).forEach(([key, value]) => {
+            const hasOverlap = value.match(new RegExp(escapeSpecialChar(search), "i"));
+            if (hasOverlap) {
+                const overlap = hasOverlap[0];
+                const listItem = document.createElement("div");
+                listItem.innerHTML = `${value.replaceAll(overlap, `<strong>${overlap}</strong>`)}`;
+                // insert an input field that will hold the current array item's value
+                listItem.innerHTML += `<input type="hidden" value="${key}">`;
+                listItem.addEventListener("click", this.onClick.bind(this));
+                this.list?.appendChild(listItem);
+            }
+        });
+        this.makeVisible(this.list);
+    }
+}

package/dist/shared/lib/slickgrid/lib/editors/Autocomplete/index.js

@@ -0,0 +1,3 @@
+export { Autocomplete } from "./Autocomplete";
+export { EditorAutocomplete } from "./EditorAutocomplete";
+export { EditorSelectWithSearch } from "./EditorSelectWithSearch";

package/dist/shared/lib/slickgrid/lib/editors/EditorAmount.js

@@ -0,0 +1,70 @@
+import { FloatEditor } from "slickgrid";
+import { toNumber } from "shared/lib/numbers";
+import { stringCalculator } from "shared/lib/stringCalculator";
+const decimalPlaces = 2;
+export class EditorAmount extends FloatEditor {
+    isValueChanged() {
+        const prevValue = toNumber(this.defaultValue);
+        let newValue = 0;
+        try {
+            newValue = stringCalculator.parse(this.input.value || "0");
+        }
+        catch {
+            return true;
+        }
+        if (!newValue && !prevValue) {
+            return false;
+        }
+        else {
+            return newValue !== prevValue;
+        }
+    }
+    loadValue(item) {
+        const num = Number(item[this.args.column.field] || "0");
+        this.defaultValue = num.toFixed(decimalPlaces);
+        this.input.value = this.defaultValue;
+        this.input.defaultValue = this.input.value;
+        this.input.select();
+    }
+    serializeValue() {
+        let rtn = stringCalculator.parse(this.input.value || "0");
+        if (FloatEditor.AllowEmptyValue) {
+            if (!rtn && rtn !== 0) {
+                rtn = undefined;
+            }
+        }
+        else {
+            rtn = rtn || 0;
+        }
+        const decPlaces = this.getDecimalPlaces();
+        if (decPlaces !== null && (rtn || rtn === 0) && rtn.toFixed) {
+            rtn = parseFloat(rtn.toFixed(decPlaces));
+        }
+        return rtn;
+    }
+    validate() {
+        let value = 0;
+        try {
+            value = stringCalculator.parse(`${this.input.value}`);
+            if (value === Infinity)
+                throw new Error();
+        }
+        catch {
+            return {
+                valid: false,
+                msg: "Please enter a valid number",
+            };
+        }
+        if (this.args.column.validator) {
+            const validationResults = this.args.column.validator(value, this.args);
+            if (!validationResults.valid) {
+                return validationResults;
+            }
+        }
+        return {
+            valid: true,
+            msg: null,
+        };
+    }
+}
+EditorAmount.DefaultDecimalPlaces = decimalPlaces;

package/dist/shared/lib/slickgrid/lib/editors/EditorDate.js

@@ -0,0 +1,101 @@
+import moment from "moment";
+import Pikaday from "pikaday";
+import { keyCode, } from "slickgrid";
+import { Dates } from "shared/lib/regexp";
+import { EDateFormat, EKey } from "shared/model/enums";
+export class EditorDate {
+    constructor(args) {
+        this.args = args;
+        this.defaultDate = "";
+        this.input = document.createElement("input");
+        this.keyCaptureList = [
+            keyCode.UP,
+            keyCode.DOWN,
+            keyCode.LEFT,
+            keyCode.RIGHT,
+            keyCode.ENTER,
+        ];
+        this.picker = new Pikaday({
+            field: this.input,
+            format: EDateFormat.ui,
+            blurFieldOnSelect: false,
+        });
+        this.init();
+    }
+    addDelimiters(event) {
+        const value = event.target.value.slice(0, EDateFormat.ui.length);
+        const onlyDigits = value.replace(/\D/g, "");
+        const withSlashed = onlyDigits.replace(/.{2}/g, (match) => {
+            return `${match}/`;
+        });
+        this.input.value = withSlashed.replace(/\/$/, "");
+    }
+    applyValue(item, state) {
+        const fullDate = Dates.MD.test(state) ? this.withYear(state) : state;
+        item[this.args.column.field] = moment(fullDate, [EDateFormat.ui]).format(EDateFormat.db);
+    }
+    destroy() {
+        this.input.removeEventListener("keydown", this.onKeydown.bind(this));
+        this.input.removeEventListener("input", this.addDelimiters.bind(this));
+        this.input.remove();
+    }
+    focus() {
+        this.input.focus();
+    }
+    init() {
+        this.input.classList.add("editor-text");
+        this.input.setAttribute("type", "text");
+        this.input.setAttribute("id", "datepicker");
+        this.input.setAttribute("autocomplete", "off");
+        this.input.addEventListener("keydown", this.onKeydown.bind(this));
+        this.input.addEventListener("input", this.addDelimiters.bind(this));
+        this.args.container.append(this.input);
+        this.initializePicker();
+        this.focus();
+    }
+    initializePicker() {
+        this.picker.setDate(new Date(this.args.item.date));
+    }
+    isValueChanged() {
+        return (!(this.input.value === "" && this.defaultDate === null) &&
+            this.input.value !== this.defaultDate);
+    }
+    loadValue(item) {
+        const initialValue = item[this.args.column.field];
+        if (initialValue) {
+            this.defaultDate = moment(initialValue).format(EDateFormat.ui);
+            this.input.value = this.defaultDate;
+        }
+        this.input.select();
+    }
+    onKeydown(event) {
+        if (event.key === EKey.Control) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this.picker?.isVisible() ? this.picker?.hide() : this.picker?.show();
+        }
+    }
+    serializeValue() {
+        return this.input.value;
+    }
+    validate() {
+        if (this.args.column.validator) {
+            const value = this.input.value;
+            return this.args.column.validator(Dates.MD.test(value) ? this.withYear(value) : value);
+        }
+        return {
+            valid: true,
+        };
+    }
+    /** add year to change date string from MM/DD to MM/DD/YY */
+    withYear(state) {
+        const dataView = this.args.grid.getData();
+        const filterArgs = dataView.getFilterArgs();
+        const startDate = filterArgs.startDate;
+        const year = moment(startDate).unix()
+            ? moment(startDate).year()
+            : new Date().getFullYear();
+        const twoDigitYear = `${year}`.slice(2);
+        return `${state}/${twoDigitYear}`;
+    }
+}

package/dist/shared/lib/slickgrid/lib/editors/EditorSelectNumber.js

@@ -0,0 +1,7 @@
+import { EditorSelectString } from "./EditorSelectString";
+/** @description The final value is of type number */
+export class EditorSelectNumber extends EditorSelectString {
+    applyValue(item, state) {
+        item[this.args.column.field] = Number(state);
+    }
+}

package/dist/shared/lib/slickgrid/lib/editors/EditorSelectString.js

@@ -0,0 +1,70 @@
+import { keyCode, } from "slickgrid";
+/** @description The final value is of type string */
+export class EditorSelectString {
+    constructor(args) {
+        this.args = args;
+        this.defaultOptions = { Yes: "Yes", No: "No" };
+        this.defaultValue = "";
+        this.keyCaptureList = [keyCode.UP, keyCode.DOWN, keyCode.ENTER];
+        this.select = document.createElement("select");
+        this.init();
+    }
+    init() {
+        this.select.classList.add("editor-yesno");
+        this.select.setAttribute("tabIndex", "0");
+        this.select.append(...sorted(this.htmlOptionElements()));
+        this.args.container.append(this.select);
+        this.select.focus();
+    }
+    htmlOptionElements() {
+        const column = this.args.column;
+        const selectOptions = column.selectOptions || this.defaultOptions;
+        const result = [];
+        for (const key in selectOptions) {
+            const option = document.createElement("option");
+            option.value = key;
+            option.innerText = `${selectOptions[key]}`;
+            result.push(option);
+        }
+        return result;
+    }
+    destroy() {
+        this.select.remove();
+    }
+    focus() {
+        this.select.focus();
+    }
+    loadValue(item) {
+        this.defaultValue = item[this.args.column.field];
+        this.select.value = `${this.defaultValue}`;
+    }
+    serializeValue() {
+        return this.select.value;
+    }
+    applyValue(item, state) {
+        item[this.args.column.field] = state;
+    }
+    isValueChanged() {
+        if (!this.select.value && !this.defaultValue) {
+            return false;
+        }
+        else {
+            return this.select.value != this.defaultValue;
+        }
+    }
+    validate() {
+        if (this.args.column.validator) {
+            return this.args.column.validator(this.select.value, this.args);
+        }
+        return { valid: true };
+    }
+}
+function sorted(options) {
+    return options.sort((a, b) => {
+        if (a.innerText.toLowerCase() > b.innerText.toLowerCase())
+            return 1;
+        if (a.innerText.toLowerCase() < b.innerText.toLowerCase())
+            return -1;
+        return 0;
+    });
+}

package/dist/shared/lib/slickgrid/lib/editors/index.js

@@ -0,0 +1,5 @@
+export { EditorAmount } from "./EditorAmount";
+export { Autocomplete, EditorAutocomplete, EditorSelectWithSearch, } from "./Autocomplete";
+export { EditorDate } from "./EditorDate";
+export { EditorSelectString } from "./EditorSelectString";
+export { EditorSelectNumber } from "./EditorSelectNumber";

package/dist/shared/lib/slickgrid/lib/formatters/DateFormatter.js

@@ -0,0 +1,4 @@
+import { dateToString } from "shared/lib/datetime";
+export const DateFormatter = (_row, _cell, value) => {
+    return dateToString(value);
+};

package/dist/shared/lib/slickgrid/lib/formatters/FormatterCheck.js

@@ -0,0 +1,6 @@
+export const FormatterCheck = (_row, _cell, value) => {
+    return value ? "<span class='sgi sgi-check'></span>" : "";
+};
+export function FormatterCheckPrinter(_row, _cell, value) {
+    return value ? "yes" : "";
+}

package/dist/shared/lib/slickgrid/lib/formatters/PercentFormatter.js

@@ -0,0 +1,4 @@
+export const PercentFormatter = function (_row, _cell, value) {
+    const val = value ?? "";
+    return val === "" ? "" : `${val?.toFixed(2)}%`;
+};

package/dist/shared/lib/slickgrid/lib/formatters/StringFormatter.js

@@ -0,0 +1 @@
+export const StringFormatter = (_row, _cell, value) => value;

package/dist/shared/lib/slickgrid/lib/formatters/getFormatterNumber.js

@@ -0,0 +1,9 @@
+import { formatNumber } from "shared/lib/format";
+export function getFormatterNumber(options) {
+    // function name should match FORMATTER_NUMBER value
+    return function FormatterNumber(_row, _cell, value) {
+        return formatNumber(value, options);
+    };
+}
+// value should match function name
+export const FORMATTER_NUMBER = "FormatterNumber";

package/dist/shared/lib/slickgrid/lib/formatters/index.js

@@ -0,0 +1,5 @@
+export { DateFormatter } from "./DateFormatter";
+export { FormatterCheck, FormatterCheckPrinter } from "./FormatterCheck";
+export { FORMATTER_NUMBER, getFormatterNumber } from "./getFormatterNumber";
+export { PercentFormatter } from "./PercentFormatter";
+export { StringFormatter } from "./StringFormatter";

package/dist/shared/lib/slickgrid/lib/functions/addNewRow.js

@@ -0,0 +1,16 @@
+import { getLastRow } from "./getLastRow";
+import { getMaxId } from "./getMaxId";
+export const addNewRow = (grid, item, clientId) => {
+    const dataView = grid.getData();
+    const lastRow = getLastRow(dataView);
+    const maxId = getMaxId(grid);
+    const newRow = {
+        ...lastRow,
+        ...item,
+        id: maxId + 1,
+        isEdited: true,
+        isNew: true,
+        clientId,
+    };
+    dataView.addItem(newRow);
+};

package/dist/shared/lib/slickgrid/lib/functions/commitCurrentEdit.js

@@ -0,0 +1,5 @@
+import { SlickGlobalEditorLock } from "slickgrid";
+export const commitCurrentEdit = () => {
+    // apply cell edit value
+    SlickGlobalEditorLock.commitCurrentEdit();
+};