px-jspreadsheet-ce 0.0.1

package/src/utils/merges.js

@@ -0,0 +1,275 @@
+import jSuites from 'jsuites';
+
+import { getColumnNameFromId, getIdFromColumnName } from './internalHelpers.js';
+import { updateCell } from './internal.js';
+import { setHistory } from './history.js';
+import dispatch from './dispatch.js';
+import { updateSelection } from './selection.js';
+
+/**
+ * Is column merged
+ */
+export const isColMerged = function (x, insertBefore) {
+    const obj = this;
+
+    const cols = [];
+    // Remove any merged cells
+    if (obj.options.mergeCells) {
+        const keys = Object.keys(obj.options.mergeCells);
+        for (let i = 0; i < keys.length; i++) {
+            const info = getIdFromColumnName(keys[i], true);
+            const colspan = obj.options.mergeCells[keys[i]][0];
+            const x1 = info[0];
+            const x2 = info[0] + (colspan > 1 ? colspan - 1 : 0);
+
+            if (insertBefore == null) {
+                if (x1 <= x && x2 >= x) {
+                    cols.push(keys[i]);
+                }
+            } else {
+                if (insertBefore) {
+                    if (x1 < x && x2 >= x) {
+                        cols.push(keys[i]);
+                    }
+                } else {
+                    if (x1 <= x && x2 > x) {
+                        cols.push(keys[i]);
+                    }
+                }
+            }
+        }
+    }
+
+    return cols;
+};
+
+/**
+ * Is rows merged
+ */
+export const isRowMerged = function (y, insertBefore) {
+    const obj = this;
+
+    const rows = [];
+    // Remove any merged cells
+    if (obj.options.mergeCells) {
+        const keys = Object.keys(obj.options.mergeCells);
+        for (let i = 0; i < keys.length; i++) {
+            const info = getIdFromColumnName(keys[i], true);
+            const rowspan = obj.options.mergeCells[keys[i]][1];
+            const y1 = info[1];
+            const y2 = info[1] + (rowspan > 1 ? rowspan - 1 : 0);
+
+            if (insertBefore == null) {
+                if (y1 <= y && y2 >= y) {
+                    rows.push(keys[i]);
+                }
+            } else {
+                if (insertBefore) {
+                    if (y1 < y && y2 >= y) {
+                        rows.push(keys[i]);
+                    }
+                } else {
+                    if (y1 <= y && y2 > y) {
+                        rows.push(keys[i]);
+                    }
+                }
+            }
+        }
+    }
+
+    return rows;
+};
+
+/**
+ * Merge cells
+ * @param cellName
+ * @param colspan
+ * @param rowspan
+ * @param ignoreHistoryAndEvents
+ */
+export const getMerge = function (cellName) {
+    const obj = this;
+
+    let data = {};
+    if (cellName) {
+        if (obj.options.mergeCells && obj.options.mergeCells[cellName]) {
+            data = [obj.options.mergeCells[cellName][0], obj.options.mergeCells[cellName][1]];
+        } else {
+            data = null;
+        }
+    } else {
+        if (obj.options.mergeCells) {
+            var mergedCells = obj.options.mergeCells;
+            const keys = Object.keys(obj.options.mergeCells);
+            for (let i = 0; i < keys.length; i++) {
+                data[keys[i]] = [obj.options.mergeCells[keys[i]][0], obj.options.mergeCells[keys[i]][1]];
+            }
+        }
+    }
+
+    return data;
+};
+
+/**
+ * Merge cells
+ * @param cellName
+ * @param colspan
+ * @param rowspan
+ * @param ignoreHistoryAndEvents
+ */
+export const setMerge = function (cellName, colspan, rowspan, ignoreHistoryAndEvents) {
+    const obj = this;
+
+    let test = false;
+
+    if (!cellName) {
+        if (!obj.highlighted.length) {
+            alert(jSuites.translate('No cells selected'));
+            return null;
+        } else {
+            const x1 = parseInt(obj.highlighted[0].getAttribute('data-x'));
+            const y1 = parseInt(obj.highlighted[0].getAttribute('data-y'));
+            const x2 = parseInt(obj.highlighted[obj.highlighted.length - 1].getAttribute('data-x'));
+            const y2 = parseInt(obj.highlighted[obj.highlighted.length - 1].getAttribute('data-y'));
+            cellName = getColumnNameFromId([x1, y1]);
+            colspan = x2 - x1 + 1;
+            rowspan = y2 - y1 + 1;
+        }
+    } else if (typeof cellName !== 'string') {
+        return null;
+    }
+
+    const cell = getIdFromColumnName(cellName, true);
+
+    if (obj.options.mergeCells && obj.options.mergeCells[cellName]) {
+        if (obj.records[cell[1]][cell[0]].element.getAttribute('data-merged')) {
+            test = 'Cell already merged';
+        }
+    } else if ((!colspan || colspan < 2) && (!rowspan || rowspan < 2)) {
+        test = 'Invalid merged properties';
+    } else {
+        var cells = [];
+        for (let j = cell[1]; j < cell[1] + rowspan; j++) {
+            for (let i = cell[0]; i < cell[0] + colspan; i++) {
+                var columnName = getColumnNameFromId([i, j]);
+                if (obj.records[j][i].element.getAttribute('data-merged')) {
+                    test = 'There is a conflict with another merged cell';
+                }
+            }
+        }
+    }
+
+    if (test) {
+        alert(jSuites.translate(test));
+    } else {
+        // Add property
+        if (colspan > 1) {
+            obj.records[cell[1]][cell[0]].element.setAttribute('colspan', colspan);
+        } else {
+            colspan = 1;
+        }
+        if (rowspan > 1) {
+            obj.records[cell[1]][cell[0]].element.setAttribute('rowspan', rowspan);
+        } else {
+            rowspan = 1;
+        }
+        // Keep links to the existing nodes
+        if (!obj.options.mergeCells) {
+            obj.options.mergeCells = {};
+        }
+
+        obj.options.mergeCells[cellName] = [colspan, rowspan, []];
+        // Mark cell as merged
+        obj.records[cell[1]][cell[0]].element.setAttribute('data-merged', 'true');
+        // Overflow
+        obj.records[cell[1]][cell[0]].element.style.overflow = 'hidden';
+        // History data
+        const data = [];
+        // Adjust the nodes
+        for (let y = cell[1]; y < cell[1] + rowspan; y++) {
+            for (let x = cell[0]; x < cell[0] + colspan; x++) {
+                if (!(cell[0] == x && cell[1] == y)) {
+                    data.push(obj.options.data[y][x]);
+                    updateCell.call(obj, x, y, '', true);
+                    obj.options.mergeCells[cellName][2].push(obj.records[y][x].element);
+                    obj.records[y][x].element.style.display = 'none';
+                    obj.records[y][x].element = obj.records[cell[1]][cell[0]].element;
+                }
+            }
+        }
+        // In the initialization is not necessary keep the history
+        updateSelection.call(obj, obj.records[cell[1]][cell[0]].element);
+
+        if (!ignoreHistoryAndEvents) {
+            setHistory.call(obj, {
+                action: 'setMerge',
+                column: cellName,
+                colspan: colspan,
+                rowspan: rowspan,
+                data: data,
+            });
+
+            dispatch.call(obj, 'onmerge', obj, { [cellName]: [colspan, rowspan] });
+        }
+    }
+};
+
+/**
+ * Remove merge by cellname
+ * @param cellName
+ */
+export const removeMerge = function (cellName, data, keepOptions) {
+    const obj = this;
+
+    if (obj.options.mergeCells && obj.options.mergeCells[cellName]) {
+        const beforeMerges = { [cellName]: obj.options.mergeCells[cellName] };
+        const cell = getIdFromColumnName(cellName, true);
+        obj.records[cell[1]][cell[0]].element.removeAttribute('colspan');
+        obj.records[cell[1]][cell[0]].element.removeAttribute('rowspan');
+        obj.records[cell[1]][cell[0]].element.removeAttribute('data-merged');
+        const info = obj.options.mergeCells[cellName];
+
+        let index = 0;
+
+        let j, i;
+
+        for (j = 0; j < info[1]; j++) {
+            for (i = 0; i < info[0]; i++) {
+                if (j > 0 || i > 0) {
+                    obj.records[cell[1] + j][cell[0] + i].element = info[2][index];
+                    obj.records[cell[1] + j][cell[0] + i].element.style.display = '';
+                    // Recover data
+                    if (data && data[index]) {
+                        updateCell.call(obj, cell[0] + i, cell[1] + j, data[index]);
+                    }
+                    index++;
+                }
+            }
+        }
+
+        // Update selection
+        updateSelection.call(obj, obj.records[cell[1]][cell[0]].element, obj.records[cell[1] + j - 1][cell[0] + i - 1].element);
+
+        if (!keepOptions) {
+            delete obj.options.mergeCells[cellName];
+        }
+
+        dispatch.call(obj, 'onunmerge', obj, cellName, beforeMerges);
+    }
+};
+
+/**
+ * Remove all merged cells
+ */
+export const destroyMerge = function (keepOptions) {
+    const obj = this;
+
+    // Remove any merged cells
+    if (obj.options.mergeCells) {
+        var mergedCells = obj.options.mergeCells;
+        const keys = Object.keys(obj.options.mergeCells);
+        for (let i = 0; i < keys.length; i++) {
+            removeMerge.call(obj, keys[i], null, keepOptions);
+        }
+    }
+};

package/src/utils/meta.js

@@ -0,0 +1,81 @@
+import dispatch from './dispatch.js';
+
+/**
+ * Get meta information from cell(s)
+ *
+ * @return integer
+ */
+export const getMeta = function (cell, key) {
+    const obj = this;
+
+    if (!cell) {
+        return obj.options.meta;
+    } else {
+        if (key) {
+            return obj.options.meta && obj.options.meta[cell] && obj.options.meta[cell][key] ? obj.options.meta[cell][key] : null;
+        } else {
+            return obj.options.meta && obj.options.meta[cell] ? obj.options.meta[cell] : null;
+        }
+    }
+};
+
+/**
+ * Update meta information
+ *
+ * @return integer
+ */
+export const updateMeta = function (affectedCells) {
+    const obj = this;
+
+    if (obj.options.meta) {
+        const newMeta = {};
+        const keys = Object.keys(obj.options.meta);
+        for (let i = 0; i < keys.length; i++) {
+            if (affectedCells[keys[i]]) {
+                newMeta[affectedCells[keys[i]]] = obj.options.meta[keys[i]];
+            } else {
+                newMeta[keys[i]] = obj.options.meta[keys[i]];
+            }
+        }
+        // Update meta information
+        obj.options.meta = newMeta;
+    }
+};
+
+/**
+ * Set meta information to cell(s)
+ *
+ * @return integer
+ */
+export const setMeta = function (o, k, v) {
+    const obj = this;
+
+    if (!obj.options.meta) {
+        obj.options.meta = {};
+    }
+
+    if (k && v) {
+        // Set data value
+        if (!obj.options.meta[o]) {
+            obj.options.meta[o] = {};
+        }
+        obj.options.meta[o][k] = v;
+
+        dispatch.call(obj, 'onchangemeta', obj, { [o]: { [k]: v } });
+    } else {
+        // Apply that for all cells
+        const keys = Object.keys(o);
+        for (let i = 0; i < keys.length; i++) {
+            if (!obj.options.meta[keys[i]]) {
+                obj.options.meta[keys[i]] = {};
+            }
+
+            const prop = Object.keys(o[keys[i]]);
+            for (let j = 0; j < prop.length; j++) {
+                obj.options.meta[keys[i]][prop[j]] = o[keys[i]][prop[j]];
+            }
+        }
+
+        dispatch.call(obj, 'onchangemeta', obj, o);
+    }
+};

package/src/utils/orderBy.js

@@ -0,0 +1,185 @@
+import jSuites from 'jsuites';
+import { setHistory } from './history.js';
+import dispatch from './dispatch.js';
+import { updateTableReferences } from './internal.js';
+import { loadPage } from './lazyLoading.js';
+import { closeFilter } from './filter.js';
+
+/**
+ * Update order arrow
+ */
+export const updateOrderArrow = function (column, order) {
+    const obj = this;
+
+    // Remove order
+    for (let i = 0; i < obj.headers.length; i++) {
+        obj.headers[i].classList.remove('arrow-up');
+        obj.headers[i].classList.remove('arrow-down');
+    }
+
+    // No order specified then toggle order
+    if (order) {
+        obj.headers[column].classList.add('arrow-up');
+    } else {
+        obj.headers[column].classList.add('arrow-down');
+    }
+};
+
+/**
+ * Update rows position
+ */
+export const updateOrder = function (rows) {
+    const obj = this;
+
+    // History
+    let data = [];
+    for (let j = 0; j < rows.length; j++) {
+        data[j] = obj.options.data[rows[j]];
+    }
+    obj.options.data = data;
+
+    data = [];
+    for (let j = 0; j < rows.length; j++) {
+        data[j] = obj.records[rows[j]];
+
+        for (let i = 0; i < data[j].length; i++) {
+            data[j][i].y = j;
+        }
+    }
+    obj.records = data;
+
+    data = [];
+    for (let j = 0; j < rows.length; j++) {
+        data[j] = obj.rows[rows[j]];
+        data[j].y = j;
+    }
+    obj.rows = data;
+
+    // Update references
+    updateTableReferences.call(obj);
+
+    // Redo search
+    if (obj.results && obj.results.length) {
+        if (obj.searchInput.value) {
+            obj.search(obj.searchInput.value);
+        } else {
+            closeFilter.call(obj);
+        }
+    } else {
+        // Create page
+        obj.results = null;
+        obj.pageNumber = 0;
+
+        if (obj.options.pagination > 0) {
+            obj.page(0);
+        } else if (obj.options.lazyLoading == true) {
+            loadPage.call(obj, 0);
+        } else {
+            for (let j = 0; j < obj.rows.length; j++) {
+                obj.tbody.appendChild(obj.rows[j].element);
+            }
+        }
+    }
+};
+
+/**
+ * Sort data and reload table
+ */
+export const orderBy = function (column, order) {
+    const obj = this;
+
+    if (column >= 0) {
+        // Merged cells
+        if (obj.options.mergeCells && Object.keys(obj.options.mergeCells).length > 0) {
+            if (!confirm(jSuites.translate('This action will destroy any existing merged cells. Are you sure?'))) {
+                return false;
+            } else {
+                // Remove merged cells
+                obj.destroyMerge();
+            }
+        }
+
+        // Direction
+        if (order == null) {
+            order = obj.headers[column].classList.contains('arrow-down') ? 1 : 0;
+        } else {
+            order = order ? 1 : 0;
+        }
+
+        // Test order
+        let temp = [];
+        if (
+            obj.options.columns &&
+            obj.options.columns[column] &&
+            (obj.options.columns[column].type == 'number' ||
+                obj.options.columns[column].type == 'numeric' ||
+                obj.options.columns[column].type == 'percentage' ||
+                obj.options.columns[column].type == 'autonumber' ||
+                obj.options.columns[column].type == 'color')
+        ) {
+            for (let j = 0; j < obj.options.data.length; j++) {
+                temp[j] = [j, Number(obj.options.data[j][column])];
+            }
+        } else if (
+            obj.options.columns &&
+            obj.options.columns[column] &&
+            (obj.options.columns[column].type == 'calendar' || obj.options.columns[column].type == 'checkbox' || obj.options.columns[column].type == 'radio')
+        ) {
+            for (let j = 0; j < obj.options.data.length; j++) {
+                temp[j] = [j, obj.options.data[j][column]];
+            }
+        } else {
+            for (let j = 0; j < obj.options.data.length; j++) {
+                temp[j] = [j, obj.records[j][column].element.textContent.toLowerCase()];
+            }
+        }
+
+        // Default sorting method
+        if (typeof obj.parent.config.sorting !== 'function') {
+            obj.parent.config.sorting = function (direction) {
+                return function (a, b) {
+                    const valueA = a[1];
+                    const valueB = b[1];
+
+                    if (!direction) {
+                        return valueA === '' && valueB !== '' ? 1 : valueA !== '' && valueB === '' ? -1 : valueA > valueB ? 1 : valueA < valueB ? -1 : 0;
+                    } else {
+                        return valueA === '' && valueB !== '' ? 1 : valueA !== '' && valueB === '' ? -1 : valueA > valueB ? -1 : valueA < valueB ? 1 : 0;
+                    }
+                };
+            };
+        }
+
+        temp = temp.sort(obj.parent.config.sorting(order));
+
+        // Save history
+        const newValue = [];
+        for (let j = 0; j < temp.length; j++) {
+            newValue[j] = temp[j][0];
+        }
+
+        // Save history
+        setHistory.call(obj, {
+            action: 'orderBy',
+            rows: newValue,
+            column: column,
+            order: order,
+        });
+
+        // Update order
+        updateOrderArrow.call(obj, column, order);
+        updateOrder.call(obj, newValue);
+
+        // On sort event
+        dispatch.call(
+            obj,
+            'onsort',
+            obj,
+            column,
+            order,
+            newValue.map((row) => row)
+        );
+
+        return true;
+    }
+};