@sme.up/ketchup 8.0.0 → 8.0.2

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

@@ -8,7 +8,7 @@ import 'dayjs/locale/it';
 import 'dayjs/locale/pl';
 import 'dayjs/locale/ru';
 import 'dayjs/locale/zh';
-import { KupDatesLocales, KupDatesNormalize } from './kup-dates-declarations';
+import { KupDateTimeFormatOptionsMonth, KupDatesFormats, KupDatesLocales, KupDatesNormalize, } from './kup-dates-declarations';
 /**
  * Handles operations and formatting of dates.
  * @module KupDates
@@ -84,6 +84,59 @@ export class KupDates {
       .filter((value) => typeof value === 'string');
     return items;
   }
+  /**
+   * Gets date format by browser locale
+   * @returns {string} date format pattern, by browser locale
+   */
+  getDateFormat() {
+    const formatObj = new Intl.DateTimeFormat(this.getLocale()).formatToParts(new Date());
+    let dateFormat = formatObj
+      .map((obj) => {
+      switch (obj.type) {
+        case 'day':
+          return 'DD';
+        case 'month':
+          return 'MM';
+        case 'year':
+          return 'YYYY';
+        default:
+          return obj.value;
+      }
+    })
+      .join('');
+    return dateFormat;
+  }
+  /**
+   * Gets time format by browser locale
+   * @param {boolean} manageSeconds flag to set seconds managing
+   * @returns {string} time format pattern, by browser locale
+   */
+  getTimeFormat(manageSeconds) {
+    const options = {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    };
+    if (manageSeconds == true) {
+      options.second = '2-digit';
+    }
+    const formatObj = new Intl.DateTimeFormat(this.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;
+  }
   /**
    * Formats the given date.
    * @param {dayjs.ConfigType} input - Date to be formatted.
@@ -96,6 +149,23 @@ export class KupDates {
     }
     return dayjs(input).format(format);
   }
+  /**
+   * Gets the time formatted
+   * @param {Date} time time as Date object
+   * @param {boolean} manageSeconds flag to set seconds managing
+   * @return {string} time as string, formatted
+   **/
+  formatTime(time, manageSeconds) {
+    const options = {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    };
+    if (manageSeconds == true) {
+      options.second = '2-digit';
+    }
+    return time.toLocaleTimeString(this.getLocale() + '-u-hc-h23', options);
+  }
   /**
    * Validates the given date.
    * @param {dayjs.ConfigType} date - Date to be validated.
@@ -111,6 +181,16 @@ export class KupDates {
       return dayjs(date, undefined, strict).isValid();
     }
   }
+  /**
+   * Validates the given date as string.
+   * @param {string} value time string, formatted by actual browser locale
+   * @param {boolean} manageSeconds if manage seconds
+   * @returns {boolean} true if time string in input is a valid time
+   */
+  isValidFormattedStringTime(value, manageSeconds) {
+    let format = this.getTimeFormat(manageSeconds);
+    return this.isValid(value, format, true);
+  }
   /**
    * Converts the input in a Date object.
    * @param {dayjs.ConfigType} input - Input date.
@@ -323,6 +403,237 @@ export class KupDates {
   subtract(input, value, unit) {
     return dayjs(input).subtract(value, unit);
   }
+  /**
+   * Gets the month formatted
+   * @param {number} month month id
+   * @param {KupDateTimeFormatOptionsMonth} format format
+   * @returns {string} the month formatted, by browser locale
+   */
+  getMonthAsString(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(this.getLocale(), options);
+    return dateTimeFormat.format(dateTmp);
+  }
+  /**
+   * Gets the year months formatted
+   * @param {KupDateTimeFormatOptionsMonth} format format
+   * @returns {string[]} the months formatted, by browser locale
+   */
+  getMonthsAsString(format) {
+    if (format == null || format.trim() == '') {
+      format = KupDateTimeFormatOptionsMonth.LONG;
+    }
+    var months = [];
+    for (var i = 0; i < 12; i++) {
+      months[i] = this.getMonthAsString(i + 1, format);
+    }
+    return months;
+  }
+  /**
+   * Gets the day formatted
+   * @param {Date} date date
+   * @returns {string} the day formatted, by browser locale
+   */
+  getDayAsString(date) {
+    if (date == null) {
+      return '';
+    }
+    const options = {
+      weekday: 'narrow',
+      /** weekday: 'narrow' 'short' 'long' */
+    };
+    const dateTimeFormat = new Intl.DateTimeFormat(this.getLocale(), options);
+    return dateTimeFormat.format(date);
+  }
+  /**
+   * First day of current week
+   * @param {number} firstDayIndex first day of week index
+   * @returns {Date} the first day of current week
+   */
+  firstDayThisWeek(firstDayIndex) {
+    var d = new Date();
+    const day = d.getDay();
+    // dayIndex0
+    d.setDate(d.getDate() - day);
+    // dayIndexX
+    d.setDate(d.getDate() + firstDayIndex);
+    return d;
+  }
+  /**
+   * Dates of current week
+   * @param {number} firstDayIndex first day of week index
+   * @returns { startDate: Date; endDate: Date } the dates of current week
+   */
+  thisWeek(firstDayIndex) {
+    const firstDay = this.firstDayThisWeek(firstDayIndex);
+    return {
+      startDate: firstDay,
+      endDate: offsetDate(firstDay, 6),
+    };
+    function offsetDate(base, count) {
+      const date = new Date(base);
+      date.setDate(base.getDate() + count);
+      return date;
+    }
+  }
+  /**
+   * Gets the days of current week as string
+   * @param {number} firstDayIndex first day of week index
+   * @returns {string[]} the days of current week as string
+   */
+  getDaysOfWeekAsString(firstDayIndex) {
+    var thisWeekDays = this.thisWeek(firstDayIndex);
+    var monday = thisWeekDays.startDate;
+    var days = [];
+    for (var i = 0; i < 7; i++) {
+      var date = new Date(monday.toISOString());
+      date.setDate(date.getDate() + i);
+      days[i] = this.getDayAsString(date);
+    }
+    return days;
+  }
+  /**
+   * Gets the timestamp formatted
+   * @param {string} value date/time as string, formatted ISO
+   * @returns {string} date/time as string, formatted by actual browser locale
+   **/
+  timestampStringToFormattedString(value) {
+    const options = {
+      day: '2-digit',
+      month: '2-digit',
+      year: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+    };
+    let date = this.toDate(this.normalize(value, KupDatesNormalize.TIMESTAMP));
+    return date.toLocaleString(this.getLocale() + '-u-hc-h23', options);
+  }
+  /**
+   * Gets ISO date/time from formatted string, as string
+   * @param {string} value date/time as string, formatted by actual browser locale
+   * @returns {string} date/time as string, formatted ISO
+   **/
+  formattedStringToTimestampString(value) {
+    return this.formattedStringToCustomDateTime(value, KupDatesFormats.ISO_DATE_TIME, true);
+  }
+  /**
+   * Gets formatted dateTime as customed ISO (see KupDatesFormats)
+   * @param {string} value time as string, formatted by actual browser locale
+   * @param {string} outputFormat time format to return (see KupDatesFormats)
+   * @param {boolean} manageSeconds flag to set seconds managing
+   * @returns {string} time as string, formatted
+   **/
+  formattedStringToCustomDateTime(value, outputFormat, manageSeconds) {
+    let inputFormat = this.getTimeFormat(manageSeconds);
+    if (this.isValid(value, inputFormat)) {
+      return this.format(this.normalize(value, KupDatesNormalize.TIME), outputFormat);
+    }
+    else {
+      return '';
+    }
+  }
+  /**
+   * Gets the time formatted
+   * @param {string} value time as string, formatted ISO
+   * @param {boolean} manageSeconds flag to set seconds managing
+   * @param {string} customedFormat time format from smeupObject
+   * @returns {string} time as string, formatted by actual browser locale
+   **/
+  timeStringToFormattedString(value, manageSeconds, customedFormat) {
+    const options = {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    };
+    if (manageSeconds == true) {
+      options.second = '2-digit';
+    }
+    let date = this.toDate(this.normalize(value, KupDatesNormalize.TIME));
+    return formatByCustomedOutputTimeFormat(value, date, options, customedFormat, this);
+    function formatByCustomedOutputTimeFormat(valueStr, date, options, customedFormat, kupDates) {
+      if (customedFormat == null) {
+        return date.toLocaleTimeString(kupDates.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(kupDates.getLocale() + '-u-hc-h23', options);
+    }
+  }
   /**
    * Registers a KupComponent in KupDates, in order to be properly handled whenever the locale changes.
    * @param {any} component - The Ketchup component to be registered.

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

@@ -8,6 +8,7 @@ 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';
+import { getRegExpFromString } from '../../utils/utils';
 const dom = document.documentElement;
 /**
  * Handles mathematical operations and number formatting/conversion.
@@ -31,7 +32,7 @@ export class KupMath {
         const maximumFractionDigits = 14;
         if (value == null || value == '')
           return value;
-        return Number(value).toLocaleString(dom.ketchup.math.locale, {
+        return Number(value).toLocaleString(this.locale, {
           maximumFractionDigits: maximumFractionDigits,
         });
       },
@@ -102,10 +103,11 @@ export class KupMath {
    * 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).
+   * @param {boolean} inputIsLocalized Numberifies assuming the input string is in the current KupMath locale's format.
    * @returns {string} Formatted number.
    */
-  format(input, format) {
-    const n = this.numberify(input);
+  format(input, format, inputIsLocalized) {
+    const n = this.numberify(input, inputIsLocalized);
     if (!format) {
       const positiveN = Math.abs(n);
       const decimals = positiveN - Math.floor(positiveN);
@@ -116,16 +118,111 @@ export class KupMath {
         format = '0,0';
       }
     }
-    const formatted = this.numeral(n).format(format);
-    return formatted;
+    return this.numeral(n).format(format);
+  }
+  /**
+   * Create the pattern string for format a number
+   * @param {boolean} thousandPoint - show thousandPoint
+   * @param {number} decimals - number of decimals
+   * @returns {string} - formatter pattern
+   */
+  createFormatPattern(thousandPoint, decimals) {
+    var format = '0';
+    if (thousandPoint) {
+      format += ',0';
+    }
+    if (decimals && decimals > 0) {
+      format += '.';
+      for (let i = 0; i < decimals; i++) {
+        format += '0';
+      }
+    }
+    return format;
+  }
+  /**
+   * Returns the decimal separator of current browser
+   * @returns {string} current decimal separator, by locale
+   */
+  decimalSeparator() {
+    const numberWithGroupAndDecimalSeparator = 1000.1;
+    return Intl.NumberFormat(this.locale)
+      .formatToParts(numberWithGroupAndDecimalSeparator)
+      .find((part) => part.type === 'decimal').value;
+  }
+  /**
+   * Returns the group separator of current browser
+   * @returns {string} current group separator, by locale
+   */
+  groupSeparator() {
+    const numberWithGroupAndDecimalSeparator = 1000.1;
+    return Intl.NumberFormat(this.locale)
+      .formatToParts(numberWithGroupAndDecimalSeparator)
+      .find((part) => part.type === 'group').value;
+  }
+  /**
+   * Checks if an input string matches options, for desired formatted decimal number (integer digits, decimal digits)
+   * @param {string} value the input value to check
+   * @param {NumericFieldFormatOptions} options options for customize the check
+   * @returns {RegExpMatchArray} an object from applying the regular expression for check
+   */
+  matchNumericValueWithOptions(value, options) {
+    value = value.replace(getRegExpFromString(this.groupSeparator(), 'g'), '');
+    // see https://github.com/24eme/jquery-input-number-format.git
+    let found = undefined;
+    let integerPartSuffix = '+';
+    if (options.integer && options.integer > 0) {
+      integerPartSuffix = '{0,' + options.integer + '}';
+    }
+    let regexp = '^[0-9]' + integerPartSuffix;
+    if (options.allowNegative) {
+      regexp = '^-{0,1}[0-9]' + integerPartSuffix;
+    }
+    if (options.decimal && options.decimal > 0) {
+      regexp +=
+        '([' +
+          this.decimalSeparator() +
+          '][0-9]{0,' +
+          options.decimal +
+          '})?';
+      let regexpObj = new RegExp(regexp + '$');
+      found = value.match(regexpObj);
+      if (!found) {
+        regexp =
+          '^[' +
+            this.decimalSeparator() +
+            '][0-9]{0,' +
+            options.decimal +
+            '}';
+        regexpObj = new RegExp(regexp + '$');
+        found = value.match(regexpObj);
+      }
+    }
+    else {
+      let regexpObj = new RegExp(regexp + '$');
+      found = value.match(regexpObj);
+    }
+    return found;
   }
   /**
    * 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.
+   * @param {string} type - type of number for calculate suffix
    * @returns {number} Resulting number or NaN (when not a number).
    */
-  numberify(input, inputIsLocalized) {
+  numberify(input, inputIsLocalized, type) {
+    if (typeof input != 'number') {
+      if (type) {
+        let suffix = this.getNumericValueSuffix(type);
+        if (suffix != '') {
+          input = input.replace(getRegExpFromString(suffix, 'g'), '');
+        }
+      }
+      const groupSeparator = inputIsLocalized
+        ? this.groupSeparator()
+        : ',';
+      input = input.replace(getRegExpFromString(groupSeparator, 'g'), '');
+    }
     let n = NaN;
     if (inputIsLocalized) {
       n = this.numeral(input).value();
@@ -141,6 +238,161 @@ export class KupMath {
     }
     return n;
   }
+  /**
+   * Returns a number from a non-specified input type between string, number, or String.
+   * If value in is null, undefined or blank, returns 0
+   * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+   * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
+   * @param {string} type - type of number for calculate suffix
+   * @returns {number} Resulting number
+   **/
+  numberifySafe(input, inputIsLocalized, type) {
+    if (!input || input == null || input.trim() == '') {
+      input = '0';
+    }
+    return this.numberify(input, inputIsLocalized, type);
+  }
+  /**
+   * Checks if input is a valid number
+   * @param {any} value input value to check
+   * @returns {boolean} if input value is valid number
+   */
+  isNumber(value) {
+    //return typeof value === 'number';
+    return !isNaN(value);
+  }
+  /**
+   * Checks if string in input is a valid formatted number
+   * @param {string} value number as string, formatted by actual browser locale
+   * @param {string} type - type of number for calculate suffix
+   * @returns {boolean} true if number string in input is a valid number
+   */
+  isStringNumber(value, type) {
+    if (value == null || value.trim() == '') {
+      return false;
+    }
+    let tmpStr = this.formattedStringToNumberString(value, type);
+    if (this.isNumber(tmpStr)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Gets number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+   * @param {string} input number as string, formatted by actual browser locale (maybe)
+   * @param {string} type - type of number for calculate suffix
+   * @param {string} decSeparator - decimal serparator of input string
+   * @returns {string} number as string, formatted by locale US, decimal separator . (like java decimal numbers), without group separator
+   **/
+  formattedStringToNumberString(input, type, decSeparator) {
+    return numberStringToNumberString(input, type, decSeparator !== null && decSeparator !== void 0 ? decSeparator : this.decimalSeparator(), this);
+    function numberStringToNumberString(input, type, decFmt, kupMath) {
+      if (!input || input == null || input.trim() == '') {
+        return '';
+      }
+      let unf = kupMath.numberifySafe(input, decFmt != '.', type);
+      if (unf == null || isNaN(unf)) {
+        return input;
+      }
+      return numberToString(unf, -1, 'en-US', kupMath);
+    }
+    function numberToString(input, decimals, locale, kupMath) {
+      if (input == null) {
+        input = 0;
+      }
+      if (decimals == null || decimals == -1) {
+        decimals = kupMath.countDecimals(input);
+      }
+      let n = Number(input);
+      let f = decimals > -1
+        ? {
+          minimumFractionDigits: decimals,
+          maximumFractionDigits: decimals,
+          useGrouping: false,
+        }
+        : { useGrouping: false };
+      return n.toLocaleString(locale, f);
+    }
+  }
+  /**
+   * Gets the number of decimals for current number
+   * @param {number} value numer input
+   * @returns {number} the number of decimals
+   */
+  countDecimals(value) {
+    var _a;
+    if (Math.floor(value) === value)
+      return 0;
+    let stringValue = value.toString().split('.')[1];
+    if (stringValue) {
+      return (_a = stringValue.length) !== null && _a !== void 0 ? _a : 0;
+    }
+    else {
+      return 0;
+    }
+  }
+  /**
+   * Gets the suffix for number, by type
+   * @param {string} type - type of number for calculate suffix
+   * @returns {string} suffix for number, by type
+   **/
+  getNumericValueSuffix(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;
+  }
+  /**
+   * Gets the number as string, formatted by actual browser locale, with suffix by type
+   * @param {number} input number
+   * @param {number} decimals number of significant decimal digits for output
+   * @param {string} type - type of number for calculate suffix
+   * @returns {string} number as string, formatted by actual browser locale, with suffix by type
+   **/
+  numberToFormattedString(input, decimals, type) {
+    if (input == null || isNaN(input)) {
+      return '';
+    }
+    if (decimals == null || decimals == -1) {
+      decimals = this.countDecimals(input);
+    }
+    let nstr = this.format(input, this.createFormatPattern(true, decimals));
+    nstr = nstr + this.getNumericValueSuffix(type);
+    return nstr;
+  }
+  /**
+   * Gets the number as string, formatted by actual browser locale, with suffix by type
+   * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+   * @param {number} decimals number of significant decimal digits for output
+   * @param {string} type - type of number for calculate suffix
+   * @param {string} decSeparator decimal separator for outpu string
+   * @returns {string} number as string, formatted by actual browser locale (or using decimal separator param), with suffix by type
+   **/
+  numberStringToFormattedString(input, decimals, type, decSeparator) {
+    let value = this.numberToFormattedString(this.numberifySafe(input), decimals, type);
+    if (!decSeparator) {
+      return value;
+    }
+    const browserDecSeparator = this.decimalSeparator();
+    if (browserDecSeparator == decSeparator) {
+      return value;
+    }
+    const browserGroupSeparator = this.groupSeparator();
+    value = value.replace(getRegExpFromString(browserGroupSeparator, 'g'), '');
+    value = value.replace(getRegExpFromString(browserDecSeparator, 'g'), decSeparator);
+    return value;
+  }
   /**
    * Registers a KupComponent in KupMath, in order to be properly handled whenever the locale changes.
    * @param {any} component - The Ketchup component to be registered.

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

@@ -1,4 +1,3 @@
-import { stringToNumber, unformattedStringToFormattedStringNumber, unformattedStringToFormattedStringTime, unformattedStringToFormattedStringTimestamp, } from './utils';
 import { KupDatesFormats } from '../managers/kup-dates/kup-dates-declarations';
 const dom = document.documentElement;
 // -------------
@@ -43,17 +42,17 @@ export function getValueForDisplay(value, obj, decimals) {
     return value;
   }
   if (dom.ketchup.objects.isNumber(obj)) {
-    return unformattedStringToFormattedStringNumber(value, decimals ? decimals : -1, obj ? obj.p : '');
+    return dom.ketchup.math.numberStringToFormattedString(value, decimals ? decimals : -1, obj ? obj.p : '');
   }
   if (dom.ketchup.objects.isDate(obj) &&
     dom.ketchup.dates.isValid(value, KupDatesFormats.ISO_DATE)) {
     return dom.ketchup.dates.format(value);
   }
   if (dom.ketchup.objects.isTime(obj)) {
-    return unformattedStringToFormattedStringTime(value, dom.ketchup.objects.isTimeWithSeconds(obj), obj.t + obj.p);
+    return dom.ketchup.dates.timeStringToFormattedString(value, dom.ketchup.objects.isTimeWithSeconds(obj), obj.t + obj.p);
   }
   if (dom.ketchup.objects.isTimestamp(obj)) {
-    return unformattedStringToFormattedStringTimestamp(value);
+    return dom.ketchup.dates.timestampStringToFormattedString(value);
   }
   return value;
 }
@@ -98,8 +97,8 @@ export function compareValues(obj1, value1, obj2, value2, sortMode) {
   let v1 = s1;
   let v2 = s2;
   if (dom.ketchup.objects.isNumber(obj1)) {
-    v1 = stringToNumber(s1);
-    v2 = stringToNumber(s2);
+    v1 = dom.ketchup.math.numberifySafe(s1);
+    v2 = dom.ketchup.math.numberifySafe(s2);
   }
   else if (dom.ketchup.objects.isDate(obj1)) {
     v1 = dom.ketchup.dates.toDate(dom.ketchup.dates.format(s1, KupDatesFormats.ISO_DATE));