@sme.up/ketchup 5.0.0 → 5.2.1-SNAPSHOT

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 = {
@@ -279,6 +279,7 @@ export class KupDebug {
             break;
           case 'kup-debug-locale-changer':
             dom.ketchup.dates.setLocale(compEvent.detail.value);
+            dom.ketchup.math.setLocale(compEvent.detail.value);
             break;
           case 'kup-debug-theme-changer':
             dom.ketchup.theme.set(compEvent.detail.value);

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,10 @@ 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';
+import { KupTooltip } from '../kup-tooltip/kup-tooltip';
+import { setAssetPath } from '@stencil/core';
 const dom = document.documentElement;
 /**
  * This class controls every other Ketchup utility suite.
@@ -23,8 +27,9 @@ export class KupManager {
    * Initializes KupManager.
    */
   constructor(overrides) {
-    let datesLocale = null, debugActive = null, debugAutoprint = null, debugLogLimit = null, dialogRestrictContainer = null, dialogZIndex = null, languageList = null, languageName = null, objectsList = null, scrollOnHoverDelay = null, scrollOnHoverStep = null, themeList = null, themeName = null;
+    let datesLocale = null, debugActive = null, debugAutoprint = null, debugLogLimit = null, dialogRestrictContainer = null, dialogZIndex = null, languageList = null, languageName = null, objectsList = null, scrollOnHoverDelay = null, scrollOnHoverStep = null, themeList = null, themeName = null, tooltipDelay = null;
     if (overrides) {
+      const assetsPath = overrides.assetsPath;
       const dates = overrides.dates;
       const debug = overrides.debug;
       const interact = overrides.interact;
@@ -32,6 +37,10 @@ export class KupManager {
       const objects = overrides.objects;
       const scrollOnHover = overrides.scrollOnHover;
       const theme = overrides.theme;
+      const tooltip = overrides.tooltip;
+      if (assetsPath) {
+        setAssetPath(assetsPath);
+      }
       if (dates) {
         datesLocale = dates.locale ? dates.locale : null;
       }
@@ -65,6 +74,9 @@ export class KupManager {
         themeList = theme.list ? theme.list : null;
         themeName = theme.name ? theme.name : null;
       }
+      if (tooltip) {
+        tooltipDelay = tooltip.delay ? tooltip.delay : null;
+      }
     }
     this.data = new KupData();
     this.dates = new KupDates(datesLocale);
@@ -73,6 +85,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) => {
@@ -99,6 +112,7 @@ export class KupManager {
     };
     this.theme = new KupTheme(themeList, themeName);
     this.toolbar = new KupToolbar();
+    this.tooltip = new KupTooltip(tooltipDelay);
     document.addEventListener('pointerdown', (e) => {
       const paths = e.composedPath();
       const lastString = paths[0].innerText || paths[0].value;
@@ -198,6 +212,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 +252,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 = {}));

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

@@ -0,0 +1,39 @@
+import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
+const dom = document.documentElement;
+/**
+ * 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 function customFormula(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;
+  }
+}
+/**
+ * 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 function normalDistributionFormula(average, variance, x) {
+  return ((1 / Math.sqrt(variance * 2 * Math.PI)) *
+    Math.exp(-Math.pow(x - average, 2) / (2 * variance)));
+}

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

@@ -0,0 +1,161 @@
+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 { KupMathLocales, } from './kup-math-declarations';
+import { customFormula, normalDistributionFormula } from './kup-math-helper';
+const dom = document.documentElement;
+/**
+ * Handles mathematical operations and number formatting/conversion.
+ * @module KupMath
+ */
+export class KupMath {
+  /**
+   * Initializes KupMath.
+   */
+  constructor(locale) {
+    this.formulas = {
+      custom(formula, row) {
+        return customFormula(formula, row);
+      },
+      normalDistribution(average, variance, x) {
+        return normalDistributionFormula(average, variance, x);
+      },
+    };
+    this.numbers = {
+      toLocaleString(value) {
+        const maximumFractionDigits = 14;
+        if (value == null || value == '')
+          return value;
+        return Number(value).toLocaleString(dom.ketchup.math.locale, {
+          maximumFractionDigits: maximumFractionDigits,
+        });
+      },
+    };
+    this.locale = locale ? locale : KupMathLocales.en;
+    this.managedComponents = new Set();
+    this.numeral = numeral;
+    this.numeral.locale(this.locale);
+  }
+  /**
+   * 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) {
+    if (!Object.values(KupMathLocales).includes(locale)) {
+      locale = KupMathLocales.en;
+      dom.ketchup.debug.logMessage('kup-math', 'Invalid locale (' + locale + ')! Defaulting to english.', KupDebugCategory.WARNING);
+    }
+    this.locale = locale;
+    this.numeral.locale(locale);
+    this.managedComponents.forEach(function (comp) {
+      if (comp.isConnected) {
+        comp.refresh();
+      }
+    });
+    document.dispatchEvent(new CustomEvent('kup-math-localechange'));
+  }
+  /**
+   * 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, precision) {
+    if (!precision) {
+      precision = 201;
+    }
+    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);
+    }
+    average = average / values.length;
+    for (let index = 0; index < values.length; index++) {
+      const value = values[index];
+      variance += Math.pow(this.numberify(value) - average, 2);
+    }
+    variance = variance / values.length;
+    if (!variance) {
+      variance = 0.001;
+    }
+    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 data;
+  }
+  /**
+   * 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, format) {
+    const n = this.numberify(input);
+    if (!format) {
+      const positiveN = Math.abs(n);
+      const decimals = positiveN - Math.floor(positiveN);
+      if (decimals) {
+        format = '0,0.00';
+      }
+      else {
+        format = '0,0';
+      }
+    }
+    const formatted = this.numeral(n).format(format);
+    return formatted;
+  }
+  /**
+   * 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, inputIsLocalized) {
+    let n = NaN;
+    if (inputIsLocalized) {
+      n = this.numeral(input).value();
+    }
+    else {
+      const locale = this.numeral.locale();
+      this.numeral.locale(KupMathLocales.en);
+      n = this.numeral(input).value();
+      this.numeral.locale(locale);
+    }
+    if (n === null) {
+      return NaN;
+    }
+    return n;
+  }
+  /**
+   * 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) {
+    this.managedComponents.add(component.rootElement ? component.rootElement : component);
+  }
+  /**
+   * 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 ? component.rootElement : component);
+    }
+  }
+}

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

@@ -285,8 +285,9 @@ export class KupObjects {
    * @returns {boolean} True when the object is null or empty.
    */
   isEmptyKupObj(obj) {
-    if (!obj)
+    if (this.isEmptyJsObject(obj)) {
       return true;
+    }
     return ((!obj.t || obj.t.trim() == '') &&
       (!obj.p || obj.p.trim() == '') &&
       (!obj.k || obj.k.trim() == ''));
@@ -317,4 +318,50 @@ export class KupObjects {
     }
     return dom.ketchup.dates.toDayjs(obj.k);
   }
+  /**
+   * 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, object2) {
+    if (!(this.isJsObject(object1) && this.isJsObject(object2))) {
+      return object1 === object2;
+    }
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+    for (const key of keys1) {
+      const val1 = object1[key];
+      const val2 = object2[key];
+      const areObjects = this.isJsObject(val1) && this.isJsObject(val2);
+      if ((areObjects && !this.deepEqual(val1, val2)) ||
+        (!areObjects && val1 !== val2)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 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) {
+    return object != null && typeof object === 'object';
+  }
+  /**
+   * Check whether the object is empty or not.
+   * @param {GenericObject} object - Object to check.
+   * @returns {boolean} True if the object is empty.
+   */
+  isEmptyJsObject(obj) {
+    return (!obj ||
+      obj === null ||
+      (Object.keys(obj).length === 0 && obj.constructor === Object));
+  }
 }

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

@@ -88,6 +88,7 @@ export const fTextFieldUsers = [
   KupTagNames.COMBOBOX,
   KupTagNames.DATA_TABLE,
   KupTagNames.DATE_PICKER,
+  KupTagNames.NUMERIC_PICKER,
   KupTagNames.TEXT_FIELD,
   KupTagNames.TIME_PICKER,
   KupTagNames.TREE,

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,191 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _KupTooltip_instances, _KupTooltip_clickCb, _KupTooltip_dynPos, _KupTooltip_create, _KupTooltip_setOptions;
+import { KupDebugCategory } from '../kup-debug/kup-debug-declarations';
+const dom = document.documentElement;
+/**
+ * Handles application-wide tooltip using card component.
+ * @module KupTooltip
+ */
+export class KupTooltip {
+  /**
+   * Initializes KupTooltip.
+   */
+  constructor(delay) {
+    _KupTooltip_instances.add(this);
+    this.currentAnchor = null;
+    this.delay = null;
+    this.element = null;
+    this.managedElements = null;
+    this.timeout = null;
+    _KupTooltip_clickCb.set(this, null);
+    this.delay = delay ? delay : 125;
+    this.managedElements = new Set();
+    document.addEventListener('pointermove', (e) => {
+      const paths = e.composedPath();
+      // Leaving the function when hovering on the tooltip itself
+      if (paths.includes(this.element)) {
+        return;
+      }
+      const enterHandler = (anchor) => {
+        this.timeout = null;
+        requestAnimationFrame(anchor.kupTooltip.enter.bind(anchor.kupTooltip.enter, e));
+      };
+      const overHandler = (anchor) => {
+        requestAnimationFrame(anchor.kupTooltip.over.bind(anchor.kupTooltip.over, e));
+      };
+      const leaveHandler = () => {
+        requestAnimationFrame(this.currentAnchor.kupTooltip.leave.bind(this.currentAnchor.kupTooltip.leave, e));
+      };
+      // If the current anchor exists and is not included in the event path,
+      // the leaving callback is fired.
+      if (this.currentAnchor && !paths.includes(this.currentAnchor)) {
+        if (this.timeout) {
+          clearTimeout(this.timeout);
+          this.timeout = null;
+        }
+        else {
+          if (this.currentAnchor.kupTooltip.leave) {
+            leaveHandler();
+          }
+        }
+        this.currentAnchor = null;
+      }
+      else if (!this.timeout) {
+        for (let index = 0; index < paths.length; index++) {
+          const element = paths[index];
+          if (this.managedElements.has(element)) {
+            // If the current anchor is the same as the registered element found
+            // in the path, the mouse over function is invoked
+            if (this.currentAnchor === element) {
+              if (element.kupTooltip.over) {
+                overHandler(element);
+              }
+              // Otherwise, the mouse enter callback will be invoked
+            }
+            else {
+              this.currentAnchor = element;
+              if (element.kupTooltip.enter) {
+                if (this.delay) {
+                  this.timeout = setTimeout(enterHandler.bind(enterHandler, element), this.delay);
+                }
+                else {
+                  enterHandler(element);
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  hide() {
+    if (this.element) {
+      this.element.menuVisible = false;
+      dom.ketchup.dynamicPosition.stop(this.element);
+      dom.ketchup.removeClickCallback(__classPrivateFieldGet(this, _KupTooltip_clickCb, "f"));
+    }
+  }
+  show(anchor, options) {
+    // Creates the card or updates it with new options
+    if (!this.element) {
+      __classPrivateFieldGet(this, _KupTooltip_instances, "m", _KupTooltip_create).call(this, options);
+    }
+    else if (options) {
+      __classPrivateFieldGet(this, _KupTooltip_instances, "m", _KupTooltip_setOptions).call(this, options);
+    }
+    // If an anchor was provided, initializes or updates dynamic positioning
+    if (anchor) {
+      __classPrivateFieldGet(this, _KupTooltip_instances, "m", _KupTooltip_dynPos).call(this, anchor);
+    }
+    // If the tooltip is already visible, it's pointless to go on
+    if (this.element.menuVisible) {
+      return;
+    }
+    // If the dynamic positioning is still to be registered, a warning is thrown
+    if (!dom.ketchup.dynamicPosition.isRegistered(this.element)) {
+      dom.ketchup.debug.logMessage('kup-tooltip', 'Unable to display KupTooltip without specifying a valid anchor point.', KupDebugCategory.WARNING);
+      return;
+    }
+    this.element.menuVisible = true;
+    dom.ketchup.addClickCallback(__classPrivateFieldGet(this, _KupTooltip_clickCb, "f"), true);
+  }
+  /**
+   * Returns whether an element was previously registered or not.
+   * @param {KupTooltipAnchor} element - Element to test.
+   * @returns {boolean} True if the element was registered.
+   */
+  isRegistered(element) {
+    return !this.managedElements
+      ? false
+      : this.managedElements.has(element);
+  }
+  /**
+   * Registers an HTMLElement as KupTooltipAnchor, triggering callback invocation on mouse over.
+   * @param {KupTooltipAnchor} element - The HTML element to be registered.
+   * @param {(e: PointerEvent) => void} cbEnter - Callback invoked when hovering on the the element for the first time.
+   * @param {(e: PointerEvent) => void} cbOver - Callback invoked when hovering on the element.
+   * @param {(e: PointerEvent) => void} cbLeave - Callback invoked when leaving the element.
+   */
+  register(element, cbEnter, cbOver, cbLeave) {
+    this.managedElements.add(element);
+    const kupTooltip = {
+      enter: cbEnter,
+      leave: cbLeave,
+      over: cbOver,
+    };
+    element.kupTooltip = kupTooltip;
+  }
+  /**
+   * Unregisters an HTMLElement, preventing its attached callback from being invoked.
+   *
+   * @param {KupTooltipAnchor} element - - The HTML element to be unregistered.
+   */
+  unregister(element) {
+    if (this.managedElements) {
+      this.managedElements.delete(element);
+    }
+  }
+}
+_KupTooltip_clickCb = new WeakMap(), _KupTooltip_instances = new WeakSet(), _KupTooltip_dynPos = function _KupTooltip_dynPos(anchor) {
+  if (dom.ketchup.dynamicPosition.isRegistered(this.element)) {
+    dom.ketchup.dynamicPosition.changeAnchor(this.element, anchor);
+  }
+  else {
+    dom.ketchup.dynamicPosition.register(this.element, anchor, null, null, true);
+  }
+  dom.ketchup.dynamicPosition.start(this.element);
+}, _KupTooltip_create = function _KupTooltip_create(options) {
+  this.element = document.createElement('kup-card');
+  this.element.id = 'kup-tooltip';
+  this.element.isMenu = true;
+  this.element.layoutNumber = 15;
+  this.element.sizeX = 'auto';
+  this.element.sizeY = 'auto';
+  if (options) {
+    __classPrivateFieldGet(this, _KupTooltip_instances, "m", _KupTooltip_setOptions).call(this, options);
+  }
+  document.body.appendChild(this.element);
+  __classPrivateFieldSet(this, _KupTooltip_clickCb, {
+    cb: () => {
+      this.hide();
+    },
+    el: this.element,
+  }, "f");
+}, _KupTooltip_setOptions = function _KupTooltip_setOptions(options) {
+  for (const key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      const prop = options[key];
+      this.element[key] = prop;
+    }
+  }
+};

package/dist/collection/types/GenericTypes.js

@@ -32,6 +32,7 @@ export var KupTagNames;
   KupTagNames["LIST"] = "KUP-LIST";
   KupTagNames["MAGIC_BOX"] = "KUP-MAGIC-BOX";
   KupTagNames["NAV_BAR"] = "KUP-NAV-BAR";
+  KupTagNames["NUMERIC_PICKER"] = "KUP-NUMERIC-PICKER";
   KupTagNames["PROBE"] = "KUP-PROBE";
   KupTagNames["PROGRESS_BAR"] = "KUP-PROGRESS-BAR";
   KupTagNames["QLIK"] = "KUP-QLIK";

package/dist/collection/utils/cell-utils.js

@@ -1,4 +1,3 @@
-import numeral from 'numeral';
 import { stringToNumber, unformattedStringToFormattedStringNumber, unformattedStringToFormattedStringTime, unformattedStringToFormattedStringTimestamp, } from './utils';
 import { KupDatesFormats } from '../managers/kup-dates/kup-dates-declarations';
 const dom = document.documentElement;
@@ -28,9 +27,9 @@ export function getValueForDisplay2(values, column) {
 }
 export function formatToNumber(cell) {
   if (cell.obj) {
-    return numeral(cell.obj.k).value();
+    return dom.ketchup.math.numberify(cell.obj.k);
   }
-  return numeral(cell.value).value();
+  return dom.ketchup.math.numberify(cell.value);
 }
 function _getCellValueForDisplay(value, column, cell) {
   let obj = column != null ? column.obj : null;