@sme.up/ketchup 5.0.0 → 5.2.1-SNAPSHOT

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

@@ -1,4 +1,4 @@
-import { finder } from './kup-data-helper';
+const dom = document.documentElement;
 /**
  * Finds all the cells matching the filters criteria in the input dataset.
  * @param {KupDataDataset} dataset - Input dataset.
@@ -6,7 +6,7 @@ import { finder } from './kup-data-helper';
  * @returns {KupDataCell[]}  Array of cells fetched after applying the filters.
  */
 export function findCell(dataset, filters) {
-  return finder(dataset, filters).cells;
+  return dom.ketchup.data.finder(dataset, filters).cells;
 }
 /**
  * Returns all the cells values of the specified columns.

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

@@ -20,6 +20,9 @@ export function findColumns(dataset, filters) {
       if (column[key] === filter) {
         result.push(column);
       }
+      else if (dom.ketchup.objects.deepEqual(column[key], filter)) {
+        result.push(column);
+      }
     }
   }
   return result;
@@ -55,6 +58,8 @@ export function newColumn(dataset, type, options) {
   switch (type) {
     case KupDataNewColumnTypes.CONCATENATE:
       return newColumnFromConcatenate(dataset, options.columns, options.separator);
+    case KupDataNewColumnTypes.DUPLICATE:
+      return newColumnFromDuplication(dataset, options.columns, options.newColumn);
     case KupDataNewColumnTypes.MATH:
       return newColumnFromMath(dataset, options.operation, options.columns);
     case KupDataNewColumnTypes.MERGE:
@@ -70,7 +75,7 @@ export function newColumn(dataset, type, options) {
  * @param {KupDataDataset} dataset - Input dataset.
  * @param {string[]} columns - Array of column names.
  * @param {string} separator - Characters used to separate values.
- * @returns {string|Column}  Returns the new column created or a string containing the error message (if something went wrong).
+ * @returns {string|KupDataColumn}  Returns the new column created or a string containing the error message (if something went wrong).
  */
 function newColumnFromConcatenate(dataset, columns, separator) {
   if (!columns || columns.length === 0) {
@@ -130,6 +135,25 @@ function newColumnFromConcatenate(dataset, columns, separator) {
   dataset.columns.splice(dataset.columns.indexOf(firstColumn) + 1, 0, newColumn);
   return newColumn;
 }
+/**
+ * Creates a duplicate of the specified column.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {string[]} column2duplicate - Name of the column to duplicate (the first occurrence of the array will be used).
+ * @param {KupDataColumn} newColumn - Column created.
+ * @returns {KupDataColumn} Resulting column.
+ */
+export function newColumnFromDuplication(dataset, column2duplicate, newColumn) {
+  const duplicatedName = column2duplicate[0];
+  for (let index = 0; index < dataset.rows.length; index++) {
+    const row = dataset.rows[index];
+    const cells = row.cells;
+    if (cells && cells[duplicatedName]) {
+      cells[newColumn.name] = Object.assign({}, cells[duplicatedName]);
+    }
+  }
+  dataset.columns.push(newColumn);
+  return newColumn;
+}
 /**
  * This method is used to create a new column from a mathematical formula.
  * @param {KupDataDataset} dataset - Input dataset.
@@ -219,11 +243,11 @@ function newColumnFromMath(dataset, operation, columns) {
           if (!base) {
             base = cell;
           }
-          formulaRow[column] = dom.ketchup.data.numberify(cell.value);
+          formulaRow[column] = dom.ketchup.math.numberify(cell.value);
         }
       }
     }
-    const value = dom.ketchup.data.formulas
+    const value = dom.ketchup.math.formulas
       .custom(formula, formulaRow)
       .toString();
     cells[newName] = Object.assign(Object.assign({}, base), { displayedValue: null, obj: Object.assign(Object.assign({}, newObj), { k: value }), value: value });

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

@@ -1,9 +1,10 @@
 /**
- * Types of column creation when invoking datasetOperations.column.new.
+ * Types of column creation when invoking column.new.
  */
 export var KupDataNewColumnTypes;
 (function (KupDataNewColumnTypes) {
   KupDataNewColumnTypes["CONCATENATE"] = "concatenate";
+  KupDataNewColumnTypes["DUPLICATE"] = "duplicate";
   KupDataNewColumnTypes["MATH"] = "math";
   KupDataNewColumnTypes["MERGE"] = "merge";
 })(KupDataNewColumnTypes || (KupDataNewColumnTypes = {}));

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

@@ -25,7 +25,7 @@ export function removeNode(nodes, node2remove) {
   return removed;
 }
 /**
- * Sets the values specified in the filters to every node of the input array.
+ * Sets the values specified in the properties to every node of the input array.
  * @param {KupDataNode[]} nodes - Input array of nodes.
  * @param {Partial<KupDataNode>} properties - New properties values to set.
  * @param {boolean} recursively - Sets values to every child node.

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

@@ -1,4 +1,4 @@
-import { finder } from './kup-data-helper';
+const dom = document.documentElement;
 /**
  * Finds all the rows containing cells matching the filters criteria in the input dataset.
  * @param {KupDataDataset} dataset - Input dataset.
@@ -6,7 +6,7 @@ import { finder } from './kup-data-helper';
  * @returns {KupDataRow[]} Array of rows fetched after applying the filters.
  */
 export function findRow(dataset, filters) {
-  return finder(dataset, filters).rows;
+  return dom.ketchup.data.finder(dataset, filters).rows;
 }
 /**
  * Converts the rows of the input dataset to tree nodes.

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);
     }
   }
 }