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

package/dist/cjs/utils-1b5c8c70.js

@@ -0,0 +1,482 @@
+'use strict';
+
+const kupManager = require('./kup-manager-5877b2ee.js');
+
+const dom = document.documentElement;
+exports.DateTimeFormatOptionsMonth = void 0;
+(function (DateTimeFormatOptionsMonth) {
+  DateTimeFormatOptionsMonth["NUMERIC"] = "numeric";
+  DateTimeFormatOptionsMonth["DIGIT2"] = "2-digit";
+  DateTimeFormatOptionsMonth["LONG"] = "long";
+  DateTimeFormatOptionsMonth["SHORT"] = "short";
+  DateTimeFormatOptionsMonth["NARROW"] = "narrow";
+})(exports.DateTimeFormatOptionsMonth || (exports.DateTimeFormatOptionsMonth = {}));
+function identify(array) {
+  if (array) {
+    for (let i = 0; i < array.length; i++) {
+      array[i].id = i.toString();
+    }
+  }
+}
+function getSeparator(locale, separatorType) {
+  const numberWithGroupAndDecimalSeparator = 1000.1;
+  return Intl.NumberFormat(locale)
+    .formatToParts(numberWithGroupAndDecimalSeparator)
+    .find((part) => part.type === separatorType).value;
+}
+function getCurrentTimeFormatFromBrowserLocale(manageSeconds) {
+  const options = {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  };
+  if (manageSeconds == true) {
+    options.second = '2-digit';
+  }
+  const formatObj = new Intl.DateTimeFormat(dom.ketchup.dates.getLocale() + '-u-hc-h23', options).formatToParts(new Date());
+  let timeFormat = formatObj
+    .map((obj) => {
+    switch (obj.type) {
+      case 'hour':
+        return 'HH';
+      case 'minute':
+        return 'mm';
+      case 'second':
+        return 'ss';
+      default:
+        return obj.value;
+    }
+  })
+    .join('');
+  return timeFormat;
+}
+/**
+ * Check if an object is undefined, null or empty
+ * @param obj the object to check
+ * @returns true or false
+ */
+function isEmpty(obj) {
+  return (!obj ||
+    obj === null ||
+    (Object.keys(obj).length === 0 && obj.constructor === Object));
+}
+/**
+ * @param value number as string, formatted by actual browser locale
+ * @param type - type of number for calculate suffix
+ * @returns true if number string in input is a valid number
+ */
+function isValidFormattedStringNumber(value, type) {
+  if (value == null || value.trim() == '') {
+    return false;
+  }
+  let tmpStr = formattedStringToUnformattedStringNumber(value, type);
+  if (isNumber(tmpStr)) {
+    return true;
+  }
+  return false;
+}
+function isNumber(value) {
+  //return typeof value === 'number';
+  return !isNaN(value);
+}
+/**
+ * @param input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+ * @returns number
+ **/
+function stringToNumber(input) {
+  if (!input || input == null || input.trim() == '') {
+    input = '0';
+  }
+  return dom.ketchup.math.numberify(input);
+}
+/**
+ * @param input number
+ * @param decimals number of significant decimal digits for output
+ * @returns number as string, formatted by actual browser locale
+ **/
+function numberToString(input, decimals) {
+  if (input == null) {
+    return '';
+  }
+  return _numberToString(input, decimals, dom.ketchup.dates.getLocale(), true);
+}
+/**
+ * @param type - type of number for calculate suffix
+ * @returns suffix for number, by type
+ **/
+function getNumericValueSuffixByType(type) {
+  type = type.toUpperCase();
+  let nstr = '';
+  if (type == 'P') {
+    nstr = ' %';
+  }
+  else if (type == 'VE') {
+    nstr = ' €';
+  }
+  else if (type == 'VL') {
+    nstr = ' £';
+  }
+  else if (type == 'VV') {
+    nstr = ' $';
+  }
+  return nstr;
+}
+/**
+ * @param input number
+ * @param decimals number of significant decimal digits for output
+ * @param type - type of number for calculate suffix
+ * @returns number as string, formatted by actual browser locale, with suffix by type
+ **/
+function numberToFormattedStringNumber(input, decimals, type) {
+  if (input == null || isNaN(input)) {
+    return '';
+  }
+  let nstr = numberToString(input, decimals);
+  nstr = nstr + getNumericValueSuffixByType(type);
+  return nstr;
+}
+/**
+ * @param input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+ * @param decimals number of significant decimal digits for output
+ * @param type - type of number for calculate suffix
+ * @returns number as string, formatted by actual browser locale, with suffix by type
+ **/
+function unformattedStringToFormattedStringNumber(input, decimals, type) {
+  return numberToFormattedStringNumber(stringToNumber(input), decimals, type);
+}
+/**
+ * @param input number as string, formatted by actual browser locale
+ * @param type - type of number for calculate suffix
+ * @returns number as string, formatted by locale US, decimal separator . (like java decimal numbers), without group separator
+ **/
+function formattedStringToUnformattedStringNumber(input, type) {
+  return numberStringToNumberString(input, type, getDecimalSeparator(dom.ketchup.dates.getLocale()));
+}
+/**
+ * @param input number as string, formatted by locale US, decimal separator . (like java decimal numbers), with group separator
+ * @param type - type of number for calculate suffix
+ * @returns number as string, formatted by locale US, decimal separator . (like java decimal numbers), without group separator
+ **/
+function unformattedStringNumberToNumber(input, type) {
+  return numberStringToNumberString(input, type, '.');
+}
+function numberStringToNumberString(input, type, decFmt) {
+  if (input == null || input.trim() == '') {
+    return '';
+  }
+  let originalInputValue = input;
+  let suffix = getNumericValueSuffixByType(type);
+  if (suffix != '') {
+    input = input.replace(suffix, '');
+  }
+  let regExpr = null;
+  if (decFmt == '.') {
+    regExpr = /,/g;
+  }
+  else {
+    regExpr = /\./g;
+  }
+  input = input.replace(regExpr, '');
+  if (decFmt != '.') {
+    input = input.replace(/,/g, '.');
+  }
+  if (dom.ketchup.math.numberify(input) == null ||
+    isNaN(dom.ketchup.math.numberify(input))) {
+    return originalInputValue;
+  }
+  let unf = stringToNumber(input);
+  return _numberToString(unf, -1, 'en-US', false);
+}
+function getDecimalSeparator(locale) {
+  return getSeparator(locale, 'decimal');
+}
+function countDecimals(value) {
+  if (Math.floor(value) === value)
+    return 0;
+  let stringValue = value.toString().split('.')[1];
+  if (stringValue) {
+    return stringValue.length ? stringValue.length : 0;
+  }
+  else {
+    return 0;
+  }
+}
+function _numberToString(input, decimals, locale, useGrouping) {
+  if (input == null) {
+    input = 0;
+  }
+  if (decimals == null || decimals == -1) {
+    decimals = countDecimals(input);
+  }
+  let n = Number(input);
+  let f = decimals > -1
+    ? {
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals,
+      useGrouping: useGrouping,
+    }
+    : { useGrouping: useGrouping };
+  return n.toLocaleString(locale, f);
+}
+/**
+ * @param time time as Date object
+ * @param manageSeconds flag to set seconds managing
+ * @return time as string, formatted
+ **/
+function formatTime(time, manageSeconds) {
+  const options = {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  };
+  if (manageSeconds == true) {
+    options.second = '2-digit';
+  }
+  return time.toLocaleTimeString(dom.ketchup.dates.getLocale() + '-u-hc-h23', options);
+}
+/**
+ * @param value time string, formatted by actual browser locale
+ * @returns true if time string in input is a valid time
+ */
+function isValidFormattedStringTime(value, manageSeconds) {
+  let format = getCurrentTimeFormatFromBrowserLocale(manageSeconds);
+  return dom.ketchup.dates.isValid(value, format, true);
+}
+/**
+ * @param value date/time as string, formatted by actual browser locale
+ * @returns date/time as string, formatted ISO
+ **/
+function formattedStringToDefaultUnformattedStringTimestamp(value) {
+  return formattedStringToCustomUnformattedStringTime(value, kupManager.KupDatesFormats.ISO_DATE_TIME, true);
+}
+/**
+ * @param value time as string, formatted by actual browser locale
+ * @param outputFormat time format to return
+ * @param manageSeconds flag to set seconds managing
+ * @returns time as string, formatted
+ **/
+function formattedStringToCustomUnformattedStringTime(value, outputFormat, manageSeconds) {
+  let inputFormat = getCurrentTimeFormatFromBrowserLocale(manageSeconds);
+  if (dom.ketchup.dates.isValid(value, inputFormat)) {
+    return dom.ketchup.dates.format(dom.ketchup.dates.normalize(value, kupManager.KupDatesNormalize.TIME), outputFormat);
+  }
+  else {
+    return '';
+  }
+}
+/**
+ * @param value time as string, formatted ISO
+ * @param manageSeconds flag to set seconds managing
+ * @param valueTimeFormat time format (default ISO)
+ * @param customedFormat time format from smeupObject
+ * @returns time as string, formatted by actual browser locale
+ **/
+function unformattedStringToFormattedStringTime(value, manageSeconds, customedFormat) {
+  const options = {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  };
+  if (manageSeconds == true) {
+    options.second = '2-digit';
+  }
+  let date = dom.ketchup.dates.toDate(dom.ketchup.dates.normalize(value, kupManager.KupDatesNormalize.TIME));
+  return formatByCustomedOutputTimeFormat(value, date, options, customedFormat);
+}
+function formatByCustomedOutputTimeFormat(valueStr, date, options, customedFormat) {
+  if (customedFormat == null) {
+    return date.toLocaleTimeString(dom.ketchup.dates.getLocale() + '-u-hc-h23', options);
+  }
+  switch (customedFormat) {
+    case 'I13': {
+      //hh:mm
+      break;
+    }
+    case 'I12': {
+      //hh:mm:ss
+      break;
+    }
+    case 'I11': {
+      //???
+      //hh:dddd
+      //return moment(date).format('HH:DDDD');
+      return valueStr;
+    }
+    case 'I14': {
+      //???
+      //sssss
+      //return moment(date).format('SSSSS');
+      return valueStr;
+    }
+    case 'I1H': {
+      //???
+      //Ora,Cen/Min HH,xx
+      return valueStr;
+    }
+    case 'I1M': {
+      //???
+      //Min,Cen/Sec  MMMM,xx
+      return valueStr;
+    }
+    case 'I21': {
+      //???
+      //Giorni,(4 decim)
+      return valueStr;
+    }
+    case 'I22': {
+      //???
+      //Ore,(4 decim)
+      return valueStr;
+    }
+    case 'I23': {
+      //???
+      //Minuti,(4 decim)
+      return valueStr;
+    }
+    case 'I24': {
+      //???
+      //Secondi
+      return valueStr;
+    }
+    case 'I2H': {
+      //???
+      //Ora,Cen/Min HHHH,xx
+      return valueStr;
+    }
+    case 'I2D': {
+      //???
+      //Ore Minuti Secondi HHMMS
+      return valueStr;
+    }
+    case 'I2M': {
+      //???
+      //Min,Cen/Sec MMMM,xx
+      return valueStr;
+    }
+  }
+  return date.toLocaleTimeString(dom.ketchup.dates.getLocale() + '-u-hc-h23', options);
+}
+/**
+ * @param value date/time as string, formatted ISO
+ * @param valueDateFormat date/time format (default ISO)
+ * @returns date/time as string, formatted by actual browser locale
+ **/
+function unformattedStringToFormattedStringTimestamp(value) {
+  const options = {
+    day: '2-digit',
+    month: '2-digit',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+  };
+  let date = dom.ketchup.dates.toDate(dom.ketchup.dates.normalize(value, kupManager.KupDatesNormalize.TIMESTAMP));
+  return date.toLocaleString(dom.ketchup.dates.getLocale() + '-u-hc-h23', options);
+}
+function getMonthAsStringByLocale(month, format) {
+  if (month == null) {
+    return '';
+  }
+  const dateTmp = new Date();
+  dateTmp.setDate(1);
+  dateTmp.setMonth(month - 1);
+  const options = {
+    month: format,
+  };
+  const dateTimeFormat = new Intl.DateTimeFormat(dom.ketchup.dates.getLocale(), options);
+  return dateTimeFormat.format(dateTmp);
+}
+function getMonthsAsStringByLocale(format) {
+  if (format == null || format.trim() == '') {
+    format = exports.DateTimeFormatOptionsMonth.LONG;
+  }
+  var months = [];
+  for (var i = 0; i < 12; i++) {
+    months[i] = getMonthAsStringByLocale(i + 1, format);
+  }
+  return months;
+}
+function deepEqual(object1, object2) {
+  if (!(isObject(object1) && isObject(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 = isObject(val1) && isObject(val2);
+    if ((areObjects && !deepEqual(val1, val2)) ||
+      (!areObjects && val1 !== val2)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isObject(object) {
+  return object != null && typeof object === 'object';
+}
+/**
+ * Used to retrieve component's props values.
+ * @param {any} comp - Component calling this function.
+ * @param {GenericObject} list - Prop list, specific for each component.
+ * @param {boolean} descriptions - When provided and true, the result will be the list of props with their description.
+ * @returns {Promise<GenericObject>} List of props as object, each key will be a prop.
+ */
+function getProps(comp, list, descriptions) {
+  let props = {};
+  if (descriptions) {
+    props = list;
+  }
+  else {
+    for (const key in list) {
+      if (Object.prototype.hasOwnProperty.call(list, key)) {
+        props[key] = comp[key];
+      }
+    }
+  }
+  return props;
+}
+/**
+ * Sets the props to the component.
+ * @param {any} comp - Component calling this function.
+ * @param {GenericObject} list - Prop list, specific for each component.
+ * @param {GenericObject} props - Prop to be set.
+ */
+function setProps(comp, list, props) {
+  for (const key in props) {
+    // If key is a custom prop it will be set on the component (i.e.: "data", "customStyle", ecc.)
+    if (list[key]) {
+      comp[key] = props[key];
+    }
+    else {
+      // Otherwise, it will be set on its HTML element (i.e.: "id", "style", ecc.)
+      comp.rootElement[key] = props[key];
+    }
+  }
+}
+
+exports.deepEqual = deepEqual;
+exports.formatTime = formatTime;
+exports.formattedStringToCustomUnformattedStringTime = formattedStringToCustomUnformattedStringTime;
+exports.formattedStringToDefaultUnformattedStringTimestamp = formattedStringToDefaultUnformattedStringTimestamp;
+exports.formattedStringToUnformattedStringNumber = formattedStringToUnformattedStringNumber;
+exports.getDecimalSeparator = getDecimalSeparator;
+exports.getMonthsAsStringByLocale = getMonthsAsStringByLocale;
+exports.getProps = getProps;
+exports.identify = identify;
+exports.isEmpty = isEmpty;
+exports.isNumber = isNumber;
+exports.isValidFormattedStringNumber = isValidFormattedStringNumber;
+exports.isValidFormattedStringTime = isValidFormattedStringTime;
+exports.numberToFormattedStringNumber = numberToFormattedStringNumber;
+exports.setProps = setProps;
+exports.stringToNumber = stringToNumber;
+exports.unformattedStringNumberToNumber = unformattedStringNumberToNumber;
+exports.unformattedStringToFormattedStringNumber = unformattedStringToFormattedStringNumber;
+exports.unformattedStringToFormattedStringTime = unformattedStringToFormattedStringTime;
+exports.unformattedStringToFormattedStringTimestamp = unformattedStringToFormattedStringTimestamp;

package/dist/collection/assets/calendar.js

@@ -168,7 +168,52 @@ const callback = (e) => {
 const calendars = document.querySelectorAll('kup-calendar');
 for (let index = 0; index < calendars.length; index++) {
     const calendar = calendars[index];
-    calendar.data = { ...data };
+    calendar.data = { columns: [...data.columns], rows: data.rows };
+    const dateCol = calendar.data.columns.find((col) => col.name === 'date');
+    const descrCol = calendar.data.columns.find((col) => col.name === 'descr');
+    const endCol = calendar.data.columns.find((col) => col.name === 'end');
+    const iconCol = calendar.data.columns.find((col) => col.name === 'icon');
+    const imageCol = calendar.data.columns.find((col) => col.name === 'image');
+    const startCol = calendar.data.columns.find((col) => col.name === 'start');
+    const styleCol = calendar.data.columns.find((col) => col.name === 'style');
+    calendar.data.columns[calendar.data.columns.indexOf(dateCol)] = {
+        ...dateCol,
+        calendarOption: 'date',
+    };
+    calendar.data.columns[calendar.data.columns.indexOf(descrCol)] = {
+        ...descrCol,
+        calendarOption: 'descr',
+    };
+    switch (calendar.id) {
+        case 'week-view':
+            calendar.data.columns[calendar.data.columns.indexOf(endCol)] = {
+                ...endCol,
+                calendarOption: 'end',
+            };
+            calendar.data.columns[calendar.data.columns.indexOf(startCol)] = {
+                ...startCol,
+                calendarOption: 'start',
+            };
+            break;
+        case 'with-icon':
+            calendar.data.columns[calendar.data.columns.indexOf(iconCol)] = {
+                ...iconCol,
+                calendarOption: 'icon',
+            };
+            break;
+        case 'with-images':
+            calendar.data.columns[calendar.data.columns.indexOf(imageCol)] = {
+                ...imageCol,
+                calendarOption: 'image',
+            };
+            break;
+        case 'with-style':
+            calendar.data.columns[calendar.data.columns.indexOf(styleCol)] = {
+                ...styleCol,
+                calendarOption: 'style',
+            };
+            break;
+    }
     calendar.addEventListener('kup-calendar-dateclick', callback);
     calendar.addEventListener('kup-calendar-eventclick', callback);
     calendar.addEventListener('kup-calendar-eventdrop', callback);

package/dist/collection/assets/card.js

@@ -325,16 +325,16 @@ for (let index = 0; index < cards.length; index++) {
             {
                 data: [
                     {
-                        value: '1_chip',
-                        icon: 'filter_1',
-                        label: 'First chip',
                         checked: false,
+                        icon: 'filter_1',
+                        id: '1_chip',
+                        value: 'First chip',
                     },
                     {
-                        value: '2_chip',
-                        icon: 'filter_2',
-                        label: 'Second chip',
                         checked: true,
+                        icon: 'filter_2',
+                        id: '2_chip',
+                        value: 'Second chip',
                     },
                 ],
             },
@@ -2711,15 +2711,15 @@ for (let index = 0; index < cards.length; index++) {
                     val = this.tag.getAttribute(prefix + key);
                     if (val === undefined || val === null) {
                         val = UNSET_OPTION;
-                    } else if (val.substr(0, 1) === '[') {
-                        val = val.substr(1, val.length - 2).split(',');
+                    } else if (val.substring(0, 1) === '[') {
+                        val = val.substring(1, val.length - 1).split(',');
                         for (i = val.length; i--; ) {
                             val[i] = normalizeValue(
                                 val[i].replace(/(^\s*)|(\s*$)/g, '')
                             );
                         }
-                    } else if (val.substr(0, 1) === '{') {
-                        pairs = val.substr(1, val.length - 2).split(',');
+                    } else if (val.substring(0, 1) === '{') {
+                        pairs = val.substring(1, val.length - 1).split(',');
                         val = {};
                         for (i = pairs.length; i--; ) {
                             keyval = pairs[i].split(':', 2);
@@ -4288,8 +4288,8 @@ for (let index = 0; index < cards.length; index++) {
             getCurrentRegionFields: function () {
                 var currentRegion = this.currentRegion;
                 return {
-                    fieldkey: currentRegion.substr(0, 1),
-                    value: this.values[currentRegion.substr(1)],
+                    fieldkey: currentRegion.substring(0, 1),
+                    value: this.values[currentRegion.substring(1)],
                     region: currentRegion,
                 };
             },
@@ -4299,10 +4299,10 @@ for (let index = 0; index < cards.length; index++) {
                     shapeid = this.valueShapes[currentRegion],
                     shape;
                 delete this.shapes[shapeid];
-                switch (currentRegion.substr(0, 1)) {
+                switch (currentRegion.substring(0, 1)) {
                     case 'r':
                         shape = this.renderRange(
-                            currentRegion.substr(1),
+                            currentRegion.substring(1),
                             highlight
                         );
                         break;
@@ -5577,7 +5577,7 @@ for (let index = 0; index < cards.length; index++) {
             },
 
             getShapeAt: function (el, x, y) {
-                var shapeid = el.id.substr(8);
+                var shapeid = el.id.substring(8);
                 return shapeid;
             },
 

package/dist/collection/assets/data-table.js

@@ -8,10 +8,21 @@ document.addEventListener('kup-cell-update', (e) => {
     };
     e.target.refresh();
 });
+document.addEventListener('kup-cell-input', (e) => {
+    console.log(e);
+});
+document.addEventListener('kup-cell-click', (e) => {
+    console.log(e);
+});
+document.addEventListener('kup-cell-iconclick', (e) => {
+    console.log(e);
+});
 document.addEventListener('kup-datatable-rowactionclick', (e) =>
     console.log(e)
 );
 document.addEventListener('kupColumnMenuActive', (e) => console.log(e));
+document.addEventListener('kup-datatable-columnmove', (e) => console.log(e));
+document.addEventListener('kup-datatable-columnremove', (e) => console.log(e));
 document.addEventListener('kup-datatable-dblclick', (e) => console.log(e));
 document.addEventListener('kup-datatable-contextmenu', (e) => console.log(e));
 document.addEventListener('kup-datatable-click', (e) => console.log(e));
@@ -346,13 +357,13 @@ const completeData = {
                     data: {
                         data: [
                             {
-                                value: 'text',
-                                label: 'Text only',
+                                id: 'text',
+                                value: 'Text only',
                             },
                             {
-                                value: 'icon',
                                 icon: 'widgets',
-                                label: 'With icon',
+                                id: 'icon',
+                                value: 'With icon',
                             },
                         ],
                     },
@@ -552,6 +563,7 @@ const completeData = {
                     value: '10',
                 },
                 RATING: {
+                    isEditable: true,
                     data: {
                         value: '5',
                         maxValue: 10,
@@ -124255,10 +124267,10 @@ const jlObjectsTestData = {
                     data: {
                         data: [
                             {
-                                label: 'Federico Robertozzi',
+                                value: 'Federico Robertozzi',
                             },
                             {
-                                label: 'Parodonte Frascati',
+                                value: 'Parodonte Frascati',
                             },
                         ],
                     },

package/dist/collection/assets/index.js

@@ -90,6 +90,10 @@ components.data = [
         text: 'Dropdown button',
         value: 'dropdown-button.html',
     },
+    {
+        text: 'Echart',
+        value: 'echart.html',
+    },
     {
         text: 'Gauge',
         value: 'gauge.html',
@@ -98,6 +102,10 @@ components.data = [
         text: 'Image',
         value: 'image.html',
     },
+    {
+        text: 'KupData',
+        value: 'kupdata.html',
+    },
     {
         text: 'Layout',
         value: 'layout.html',