@sme.up/ketchup 4.3.0-SNAPSHOT → 5.1.0-SNAPSHOT

package/dist/collection/managers/kup-data/kup-data.js

@@ -0,0 +1,382 @@
+import { KupDataNewColumnTypes, } from './kup-data-declarations';
+import { findCell, getCellValue, replaceCell } from './kup-data-cell-helper';
+import { findColumns, hideColumns, newColumn } from './kup-data-column-helper';
+import { findRow, toNode } from './kup-data-row-helper';
+import { removeNode, setPropertiesNode, toStreamNode, } from './kup-data-node-helper';
+import { fieldColumn } from '../../components/kup-data-table/kup-data-table-declarations';
+import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
+const dom = document.documentElement;
+/**
+ * Handles data operations.
+ * @module KupData
+ */
+export class KupData {
+  constructor() {
+    this.cell = {
+      find(dataset, filters) {
+        return findCell(dataset, filters);
+      },
+      getValue(dataset, columns) {
+        return getCellValue(dataset, columns);
+      },
+      replace(dataset, cell, columns) {
+        return replaceCell(dataset, cell, columns);
+      },
+    };
+    this.column = {
+      find(dataset, filters) {
+        return findColumns(dataset, filters);
+      },
+      hide(dataset, columns2hide) {
+        return hideColumns(dataset, columns2hide);
+      },
+      new(dataset, type, options) {
+        return newColumn(dataset, type, options);
+      },
+    };
+    this.node = {
+      remove(nodes, node2remove) {
+        return removeNode(nodes, node2remove);
+      },
+      setProperties(nodes, properties, recursively, exclude) {
+        return setPropertiesNode(nodes, properties, recursively, exclude);
+      },
+      toStream(nodes) {
+        return toStreamNode(nodes);
+      },
+    };
+    this.row = {
+      find(dataset, filters) {
+        return findRow(dataset, filters);
+      },
+      toNode(dataset) {
+        return toNode(dataset);
+      },
+    };
+  }
+  /**
+   * Utility used by findRow and findCell.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataFindCellFilters} filters - Filters of the research.
+   * @returns {{cells: KupDataCell[], rows: KupDataRow[]}}  Object containing rows and cells.
+   */
+  finder(dataset, filters) {
+    const columns = filters ? filters.columns : null;
+    const range = filters ? filters.range : null;
+    const value = filters ? filters.value : null;
+    const min = range && range.min ? range.min : null;
+    const max = range && range.max ? range.max : null;
+    const result = {
+      cells: [],
+      rows: [],
+    };
+    for (let index = 0; index < dataset.rows.length; index++) {
+      const row = dataset.rows[index];
+      const cells = row.cells;
+      for (const key in cells) {
+        const cell = cells[key];
+        if (!columns || !columns.length || columns.includes(key)) {
+          if (min && max) {
+            let d = null, s = '', n = 0;
+            if (dom.ketchup.objects.isDate(cell.obj)) {
+              d = dom.ketchup.dates.toDate(cell.value);
+              const dMax = dom.ketchup.dates.toDate(max instanceof String ? max.valueOf() : max);
+              const dMin = dom.ketchup.dates.toDate(min instanceof String ? min.valueOf() : min);
+              if (d === dMax ||
+                d === dMin ||
+                (d < dMax && d > dMin)) {
+                result.cells.push(cell);
+                result.rows.push(row);
+              }
+            }
+            else if (typeof min === 'string' ||
+              min instanceof String) {
+              s = cell.value;
+              if (s === max ||
+                s === min ||
+                (s < max && s > min)) {
+                result.cells.push(cell);
+                result.rows.push(row);
+              }
+            }
+            else {
+              n = dom.ketchup.math.numberify(cell.value);
+              if (n === max ||
+                n === min ||
+                (n < max && n > min)) {
+                result.cells.push(cell);
+                result.rows.push(row);
+              }
+            }
+          }
+          else if (value === cell.value) {
+            result.cells.push(cell);
+            result.rows.push(row);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Creates a new dataset with an amount of cells equal to a distinct calculation applied to the given columns.
+   * The original value of cells will be stored in the title property of the new cells.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {string[]} columns - Column names to manage. When missing, defaults to all columns.
+   * @param {KupDataColumn} valuesColumn - When present, this column will be included in the final dataset containing the original values of the cells.
+   * @returns {KupDataDataset} New dataset with processed data.
+   */
+  distinct(dataset, columns, valuesColumn) {
+    const occurrencies = {};
+    const rows = dataset.rows;
+    for (let index = 0; index < rows.length; index++) {
+      const row = rows[index];
+      const cells = row.cells;
+      for (const key in cells) {
+        const cell = cells[key];
+        if (!columns ||
+          !columns.length ||
+          (columns && columns.includes(key))) {
+          if (!occurrencies[key]) {
+            occurrencies[key] = {};
+          }
+          const occurrency = occurrencies[key];
+          occurrency[cell.value] = occurrency[cell.value]
+            ? occurrency[cell.value] + 1
+            : 1;
+        }
+      }
+    }
+    const newColumns = [];
+    const newRows = [];
+    if (valuesColumn) {
+      newColumns.push(valuesColumn);
+    }
+    for (const key in occurrencies) {
+      const occurrency = occurrencies[key];
+      const column = Object.assign({}, dataset.columns.find((col) => col.name === key));
+      column.obj = {
+        t: 'NR',
+        p: '',
+        k: '',
+      };
+      let rowIndex = 0;
+      newColumns.push(column);
+      for (const j in occurrency) {
+        const value = occurrency[j];
+        let row = null;
+        if (!newRows[rowIndex]) {
+          newRows[rowIndex] = { cells: {} };
+        }
+        row = newRows[rowIndex];
+        row.cells[key] = {
+          obj: {
+            t: 'NR',
+            p: '',
+            k: value.toString(),
+          },
+          title: j,
+          value: value.toString(),
+        };
+        if (valuesColumn) {
+          row.cells[valuesColumn.name] = {
+            value: j,
+          };
+        }
+        rowIndex++;
+      }
+    }
+    return {
+      columns: newColumns,
+      rows: newRows,
+    };
+  }
+  /**
+   * Creates a new dataset from the input one.
+   * The new columns are to be specified in the columns argument along with their creation criteria.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataNewColumn[]} newColumns - Array containing the specifics of the new columns to be created.
+   * @returns {KupDataDataset} Resulting dataset.
+   */
+  new(dataset, newColumns) {
+    const outputColumns = [];
+    const outputRows = [];
+    for (let index = 0; index < newColumns.length; index++) {
+      const newColumn = newColumns[index].column;
+      const criteria = newColumns[index].criteria;
+      const cells = findCell(dataset, criteria);
+      let rowIndex = 0;
+      for (let index = 0; index < cells.length; index++) {
+        const cell = cells[index];
+        let outputRow = null;
+        if (!outputRows[rowIndex]) {
+          outputRows[rowIndex] = { cells: {} };
+        }
+        outputRow = outputRows[rowIndex];
+        outputRow.cells[newColumn.name] = JSON.parse(JSON.stringify(cell));
+        rowIndex++;
+      }
+      outputColumns.push(newColumn);
+    }
+    return {
+      columns: outputColumns,
+      rows: outputRows,
+    };
+  }
+  /**
+   * Performs a distinct/count after previously grouping columns by ranges.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataNewColumn[]} rangeColumns - A list of columns coupled with their criteria for creation. These are used to define ranges.
+   * @param {KupDataColumn} resultingColumn - The resulting column.
+   * @param {KupDataColumn} valuesColumn - When present, this column will be included in the final dataset containing the original values of the cells.
+   * @returns {KupDataDataset} New dataset with processed data.
+   */
+  rangedDistinct(dataset, rangeColumns, resultingColumn, valuesColumn) {
+    const newD = this.new(dataset, rangeColumns);
+    const columnNames = [];
+    for (let index = 0; index < rangeColumns.length; index++) {
+      const newColumn = rangeColumns[index].column;
+      columnNames.push(newColumn.name);
+      replaceCell(newD, { value: newColumn.title }, [newColumn.name]);
+    }
+    newColumn(newD, KupDataNewColumnTypes.MERGE, {
+      columns: columnNames,
+      newColumn: resultingColumn,
+    });
+    return this.distinct(newD, null, valuesColumn);
+  }
+  /**
+   * Creates a new dataset with sorted elements.
+   * @param {KupDataDataset} dataset Input dataset.
+   * @param {KupDataDatasetSort} sortType Type of sort to apply.
+   * @param {string} headerColumn The column used for sorting.
+   * @returns {KupDataDataset} Sorted dataset.
+   */
+  sort(dataset, sortType, headerColumn) {
+    if (sortType != 'normalDistribution') {
+      const message = 'Wrong sort type! (' + sortType + ')';
+      dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+      return dataset;
+    }
+    const output = {
+      columns: JSON.parse(JSON.stringify(dataset.columns)),
+      rows: [],
+    };
+    const length = dataset.rows.length;
+    // sort all columns values by descending
+    let values = getCellValue(dataset, [headerColumn]);
+    values.sort(function (a, b) {
+      return Number(a) - Number(b);
+    });
+    values.reverse();
+    // excluding duplicates values.
+    values = [...new Set(values)];
+    // calculating middle index
+    const idx = Math.floor(length / 2);
+    let lastIdx = idx - 1;
+    let leftIdx = idx - 1;
+    let rightIdx = idx + 1;
+    // sort the rows like a "mountain", the greatest is in the middle and the other ones are splitted left and right
+    for (let i = 0; i < length; i++) {
+      const value = values[i];
+      // looping the rows because we have many rows with same value.
+      this.finder(dataset, {
+        columns: [headerColumn],
+        value: value,
+      }).rows.forEach((row) => {
+        const xC = output.rows[idx];
+        if (xC == null) {
+          output.rows[idx] = JSON.parse(JSON.stringify(row));
+        }
+        else {
+          output.rows[lastIdx] = JSON.parse(JSON.stringify(row));
+          if (lastIdx > idx) {
+            // right from the middle index.
+            lastIdx = leftIdx;
+            rightIdx++;
+          }
+          else {
+            // left from the middle index.
+            lastIdx = rightIdx;
+            leftIdx--;
+          }
+        }
+      });
+    }
+    return output;
+  }
+  /**
+   * Creates a new dataset with transposed columns and rows.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {string} headerColumn - When specified, it will be the column used as header. When missing, the header will be a series of progressive numbers.
+   * @returns {KupDataDataset} Transposed dataset.
+   */
+  transpose(dataset, headerColumn) {
+    const transposed = { columns: [], rows: [] };
+    let firstColumn = null;
+    if (headerColumn) {
+      firstColumn = findColumns(dataset, { name: headerColumn })[0];
+      transposed.columns.push(firstColumn);
+      for (let index = 0; index < dataset.rows.length; index++) {
+        const row = dataset.rows[index];
+        const cell = row.cells[firstColumn.name];
+        const title = cell.displayedValue
+          ? cell.displayedValue
+          : cell.value;
+        transposed.columns.push({
+          name: cell.value + '_' + row.id,
+          title,
+        });
+      }
+    }
+    else {
+      firstColumn = {
+        name: fieldColumn.toUpperCase(),
+        title: fieldColumn,
+      };
+      transposed.columns.push(firstColumn);
+      for (let index = 0; index < dataset.rows.length; index++) {
+        const row = dataset.rows[index];
+        transposed.columns.push({
+          name: row.id,
+          title: '#' + index,
+        });
+      }
+    }
+    for (let index = headerColumn ? 1 : 0; index < dataset.columns.length; index++) {
+      const oldColumn = dataset.columns[index];
+      const cells = {};
+      cells[firstColumn.name] = {
+        value: oldColumn.title,
+      };
+      for (let index = 1; index < transposed.columns.length; index++) {
+        const newColumn = transposed.columns[index];
+        const oldRow = dataset.rows[index - 1];
+        const cellName = headerColumn ? newColumn.name : oldRow.id;
+        cells[cellName] = oldRow.cells[oldColumn.name];
+        if (oldColumn.icon && !cells[cellName].icon) {
+          cells[cellName].icon = oldColumn.icon;
+        }
+        if (oldColumn.shape && !cells[cellName].shape) {
+          cells[cellName].shape = oldColumn.shape;
+        }
+      }
+      // If a record is key and no column argument is provided, it will be placed on top
+      if (!headerColumn && oldColumn.isKey) {
+        transposed.rows.unshift({
+          id: String(index),
+          cells,
+          transposedColumnName: oldColumn.name,
+        });
+      }
+      else {
+        transposed.rows.push({
+          id: String(index),
+          cells,
+          transposedColumnName: oldColumn.name,
+        });
+      }
+    }
+    return transposed;
+  }
+}

package/dist/collection/{utils → managers}/kup-dates/kup-dates.js

@@ -18,6 +18,7 @@ export class KupDates {
    * Initializes KupDates.
    */
   constructor(locale) {
+    this.managedComponents = new Set();
     this.setLocale(locale);
     this.dayjs = dayjs;
     dayjs.extend(customParseFormat);
@@ -46,11 +47,15 @@ export class KupDates {
         .toLowerCase();
     }
     dayjs.locale(this.locale);
+    this.managedComponents.forEach(function (comp) {
+      if (comp.isConnected) {
+        comp.refresh();
+      }
+    });
     document.dispatchEvent(new CustomEvent('kup-dates-localechange'));
   }
   /**
-   *
-   * @returns the current locale
+   * @returns {string} The current locale.
    */
   getLocale() {
     return this.locale;
@@ -81,6 +86,7 @@ export class KupDates {
    * Validates the given date.
    * @param {dayjs.ConfigType} date - Date to be validated.
    * @param {string} format - Format of the input date.
+   * @param {boolean} strict - Strict parsing requires that the format and input match exactly, including delimiters.
    * @returns {boolean} Returns whether the argument is a valid date or not.
    */
   isValid(date, format, strict) {
@@ -173,8 +179,8 @@ export class KupDates {
         case 3:
         //input = '0' + input; // continue into case 4
         case 4:
-          sub1 = parseInt(input.substr(0, 2));
-          sub2 = parseInt(input.substr(2));
+          sub1 = parseInt(input.substring(0, 2));
+          sub2 = parseInt(input.substring(2, 4));
           if (mIndex === 0) {
             today.setDate(sub2);
             today.setMonth(sub1 - 1); // -1 because it's 0 based
@@ -187,10 +193,10 @@ export class KupDates {
         case 5:
         //input = '0' + input; // continue into case 6
         case 6:
-          sub1 = parseInt(input.substr(0, 2));
-          sub2 = parseInt(input.substr(2, 2));
+          sub1 = parseInt(input.substring(0, 2));
+          sub2 = parseInt(input.substring(2, 4));
           year = today.getFullYear().toString();
-          year = year.substr(0, 2) + input.substr(4);
+          year = year.substring(0, 2) + input.substring(4);
           if (mIndex === 0) {
             today.setFullYear(parseInt(year), sub1 - 1, sub2);
           }
@@ -201,9 +207,9 @@ export class KupDates {
         case 7:
         //input = '0' + input; // continue into case 8
         case 8:
-          sub1 = parseInt(input.substr(0, 2));
-          sub2 = parseInt(input.substr(2, 2));
-          year = input.substr(4);
+          sub1 = parseInt(input.substring(0, 2));
+          sub2 = parseInt(input.substring(2, 4));
+          year = input.substring(4);
           if (mIndex === 0) {
             today.setFullYear(parseInt(year), sub1 - 1, sub2);
           }
@@ -228,25 +234,25 @@ export class KupDates {
         case 3:
         //input = '0' + input; // continue into case 4
         case 4:
-          hh = parseInt(input.substr(0, 2));
-          mm = parseInt(input.substr(2));
+          hh = parseInt(input.substring(0, 2));
+          mm = parseInt(input.substring(2, 4));
           today.setHours(hh, mm, 0, 0);
           break;
         case 5:
         //input = '0' + input; // continue into case 6
         case 6:
-          hh = parseInt(input.substr(0, 2));
-          mm = parseInt(input.substr(2, 2));
-          ss = parseInt(input.substr(4));
+          hh = parseInt(input.substring(0, 2));
+          mm = parseInt(input.substring(2, 4));
+          ss = parseInt(input.substring(4, 6));
           today.setHours(hh, mm, ss, 0);
           break;
         case 7:
         //input = '0' + input; // continue into case 8
         case 8:
-          hh = parseInt(input.substr(0, 2));
-          mm = parseInt(input.substr(2, 2));
-          ss = parseInt(input.substr(4, 2));
-          ms = parseInt(input.substr(6));
+          hh = parseInt(input.substring(0, 2));
+          mm = parseInt(input.substring(2, 4));
+          ss = parseInt(input.substring(4, 6));
+          ms = parseInt(input.substring(6, 8));
           today.setHours(hh, mm, ss, ms);
           break;
         default:
@@ -281,6 +287,17 @@ export class KupDates {
     }
     return dayjs.max(dayjsDates);
   }
+  /**
+   * Adds the given amount of time to the input date.
+   * @param {dayjs.ConfigType} input - Input date.
+   * @param {number} value - The value of the addition (i.e.: 7).
+   * @param {dayjs.OpUnitType} unit - The unit of the addition (i.e.: "year").
+   * @returns {dayjs.Dayjs} Computed date.
+   * @see https://day.js.org/docs/en/manipulate/add
+   */
+  add(input, value, unit) {
+    return dayjs(input).add(value, unit);
+  }
   /**
    * Subtracts the given amount of time from the input date.
    * @param {dayjs.ConfigType} input - Input date.
@@ -292,4 +309,21 @@ export class KupDates {
   subtract(input, value, unit) {
     return dayjs(input).subtract(value, unit);
   }
+  /**
+   * Registers a KupComponent in KupDates, in order to be properly handled whenever the locale changes.
+   * @param {any} component - The Ketchup component to be registered.
+   */
+  register(component) {
+    this.managedComponents.add(component.rootElement);
+  }
+  /**
+   * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
+   *
+   * @param {any} component - The component calling this function.
+   */
+  unregister(component) {
+    if (this.managedComponents) {
+      this.managedComponents.delete(component.rootElement);
+    }
+  }
 }

package/dist/collection/{utils → managers}/kup-debug/kup-debug-browser-utils.js

@@ -16,7 +16,7 @@ function logCSS(selector, detailedLog) {
         const cssRule = shadowCSS[index].cssText;
         if (cssRule.indexOf('@') < 0) {
             let selectorEnd = shadowCSS[index].cssText.indexOf('{');
-            CSSArray.push(cssRule.substr(0, selectorEnd));
+            CSSArray.push(cssRule.substring(0, selectorEnd));
         }
     }