dce-reactkit 4.2.4-beta-timestamp.2 → 4.2.4-beta.heat-seek.1

package/dist/cjs/index.js

@@ -16385,6 +16385,58 @@ const getWordCount = (text) => {
 };
 
 // Import shared types
+/*----------------------------------------*/
+/* --------------- Helpers -------------- */
+/*----------------------------------------*/
+/**
+ * Check if a timestamp is valid
+ * @param opts object containing all arguments
+ * @param opts.timestamp Timestamp in milliseconds since epoch
+ * @param opts.expectedYear Expected year
+ * @param opts.expectedMonth Expected month
+ * @param opts.expectedDay Expected day
+ * @param opts.expectedHour Expected hour
+ * @param opts.expectedMinute Expected minute
+ * @returns 1 if the timestamp needs to be increased, -1 if it needs to be decreased, 0 if it is valid
+ */
+const checkTimestamp = (opts) => {
+    const { timestamp, expectedYear, expectedMonth, expectedDay, expectedHour, expectedMinute, } = opts;
+    const timeInfoInET = getTimeInfoInET(timestamp);
+    if (timeInfoInET.year < expectedYear) {
+        return 1;
+    }
+    if (timeInfoInET.year > expectedYear) {
+        return -1;
+    }
+    if (timeInfoInET.month < expectedMonth) {
+        return 1;
+    }
+    if (timeInfoInET.month > expectedMonth) {
+        return -1;
+    }
+    if (timeInfoInET.day < expectedDay) {
+        return 1;
+    }
+    if (timeInfoInET.day > expectedDay) {
+        return -1;
+    }
+    if (timeInfoInET.hour < expectedHour) {
+        return 1;
+    }
+    if (timeInfoInET.hour > expectedHour) {
+        return -1;
+    }
+    if (timeInfoInET.minute < expectedMinute) {
+        return 1;
+    }
+    if (timeInfoInET.minute > expectedMinute) {
+        return -1;
+    }
+    return 0;
+};
+/*----------------------------------------*/
+/* ---------------- Main ---------------- */
+/*----------------------------------------*/
 /**
  * Get a timestamp (ms since epoch) from time info (year, month, day, hour, minute, etc.) in Eastern Time (ET)
  * @author Gardenia Liu
@@ -16394,79 +16446,64 @@ const getWordCount = (text) => {
  * @param opts.month Month (1-12)
  * @param opts.day Day of the month (1-31)
  * @param opts.hour Hour (0-23)
- * @param opts.minute Minute (0-59))
+ * @param opts.minute Minute (0-59)
  * @returns Timestamp in milliseconds since epoch
  */
 const getTimestampFromTimeInfoInET = (opts) => {
-    var _a, _b, _c, _d, _e, _f, _g;
     // Destructure opts
     const { year, month, day, hour, minute, } = opts;
+    // Determine if the date is in DST in Eastern Time
+    const tempDate = new Date(year, month - 1, day);
+    const janOffset = new Date(year, 0, 1).getTimezoneOffset();
+    const isDST = tempDate.getTimezoneOffset() < janOffset;
+    const etOffset = isDST ? '-04:00' : '-05:00';
     // Format with leading zeroes
     const mm = padZerosLeft(month, 2);
     const dd = padZerosLeft(day, 2);
     const hh = padZerosLeft(hour, 2);
     const min = padZerosLeft(minute, 2);
-    // Use Intl.DateTimeFormat to get the ET offset and ET components
-    const dateForET = new Date(Date.UTC(year, month - 1, day, hour, minute, 0));
-    const options = {
-        timeZone: 'America/New_York',
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: false,
-        timeZoneName: 'shortOffset',
-    };
-    const parts = new Intl.DateTimeFormat('en-US', options).formatToParts(dateForET);
-    const etYear = (_a = parts.find((p) => {
-        return p.type === 'year';
-    })) === null || _a === void 0 ? void 0 : _a.value;
-    const etMonth = (_b = parts.find((p) => {
-        return p.type === 'month';
-    })) === null || _b === void 0 ? void 0 : _b.value;
-    const etDay = (_c = parts.find((p) => {
-        return p.type === 'day';
-    })) === null || _c === void 0 ? void 0 : _c.value;
-    const etHour = (_d = parts.find((p) => {
-        return p.type === 'hour';
-    })) === null || _d === void 0 ? void 0 : _d.value;
-    const etMinute = (_e = parts.find((p) => {
-        return p.type === 'minute';
-    })) === null || _e === void 0 ? void 0 : _e.value;
-    const etSecond = (_f = parts.find((p) => {
-        return p.type === 'second';
-    })) === null || _f === void 0 ? void 0 : _f.value;
-    const tzName = (_g = parts.find((p) => {
-        return p.type === 'timeZoneName';
-    })) === null || _g === void 0 ? void 0 : _g.value;
-    // Validate we got everything we need
-    if (!etYear || !etMonth || !etDay || !etHour || !etMinute || !etSecond || !tzName) {
-        throw new ErrorWithCode('Failed to parse date parts from Intl.DateTimeFormat', ReactKitErrorCode$1.ETTimestampInvalid);
-    }
-    // Extract numeric offset from "GMT-4" or "UTC-5"
-    const offsetNum = Number(tzName.replace(/^(GMT|UTC)/, ''));
-    const sign = offsetNum >= 0 ? '+' : '-';
-    const offset = `${sign}${padZerosLeft(Math.abs(offsetNum), 2)}:00`;
-    // Build ISO string with offset
-    const etDateString = `${etYear}-${etMonth}-${etDay}T${etHour}:${etMinute}:${etSecond}${offset}`;
-    // Parse into ET timestamp
-    const etDate = new Date(etDateString);
-    const timestamp = etDate.getTime();
-    // Verify that the timestamp is correct
-    const timeInfoInET = getTimeInfoInET(timestamp);
-    if (timeInfoInET.year !== year
-        || timeInfoInET.month !== month
-        || timeInfoInET.day !== day
-        || timeInfoInET.hour !== hour
-        || timeInfoInET.minute !== minute) {
-        throw new ErrorWithCode(`Timestamp mismatch: expected ${year}-${mm}-${dd} ${hh}:${min}, `
-            + `got ${timeInfoInET.year}-${padZerosLeft(timeInfoInET.month, 2)}-${padZerosLeft(timeInfoInET.day, 2)} `
-            + `${padZerosLeft(timeInfoInET.hour, 2)}:${padZerosLeft(timeInfoInET.minute, 2)}`, ReactKitErrorCode$1.ETTimestampInvalid);
-    }
-    // Valid! Return the timestamp
-    return timestamp;
+    // Build ET ISO string and convert to UTC timestamp
+    const etISOString = `${year}-${mm}-${dd}T${hh}:${min}:00${etOffset}`;
+    let timestamp = (new Date(etISOString)).getTime();
+    // Heat seek to get the right timestamp
+    const maxOffset = 24 * 60; // 24 hours in minutes
+    let currentOffset = 0; // minutes
+    const offsetIncrement = 15; // minutes
+    const offsetDirection = checkTimestamp({
+        timestamp,
+        expectedYear: year,
+        expectedMonth: month,
+        expectedDay: day,
+        expectedHour: hour,
+        expectedMinute: minute,
+    });
+    if (offsetDirection === 0) {
+        // Valid! Return the timestamp
+        return timestamp;
+    }
+    // Heat seek
+    while (Math.abs(currentOffset) < maxOffset) {
+        // Update offset
+        currentOffset += (offsetDirection * offsetIncrement);
+        // Update timestamp
+        const offsetMs = currentOffset * 60 * 1000;
+        timestamp += offsetMs;
+        // Check timestamp again
+        const newDirection = checkTimestamp({
+            timestamp,
+            expectedYear: year,
+            expectedMonth: month,
+            expectedDay: day,
+            expectedHour: hour,
+            expectedMinute: minute,
+        });
+        if (newDirection === 0) {
+            // Valid! Return the timestamp
+            return timestamp;
+        }
+        // Invalid. Keep looping.
+    }
+    throw new ErrorWithCode(`Timestamp mismatch: expected ${year}-${mm}-${dd} ${hh}:${min}, seeked to offset ${currentOffset} minutes but could not find a valid timestamp.`, ReactKitErrorCode$1.ETTimestampInvalid);
 };
 
 /*------------------------------------------------------------------------*/