tradeblocks-mcp 4.2.0 → 4.4.0

package/dist/{chunk-4UU7IT2A.js → chunk-ENXBPJ7Y.js}

@@ -5327,6 +5327,131 @@ async function getTradesPage(blockId, offset, limit) {
 // ../lib/utils/trade-frequency.ts
 var MS_PER_DAY = 1e3 * 60 * 60 * 24;
 
+// ../lib/calculations/xnys-session-calendar.ts
+var XNYS_SESSION_CALENDAR_REVISION = "xnys-full-day-2022-2030-v1";
+var XNYS_SESSION_CALENDAR_SUPPORTED_FROM = "2022-01-01";
+var XNYS_SESSION_CALENDAR_SUPPORTED_THROUGH = "2030-12-31";
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
+var SPECIAL_CLOSURES = /* @__PURE__ */ new Set(["2025-01-09"]);
+function isoDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function utcDate(year, monthIndex, day) {
+  return new Date(Date.UTC(year, monthIndex, day));
+}
+function parseSupportedDate(value, label) {
+  if (!ISO_DATE_RE.test(value)) {
+    throw new TypeError(
+      `${label} must be an ISO calendar date (YYYY-MM-DD): ${JSON.stringify(value)}`
+    );
+  }
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (!Number.isFinite(parsed.getTime()) || isoDate(parsed) !== value) {
+    throw new TypeError(`${label} is not a real calendar date: ${JSON.stringify(value)}`);
+  }
+  if (value < XNYS_SESSION_CALENDAR_SUPPORTED_FROM || value > XNYS_SESSION_CALENDAR_SUPPORTED_THROUGH) {
+    throw new RangeError(
+      `${label} ${JSON.stringify(value)} is outside XNYS calendar revision ${XNYS_SESSION_CALENDAR_REVISION} [${XNYS_SESSION_CALENDAR_SUPPORTED_FROM}, ${XNYS_SESSION_CALENDAR_SUPPORTED_THROUGH}]`
+    );
+  }
+  return parsed;
+}
+function nthWeekdayOfMonth(year, monthIndex, weekday, occurrence) {
+  const first = utcDate(year, monthIndex, 1);
+  const offset = (weekday - first.getUTCDay() + 7) % 7;
+  return utcDate(year, monthIndex, 1 + offset + (occurrence - 1) * 7);
+}
+function lastWeekdayOfMonth(year, monthIndex, weekday) {
+  const last = utcDate(year, monthIndex + 1, 0);
+  const offset = (last.getUTCDay() - weekday + 7) % 7;
+  return utcDate(year, monthIndex, last.getUTCDate() - offset);
+}
+function easterSunday(year) {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31);
+  const day = (h + l - 7 * m + 114) % 31 + 1;
+  return utcDate(year, month - 1, day);
+}
+function addDays(date, days) {
+  return new Date(date.getTime() + days * MS_PER_DAY2);
+}
+function observedFixedHoliday(year, monthIndex, day) {
+  const holiday = utcDate(year, monthIndex, day);
+  if (holiday.getUTCDay() === 6) return addDays(holiday, -1);
+  if (holiday.getUTCDay() === 0) return addDays(holiday, 1);
+  return holiday;
+}
+function addNewYearsClosure(closures, holidayYear) {
+  const holiday = utcDate(holidayYear, 0, 1);
+  if (holiday.getUTCDay() === 6) {
+    return;
+  }
+  closures.add(isoDate(holiday.getUTCDay() === 0 ? addDays(holiday, 1) : holiday));
+}
+function holidayClosures(year) {
+  const closures = /* @__PURE__ */ new Set();
+  const add = (date) => {
+    closures.add(isoDate(date));
+  };
+  addNewYearsClosure(closures, year);
+  addNewYearsClosure(closures, year + 1);
+  add(nthWeekdayOfMonth(year, 0, 1, 3));
+  add(nthWeekdayOfMonth(year, 1, 1, 3));
+  add(addDays(easterSunday(year), -2));
+  add(lastWeekdayOfMonth(year, 4, 1));
+  add(observedFixedHoliday(year, 5, 19));
+  add(observedFixedHoliday(year, 6, 4));
+  add(nthWeekdayOfMonth(year, 8, 1, 1));
+  add(nthWeekdayOfMonth(year, 10, 4, 4));
+  add(observedFixedHoliday(year, 11, 25));
+  for (const date of SPECIAL_CLOSURES) {
+    if (date.startsWith(`${year}-`)) closures.add(date);
+  }
+  return closures;
+}
+var CLOSURES_BY_YEAR = /* @__PURE__ */ new Map();
+function closuresForYear(year) {
+  let closures = CLOSURES_BY_YEAR.get(year);
+  if (!closures) {
+    closures = holidayClosures(year);
+    CLOSURES_BY_YEAR.set(year, closures);
+  }
+  return closures;
+}
+function isXnysSessionDate(value) {
+  const date = parseSupportedDate(value, "XNYS session date");
+  const weekday = date.getUTCDay();
+  if (weekday === 0 || weekday === 6) return false;
+  return !closuresForYear(date.getUTCFullYear()).has(value);
+}
+function enumerateXnysSessions(from, through) {
+  const first = parseSupportedDate(from, "XNYS session range from");
+  const last = parseSupportedDate(through, "XNYS session range through");
+  if (first.getTime() > last.getTime()) {
+    throw new RangeError(
+      `XNYS session range from ${JSON.stringify(from)} exceeds through ${JSON.stringify(through)}`
+    );
+  }
+  const sessions = [];
+  for (let cursor = first; cursor.getTime() <= last.getTime(); cursor = addDays(cursor, 1)) {
+    const date = isoDate(cursor);
+    if (isXnysSessionDate(date)) sessions.push(date);
+  }
+  return Object.freeze(sessions);
+}
+
 // ../lib/calculations/static-dataset-matcher.ts
 function getDatasetValueAvailableAt(dataset, row, column) {
   if (!dataset.columns.includes(column)) throw new Error(`Unknown dataset column: ${column}`);
@@ -5347,7 +5472,9 @@ function getDatasetValueAvailableAt(dataset, row, column) {
   return combineDateAndTime(next, "00:00");
 }
 var availabilityIndexes = /* @__PURE__ */ new WeakMap();
-function resolveDatasetColumnAtTime(dataset, rows, column, entryTime) {
+function resolveDatasetColumnAtTime(dataset, rows, column, entryTime, maxMissedSessions) {
+  if (maxMissedSessions !== void 0 && (!Number.isInteger(maxMissedSessions) || maxMissedSessions < 0))
+    throw new Error("maxMissedSessions must be a nonnegative integer");
   if (!dataset.columns.includes(column)) throw new Error(`Unknown dataset column: ${column}`);
   let rowIndexes = availabilityIndexes.get(dataset);
   if (!rowIndexes) {
@@ -5380,7 +5507,22 @@ function resolveDatasetColumnAtTime(dataset, rows, column, entryTime) {
   }
   if (!left) return null;
   const match = index[left - 1];
-  return { value: match.row.values[column], row: match.row, availableAt: new Date(match.time) };
+  const sourceDay = getDateOnly(new Date(match.row.timestamp));
+  const entryDay = getDateOnly(entryTime);
+  let sessionAge = "unsupported";
+  if (dataset.timingMode === "declared" && sourceDay >= XNYS_SESSION_CALENDAR_SUPPORTED_FROM && entryDay <= XNYS_SESSION_CALENDAR_SUPPORTED_THROUGH) {
+    const includeToday = dataset.columnTiming?.[column] === "open" && entryTime >= combineDateAndTime(/* @__PURE__ */ new Date(`${entryDay}T00:00:00Z`), dataset.knownBy ?? "00:00");
+    sessionAge = enumerateXnysSessions(sourceDay, entryDay).filter(
+      (day) => day > sourceDay && (day < entryDay || includeToday)
+    ).length;
+  }
+  return {
+    value: match.row.values[column],
+    row: match.row,
+    availableAt: new Date(match.time),
+    sessionAge,
+    accepted: maxMissedSessions === void 0 || sessionAge !== "unsupported" && sessionAge <= maxMissedSessions
+  };
 }
 function combineDateAndTime(dateOpened, timeOpened) {
   const d = new Date(dateOpened);
@@ -5406,10 +5548,10 @@ function combineDateAndTime(dateOpened, timeOpened) {
     minutes = parseInt(timeParts[1], 10) || 0;
     seconds = timeParts.length > 2 ? parseInt(timeParts[2], 10) || 0 : 0;
   }
-  const utcDate = Date.UTC(year, month, day, hours, minutes, seconds, 0);
-  const testDate = new Date(utcDate);
+  const utcDate2 = Date.UTC(year, month, day, hours, minutes, seconds, 0);
+  const testDate = new Date(utcDate2);
   const etOffset = getEasternTimeOffset(testDate);
-  return new Date(utcDate - etOffset * 60 * 1e3);
+  return new Date(utcDate2 - etOffset * 60 * 1e3);
 }
 function getEasternTimeOffset(date) {
   const formatter = new Intl.DateTimeFormat("en-US", {
@@ -5941,4 +6083,4 @@ export {
   searchTrades,
   getTradesPage
 };
-//# sourceMappingURL=chunk-4UU7IT2A.js.map
+//# sourceMappingURL=chunk-ENXBPJ7Y.js.map