@zelgadis87/utils-core 5.2.10 → 5.2.12

package/esbuild/index.mjs

@@ -1891,13 +1891,18 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     return TimeDuration_default.fromMs(Math.max(distance, 0));
   }
   distanceFromStartOfDay() {
-    return this.distanceFrom(this.atStartOfDay());
+    const params = this.toParameters();
+    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
+    return TimeDuration_default.fromMs(msInDay);
   }
   atStartOfDay() {
     return this.atTime({ hours: 0, minutes: 0, seconds: 0, milliseconds: 0 });
   }
   distanceFromEndOfDay() {
-    return this.distanceFrom(this.atEndOfDay());
+    const params = this.toParameters();
+    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
+    const msUntilEndOfDay = 86399999 - msInDay;
+    return TimeDuration_default.fromMs(msUntilEndOfDay);
   }
   atEndOfDay() {
     return this.atTime({ hours: 23, minutes: 59, seconds: 59, milliseconds: 999 });
@@ -1923,7 +1928,7 @@ var TimeInstant = class _TimeInstant extends TimeBase {
       throw new Error("Instant is not in the past");
   }
   isToday() {
-    return Math.floor(this.days) === Math.floor(_TimeInstant.now().days);
+    return Math.floor(this.ms / 864e5) === Math.floor(Date.now() / 864e5);
   }
   /**
    * Formats this instant using the given pattern. The pattern can contain the following tokens:
@@ -1990,9 +1995,12 @@ var TimeInstant = class _TimeInstant extends TimeBase {
    * @throws Error if the string doesn't match the pattern or contains invalid basic values
    * @todo Add calendar-aware validation to reject dates like February 30th, April 31st
    */
-  static parse(dateString, pattern, base = _TimeInstant.now(), config = {}) {
+  static fromString(dateString, pattern, base = _TimeInstant.now(), config = {}) {
     return parseTimeInstant(dateString, pattern, base, config);
   }
+  static parse(dateString, pattern, config = {}) {
+    return parseTimeInstantComponents(dateString, pattern, config);
+  }
   /**
   * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
   */
@@ -2011,8 +2019,17 @@ var TimeInstant = class _TimeInstant extends TimeBase {
   toDate() {
     return new Date(this.ms);
   }
-  toDateUTC() {
-    return new Date(this.ms + (/* @__PURE__ */ new Date()).getTimezoneOffset() * 60 * 1e3);
+  toParameters() {
+    const d = this.toDate();
+    return {
+      year: d.getUTCFullYear(),
+      month: d.getUTCMonth() + 1,
+      date: d.getUTCDate(),
+      hours: d.getUTCHours(),
+      minutes: d.getUTCMinutes(),
+      seconds: d.getUTCSeconds(),
+      milliseconds: d.getUTCMilliseconds()
+    };
   }
   /**
    * @returns true if the instant is in the past, false otherwise
@@ -2143,30 +2160,21 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     const timestamp2 = Math.round(this.ms / unitMs) * unitMs;
     return _TimeInstant.fromUnixTimestamp(timestamp2);
   }
-  get dayOfMonth() {
-    return this.toDate().getUTCDate();
-  }
-  get dayOfWeek() {
-    return this.toDate().getUTCDay() + 1;
-  }
-  get month() {
-    return this.toDate().getUTCMonth() + 1;
-  }
-  get year() {
-    return this.toDate().getUTCFullYear();
-  }
   /**
    * Returns the week number represented by this instant, according to the ISO 8601 standard.
-  	* Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
+   * Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
    */
   get weekNumber() {
     const date = this.toDate();
     const oneDay = 1e3 * 60 * 60 * 24;
-    const thursdayOfThisWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 4 - (date.getDay() || 7), 14, 0, 0);
-    const firstOfJanuary = new Date(thursdayOfThisWeek.getFullYear(), 0, 1, 14, 0, 0);
-    const dayOfTheYear = Math.round((thursdayOfThisWeek.getTime() - firstOfJanuary.getTime()) / oneDay);
+    const dayOfWeek = date.getUTCDay() || 7;
+    const thursdayMs = this.ms + (4 - dayOfWeek) * oneDay;
+    const thursdayDate = new Date(thursdayMs);
+    const thursdayYear = thursdayDate.getUTCFullYear();
+    const firstOfJanMs = Date.UTC(thursdayYear, 0, 1, 12, 0, 0);
+    const dayOfTheYear = Math.round((thursdayMs - firstOfJanMs) / oneDay);
     const weekNumber = Math.floor(dayOfTheYear / 7) + 1;
-    return { weekNumber, year: thursdayOfThisWeek.getFullYear() };
+    return { weekNumber, year: thursdayYear };
   }
   /**
    * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
@@ -2207,111 +2215,118 @@ function isValidSecond(num) {
 function isValidMillisecond(num) {
   return num >= 0 && num <= 999;
 }
+var monthNamesCache = /* @__PURE__ */ new Map();
+function getMonthNames(locale = "en") {
+  const cached = monthNamesCache.get(locale);
+  if (cached) {
+    return cached;
+  }
+  const shortFormatter = new Intl.DateTimeFormat(locale, { month: "short" });
+  const longFormatter = new Intl.DateTimeFormat(locale, { month: "long" });
+  const short = [];
+  const long = [];
+  for (let month = 0; month < 12; month++) {
+    const date = new Date(2e3, month, 1);
+    short.push(normalizeMonthName(shortFormatter.format(date)));
+    long.push(normalizeMonthName(longFormatter.format(date)));
+  }
+  const result = { short, long };
+  monthNamesCache.set(locale, result);
+  return result;
+}
+function normalizeMonthName(name) {
+  return name.replace(/[.,;:!?]/g, "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim();
+}
 var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
 var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
-var optionNames = {
-  y: "year",
-  M: "month",
-  d: "day",
-  D: "weekday",
-  S: "fractionalSecondDigits",
-  G: "era",
-  Z: "timeZoneName",
-  P: "dayPeriod",
-  a: "hour12",
-  h: "hour",
-  H: "hour",
-  m: "minute",
-  s: "second"
-};
-var values = {
-  y: ["numeric", "2-digit", void 0, "numeric"],
-  M: ["narrow", "2-digit", "short", "long"],
-  d: ["numeric", "2-digit"],
-  D: ["narrow", "short", "long"],
-  S: [1, 2, 3],
-  G: ["narrow", "short", "long"],
-  Z: ["short", "long"],
-  P: ["narrow", "short", "long"],
-  a: [true],
-  h: ["numeric", "2-digit"],
-  H: ["numeric", "2-digit"],
-  m: ["numeric", "2-digit"],
-  s: ["numeric", "2-digit"]
+var formatterConfigs = {
+  // Year
+  "y": { options: { year: "numeric" } },
+  "yy": { options: { year: "2-digit" } },
+  "yyyy": { options: { year: "numeric" } },
+  // Month
+  "M": { options: { month: "numeric" } },
+  "MM": { options: { month: "2-digit" } },
+  "MMM": { options: { month: "short" } },
+  "MMMM": { options: { month: "long" } },
+  // Day
+  "d": { options: { day: "numeric" } },
+  "dd": { options: { day: "2-digit" } },
+  // Hours (24-hour) - extract and pad manually due to Intl quirk
+  "H": { options: { hour: "numeric", hour12: false }, extract: { partType: "hour" } },
+  "HH": { options: { hour: "2-digit", hour12: false }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
+  // Hours (12-hour) - extract and pad manually due to Intl quirk
+  "h": { options: { hour: "numeric", hour12: true }, extract: { partType: "hour" } },
+  "hh": { options: { hour: "2-digit", hour12: true }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
+  // Minutes - extract and pad manually due to Intl quirk
+  "m": { options: { minute: "numeric" }, extract: { partType: "minute" } },
+  "mm": { options: { minute: "2-digit" }, extract: { partType: "minute", transform: (v) => v.padStart(2, "0") } },
+  // Seconds - extract and pad manually due to Intl quirk
+  "s": { options: { second: "numeric" }, extract: { partType: "second" } },
+  "ss": { options: { second: "2-digit" }, extract: { partType: "second", transform: (v) => v.padStart(2, "0") } },
+  // Milliseconds - extract manually
+  "S": { options: { fractionalSecondDigits: 1 }, extract: { partType: "fractionalSecond" } },
+  "SS": { options: { fractionalSecondDigits: 2 }, extract: { partType: "fractionalSecond" } },
+  "SSS": { options: { fractionalSecondDigits: 3 }, extract: { partType: "fractionalSecond" } },
+  // Weekday
+  "D": { options: { weekday: "narrow" } },
+  "DD": { options: { weekday: "short" } },
+  "DDD": { options: { weekday: "long" } },
+  // Era
+  "G": { options: { era: "narrow" } },
+  "GG": { options: { era: "short" } },
+  "GGG": { options: { era: "long" } },
+  // Timezone
+  "Z": { options: { timeZoneName: "short" } },
+  "ZZ": { options: { timeZoneName: "long" } },
+  // Day period
+  "P": { options: { dayPeriod: "narrow" } },
+  "PP": { options: { dayPeriod: "short" } },
+  "PPP": { options: { dayPeriod: "long" } },
+  // Meridiem - extract dayPeriod and lowercase it
+  "a": { options: { hour: "numeric", hour12: true }, extract: { partType: "dayPeriod", transform: (v) => v.toLowerCase() } }
 };
-function formatType(instant, type, length, { locale, timeZone } = {}) {
-  if (type === "y") {
-    const year = instant.year;
-    if (length === 2) {
-      return String(year).slice(-2);
-    }
-    return String(year);
-  }
-  if (type === "M" && (length === 1 || length === 2)) {
-    const month = instant.month;
-    return length === 2 && month < 10 ? "0" + month : String(month);
-  }
-  if (type === "d" && (length === 1 || length === 2)) {
-    const day = instant.dayOfMonth;
-    return length === 2 && day < 10 ? "0" + day : String(day);
-  }
-  if (type === "H" && (length === 1 || length === 2)) {
-    const hours = instant.toDate().getUTCHours();
-    return length === 2 && hours < 10 ? "0" + hours : String(hours);
-  }
-  if (type === "h" && (length === 1 || length === 2)) {
-    let hours = instant.toDate().getUTCHours();
-    hours = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-    return length === 2 && hours < 10 ? "0" + hours : String(hours);
-  }
-  if (type === "m" && (length === 1 || length === 2)) {
-    const minutes = instant.toDate().getUTCMinutes();
-    return length === 2 && minutes < 10 ? "0" + minutes : String(minutes);
-  }
-  if (type === "s" && (length === 1 || length === 2)) {
-    const seconds = instant.toDate().getUTCSeconds();
-    return length === 2 && seconds < 10 ? "0" + seconds : String(seconds);
-  }
-  if (type === "S") {
-    const ms = instant.toDate().getUTCMilliseconds();
-    if (length === 1) return String(Math.floor(ms / 100));
-    if (length === 2) return String(Math.floor(ms / 10)).padStart(2, "0");
-    if (length === 3) return String(ms).padStart(3, "0");
-    return String(ms);
-  }
-  const date = instant.toDate();
-  const option = optionNames[type];
-  const value = values[type][length - 1];
-  if (!value) {
-    return;
-  }
-  const options = {
-    [option]: value,
-    timeZone
-  };
-  if (type === "a") {
-    return Intl.DateTimeFormat(locale, {
-      ...options,
-      hour: "numeric"
-    }).formatToParts(date).pop()?.value;
-  }
-  if (type === "G" || type === "Z") {
-    return Intl.DateTimeFormat(locale, options).formatToParts(date).pop()?.value;
+function formatType(type, length, date, locale = "en", timeZone = "UTC") {
+  const tokenKey = type.repeat(length);
+  const config = formatterConfigs[tokenKey];
+  if (!config) {
+    return void 0;
+  }
+  const formatter = new Intl.DateTimeFormat(locale, { ...config.options, timeZone });
+  if (config.extract) {
+    const part = formatter.formatToParts(date).find((p) => p.type === config.extract.partType);
+    const value = part?.value;
+    if (!value) {
+      return void 0;
+    }
+    return config.extract.transform ? config.extract.transform(value) : value;
   }
-  return Intl.DateTimeFormat(locale, options).format(date);
+  return formatter.format(date);
 }
 function formatTimeInstant(instant, pattern, config = {}) {
+  const date = instant.toDate();
+  const locale = config.locale || "en";
+  const timeZone = config.timeZone || "UTC";
   return pattern.split(ESCAPE_REGEX).filter((sub) => sub !== void 0).map((sub, index) => {
     if (index % 2 !== 0) {
       return sub;
     }
     return sub.replace(PATTERN_REGEX, (match) => {
       const type = match.charAt(0);
-      return formatType(instant, type, match.length, config) || match;
+      const length = match.length;
+      return formatType(type, length, date, locale, timeZone) || match;
     });
   }).join("");
 }
 function parseTimeInstant(dateString, pattern, base, config = {}) {
+  const parsed = parseTimeInstantComponents(dateString, pattern, config);
+  const params = {
+    ...base.toParameters(),
+    ...parsed
+  };
+  return TimeInstant.fromParameters(params);
+}
+function parseTimeInstantComponents(dateString, pattern, config = {}) {
   let regexPattern = pattern;
   const tokens = [];
   let position = 0;
@@ -2329,7 +2344,7 @@ function parseTimeInstant(dateString, pattern, base, config = {}) {
         case "M":
           if (match.length === 1) return "(\\d{1,2})";
           if (match.length === 2) return "(\\d{2})";
-          if (match.length === 3) return "([A-Za-z]{3})";
+          if (match.length === 3) return "([A-Za-z.]{1,7})";
           return "([A-Za-z]+)";
         case "d":
           return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
@@ -2365,113 +2380,110 @@ function parseTimeInstant(dateString, pattern, base, config = {}) {
   if (!matches) {
     throw new Error(`Date string "${dateString}" does not match pattern "${pattern}"`);
   }
-  let year = base.year;
-  let month = base.month;
-  let day = base.dayOfMonth;
-  let hour = base.toDate().getUTCHours();
-  let minute = base.toDate().getUTCMinutes();
-  let second = base.toDate().getUTCSeconds();
-  let millisecond = base.toDate().getUTCMilliseconds();
+  const result = {};
+  const locale = config.locale || "en";
   let isPM = false;
   let is12Hour = false;
+  let hourValue;
   tokens.forEach((token, index) => {
     const value = matches[index + 1];
     switch (token.type) {
       case "y":
         if (token.length === 2) {
           const shortYear = parseInt(value, 10);
-          year = shortYear < 50 ? 2e3 + shortYear : 1900 + shortYear;
+          result.year = shortYear < 50 ? 2e3 + shortYear : 1900 + shortYear;
         } else {
-          year = parseInt(value, 10);
+          result.year = parseInt(value, 10);
         }
         break;
       case "M":
-        if (token.length <= 2) {
-          month = parseInt(value, 10);
-        } else {
-          const monthNames2 = [
-            "Jan",
-            "Feb",
-            "Mar",
-            "Apr",
-            "May",
-            "Jun",
-            "Jul",
-            "Aug",
-            "Sep",
-            "Oct",
-            "Nov",
-            "Dec"
-          ];
-          const longMonthNames = [
-            "January",
-            "February",
-            "March",
-            "April",
-            "May",
-            "June",
-            "July",
-            "August",
-            "September",
-            "October",
-            "November",
-            "December"
-          ];
-          let monthIndex = monthNames2.findIndex((name) => name.toLowerCase() === value.toLowerCase());
-          if (monthIndex === -1) {
-            monthIndex = longMonthNames.findIndex((name) => name.toLowerCase() === value.toLowerCase());
+        switch (token.length) {
+          case 1:
+          case 2:
+            result.month = parseInt(value, 10);
+            break;
+          case 3: {
+            const normalizedValue = normalizeMonthName(value);
+            const monthIndex = getMonthNames(locale).short.findIndex(
+              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
+            );
+            if (monthIndex === -1)
+              throw new Error(`Invalid short month name in date string: ${dateString}`);
+            result.month = monthIndex + 1;
+            break;
+          }
+          case 4: {
+            const normalizedValue = normalizeMonthName(value);
+            const monthIndex = getMonthNames(locale).long.findIndex(
+              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
+            );
+            if (monthIndex === -1)
+              throw new Error(`Invalid full month name in date string: ${dateString}`);
+            result.month = monthIndex + 1;
+            break;
           }
-          month = monthIndex !== -1 ? monthIndex + 1 : 1;
+          default:
+            throw new Error(`Invalid month pattern: ${token}`);
         }
         break;
       case "d":
-        day = parseInt(value, 10);
+        result.date = parseInt(value, 10);
         break;
       case "H":
-        hour = parseInt(value, 10);
+        result.hours = parseInt(value, 10);
         break;
       case "h":
-        hour = parseInt(value, 10);
+        hourValue = parseInt(value, 10);
         is12Hour = true;
         break;
       case "m":
-        minute = parseInt(value, 10);
+        result.minutes = parseInt(value, 10);
         break;
       case "s":
-        second = parseInt(value, 10);
+        result.seconds = parseInt(value, 10);
         break;
       case "S":
         let ms = parseInt(value, 10);
         if (token.length === 1) ms *= 100;
         else if (token.length === 2) ms *= 10;
-        millisecond = ms;
+        result.milliseconds = ms;
         break;
       case "a":
         isPM = value.toLowerCase().includes("p");
         break;
     }
   });
-  if (is12Hour && isPM && hour < 12) {
-    hour += 12;
-  } else if (is12Hour && !isPM && hour === 12) {
-    hour = 0;
-  }
-  if (!isValidYear(year)) throw new Error(`Invalid year in date string: ${dateString}`);
-  if (!isValidMonth(month)) throw new Error(`Invalid month in date string: ${dateString}`);
-  if (!isValidDayOfMonth(day)) throw new Error(`Invalid day in date string: ${dateString}`);
-  if (!isValidHour(hour)) throw new Error(`Invalid hour in date string: ${dateString}`);
-  if (!isValidMinute(minute)) throw new Error(`Invalid minute in date string: ${dateString}`);
-  if (!isValidSecond(second)) throw new Error(`Invalid second in date string: ${dateString}`);
-  if (!isValidMillisecond(millisecond)) throw new Error(`Invalid millisecond in date string: ${dateString}`);
-  return TimeInstant.fromParameters({
-    year,
-    month,
-    date: day,
-    hours: hour,
-    minutes: minute,
-    seconds: second,
-    milliseconds: millisecond
-  });
+  if (is12Hour && hourValue !== void 0) {
+    if (isPM && hourValue < 12) {
+      result.hours = hourValue + 12;
+    } else if (!isPM && hourValue === 12) {
+      result.hours = 0;
+    } else {
+      result.hours = hourValue;
+    }
+  }
+  if (typeof result.year === "number" && !isValidYear(result.year)) {
+    throw new Error(`Invalid year in date string: ${dateString}`);
+  }
+  if (typeof result.month === "number" && !isValidMonth(result.month)) {
+    throw new Error(`Invalid month in date string: ${dateString}`);
+  }
+  if (typeof result.date === "number" && !isValidDayOfMonth(result.date)) {
+    throw new Error(`Invalid day in date string: ${dateString}`);
+  }
+  if (typeof result.hours === "number" && !isValidHour(result.hours)) {
+    throw new Error(`Invalid hour in date string: ${dateString}`);
+  }
+  if (typeof result.minutes === "number" && !isValidMinute(result.minutes)) {
+    throw new Error(`Invalid minute in date string: ${dateString}`);
+  }
+  if (typeof result.seconds === "number" && !isValidSecond(result.seconds)) {
+    throw new Error(`Invalid second in date string: ${dateString}`);
+  }
+  if (typeof result.milliseconds === "number" && !isValidMillisecond(result.milliseconds)) {
+    throw new Error(`Invalid millisecond in date string: ${dateString}`);
+  }
+  return result;
 }
 
 // src/Logger.ts