@sme.up/ketchup 5.0.0 → 5.1.1

package/dist/types/managers/kup-data/kup-data-declarations.d.ts

@@ -79,25 +79,12 @@ export interface KupDataNode extends KupDataRow {
   value: string;
   children?: KupDataNode[];
   disabled?: boolean;
+  expandable?: boolean;
   obj?: KupObj;
   icon?: string;
   isExpanded?: boolean;
   title?: string;
 }
-/**
- * Interface related to dataset operations.
- */
-export interface KupDataDatasetOperations {
-  cell: KupDataCellOperations;
-  column: KupDataColumnOperations;
-  node: KupDataNodeOperations;
-  row: KupDataRowOperations;
-  distinct: (dataset: KupDataDataset, columns?: string[], valuesColumn?: KupDataColumn) => KupDataDataset;
-  new: (dataset: KupDataDataset, newColumns: KupDataNewColumn[]) => KupDataDataset;
-  rangedDistinct: (dataset: KupDataDataset, rangeColumns: KupDataNewColumn[], resultingColumn: KupDataColumn, valuesColumn?: KupDataColumn) => KupDataDataset;
-  sort: (dataset: KupDataDataset, sortType: KupDataDatasetSort, headerColumn: string) => KupDataDataset;
-  transpose: (dataset: KupDataDataset, headerColumn?: string) => KupDataDataset;
-}
 /**
  * Interface related to cells operations.
  */
@@ -129,15 +116,6 @@ export interface KupDataRowOperations {
   find: (dataset: KupDataDataset, filters?: KupDataFindCellFilters) => KupDataRow[];
   toNode: (dataset: KupDataDataset) => KupDataNode[];
 }
-/**
- * Interface related to the formulas factory function.
- */
-export interface KupDataFormulas {
-  custom: (formula: string, row: {
-    [index: string]: number;
-  }) => number;
-  normalDistribution: (average: number, variance: number, x: number) => number;
-}
 /**
  * Sets the filters for the cell finder method.
  */
@@ -165,7 +143,7 @@ export interface KupDataNewColumn {
  */
 export declare type KupDataDatasetSort = 'normalDistribution';
 /**
- * Interface containing the options related to column creation when invoking datasetOperations.column.new.
+ * Interface containing the options related to column creation when invoking column.new.
  */
 export interface KupDataNewColumnOptions {
   columns?: string[];
@@ -174,10 +152,11 @@ export interface KupDataNewColumnOptions {
   separator?: string;
 }
 /**
- * Types of column creation when invoking datasetOperations.column.new.
+ * Types of column creation when invoking column.new.
  */
 export declare enum KupDataNewColumnTypes {
   CONCATENATE = "concatenate",
+  DUPLICATE = "duplicate",
   MATH = "math",
   MERGE = "merge"
 }

package/dist/types/managers/kup-data/kup-data-node-helper.d.ts

@@ -7,7 +7,7 @@ import { KupDataNode } from './kup-data-declarations';
  */
 export declare function removeNode(nodes: KupDataNode[], node2remove: KupDataNode): KupDataNode;
 /**
- * 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/types/managers/kup-data/kup-data.d.ts

@@ -1,41 +1,77 @@
-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 { KupDataDatasetOperations, KupDataFormulas } from './kup-data-declarations';
+import { KupDataCell, KupDataColumn, KupDataDataset, KupDataDatasetSort, KupDataFindCellFilters, KupDataNewColumn, KupDataNewColumnOptions, KupDataNewColumnTypes, KupDataNode, KupDataRow } from './kup-data-declarations';
 /**
  * Handles data operations.
  * @module KupData
  */
 export declare class KupData {
-  datasetOperations: KupDataDatasetOperations;
-  formulas: KupDataFormulas;
-  numeral: typeof numeral;
+  cell: {
+    find(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataCell[];
+    getValue(dataset: KupDataDataset, columns?: string[]): string[];
+    replace(dataset: KupDataDataset, cell: KupDataCell, columns?: string[]): KupDataCell[];
+  };
+  column: {
+    find(dataset: KupDataDataset | KupDataColumn[], filters: Partial<KupDataColumn>): KupDataColumn[];
+    hide(dataset: KupDataDataset | KupDataColumn[], columns2hide: string[]): KupDataColumn[];
+    new(dataset: KupDataDataset, type: KupDataNewColumnTypes, options: KupDataNewColumnOptions): string | KupDataColumn;
+  };
+  node: {
+    remove(nodes: KupDataNode[], node2remove: KupDataNode): KupDataNode;
+    setProperties(nodes: KupDataNode[], properties: Partial<KupDataNode>, recursively?: boolean, exclude?: KupDataNode[]): KupDataNode[];
+    toStream(nodes: KupDataNode[]): KupDataNode[];
+  };
+  row: {
+    find(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataRow[];
+    toNode(dataset: KupDataDataset): KupDataNode[];
+  };
   /**
-   * Initializes KupData.
+   * 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.
    */
-  constructor();
+  finder(dataset: KupDataDataset, filters: KupDataFindCellFilters): {
+    cells: KupDataCell[];
+    rows: KupDataRow[];
+  };
   /**
-   * 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.
+   * 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: string[] | number[] | String[], precision?: number): number[][];
+  distinct(dataset: KupDataDataset, columns?: string[], valuesColumn?: KupDataColumn): KupDataDataset;
   /**
-   * 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 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.
    */
-  numberify(input: string | String | number): number;
+  new(dataset: KupDataDataset, newColumns: KupDataNewColumn[]): KupDataDataset;
   /**
-   * 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.
+   * 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.
    */
-  format(input: string | String | number, format?: string): string;
+  rangedDistinct(dataset: KupDataDataset, rangeColumns: KupDataNewColumn[], resultingColumn: KupDataColumn, valuesColumn?: KupDataColumn): KupDataDataset;
+  /**
+   * 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: KupDataDataset, sortType: KupDataDatasetSort, headerColumn: string): KupDataDataset;
+  /**
+   * 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: KupDataDataset, headerColumn?: string): KupDataDataset;
 }

package/dist/types/managers/kup-manager/kup-manager-declarations.d.ts

@@ -9,6 +9,7 @@ import type { KupDynamicPosition } from '../kup-dynamic-position/kup-dynamic-pos
 import type { KupInteract } from '../kup-interact/kup-interact';
 import type { KupLanguage } from '../kup-language/kup-language';
 import type { KupLanguageJSON } from '../kup-language/kup-language-declarations';
+import type { KupMath } from '../kup-math/kup-math';
 import type { KupObjects } from '../kup-objects/kup-objects';
 import type { KupObjectsJSON } from '../kup-objects/kup-objects-declarations';
 import type { KupScrollOnHover } from '../kup-scroll-on-hover/kup-scroll-on-hover';
@@ -17,6 +18,7 @@ import type { KupTheme } from '../kup-theme/kup-theme';
 import type { KupThemeJSON } from '../kup-theme/kup-theme-declarations';
 import type { KupToolbar } from '../kup-toolbar/kup-toolbar';
 import type { ResizeObserver } from 'resize-observer';
+import { KupMathLocales } from '../kup-math/kup-math-declarations';
 /**
  * Interface used to define the HTML element with Ketchup specific properties.
  */
@@ -35,6 +37,7 @@ export interface KupManager {
   interact: KupInteract;
   language: KupLanguage;
   magicBox: HTMLKupMagicBoxElement;
+  math: KupMath;
   objects: KupObjects;
   overrides?: KupManagerInitialization;
   resize: ResizeObserver;
@@ -68,10 +71,12 @@ export interface KupManagerClickCb {
  * Interface for the KupManager override settings.
  */
 export interface KupManagerInitialization {
+  autoSetLocalization?: boolean;
   dates?: KupManagerDatesSettings;
   debug?: KupManagerDebugSettings;
   interact?: KupManagerInteractSettings;
   language?: KupManagerLanguageSettings;
+  math?: KupManagerMathSettings;
   objects?: KupManagerObjectsSettings;
   scrollOnHover?: KupManagerScrollOnHoverSettings;
   theme?: KupManagerThemeSettings;
@@ -108,6 +113,12 @@ export interface KupManagerLanguageSettings {
   list?: KupLanguageJSON;
   name?: string;
 }
+/**
+ * KupMath initialization settings.
+ */
+export interface KupManagerMathSettings {
+  locale?: KupMathLocales;
+}
 /**
  * KupObjects initialization settings.
  */

package/dist/types/managers/kup-manager/kup-manager.d.ts

@@ -12,6 +12,7 @@ import { KupData } from '../kup-data/kup-data';
 import { KupDates } from '../kup-dates/kup-dates';
 import { KupDatesLocales } from '../kup-dates/kup-dates-declarations';
 import { KupSearch } from '../kup-search/kup-search';
+import { KupMath } from '../kup-math/kup-math';
 /**
  * This class controls every other Ketchup utility suite.
  * @module KupManager
@@ -24,6 +25,7 @@ export declare class KupManager {
   interact: KupInteract;
   language: KupLanguage;
   magicBox: HTMLKupMagicBoxElement;
+  math: KupMath;
   objects: KupObjects;
   overrides?: KupManagerInitialization;
   resize: ResizeObserver;

package/dist/types/managers/kup-math/kup-math-declarations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Interface related to the formulas factory function.
+ */
+export interface KupMathFormulas {
+  custom: (formula: string, row: {
+    [index: string]: number;
+  }) => number;
+  normalDistribution: (average: number, variance: number, x: number) => number;
+}
+/**
+ * Locales available for KupMath.
+ */
+export declare enum KupMathLocales {
+  cn = "chs",
+  en = "en",
+  es = "es",
+  it = "it",
+  fr = "fr",
+  pl = "pl",
+  ru = "ru"
+}

package/dist/types/managers/kup-math/kup-math-helper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export declare function customFormula(formula: string, row: {
+  [index: string]: number;
+}): number;
+/**
+ * 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.
+ */
+export declare function normalDistributionFormula(average: number, variance: number, x: number): number;

package/dist/types/managers/kup-math/kup-math.d.ts

@@ -0,0 +1,60 @@
+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 { KupComponent } from '../../types/GenericTypes';
+import { KupMathFormulas, KupMathLocales } from './kup-math-declarations';
+/**
+ * Handles mathematical operations and number formatting/conversion.
+ * @module KupMath
+ */
+export declare class KupMath {
+  formulas: KupMathFormulas;
+  locale: KupMathLocales;
+  managedComponents: Set<KupComponent>;
+  numeral: typeof numeral;
+  /**
+   * Initializes KupMath.
+   */
+  constructor(locale?: KupMathLocales);
+  /**
+   * Sets the locale of the numeral instance. The locales available must be tied to the KupDates locales.
+   * @param {KupMathLocales} locale - Numeraljs locale string.
+   */
+  setLocale(locale: KupMathLocales): void;
+  /**
+   * 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.
+   */
+  normalDistribution(values: string[] | number[] | String[], precision?: number): number[][];
+  /**
+   * 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.00' (i.e.: 2,000,000.51).
+   * @returns {string} Formatted number.
+   */
+  format(input: string | String | number, format?: string): string;
+  /**
+   * Returns a number from a non-specified input type between string, number, or String.
+   * @param {string | String | number} input - Input value to numberify.
+   * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
+   * @returns {number} Resulting number or NaN (when not a number).
+   */
+  numberify(input: string | String | number, inputIsLocalized?: boolean): number;
+  /**
+   * Registers a KupComponent in KupMath, in order to be properly handled whenever the locale changes.
+   * @param {any} component - The Ketchup component to be registered.
+   */
+  register(component: any): void;
+  /**
+   * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
+   *
+   * @param {any} component - The component calling this function.
+   */
+  unregister(component: any): void;
+}

package/dist/types/managers/kup-objects/kup-objects.d.ts

@@ -1,4 +1,5 @@
 import type { Dayjs } from 'dayjs';
+import type { GenericObject } from '../../types/GenericTypes';
 import type { KupObj, KupObjectsJSON } from './kup-objects-declarations';
 /**
  * Handles objects definition and validation.
@@ -173,4 +174,25 @@ export declare class KupObjects {
    * @returns {Dayjs} Dayjs object.
    */
   parseDate(obj: KupObj): Dayjs;
+  /**
+   * Check whether two JS objects are deeply equal. When the arguments aren't objects, they are tested directly for equity.
+   * @param {GenericObject} object1 - First object to test.
+   * @param {GenericObject} object2 - Second object to test.
+   * @returns {boolean} True if the objects are equal.
+   * @see https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
+   */
+  deepEqual(object1: any, object2: any): boolean;
+  /**
+   * Check whether the argument is a JavaScript object.
+   * @param {GenericObject} object - Object to test.
+   * @returns {boolean} True if the argument is a JavaScript object.
+   * @see https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
+   */
+  isJsObject(object: any): boolean;
+  /**
+   * Check whether the object is empty or not.
+   * @param {GenericObject} object - Object to check.
+   * @returns {boolean} True if the object is empty.
+   */
+  isEmptyJsObject(obj: GenericObject): boolean;
 }

package/dist/types/utils/utils.d.ts

@@ -9,23 +9,7 @@ export declare enum DateTimeFormatOptionsMonth {
   NARROW = "narrow"
 }
 export declare function identify(array: Array<KupBoxRow | KupDataRow>): void;
-export declare function format(first: string, middle: string, last: string): string;
-export declare function generateUniqueId(field?: string): string;
-export declare function generateUuidv4(): string;
-export declare function eventFromElement(element: HTMLElement, eventSource: HTMLElement): boolean;
 export declare function getCurrentDateFormatFromBrowserLocale(): string;
-/**
- * Convert argument to boolean. Everything is false unless: true, "true", 1, "1", "on", "yes"
- * @param value the value to convert
- * @returns the boolean value of passed argument
- */
-export declare function getBoolean(value: any): boolean;
-/**
- * Check if an object is undefined, null or empty
- * @param obj the object to check
- * @returns true or false
- */
-export declare function isEmpty(obj: any): boolean;
 /**
  * @param value number as string, formatted by actual browser locale
  * @param type - type of number for calculate suffix
@@ -124,8 +108,6 @@ export declare function getMonthsAsStringByLocale(format?: DateTimeFormatOptions
 export declare function getDayAsStringByLocale(date: Date): string;
 export declare function getDaysOfWeekAsStringByLocale(firstDayIndex?: number): string[];
 export declare function fillString(stringIn: string, stringForFill: string, finalLen: number, addBefore: boolean): string;
-export declare function deepEqual(object1: any, object2: any): boolean;
-export declare function isObject(object: any): boolean;
 /**
  * Used to retrieve component's props values.
  * @param {any} comp - Component calling this function.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sme.up/ketchup",
-    "version": "5.0.0",
+    "version": "5.1.1",
     "keywords": [
         "smeup",
         "KetchUP",
@@ -55,7 +55,7 @@
         "vanilla-picker": "^2.12.1"
     },
     "devDependencies": {
-        "@stencil/core": "^2.14.0",
+        "@stencil/core": "^2.14.1",
         "@stencil/sass": "^1.4.1",
         "@types/d3-shape": "^2.1.0",
         "@types/geojson": "^7946.0.8",