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

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

@@ -0,0 +1,272 @@
+import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
+import { KupLanguageTotals } from '../kup-language/kup-language-declarations';
+import { KupDataNewColumnTypes, } from './kup-data-declarations';
+const dom = document.documentElement;
+/**
+ * Finds the columns matching the criteria specified in the filters argument.
+ * @param {KupDataDataset | Column[]} dataset - Input dataset or array of columns.
+ * @param {Partial<Column>} filters - Column interface containing the filters to match.
+ * @returns {Column[]} Columns matching the criteria.
+ */
+export function findColumns(dataset, filters) {
+  const columns = dataset.columns
+    ? dataset.columns
+    : dataset;
+  const result = [];
+  for (let index = 0; index < columns.length; index++) {
+    const column = columns[index];
+    for (const key in filters) {
+      const filter = filters[key];
+      if (column[key] === filter) {
+        result.push(column);
+      }
+    }
+  }
+  return result;
+}
+/**
+ * Sets the given columns of the input dataset to be hidden.
+ * @param {KupDataDataset | Column[]} dataset - Input dataset or array of columns.
+ * @param {string[]} columns2hide - Names of columns to hide.
+ * @returns {KupDataColumn[]} Columns that were set to hidden.
+ */
+export function hideColumns(dataset, columns2hide) {
+  const columns = dataset.columns
+    ? dataset.columns
+    : dataset;
+  const hidden = [];
+  for (let index = 0; index < columns.length; index++) {
+    const column = columns[index];
+    if (columns2hide.includes(column.name)) {
+      column.visible = false;
+      hidden.push(column);
+    }
+  }
+  return hidden;
+}
+/**
+ * Creates a new column with the specified options.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataNewColumnTypes} type - Type of column creation.
+ * @param {KupDataNewColumnOptions} options - Options used by the submethods to create the column.
+ * @returns {string | Column} Returns the new column created or a string containing the error message (if something went wrong).
+ */
+export function newColumn(dataset, type, options) {
+  switch (type) {
+    case KupDataNewColumnTypes.CONCATENATE:
+      return newColumnFromConcatenate(dataset, options.columns, options.separator);
+    case KupDataNewColumnTypes.MATH:
+      return newColumnFromMath(dataset, options.operation, options.columns);
+    case KupDataNewColumnTypes.MERGE:
+      return newColumnFromMerge(dataset, options.columns, options.newColumn);
+    default:
+      const message = 'Wrong type used to invoke new column creation!(' + type + ')';
+      dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+      return message;
+  }
+}
+/**
+ * This method concatenates all the columns specified in the argument into a single one.
+ * @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).
+ */
+function newColumnFromConcatenate(dataset, columns, separator) {
+  if (!columns || columns.length === 0) {
+    const message = 'Invalid array, interrupting column merging!(' + columns + ')';
+    dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+    return message;
+  }
+  let firstColumn = null;
+  const titles = [];
+  const objs = [];
+  separator = separator ? separator : ' ';
+  for (let index = 0; index < dataset.columns.length; index++) {
+    const col = dataset.columns[index];
+    if (columns.includes(col.name)) {
+      objs.push(col.obj);
+      titles[columns.indexOf(col.name)] = col.title;
+    }
+    if (columns[0] === col.name) {
+      firstColumn = col;
+    }
+    if (col.mergedFrom &&
+      col.mergedFrom.toString() === columns.toString()) {
+      const message = 'The product of these columns in the same order already exists!(' +
+        columns.toString() +
+        ')';
+      dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+      return message;
+    }
+  }
+  const newName = columns.join('_');
+  const newObj = objs.length > 0 && dom.ketchup.objects.isSameKupObj(objs)
+    ? objs[0]
+    : null;
+  const newTitle = titles.join(separator);
+  dataset.rows.forEach((row) => {
+    const cells = row.cells;
+    const values = [];
+    let base = null;
+    if (cells) {
+      for (let index = 0; index < columns.length; index++) {
+        const column = columns[index];
+        const cell = cells[column];
+        if (cell) {
+          if (!base) {
+            base = cell;
+          }
+          values.push(cell.value);
+        }
+      }
+    }
+    const value = values.join(separator);
+    if (values.length > 0) {
+      cells[newName] = Object.assign(Object.assign({}, base), { displayedValue: null, obj: newObj ? Object.assign(Object.assign({}, newObj), { k: value }) : null, value: value });
+    }
+  });
+  const newColumn = Object.assign(Object.assign({}, firstColumn), { name: newName, title: newTitle, obj: newObj, mergedFrom: columns });
+  dataset.columns.splice(dataset.columns.indexOf(firstColumn) + 1, 0, newColumn);
+  return newColumn;
+}
+/**
+ * This method is used to create a new column from a mathematical formula.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {string} operation - Mathematical operation to apply (i.e.: "sum", "average", ([COL1] - [COL2]) * 100 / [COL3]).
+ * @param {string[]} columns - Column names used for the mathematical operation. When missing, they will be extracted from the formula.
+ * @returns {string | KupDataColumn} Returns the new column created or a string containing the error message (if something went wrong).
+ */
+function newColumnFromMath(dataset, operation, columns) {
+  if (!columns) {
+    columns = [];
+  }
+  if (columns.length === 0) {
+    const names = operation.split('[');
+    for (let i = 1; i < names.length; i++) {
+      columns.push(names[i].split(']')[0]);
+    }
+  }
+  if (columns.length === 0) {
+    const message = "Can't apply math formulas without columns!(" + columns + ')';
+    dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+    return message;
+  }
+  const titles = [];
+  const formulaRow = {};
+  let firstColumn = null;
+  let formula = '';
+  switch (operation) {
+    case KupLanguageTotals.AVERAGE:
+      formula = `(${columns.join(' + ')}) / ${columns.length}`;
+      break;
+    case KupLanguageTotals.DIFFERENCE:
+      formula = columns.join(' - ');
+      break;
+    case KupLanguageTotals.PRODUCT:
+      formula = columns.join(' * ');
+      break;
+    case KupLanguageTotals.SUM:
+      formula = columns.join(' + ');
+      break;
+    default:
+      formula = operation;
+  }
+  for (let index = 0; index < dataset.columns.length; index++) {
+    const col = dataset.columns[index];
+    if (columns.includes(col.name)) {
+      titles[columns.indexOf(col.name)] = col.title;
+      if (!dom.ketchup.objects.isNumber(col.obj)) {
+        const message = "Can't apply math formulas on non-numerical columns!(" +
+          columns +
+          ')';
+        dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+        return message;
+      }
+    }
+    if (columns[0] === col.name) {
+      firstColumn = col;
+    }
+    if (col.resultOf && col.resultOf === formula) {
+      const message = 'This mathematical operation on these columns was already performed!(' +
+        formula +
+        ')';
+      dom.ketchup.debug.logMessage('kup-data', message, KupDebugCategory.WARNING);
+      return message;
+    }
+  }
+  let prog = 0;
+  let newName = 'MATH_';
+  while (findColumns(dataset, { name: newName + prog }).length > 0) {
+    prog++;
+  }
+  newName = newName + prog;
+  const newObj = firstColumn.obj;
+  let newTitle = formula;
+  for (let i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    let re = new RegExp(column, 'g');
+    newTitle = newTitle.replace(re, titles[i]);
+  }
+  dataset.rows.forEach((row) => {
+    const cells = row.cells;
+    let base = null;
+    if (cells) {
+      for (let index = 0; index < columns.length; index++) {
+        const column = columns[index];
+        const cell = cells[column];
+        if (cell) {
+          if (!base) {
+            base = cell;
+          }
+          formulaRow[column] = dom.ketchup.math.numberify(cell.value);
+        }
+      }
+    }
+    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 });
+  });
+  const newColumn = Object.assign(Object.assign({}, firstColumn), { name: newName, title: newTitle, obj: newObj, resultOf: formula });
+  dataset.columns.splice(dataset.columns.indexOf(firstColumn) + 1, 0, newColumn);
+  return newColumn;
+}
+/**
+ * Takes the columns to merge and creates a new column with their cells. The merged columns will then be removed.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {string[]} columns2merge - Names of columns to merge.
+ * @param {KupDataColumn} newColumn - Column created.
+ * @returns {KupDataColumn} Resulting column.
+ */
+export function newColumnFromMerge(dataset, columns2merge, newColumn) {
+  const outputCells = [];
+  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 (columns2merge.includes(key)) {
+        outputCells.push(Object.assign({}, cell));
+        delete cells[key];
+      }
+    }
+  }
+  for (let index = 0; index < columns2merge.length; index++) {
+    const column2removeIndex = dataset.columns.findIndex((col) => col.name === columns2merge[index]);
+    dataset.columns.splice(column2removeIndex, 1);
+  }
+  let rowIndex = 0;
+  for (let index = 0; index < outputCells.length; index++) {
+    const outputCell = outputCells[index];
+    let row = null;
+    if (!dataset.rows[rowIndex]) {
+      dataset.rows[rowIndex] = { cells: {} };
+    }
+    row = dataset.rows[rowIndex];
+    row.cells[newColumn.name] = outputCell;
+    rowIndex++;
+  }
+  dataset.columns.push(newColumn);
+  return newColumn;
+}

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

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

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

@@ -0,0 +1,72 @@
+/**
+ * Removes the given node from the input array, by searching even children.
+ * @param {KupDataNode[]} nodes - Input array of nodes.
+ * @param {KupDataNode} node2remove - Node to remove.
+ * @returns {KupDataNode} Copy of the removed node.
+ */
+export function removeNode(nodes, node2remove) {
+  let removed = null;
+  for (let index = 0; index < nodes.length; index++) {
+    recursive(nodes[index], nodes);
+    function recursive(node, array) {
+      const i = array.indexOf(node2remove);
+      if (i > -1) {
+        removed = Object.assign({}, node2remove);
+        array.splice(i, 1);
+        return;
+      }
+      for (let index = 0; node.children && index < node.children.length; index++) {
+        if (node.children[index]) {
+          recursive(node.children[index], node.children);
+        }
+      }
+    }
+  }
+  return removed;
+}
+/**
+ * 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.
+ * @param {KupDataNode[]} exclude - Nodes to exclude (they won't be updated).
+ * @returns {KupDataNode[]} Array of the updated nodes.
+ */
+export function setPropertiesNode(nodes, properties, recursively, exclude) {
+  const updated = [];
+  if (!exclude) {
+    exclude = [];
+  }
+  if (recursively) {
+    nodes = toStreamNode(nodes);
+  }
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    for (const key in properties) {
+      if (!exclude.includes(node)) {
+        node[key] = properties[key];
+        updated.push(node);
+      }
+    }
+  }
+  return updated;
+}
+/**
+ * Streamlines an array of nodes by recursively fetching every child node.
+ * @param {KupDataNode[]} nodes - Input array of nodes.
+ * @returns {KupDataNode[]} Streamlined array of every node and their children.
+ */
+export function toStreamNode(nodes) {
+  const streamlined = [];
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    recursive(node);
+    function recursive(node) {
+      streamlined.push(node);
+      for (let index = 0; node.children && index < node.children.length; index++) {
+        recursive(node.children[index]);
+      }
+    }
+  }
+  return streamlined;
+}

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

@@ -0,0 +1,28 @@
+const dom = document.documentElement;
+/**
+ * Finds all the rows containing cells matching the filters criteria in the input dataset.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataFindCellFilters} filters - Filters of the research.
+ * @returns {KupDataRow[]} Array of rows fetched after applying the filters.
+ */
+export function findRow(dataset, filters) {
+  return dom.ketchup.data.finder(dataset, filters).rows;
+}
+/**
+ * Converts the rows of the input dataset to tree nodes.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @returns {KupDataNode[]} Array of tree nodes.
+ */
+export function toNode(dataset) {
+  const nodes = [];
+  for (let index = 0; index < dataset.rows.length; index++) {
+    const node = Object.assign({}, dataset.rows[index]);
+    if (!node.value) {
+      node.value = dataset.rows[index].id
+        ? dataset.rows[index].id
+        : '#' + (index + 1);
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}