@sme.up/ketchup 5.0.0 → 5.1.1

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

@@ -1,200 +1,382 @@
-import numeral from 'numeral';
-import 'numeral/locales/chs';
-import 'numeral/locales/es';
-import 'numeral/locales/fr';
-import 'numeral/locales/it';
-import 'numeral/locales/pl';
-import 'numeral/locales/ru';
-import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
-import { distinctDataset, newDataset, rangedDistinctDataset, sortDataset, transposeDataset, } from './kup-data-dataset-helper';
+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 {
-  /**
-   * Initializes KupData.
-   */
   constructor() {
-    this.datasetOperations = null;
-    this.formulas = null;
-    this.numeral = numeral;
-    this.datasetOperations = {
-      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.cell = {
+      find(dataset, filters) {
+        return findCell(dataset, filters);
       },
-      column: {
-        find(dataset, filters) {
-          return findColumns(dataset, filters);
-        },
-        hide(dataset, columns2hide) {
-          return hideColumns(dataset, columns2hide);
-        },
-        new(dataset, type, options) {
-          return newColumn(dataset, type, options);
-        },
+      getValue(dataset, columns) {
+        return getCellValue(dataset, columns);
       },
-      node: {
-        remove(nodes, node2remove) {
-          return removeNode(nodes, node2remove);
-        },
-        setProperties(nodes, properties, recursively, exclude) {
-          return setPropertiesNode(nodes, properties, recursively, exclude);
-        },
-        toStream(nodes) {
-          return toStreamNode(nodes);
-        },
+      replace(dataset, cell, columns) {
+        return replaceCell(dataset, cell, columns);
       },
-      row: {
-        find(dataset, filters) {
-          return findRow(dataset, filters);
-        },
-        toNode(dataset) {
-          return toNode(dataset);
-        },
+    };
+    this.column = {
+      find(dataset, filters) {
+        return findColumns(dataset, filters);
       },
-      distinct(dataset, columns, valuesColumn) {
-        return distinctDataset(dataset, columns, valuesColumn);
+      hide(dataset, columns2hide) {
+        return hideColumns(dataset, columns2hide);
       },
-      new(dataset, newColumns) {
-        return newDataset(dataset, newColumns);
+      new(dataset, type, options) {
+        return newColumn(dataset, type, options);
       },
-      rangedDistinct(dataset, rangeColumns, resultingColumn, valuesColumn) {
-        return rangedDistinctDataset(dataset, rangeColumns, resultingColumn, valuesColumn);
+    };
+    this.node = {
+      remove(nodes, node2remove) {
+        return removeNode(nodes, node2remove);
       },
-      sort(dataset, sortType, headerColumn) {
-        return sortDataset(dataset, sortType, headerColumn);
+      setProperties(nodes, properties, recursively, exclude) {
+        return setPropertiesNode(nodes, properties, recursively, exclude);
       },
-      transpose(dataset, headerColumn) {
-        return transposeDataset(dataset, headerColumn);
+      toStream(nodes) {
+        return toStreamNode(nodes);
       },
     };
-    this.formulas = {
-      /**
-       * Takes a mathematical formula as string in input, with column names between brackets, and returns the result as a number.
-       * @param {string} formula - Mathematical operation (i.e.: ([COL1] - [COL2]) * 100 / [COL3]).
-       * @param {{ [index: string]: number }} row - Object containing column names as indexes and the related values as keys.
-       * @returns {number} Result of the formula.
-       */
-      custom(formula, row) {
-        const keys = Object.keys(row);
-        for (let i = 0; i < keys.length; i++) {
-          let key = keys[i];
-          let value = row[key];
-          if (value != null && !isNaN(value)) {
-            let re = new RegExp(key, 'g');
-            formula = formula.replace(re, value.toString());
-          }
-        }
-        formula = formula.replace(/[\[\]']+/g, '');
-        try {
-          const result = Function('"use strict"; return (' + formula + ')')();
-          return result;
-        }
-        catch (e) {
-          dom.ketchup.debug.logMessage('kup-data', 'Error while evaluating the following formula!(' +
-            formula +
-            ')', KupDebugCategory.ERROR);
-          return NaN;
-        }
+    this.row = {
+      find(dataset, filters) {
+        return findRow(dataset, filters);
       },
-      /**
-       * Calculates a single Y point of a normal distribution.
-       * @param {number} average - Average.
-       * @param {number} variance - Variance.
-       * @param {number} x - X coordinate.
-       * @returns {number} Result.
-       */
-      normalDistribution(average, variance, x) {
-        return ((1 / Math.sqrt(variance * 2 * Math.PI)) *
-          Math.exp(-Math.pow(x - average, 2) / (2 * variance)));
+      toNode(dataset) {
+        return toNode(dataset);
       },
     };
   }
   /**
-   * Calculates the normal distribution on a set of values.
-   * @param {string[] | number[] | String[]} values - Array of values.
-   * @param {number} precision - Number of iterations to run (points). When not specified, defaults to 201.
-   * @returns {number[][]} Returns an array of arrays containing numbers, which are the representation of the calculated normal distribution.
+   * 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.
    */
-  normalDistribution(values, precision) {
-    if (!precision) {
-      precision = 201;
+  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 data = [];
-    let max = Math.max.apply(Math, values);
-    let min = Math.min.apply(Math, values);
-    let average = 0;
-    let variance = 0;
-    for (let index = 0; index < values.length; index++) {
-      const value = values[index];
-      average += this.numberify(value);
+    const newColumns = [];
+    const newRows = [];
+    if (valuesColumn) {
+      newColumns.push(valuesColumn);
     }
-    average = average / values.length;
-    for (let index = 0; index < values.length; index++) {
-      const value = values[index];
-      variance += Math.pow(this.numberify(value) - average, 2);
+    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++;
+      }
     }
-    variance = variance / values.length;
-    if (!variance) {
-      variance = 0.001;
+    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);
     }
-    max = max + ((average / 100) * 50 + (variance / average) * 3);
-    min = min - ((average / 100) * 50 + (variance / average) * 3);
-    for (let i = 0; i < precision; i++) {
-      const x = ((max - min) * i) / precision + min;
-      data.push([
-        x,
-        this.formulas.normalDistribution(average, variance, x),
-      ]);
+    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]);
     }
-    return data;
+    newColumn(newD, KupDataNewColumnTypes.MERGE, {
+      columns: columnNames,
+      newColumn: resultingColumn,
+    });
+    return this.distinct(newD, null, valuesColumn);
   }
   /**
-   * Returns a number from a non-specified input type between string, number, or String.
-   * @param {string | String | number} input - Input value to numberify.
-   * @returns {number} Resulting number or NaN (when not a number).
+   * 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.
    */
-  numberify(input) {
-    const n = this.numeral(input).value();
-    if (n === null) {
-      return NaN;
+  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 n;
+    return output;
   }
   /**
-   * Formats the input number with the specified format of the currently set locale.
-   * @param {string | String | number} input - Input number which will be automatically "numberified".
-   * @param {string} format - Desired format. Defaults to '0,0.0' (i.e.: 2,000,000.51)
-   * @returns {string} Formatted number.
+   * 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.
    */
-  format(input, format) {
-    const n = this.numberify(input);
-    if (!format) {
-      const positiveN = Math.abs(n);
-      const decimals = positiveN - Math.floor(positiveN);
-      if (decimals) {
-        format = '0,0.0';
+  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 {
-        format = '0,0';
+        transposed.rows.push({
+          id: String(index),
+          cells,
+          transposedColumnName: oldColumn.name,
+        });
       }
     }
-    const formatted = this.numeral(n).format(format);
-    this.numeral.locale('en'); // TODO: Remove when KupData locale is handled [KupDataLocale]
-    return formatted;
+    return transposed;
   }
 }

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

@@ -314,7 +314,7 @@ export class KupDates {
    * @param {any} component - The Ketchup component to be registered.
    */
   register(component) {
-    this.managedComponents.add(component.rootElement);
+    this.managedComponents.add(component.rootElement ? component.rootElement : component);
   }
   /**
    * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
@@ -323,7 +323,7 @@ export class KupDates {
    */
   unregister(component) {
     if (this.managedComponents) {
-      this.managedComponents.delete(component.rootElement);
+      this.managedComponents.delete(component.rootElement ? component.rootElement : component);
     }
   }
 }

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

@@ -64,29 +64,29 @@ export class KupDebug {
     const languagesListData = [];
     for (let index = 0; index < languages.length; index++) {
       languagesListData.push({
-        text: languages[index],
-        value: languages[index],
+        id: languages[index],
         selected: languages[index] === dom.ketchup.language.name
           ? true
           : false,
+        value: languages[index],
       });
     }
     const themes = dom.ketchup.theme.getThemes();
     const themesListData = [];
     for (let index = 0; index < themes.length; index++) {
       themesListData.push({
-        text: themes[index],
-        value: themes[index],
+        id: themes[index],
         selected: themes[index] === dom.ketchup.theme.name ? true : false,
+        value: themes[index],
       });
     }
     const locales = dom.ketchup.dates.getLocales();
     const localesListData = [];
     for (let index = 0; index < locales.length; index++) {
       localesListData.push({
-        text: locales[index],
-        value: locales[index],
+        id: locales[index],
         selected: locales[index] === dom.ketchup.dates.locale ? true : false,
+        value: locales[index],
       });
     }
     debugWidget.data = {

package/dist/collection/managers/kup-dynamic-position/kup-dynamic-position.js

@@ -40,7 +40,7 @@ export class KupDynamicPosition {
     if (this.anchorIsHTMLElement(anchorEl)) {
       anchorEl.setAttribute(kupDynamicPositionAnchorAttribute, '');
     }
-    el.style.zIndex = `calc(var(--kup-navbar-zindex) - 1)`;
+    el.style.zIndex = `calc(var(--kup-navbar-zindex) + 1)`;
     const originalPath = [];
     if (detach) {
       let currentEl = el;

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

@@ -136,7 +136,7 @@ export class KupLanguage {
    * @param {any} component - The component calling this function.
    */
   register(component) {
-    this.managedComponents.add(component.rootElement);
+    this.managedComponents.add(component.rootElement ? component.rootElement : component);
   }
   /**
    * Unregisters a KupComponent, so it won't be refreshed when the language changes.
@@ -145,7 +145,7 @@ export class KupLanguage {
    */
   unregister(component) {
     if (this.managedComponents) {
-      this.managedComponents.delete(component.rootElement);
+      this.managedComponents.delete(component.rootElement ? component.rootElement : component);
     }
   }
 }

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

@@ -13,6 +13,8 @@ import { KupDates } from '../kup-dates/kup-dates';
 import { KupDatesLocales } from '../kup-dates/kup-dates-declarations';
 import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
 import { KupSearch } from '../kup-search/kup-search';
+import { KupMathLocales } from '../kup-math/kup-math-declarations';
+import { KupMath } from '../kup-math/kup-math';
 const dom = document.documentElement;
 /**
  * This class controls every other Ketchup utility suite.
@@ -73,6 +75,7 @@ export class KupManager {
     this.interact = new KupInteract(dialogZIndex, dialogRestrictContainer);
     this.language = new KupLanguage(languageList, languageName);
     this.magicBox = null;
+    this.math = new KupMath();
     this.overrides = overrides ? overrides : null;
     this.objects = new KupObjects(objectsList);
     this.resize = new ResizeObserver((entries) => {
@@ -198,6 +201,7 @@ export class KupManager {
     }
     this.dates.setLocale(locale);
     this.language.set(KupLanguageDefaults[locale]);
+    this.math.setLocale(KupMathLocales[locale]);
   }
   /**
    * Adds a new click callback.
@@ -237,6 +241,15 @@ export function kupManagerInstance() {
       dom.ketchup.debug.toggle(dom.ketchup.debug.active);
     }
     globalThis.kupManager = dom.ketchup;
+    if (overrides && overrides.autoSetLocalization) {
+      const locale = dom.ketchup.dates.locale;
+      if (!overrides.language || !overrides.language.name) {
+        dom.ketchup.language.set(KupLanguageDefaults[locale]);
+      }
+      if (!overrides.math || !overrides.math.locale) {
+        dom.ketchup.math.setLocale(KupMathLocales[locale]);
+      }
+    }
     document.dispatchEvent(new CustomEvent('kup-manager-ready'));
   }
   return dom.ketchup;

package/dist/collection/managers/kup-math/kup-math-declarations.js

@@ -0,0 +1,13 @@
+/**
+ * Locales available for KupMath.
+ */
+export var KupMathLocales;
+(function (KupMathLocales) {
+  KupMathLocales["cn"] = "chs";
+  KupMathLocales["en"] = "en";
+  KupMathLocales["es"] = "es";
+  KupMathLocales["it"] = "it";
+  KupMathLocales["fr"] = "fr";
+  KupMathLocales["pl"] = "pl";
+  KupMathLocales["ru"] = "ru";
+})(KupMathLocales || (KupMathLocales = {}));