@ionic/core 7.5.7 → 7.5.8-dev.11701293337.112ba209

package/dist/collection/components/datetime/utils/format.js

@@ -4,65 +4,65 @@
 import { is24Hour } from "./helpers";
 import { convertDataToISO } from "./manipulation";
 const getFormattedDayPeriod = (dayPeriod) => {
-  if (dayPeriod === undefined) {
-    return '';
-  }
-  return dayPeriod.toUpperCase();
+    if (dayPeriod === undefined) {
+        return '';
+    }
+    return dayPeriod.toUpperCase();
 };
 export const getLocalizedTime = (locale, refParts, hourCycle) => {
-  const timeParts = {
-    hour: refParts.hour,
-    minute: refParts.minute,
-  };
-  if (timeParts.hour === undefined || timeParts.minute === undefined) {
-    return 'Invalid Time';
-  }
-  return new Intl.DateTimeFormat(locale, {
-    hour: 'numeric',
-    minute: 'numeric',
-    /**
-     * Setting the timeZone to UTC prevents
-     * new Intl.DatetimeFormat from subtracting
-     * the user's current timezone offset
-     * when formatting the time.
-     */
-    timeZone: 'UTC',
-    /**
-     * We use hourCycle here instead of hour12 due to:
-     * https://bugs.chromium.org/p/chromium/issues/detail?id=1347316&q=hour12&can=2
-     */
-    hourCycle,
-    /**
-     * Setting Z at the end indicates that this
-     * date string is in the UTC time zone. This
-     * prevents new Date from adding the time zone
-     * offset when getting the ISO string.
-     */
-  }).format(new Date(convertDataToISO(Object.assign({
-    /**
-     * JS uses a simplified ISO 8601 format which allows for
-     * date-only formats and date-time formats, but not
-     * time-only formats: https://tc39.es/ecma262/#sec-date-time-string-format
-     * As a result, developers who only pass a time will get
-     * an "Invalid Date" error. To account for this, we make sure that
-     * year/day/month values are set when passing to new Date().
-     * The Intl.DateTimeFormat call above only uses the hour/minute
-     * values, so passing these date values should have no impact
-     * on the time output.
-     */
-    year: 2023, day: 1, month: 1
-  }, timeParts)) + 'Z'));
+    const timeParts = {
+        hour: refParts.hour,
+        minute: refParts.minute,
+    };
+    if (timeParts.hour === undefined || timeParts.minute === undefined) {
+        return 'Invalid Time';
+    }
+    return new Intl.DateTimeFormat(locale, {
+        hour: 'numeric',
+        minute: 'numeric',
+        /**
+         * Setting the timeZone to UTC prevents
+         * new Intl.DatetimeFormat from subtracting
+         * the user's current timezone offset
+         * when formatting the time.
+         */
+        timeZone: 'UTC',
+        /**
+         * We use hourCycle here instead of hour12 due to:
+         * https://bugs.chromium.org/p/chromium/issues/detail?id=1347316&q=hour12&can=2
+         */
+        hourCycle,
+        /**
+         * Setting Z at the end indicates that this
+         * date string is in the UTC time zone. This
+         * prevents new Date from adding the time zone
+         * offset when getting the ISO string.
+         */
+    }).format(new Date(convertDataToISO(Object.assign({
+        /**
+         * JS uses a simplified ISO 8601 format which allows for
+         * date-only formats and date-time formats, but not
+         * time-only formats: https://tc39.es/ecma262/#sec-date-time-string-format
+         * As a result, developers who only pass a time will get
+         * an "Invalid Date" error. To account for this, we make sure that
+         * year/day/month values are set when passing to new Date().
+         * The Intl.DateTimeFormat call above only uses the hour/minute
+         * values, so passing these date values should have no impact
+         * on the time output.
+         */
+        year: 2023, day: 1, month: 1
+    }, timeParts)) + 'Z'));
 };
 /**
  * Adds padding to a time value so
  * that it is always 2 digits.
  */
 export const addTimePadding = (value) => {
-  const valueToString = value.toString();
-  if (valueToString.length > 1) {
-    return valueToString;
-  }
-  return `0${valueToString}`;
+    const valueToString = value.toString();
+    if (valueToString.length > 1) {
+        return valueToString;
+    }
+    return `0${valueToString}`;
 };
 /**
  * Formats 24 hour times so that
@@ -71,34 +71,34 @@ export const addTimePadding = (value) => {
  * hour 0 is formatted as '12'.
  */
 export const getFormattedHour = (hour, hourCycle) => {
-  /**
-   * Midnight for h11 starts at 0:00am
-   * Midnight for h12 starts at 12:00am
-   * Midnight for h23 starts at 00:00
-   * Midnight for h24 starts at 24:00
-   */
-  if (hour === 0) {
-    switch (hourCycle) {
-      case 'h11':
-        return '0';
-      case 'h12':
-        return '12';
-      case 'h23':
-        return '00';
-      case 'h24':
-        return '24';
-      default:
-        throw new Error(`Invalid hour cycle "${hourCycle}"`);
+    /**
+     * Midnight for h11 starts at 0:00am
+     * Midnight for h12 starts at 12:00am
+     * Midnight for h23 starts at 00:00
+     * Midnight for h24 starts at 24:00
+     */
+    if (hour === 0) {
+        switch (hourCycle) {
+            case 'h11':
+                return '0';
+            case 'h12':
+                return '12';
+            case 'h23':
+                return '00';
+            case 'h24':
+                return '24';
+            default:
+                throw new Error(`Invalid hour cycle "${hourCycle}"`);
+        }
     }
-  }
-  const use24Hour = is24Hour(hourCycle);
-  /**
-   * h23 and h24 use 24 hour times.
-   */
-  if (use24Hour) {
-    return addTimePadding(hour);
-  }
-  return hour.toString();
+    const use24Hour = is24Hour(hourCycle);
+    /**
+     * h23 and h24 use 24 hour times.
+     */
+    if (use24Hour) {
+        return addTimePadding(hour);
+    }
+    return hour.toString();
 };
 /**
  * Generates an aria-label to be read by screen readers
@@ -106,32 +106,32 @@ export const getFormattedHour = (hour, hourCycle) => {
  * today's date.
  */
 export const generateDayAriaLabel = (locale, today, refParts) => {
-  if (refParts.day === null) {
-    return null;
-  }
-  /**
-   * MM/DD/YYYY will return midnight in the user's timezone.
-   */
-  const date = getNormalizedDate(refParts);
-  const labelString = new Intl.DateTimeFormat(locale, {
-    weekday: 'long',
-    month: 'long',
-    day: 'numeric',
-    timeZone: 'UTC',
-  }).format(date);
-  /**
-   * If date is today, prepend "Today" so screen readers indicate
-   * that the date is today.
-   */
-  return today ? `Today, ${labelString}` : labelString;
+    if (refParts.day === null) {
+        return null;
+    }
+    /**
+     * MM/DD/YYYY will return midnight in the user's timezone.
+     */
+    const date = getNormalizedDate(refParts);
+    const labelString = new Intl.DateTimeFormat(locale, {
+        weekday: 'long',
+        month: 'long',
+        day: 'numeric',
+        timeZone: 'UTC',
+    }).format(date);
+    /**
+     * If date is today, prepend "Today" so screen readers indicate
+     * that the date is today.
+     */
+    return today ? `Today, ${labelString}` : labelString;
 };
 /**
  * Gets the day of the week, month, and day
  * Used for the header in MD mode.
  */
 export const getMonthAndDay = (locale, refParts) => {
-  const date = getNormalizedDate(refParts);
-  return new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' }).format(date);
+    const date = getNormalizedDate(refParts);
+    return new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' }).format(date);
 };
 /**
  * Given a locale and a date object,
@@ -140,8 +140,8 @@ export const getMonthAndDay = (locale, refParts) => {
  * Example: May 2021
  */
 export const getMonthAndYear = (locale, refParts) => {
-  const date = getNormalizedDate(refParts);
-  return new Intl.DateTimeFormat(locale, { month: 'long', year: 'numeric', timeZone: 'UTC' }).format(date);
+    const date = getNormalizedDate(refParts);
+    return new Intl.DateTimeFormat(locale, { month: 'long', year: 'numeric', timeZone: 'UTC' }).format(date);
 };
 /**
  * Given a locale and a date object,
@@ -150,7 +150,7 @@ export const getMonthAndYear = (locale, refParts) => {
  * Example: Apr 22, 2021
  */
 export const getMonthDayAndYear = (locale, refParts) => {
-  return getLocalizedDateTime(locale, refParts, { month: 'short', day: 'numeric', year: 'numeric' });
+    return getLocalizedDateTime(locale, refParts, { month: 'short', day: 'numeric', year: 'numeric' });
 };
 /**
  * Given a locale and a date object,
@@ -161,7 +161,7 @@ export const getMonthDayAndYear = (locale, refParts) => {
  * Example: 29
  */
 export const getDay = (locale, refParts) => {
-  return getLocalizedDateTimeParts(locale, refParts, { day: 'numeric' }).find((obj) => obj.type === 'day').value;
+    return getLocalizedDateTimeParts(locale, refParts, { day: 'numeric' }).find((obj) => obj.type === 'day').value;
 };
 /**
  * Given a locale and a date object,
@@ -170,26 +170,26 @@ export const getDay = (locale, refParts) => {
  * Example: 2022
  */
 export const getYear = (locale, refParts) => {
-  return getLocalizedDateTime(locale, refParts, { year: 'numeric' });
+    return getLocalizedDateTime(locale, refParts, { year: 'numeric' });
 };
 /**
  * Given reference parts, return a JS Date object
  * with a normalized time.
  */
 export const getNormalizedDate = (refParts) => {
-  var _a, _b, _c;
-  const timeString = refParts.hour !== undefined && refParts.minute !== undefined ? ` ${refParts.hour}:${refParts.minute}` : '';
-  /**
-   * We use / notation here for the date
-   * so we do not need to do extra work and pad values with zeroes.
-   * Values such as YYYY-MM are still valid, so
-   * we add fallback values so we still get
-   * a valid date otherwise we will pass in a string
-   * like "//2023". Some browsers, such as Chrome, will
-   * account for this and still return a valid date. However,
-   * this is not a consistent behavior across all browsers.
-   */
-  return new Date(`${(_a = refParts.month) !== null && _a !== void 0 ? _a : 1}/${(_b = refParts.day) !== null && _b !== void 0 ? _b : 1}/${(_c = refParts.year) !== null && _c !== void 0 ? _c : 2023}${timeString} GMT+0000`);
+    var _a, _b, _c;
+    const timeString = refParts.hour !== undefined && refParts.minute !== undefined ? ` ${refParts.hour}:${refParts.minute}` : '';
+    /**
+     * We use / notation here for the date
+     * so we do not need to do extra work and pad values with zeroes.
+     * Values such as YYYY-MM are still valid, so
+     * we add fallback values so we still get
+     * a valid date otherwise we will pass in a string
+     * like "//2023". Some browsers, such as Chrome, will
+     * account for this and still return a valid date. However,
+     * this is not a consistent behavior across all browsers.
+     */
+    return new Date(`${(_a = refParts.month) !== null && _a !== void 0 ? _a : 1}/${(_b = refParts.day) !== null && _b !== void 0 ? _b : 1}/${(_c = refParts.year) !== null && _c !== void 0 ? _c : 2023}${timeString} GMT+0000`);
 };
 /**
  * Given a locale, DatetimeParts, and options
@@ -200,8 +200,8 @@ export const getNormalizedDate = (refParts) => {
  * getLocalizedDateTimeParts.
  */
 export const getLocalizedDateTime = (locale, refParts, options) => {
-  const date = getNormalizedDate(refParts);
-  return getDateTimeFormat(locale, options).format(date);
+    const date = getNormalizedDate(refParts);
+    return getDateTimeFormat(locale, options).format(date);
 };
 /**
  * Given a locale, DatetimeParts, and options
@@ -210,8 +210,8 @@ export const getLocalizedDateTime = (locale, refParts, options) => {
  * each piece of the date.
  */
 export const getLocalizedDateTimeParts = (locale, refParts, options) => {
-  const date = getNormalizedDate(refParts);
-  return getDateTimeFormat(locale, options).formatToParts(date);
+    const date = getNormalizedDate(refParts);
+    return getDateTimeFormat(locale, options).formatToParts(date);
 };
 /**
  * Wrapper function for Intl.DateTimeFormat.
@@ -220,7 +220,7 @@ export const getLocalizedDateTimeParts = (locale, refParts, options) => {
  * with Intl.DateTimeFormat.
  */
 const getDateTimeFormat = (locale, options) => {
-  return new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, options), { timeZone: 'UTC' }));
+    return new Intl.DateTimeFormat(locale, Object.assign(Object.assign({}, options), { timeZone: 'UTC' }));
 };
 /**
  * Gets a localized version of "Today"
@@ -228,13 +228,13 @@ const getDateTimeFormat = (locale, options) => {
  * browsers that do not support RelativeTimeFormat.
  */
 export const getTodayLabel = (locale) => {
-  if ('RelativeTimeFormat' in Intl) {
-    const label = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' }).format(0, 'day');
-    return label.charAt(0).toUpperCase() + label.slice(1);
-  }
-  else {
-    return 'Today';
-  }
+    if ('RelativeTimeFormat' in Intl) {
+        const label = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' }).format(0, 'day');
+        return label.charAt(0).toUpperCase() + label.slice(1);
+    }
+    else {
+        return 'Today';
+    }
 };
 /**
  * When calling toISOString(), the browser
@@ -266,9 +266,9 @@ export const getTodayLabel = (locale) => {
  * https://www.timeanddate.com/time/time-zones-interesting.html
  */
 export const removeDateTzOffset = (date) => {
-  const tzOffset = date.getTimezoneOffset();
-  date.setMinutes(date.getMinutes() - tzOffset);
-  return date;
+    const tzOffset = date.getTimezoneOffset();
+    date.setMinutes(date.getMinutes() - tzOffset);
+    return date;
 };
 const DATE_AM = removeDateTzOffset(new Date('2022T01:00'));
 const DATE_PM = removeDateTzOffset(new Date('2022T13:00'));
@@ -281,17 +281,17 @@ const DATE_PM = removeDateTzOffset(new Date('2022T13:00'));
  * @returns The localized day period (am/pm) representation of the given value.
  */
 export const getLocalizedDayPeriod = (locale, dayPeriod) => {
-  const date = dayPeriod === 'am' ? DATE_AM : DATE_PM;
-  const localizedDayPeriod = new Intl.DateTimeFormat(locale, {
-    hour: 'numeric',
-    timeZone: 'UTC',
-  })
-    .formatToParts(date)
-    .find((part) => part.type === 'dayPeriod');
-  if (localizedDayPeriod) {
-    return localizedDayPeriod.value;
-  }
-  return getFormattedDayPeriod(dayPeriod);
+    const date = dayPeriod === 'am' ? DATE_AM : DATE_PM;
+    const localizedDayPeriod = new Intl.DateTimeFormat(locale, {
+        hour: 'numeric',
+        timeZone: 'UTC',
+    })
+        .formatToParts(date)
+        .find((part) => part.type === 'dayPeriod');
+    if (localizedDayPeriod) {
+        return localizedDayPeriod.value;
+    }
+    return getFormattedDayPeriod(dayPeriod);
 };
 /**
  * Formats the datetime's value to a string, for use in the native input.
@@ -299,5 +299,5 @@ export const getLocalizedDayPeriod = (locale, dayPeriod) => {
  * @param value The value to format, either an ISO string or an array thereof.
  */
 export const formatValue = (value) => {
-  return Array.isArray(value) ? value.join(',') : value;
+    return Array.isArray(value) ? value.join(',') : value;
 };

package/dist/collection/components/datetime/utils/helpers.js

@@ -8,7 +8,7 @@
  * otherwise.
  */
 export const isLeapYear = (year) => {
-  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
 };
 /**
  * Determines the hour cycle for a user.
@@ -17,53 +17,53 @@ export const isLeapYear = (year) => {
  * locale extension tags or from Intl.DateTimeFormat directly.
  */
 export const getHourCycle = (locale, hourCycle) => {
-  /**
-   * If developer has explicitly enabled 24-hour time
-   * then return early and do not look at the system default.
-   */
-  if (hourCycle !== undefined) {
-    return hourCycle;
-  }
-  /**
-   * If hourCycle was not specified, check the locale
-   * that is set on the user's device. We first check the
-   * Intl.DateTimeFormat hourCycle option as developers can encode this
-   * option into the locale string. Example: `en-US-u-hc-h23`
-   */
-  const formatted = new Intl.DateTimeFormat(locale, { hour: 'numeric' });
-  const options = formatted.resolvedOptions();
-  if (options.hourCycle !== undefined) {
-    return options.hourCycle;
-  }
-  /**
-   * If hourCycle is not specified (either through lack
-   * of browser support or locale information) then fall
-   * back to this slower hourCycle check.
-   */
-  const date = new Date('5/18/2021 00:00');
-  const parts = formatted.formatToParts(date);
-  const hour = parts.find((p) => p.type === 'hour');
-  if (!hour) {
-    throw new Error('Hour value not found from DateTimeFormat');
-  }
-  /**
-   * Midnight for h11 starts at 0:00am
-   * Midnight for h12 starts at 12:00am
-   * Midnight for h23 starts at 00:00
-   * Midnight for h24 starts at 24:00
-   */
-  switch (hour.value) {
-    case '0':
-      return 'h11';
-    case '12':
-      return 'h12';
-    case '00':
-      return 'h23';
-    case '24':
-      return 'h24';
-    default:
-      throw new Error(`Invalid hour cycle "${hourCycle}"`);
-  }
+    /**
+     * If developer has explicitly enabled 24-hour time
+     * then return early and do not look at the system default.
+     */
+    if (hourCycle !== undefined) {
+        return hourCycle;
+    }
+    /**
+     * If hourCycle was not specified, check the locale
+     * that is set on the user's device. We first check the
+     * Intl.DateTimeFormat hourCycle option as developers can encode this
+     * option into the locale string. Example: `en-US-u-hc-h23`
+     */
+    const formatted = new Intl.DateTimeFormat(locale, { hour: 'numeric' });
+    const options = formatted.resolvedOptions();
+    if (options.hourCycle !== undefined) {
+        return options.hourCycle;
+    }
+    /**
+     * If hourCycle is not specified (either through lack
+     * of browser support or locale information) then fall
+     * back to this slower hourCycle check.
+     */
+    const date = new Date('5/18/2021 00:00');
+    const parts = formatted.formatToParts(date);
+    const hour = parts.find((p) => p.type === 'hour');
+    if (!hour) {
+        throw new Error('Hour value not found from DateTimeFormat');
+    }
+    /**
+     * Midnight for h11 starts at 0:00am
+     * Midnight for h12 starts at 12:00am
+     * Midnight for h23 starts at 00:00
+     * Midnight for h24 starts at 24:00
+     */
+    switch (hour.value) {
+        case '0':
+            return 'h11';
+        case '12':
+            return 'h12';
+        case '00':
+            return 'h23';
+        case '24':
+            return 'h24';
+        default:
+            throw new Error(`Invalid hour cycle "${hourCycle}"`);
+    }
 };
 /**
  * Determine if the hour cycle uses a 24-hour format.
@@ -72,7 +72,7 @@ export const getHourCycle = (locale, hourCycle) => {
  * and pass the result into this function.
  */
 export const is24Hour = (hourCycle) => {
-  return hourCycle === 'h23' || hourCycle === 'h24';
+    return hourCycle === 'h23' || hourCycle === 'h24';
 };
 /**
  * Given a date object, returns the number
@@ -81,13 +81,13 @@ export const is24Hour = (hourCycle) => {
  * i.e. January = month 1.
  */
 export const getNumDaysInMonth = (month, year) => {
-  return month === 4 || month === 6 || month === 9 || month === 11
-    ? 30
-    : month === 2
-      ? isLeapYear(year)
-        ? 29
-        : 28
-      : 31;
+    return month === 4 || month === 6 || month === 9 || month === 11
+        ? 30
+        : month === 2
+            ? isLeapYear(year)
+                ? 29
+                : 28
+            : 31;
 };
 /**
  * Certain locales display month then year while
@@ -101,23 +101,23 @@ export const getNumDaysInMonth = (month, year) => {
  * used for variations of the same "month first" check.
  */
 export const isMonthFirstLocale = (locale, formatOptions = {
-  month: 'numeric',
-  year: 'numeric',
+    month: 'numeric',
+    year: 'numeric',
 }) => {
-  /**
-   * By setting month and year we guarantee that only
-   * month, year, and literal (slashes '/', for example)
-   * values are included in the formatToParts results.
-   *
-   * The ordering of the parts will be determined by
-   * the locale. So if the month is the first value,
-   * then we know month should be shown first. If the
-   * year is the first value, then we know year should be shown first.
-   *
-   * This ordering can be controlled by customizing the locale property.
-   */
-  const parts = new Intl.DateTimeFormat(locale, formatOptions).formatToParts(new Date());
-  return parts[0].type === 'month';
+    /**
+     * By setting month and year we guarantee that only
+     * month, year, and literal (slashes '/', for example)
+     * values are included in the formatToParts results.
+     *
+     * The ordering of the parts will be determined by
+     * the locale. So if the month is the first value,
+     * then we know month should be shown first. If the
+     * year is the first value, then we know year should be shown first.
+     *
+     * This ordering can be controlled by customizing the locale property.
+     */
+    const parts = new Intl.DateTimeFormat(locale, formatOptions).formatToParts(new Date());
+    return parts[0].type === 'month';
 };
 /**
  * Determines if the given locale formats the day period (am/pm) to the
@@ -126,6 +126,6 @@ export const isMonthFirstLocale = (locale, formatOptions = {
  * @returns `true` if the locale formats the day period to the left of the hour.
  */
 export const isLocaleDayPeriodRTL = (locale) => {
-  const parts = new Intl.DateTimeFormat(locale, { hour: 'numeric' }).formatToParts(new Date());
-  return parts[0].type === 'dayPeriod';
+    const parts = new Intl.DateTimeFormat(locale, { hour: 'numeric' }).formatToParts(new Date());
+    return parts[0].type === 'dayPeriod';
 };