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

package/dist/esm/types/helpers/getTimestampFromTimeInfoInET.d.ts

@@ -7,7 +7,7 @@
  * @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
  */
 declare const getTimestampFromTimeInfoInET: (opts: {

package/dist/index.d.ts

@@ -1574,7 +1574,7 @@ declare const cloneDeep: <T>(obj: T) => T;
  * @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
  */
 declare const getTimestampFromTimeInfoInET: (opts: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dce-reactkit",
-  "version": "4.2.4-beta-timestamp.2",
+  "version": "4.2.4-beta.heat-seek.1",
   "description": "Shared components for Harvard DCE apps",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/src/helpers/getTimestampFromTimeInfoInET.ts

@@ -6,6 +6,78 @@ import ReactKitErrorCode from '../types/ReactKitErrorCode';
 import getTimeInfoInET from './getTimeInfoInET';
 import padZerosLeft from './padZerosLeft';
 
+/*----------------------------------------*/
+/* --------------- 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: {
+    timestamp: number,
+    expectedYear: number,
+    expectedMonth: number,
+    expectedDay: number,
+    expectedHour: number,
+    expectedMinute: number,
+  },
+): number => {
+  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
@@ -15,7 +87,7 @@ import padZerosLeft from './padZerosLeft';
  * @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 = (
@@ -36,87 +108,69 @@ const getTimestampFromTimeInfoInET = (
     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: Intl.DateTimeFormatOptions = {
-    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: Intl.DateTimeFormatPart[] = new Intl.DateTimeFormat('en-US', options).formatToParts(dateForET);
-  const etYear: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'year';
-  })?.value;
-  const etMonth: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'month';
-  })?.value;
-  const etDay: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'day';
-  })?.value;
-  const etHour: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'hour';
-  })?.value;
-  const etMinute: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'minute';
-  })?.value;
-  const etSecond: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'second';
-  })?.value;
-  const tzName: string | undefined = parts.find((p: Intl.DateTimeFormatPart) => {
-    return p.type === 'timeZoneName';
-  })?.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.ETTimestampInvalid,
-    );
+  // 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;
   }
 
-  // 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`;
+  // Heat seek
+  while (Math.abs(currentOffset) < maxOffset) {
+    // Update offset
+    currentOffset += (offsetDirection * offsetIncrement);
 
-  // Build ISO string with offset
-  const etDateString = `${etYear}-${etMonth}-${etDay}T${etHour}:${etMinute}:${etSecond}${offset}`;
+    // Update timestamp
+    const offsetMs = currentOffset * 60 * 1000;
+    timestamp += offsetMs;
 
-  // Parse into ET timestamp
-  const etDate = new Date(etDateString);
-  const timestamp = etDate.getTime();
+    // 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;
+    }
 
-  // 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.ETTimestampInvalid,
-    );
+    // Invalid. Keep looping.
   }
 
-  // Valid! Return the timestamp
-  return timestamp;
+  throw new ErrorWithCode(
+    `Timestamp mismatch: expected ${year}-${mm}-${dd} ${hh}:${min}, seeked to offset ${currentOffset} minutes but could not find a valid timestamp.`,
+    ReactKitErrorCode.ETTimestampInvalid,
+  );
 };
 
 export default getTimestampFromTimeInfoInET;