@discomedia/utils 1.0.30 → 1.0.32

package/dist/test.js

@@ -146,12 +146,18 @@ const marketEarlyCloses = {
 
 // Constants for NY market times (Eastern Time)
 const MARKET_CONFIG = {
+    TIMEZONE: 'America/New_York',
     UTC_OFFSET_STANDARD: -5, // EST
     UTC_OFFSET_DST: -4, // EDT
     TIMES: {
+        EXTENDED_START: { hour: 4, minute: 0 },
         MARKET_OPEN: { hour: 9, minute: 30 },
+        EARLY_MARKET_END: { hour: 10, minute: 0 },
         MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 }},
+        EARLY_CLOSE: { hour: 13, minute: 0 },
+        EXTENDED_END: { hour: 20, minute: 0 },
+        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
+    },
 };
 // Helper: Get NY offset for a given UTC date (DST rules for US)
 /**
@@ -219,6 +225,33 @@ function fromNYTime(date) {
     const utcMillis = nyMillis - offset * 60 * 60 * 1000;
     return new Date(utcMillis);
 }
+// Helper: Format date in ISO, unix, etc.
+/**
+ * Formats a date in ISO, unix-seconds, or unix-ms format.
+ * @param date - Date object
+ * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
+ * @returns Formatted date string or number
+ */
+function formatDate(date, outputFormat = 'iso') {
+    switch (outputFormat) {
+        case 'unix-seconds':
+            return Math.floor(date.getTime() / 1000);
+        case 'unix-ms':
+            return date.getTime();
+        case 'iso':
+        default:
+            return date.toISOString();
+    }
+}
+// Helper: Format date in NY locale string
+/**
+ * Formats a date in NY locale string.
+ * @param date - Date object
+ * @returns NY locale string
+ */
+function formatNYLocale(date) {
+    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+}
 // Market calendar logic
 /**
  * Market calendar logic for holidays, weekends, and market days.
@@ -314,6 +347,82 @@ class MarketCalendar {
         return prevDay;
     }
 }
+// Market open/close times
+/**
+ * Returns market open/close times for a given date, including extended and early closes.
+ * @param date - Date object
+ * @returns MarketOpenCloseResult
+ */
+function getMarketTimes(date) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    if (!calendar.isMarketDay(date)) {
+        return {
+            marketOpen: false,
+            open: null,
+            close: null,
+            openExt: null,
+            closeExt: null,
+        };
+    }
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    // Helper to build NY time for a given hour/minute
+    function buildNYTime(hour, minute) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+        return fromNYTime(d);
+    }
+    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
+    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
+    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
+    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
+    if (calendar.isEarlyCloseDay(date)) {
+        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
+        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
+    }
+    return {
+        marketOpen: true,
+        open,
+        close,
+        openExt,
+        closeExt,
+    };
+}
+// Is within market hours
+/**
+ * Checks if a date/time is within market hours, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns true if within hours, false otherwise
+ */
+function isWithinMarketHours(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    if (!calendar.isMarketDay(date))
+        return false;
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    switch (intradayReporting) {
+        case 'extended_hours': {
+            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+        case 'continuous':
+            return true;
+        default: {
+            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+            }
+            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
+        }
+    }
+}
 // Get last full trading date
 /**
  * Returns the last full trading date (market close) for a given date.
@@ -353,6 +462,244 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
     const closeMinute = marketCloseMinutes % 60;
     return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
+// Get day boundaries
+/**
+ * Returns the start and end boundaries for a market day, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns Object with start and end Date
+ */
+function getDayBoundaries(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    function buildNYTime(hour, minute, sec = 0, ms = 0) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
+        return fromNYTime(d);
+    }
+    let start;
+    let end;
+    switch (intradayReporting) {
+        case 'extended_hours':
+            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
+            }
+            break;
+        case 'continuous':
+            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
+            break;
+        default:
+            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
+            }
+            break;
+    }
+    return { start, end };
+}
+// Period calculator
+/**
+ * Calculates the start date for a given period ending at endDate.
+ * @param endDate - Date object
+ * @param period - Period string
+ * @returns Date object for period start
+ */
+function calculatePeriodStartDate(endDate, period) {
+    const calendar = new MarketCalendar();
+    let startDate;
+    switch (period) {
+        case 'YTD':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
+            break;
+        case '1D':
+            startDate = calendar.getPreviousMarketDay(endDate);
+            break;
+        case '3D':
+            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
+            break;
+        case '1W':
+            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case '2W':
+            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
+            break;
+        case '1M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
+            break;
+        case '3M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
+            break;
+        case '6M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
+            break;
+        case '1Y':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
+            break;
+        default:
+            throw new Error(`Invalid period: ${period}`);
+    }
+    // Ensure start date is a market day
+    while (!calendar.isMarketDay(startDate)) {
+        startDate = calendar.getNextMarketDay(startDate);
+    }
+    return startDate;
+}
+// Get market time period
+/**
+ * Returns the start and end dates for a market time period.
+ * @param params - MarketTimeParams
+ * @returns PeriodDates object
+ */
+function getMarketTimePeriod(params) {
+    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso' } = params;
+    if (!period)
+        throw new Error('Period is required');
+    const calendar = new MarketCalendar();
+    const nyEndDate = toNYTime(end);
+    let endDate;
+    const isCurrentMarketDay = calendar.isMarketDay(end);
+    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
+    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    if (isCurrentMarketDay) {
+        if (minutes < marketStartMinutes) {
+            // Before market open - use previous day's close
+            const lastMarketDay = calendar.getPreviousMarketDay(end);
+            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+            endDate = dayEnd;
+        }
+        else if (isWithinHours) {
+            // During market hours - use current time
+            endDate = end;
+        }
+        else {
+            // After market close - use today's close
+            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
+            endDate = dayEnd;
+        }
+    }
+    else {
+        // Not a market day - use previous market day's close
+        const lastMarketDay = calendar.getPreviousMarketDay(end);
+        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+        endDate = dayEnd;
+    }
+    // Calculate start date
+    const periodStartDate = calculatePeriodStartDate(endDate, period);
+    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
+    if (endDate.getTime() < dayStart.getTime()) {
+        throw new Error('Start date cannot be after end date');
+    }
+    return {
+        start: formatDate(dayStart, outputFormat),
+        end: formatDate(endDate, outputFormat),
+    };
+}
+// Market status
+/**
+ * Returns the current market status for a given date.
+ * @param date - Date object (default: now)
+ * @returns MarketStatus object
+ */
+function getMarketStatusImpl(date = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const isMarketDay = calendar.isMarketDay(date);
+    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
+    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+    if (isEarlyCloseDay) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        extendedEndMinutes =
+            MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+    }
+    let status;
+    let nextStatus;
+    let nextStatusTime;
+    let marketPeriod;
+    if (!isMarketDay) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    else if (minutes < extendedStartMinutes) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
+    }
+    else if (minutes < marketStartMinutes) {
+        status = 'extended hours';
+        nextStatus = 'open';
+        marketPeriod = 'preMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
+    }
+    else if (minutes < marketCloseMinutes) {
+        status = 'open';
+        nextStatus = 'extended hours';
+        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
+    }
+    else if (minutes < extendedEndMinutes) {
+        status = 'extended hours';
+        nextStatus = 'closed';
+        marketPeriod = 'afterMarket';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
+    }
+    else {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    // I think using nyDate here may be wrong - should use current time? i.e. date.getTime()
+    const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
+    return {
+        time: date,
+        timeString: formatNYLocale(nyDate),
+        status,
+        nextStatus,
+        marketPeriod,
+        nextStatusTime,
+        nextStatusTimeDifference,
+        nextStatusTimeString: formatNYLocale(nextStatusTime),
+    };
+}
+// API exports
+/**
+ * Returns market open/close times for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketOpenCloseResult
+ */
+function getMarketOpenClose(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketTimes(date);
+}
+/**
+ * Returns the start and end dates for a market time period as Date objects.
+ * @param params - MarketTimeParams
+ * @returns Object with start and end Date
+ */
+function getStartAndEndDates(params = {}) {
+    const { start, end } = getMarketTimePeriod(params);
+    return {
+        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
+        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
+    };
+}
 /**
  * Returns the last full trading date as a Date object.
  */
@@ -364,6 +711,230 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
+/**
+ * Returns the next market day after the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getNextMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate ?? new Date();
+    // Find the next trading day (UTC Date object)
+    const nextDate = calendar.getNextMarketDay(startDate);
+    // Convert to NY time before extracting Y-M-D parts
+    const nyNext = toNYTime(nextDate);
+    const yyyymmdd = `${nyNext.getUTCFullYear()}-${String(nyNext.getUTCMonth() + 1).padStart(2, '0')}-${String(nyNext.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: nextDate, // raw Date, unchanged
+        yyyymmdd, // correct trading date string
+        dateISOString: nextDate.toISOString(),
+    };
+}
+/**
+ * Returns the previous market day before the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
+ */
+function getPreviousMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
+    const startDate = referenceDate || new Date();
+    const prevDate = calendar.getPreviousMarketDay(startDate);
+    // convert to NY time first
+    const nyPrev = toNYTime(prevDate); // ← already in this file
+    const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, '0')}-${String(nyPrev.getUTCDate()).padStart(2, '0')}`;
+    return {
+        date: prevDate,
+        yyyymmdd,
+        dateISOString: prevDate.toISOString(),
+    };
+}
+/**
+ * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
+ * @param time - a string, number (unix timestamp), or Date object representing the time
+ * @returns the trading date as a string in YYYY-MM-DD format
+ */
+/**
+ * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
+ * @param time - string, number, or Date
+ * @returns trading date string
+ */
+function getTradingDate(time) {
+    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
+    const nyDate = toNYTime(date);
+    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+}
+/**
+ * Returns the NY timezone offset string for a given date.
+ * @param date - Date object (default: now)
+ * @returns '-04:00' for EDT, '-05:00' for EST
+ */
+function getNYTimeZone(date) {
+    const offset = getNYOffset(date || new Date());
+    return offset === -4 ? '-04:00' : '-05:00';
+}
+/**
+ * Returns the current market status for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketStatus object
+ */
+function getMarketStatus(options = {}) {
+    const { date = new Date() } = options;
+    return getMarketStatusImpl(date);
+}
+/**
+ * Checks if a date is a market day.
+ * @param date - Date object
+ * @returns true if market day, false otherwise
+ */
+function isMarketDay(date) {
+    const calendar = new MarketCalendar();
+    return calendar.isMarketDay(date);
+}
+/**
+ * Returns full trading days from market open to market close.
+ * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
+ * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
+ */
+/**
+ * Returns full trading days from market open to market close.
+ * @param options - { endDate?: Date, days?: number }
+ * @returns Object with startDate and endDate
+ */
+function getTradingStartAndEndDates(options = {}) {
+    const { endDate = new Date(), days = 1 } = options;
+    const calendar = new MarketCalendar();
+    // Find the most recent market close
+    let endMarketDay = endDate;
+    const nyEnd = toNYTime(endDate);
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
+    if (!calendar.isMarketDay(endDate) ||
+        minutes < marketOpenMinutes ||
+        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        // Before market open, not a market day, or during market hours: use previous market day
+        endMarketDay = calendar.getPreviousMarketDay(endDate);
+    }
+    else {
+        // After market close: use today
+        endMarketDay = endDate;
+    }
+    // Get market close for endMarketDay
+    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
+    // Find start market day by iterating back over market days
+    let startMarketDay = endMarketDay;
+    let count = Math.max(1, days);
+    for (let i = 1; i < count; i++) {
+        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+    }
+    // If days > 1, we need to go back (days-1) market days from endMarketDay
+    if (days > 1) {
+        startMarketDay = endMarketDay;
+        for (let i = 1; i < days; i++) {
+            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+        }
+    }
+    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
+    return { startDate: startOpen, endDate: endClose };
+}
+/**
+ * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
+ *
+ * This function calculates the actual trading time between two dates by:
+ * 1. Iterating through each calendar day between startDate and endDate (inclusive)
+ * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
+ * 3. Calculating the overlap between the time range and market hours for that day
+ * 4. Summing up all the trading minutes across all days
+ *
+ * The function automatically handles:
+ * - Weekends (Saturday/Sunday) - skipped entirely
+ * - Market holidays - skipped entirely
+ * - Early close days (e.g. day before holidays) - uses early close time
+ * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
+ *
+ * Examples:
+ * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
+ * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
+ * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
+ *
+ * @param startDate - Start date/time
+ * @param endDate - End date/time (default: now)
+ * @returns Object containing:
+ *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
+ *   - hours: Trading time in hours
+ *   - minutes: Trading time in minutes
+ */
+function countTradingDays(startDate, endDate = new Date()) {
+    const calendar = new MarketCalendar();
+    // Ensure start is before end
+    if (startDate.getTime() > endDate.getTime()) {
+        throw new Error('Start date must be before end date');
+    }
+    let totalMinutes = 0;
+    // Get the NY dates for iteration
+    const startNY = toNYTime(startDate);
+    const endNY = toNYTime(endDate);
+    // Create date at start of first day (in NY time)
+    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
+    // Iterate through each calendar day
+    while (currentNY.getTime() <= endNY.getTime()) {
+        const currentUTC = fromNYTime(currentNY);
+        // Check if this is a market day
+        if (calendar.isMarketDay(currentUTC)) {
+            // Get market hours for this day
+            const marketTimes = getMarketTimes(currentUTC);
+            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
+                // Calculate the overlap between our time range and market hours
+                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
+                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
+                // Only count if there's actual overlap
+                if (dayStart < dayEnd) {
+                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
+                }
+            }
+        }
+        // Move to next day
+        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
+    }
+    // Convert to days, hours, minutes
+    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
+    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
+    const hours = totalMinutes / 60;
+    const minutes = totalMinutes;
+    return {
+        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
+        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
+        minutes: Math.round(minutes),
+    };
+}
+// Export MARKET_TIMES for compatibility
+const MARKET_TIMES = {
+    TIMEZONE: MARKET_CONFIG.TIMEZONE,
+    PRE: {
+        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
+        END: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+    },
+    EARLY_MORNING: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 10, MINUTE: 0, MINUTES: 600 },
+    },
+    EARLY_CLOSE_BEFORE_HOLIDAY: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+    },
+    EARLY_EXTENDED_BEFORE_HOLIDAY: {
+        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
+        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
+    },
+    REGULAR: {
+        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
+        END: { HOUR: 16, MINUTE: 0, MINUTES: 960 },
+    },
+    EXTENDED: {
+        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
+        END: { HOUR: 20, MINUTE: 0, MINUTES: 1200 },
+    },
+};
 
 /*
 How it works:
@@ -533,7 +1104,7 @@ function pLimit(concurrency) {
 		},
 		map: {
 			async value(array, function_) {
-				const promises = array.map(value => this(function_, value));
+				const promises = array.map((value, index) => this(function_, value, index));
 				return Promise.all(promises);
 			},
 		},
@@ -799,7 +1370,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '5.12.2'; // x-release-please-version
+const VERSION = '5.16.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -2139,6 +2710,36 @@ class CursorPage extends AbstractPage {
         };
     }
 }
+class ConversationCursorPage extends AbstractPage {
+    constructor(client, response, body, options) {
+        super(client, response, body, options);
+        this.data = body.data || [];
+        this.has_more = body.has_more || false;
+        this.last_id = body.last_id || '';
+    }
+    getPaginatedItems() {
+        return this.data ?? [];
+    }
+    hasNextPage() {
+        if (this.has_more === false) {
+            return false;
+        }
+        return super.hasNextPage();
+    }
+    nextPageRequestOptions() {
+        const cursor = this.last_id;
+        if (!cursor) {
+            return null;
+        }
+        return {
+            ...this.options,
+            query: {
+                ...maybeObj(this.options.query),
+                after: cursor,
+            },
+        };
+    }
+}
 
 const checkFileSupport = () => {
     if (typeof File === 'undefined') {
@@ -5229,6 +5830,74 @@ class Containers extends APIResource {
 }
 Containers.Files = Files$2;
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Items extends APIResource {
+    /**
+     * Create items in a conversation with the given ID.
+     */
+    create(conversationID, params, options) {
+        const { include, ...body } = params;
+        return this._client.post(path `/conversations/${conversationID}/items`, {
+            query: { include },
+            body,
+            ...options,
+        });
+    }
+    /**
+     * Get a single item from a conversation with the given IDs.
+     */
+    retrieve(itemID, params, options) {
+        const { conversation_id, ...query } = params;
+        return this._client.get(path `/conversations/${conversation_id}/items/${itemID}`, { query, ...options });
+    }
+    /**
+     * List all items for a conversation with the given ID.
+     */
+    list(conversationID, query = {}, options) {
+        return this._client.getAPIList(path `/conversations/${conversationID}/items`, (ConversationCursorPage), { query, ...options });
+    }
+    /**
+     * Delete an item from a conversation with the given IDs.
+     */
+    delete(itemID, params, options) {
+        const { conversation_id } = params;
+        return this._client.delete(path `/conversations/${conversation_id}/items/${itemID}`, options);
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Conversations extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.items = new Items(this._client);
+    }
+    /**
+     * Create a conversation.
+     */
+    create(body, options) {
+        return this._client.post('/conversations', { body, ...options });
+    }
+    /**
+     * Get a conversation with the given ID.
+     */
+    retrieve(conversationID, options) {
+        return this._client.get(path `/conversations/${conversationID}`, options);
+    }
+    /**
+     * Update a conversation's metadata with the given ID.
+     */
+    update(conversationID, body, options) {
+        return this._client.post(path `/conversations/${conversationID}`, { body, ...options });
+    }
+    /**
+     * Delete a conversation with the given ID.
+     */
+    delete(conversationID, options) {
+        return this._client.delete(path `/conversations/${conversationID}`, options);
+    }
+}
+Conversations.Items = Items;
+
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Embeddings extends APIResource {
     /**
@@ -5393,7 +6062,7 @@ let Files$1 = class Files extends APIResource {
     /**
      * Upload a file that can be used across various endpoints. Individual files can be
      * up to 512 MB, and the size of all files uploaded by one organization can be up
-     * to 100 GB.
+     * to 1 TB.
      *
      * The Assistants API supports files up to 2 million tokens and of specific file
      * types. See the
@@ -6822,6 +7491,7 @@ class OpenAI {
         this.batches = new Batches(this);
         this.uploads = new Uploads(this);
         this.responses = new Responses(this);
+        this.conversations = new Conversations(this);
         this.evals = new Evals(this);
         this.containers = new Containers(this);
         if (apiKey === undefined) {
@@ -7212,7 +7882,7 @@ class OpenAI {
                 // Preserve legacy string encoding behavior for now
                 headers.values.has('content-type')) ||
             // `Blob` is superset of `File`
-            body instanceof Blob ||
+            (globalThis.Blob && body instanceof globalThis.Blob) ||
             // `FormData` -> `multipart/form-data`
             body instanceof FormData ||
             // `URLSearchParams` -> `application/x-www-form-urlencoded`
@@ -7267,6 +7937,7 @@ OpenAI.Beta = Beta;
 OpenAI.Batches = Batches;
 OpenAI.Uploads = Uploads;
 OpenAI.Responses = Responses;
+OpenAI.Conversations = Conversations;
 OpenAI.Evals = Evals;
 OpenAI.Containers = Containers;
 
@@ -13675,87 +14346,124 @@ class AlpacaMarketDataAPI extends EventEmitter {
     }
 }
 // Export the singleton instance
-const marketDataAPI = AlpacaMarketDataAPI.getInstance();
+AlpacaMarketDataAPI.getInstance();
+
+const disco = {
+    time: {
+        getStartAndEndDates: getStartAndEndDates,
+        getMarketOpenClose: getMarketOpenClose,
+        getLastFullTradingDate: getLastFullTradingDate,
+        getNextMarketDay: getNextMarketDay,
+        getPreviousMarketDay: getPreviousMarketDay,
+        getMarketTimePeriod: getMarketTimePeriod,
+        getMarketStatus: getMarketStatus,
+        getNYTimeZone: getNYTimeZone,
+        getTradingDate: getTradingDate,
+        getTradingStartAndEndDates: getTradingStartAndEndDates,
+        isMarketDay: isMarketDay,
+        isWithinMarketHours: isWithinMarketHours,
+        countTradingDays: countTradingDays,
+        MARKET_TIMES: MARKET_TIMES,
+    }};
 
 // Test file for context functionality
-async function testGetPortfolioDailyHistory() {
-    console.log('\n--- Testing getPortfolioDailyHistory with Real API ---');
-    const log = (message, options = { type: 'info' }) => {
-        log$1(message, { ...options, source: 'Test' });
-    };
-    if (!process.env.ALPACA_API_KEY || !process.env.ALPACA_SECRET_KEY || !process.env.ALPACA_ACCOUNT_TYPE) {
-        console.log('Skipping Alpaca tests: Missing environment variables (ALPACA_API_KEY, ALPACA_SECRET_KEY, ALPACA_ACCOUNT_TYPE)');
-        return;
-    }
-    try {
-        // Create real Alpaca API instance with credentials from .env
-        const { AlpacaTradingAPI } = await import('./alpaca-trading-api-CPaXTnjf.js');
-        const credentials = {
-            accountName: 'TestAccount',
-            apiKey: process.env.ALPACA_API_KEY,
-            apiSecret: process.env.ALPACA_SECRET_KEY,
-            type: process.env.ALPACA_ACCOUNT_TYPE,
-            orderType: 'limit',
-            engine: 'brain'
-        };
-        const alpacaAPI = new AlpacaTradingAPI(credentials);
-        log('Created Alpaca Trading API instance');
-        // Test getPortfolioDailyHistory with a short period to get recent data
-        log('Calling getPortfolioDailyHistory...');
-        const dailyHistoryResult = await alpacaAPI.getPortfolioDailyHistory({
-            period: '7D' // Last 7 days
-        });
-        log('✓ Successfully called getPortfolioDailyHistory');
-        console.log('Daily history result:');
-        console.log(`  Timestamps: ${dailyHistoryResult.timestamp.length} entries`);
-        console.log(`  First timestamp: ${new Date(dailyHistoryResult.timestamp[0] * 1000).toLocaleString('en-US', { timeZone: 'America/New_York' })}`);
-        console.log(`  Last timestamp: ${new Date(dailyHistoryResult.timestamp[dailyHistoryResult.timestamp.length - 1] * 1000).toLocaleString('en-US', { timeZone: 'America/New_York' })}`);
-        console.log(`  Base value: $${dailyHistoryResult.base_value}`);
-        console.log(`  Latest equity: $${dailyHistoryResult.equity[dailyHistoryResult.equity.length - 1]}`);
-        console.log(`  Latest P&L: $${dailyHistoryResult.profit_loss[dailyHistoryResult.profit_loss.length - 1]}`);
-        console.log(`  Latest P&L %: ${dailyHistoryResult.profit_loss_pct[dailyHistoryResult.profit_loss_pct.length - 1]}%`);
-        console.log(`  Timeframe: ${dailyHistoryResult.timeframe}`);
-        // Compare with regular daily history to see if there's a difference
-        log('Comparing with regular getPortfolioHistory (daily)...');
-        const regularDailyHistory = await alpacaAPI.getPortfolioHistory({
-            timeframe: '1D',
-            period: '7D'
-        });
-        const dailyHistoryCount = dailyHistoryResult.timestamp.length;
-        const regularDailyCount = regularDailyHistory.timestamp.length;
-        console.log(`Regular daily history: ${regularDailyCount} entries`);
-        console.log(`Enhanced daily history: ${dailyHistoryCount} entries`);
-        if (dailyHistoryCount > regularDailyCount) {
-            log('✓ getPortfolioDailyHistory successfully added recent data from hourly history');
-            console.log(`  Added ${dailyHistoryCount - regularDailyCount} additional day(s)`);
-        }
-        else if (dailyHistoryCount === regularDailyCount) {
-            log('✓ No recent hourly data to merge - both histories have same length');
-        }
-        else {
-            log('⚠ Unexpected: Enhanced history has fewer entries than regular history');
-        }
-        // Test with a longer period to ensure it works with more data
-        // Note: For periods > 30 days, Alpaca API only allows 1D timeframe for hourly data
-        // So the function will gracefully handle this by only merging when hourly data is available
-        log('Testing with longer period (2 weeks)...');
-        const longerResult = await alpacaAPI.getPortfolioDailyHistory({
-            period: '14D'
-        });
-        console.log(`2-week daily history: ${longerResult.timestamp.length} entries`);
-        log('✓ Successfully retrieved 2-week daily history');
-        log('✓ All getPortfolioDailyHistory tests completed successfully!');
-    }
-    catch (error) {
-        console.error('✗ Test failed:', error);
-        if (error instanceof Error) {
-            console.error('Error message:', error.message);
-            console.error('Stack trace:', error.stack);
-        }
-    }
-}
-testGetPortfolioDailyHistory();
+// Test getMarketStatus with various scenarios
+function testGetMarketStatus() {
+    const testCases = [
+        {
+            label: 'Weekend (Saturday, market closed)',
+            date: '2025-07-12T12:00:00-04:00',
+            expected: {
+                status: 'closed',
+                nextStatus: 'extended hours',
+                marketPeriod: 'closed',
+            },
+        },
+        // do before preMarket
+        {
+            label: 'Before pre-market (market closed)',
+            date: '2025-07-10T03:00:00-04:00',
+            expected: {
+                status: 'closed',
+                nextStatus: 'extended hours',
+                marketPeriod: 'closed',
+            },
+        },
+        {
+            label: 'Pre-market (before open)',
+            date: '2025-07-10T08:00:00-04:00', // 8am EDT
+            expected: {
+                status: 'extended hours',
+                nextStatus: 'open',
+                marketPeriod: 'preMarket',
+            },
+        },
+        {
+            label: 'Extended hours (pre-market)',
+            date: '2025-07-10T05:00:00-04:00',
+            expected: {
+                status: 'extended hours',
+                nextStatus: 'open',
+                marketPeriod: 'preMarket',
+            },
+        },
+        {
+            label: 'Market open (regular)',
+            date: '2025-07-10T10:00:00-04:00',
+            expected: {
+                status: 'open',
+                nextStatus: 'extended hours',
+                marketPeriod: 'regularMarket',
+            },
+        },
+        {
+            label: 'Market open (early market)',
+            date: '2025-07-03T09:45:00-04:00', // Early close day
+            expected: {
+                status: 'open',
+                nextStatus: 'extended hours',
+                marketPeriod: 'earlyMarket',
+            },
+        },
+        {
+            label: 'After market close (extended hours)',
+            date: '2025-07-10T17:00:00-04:00',
+            expected: {
+                status: 'extended hours',
+                nextStatus: 'closed',
+                marketPeriod: 'afterMarket',
+            },
+        },
+        {
+            label: 'After extended hours (market closed)',
+            date: '2025-07-10T21:00:00-04:00',
+            expected: {
+                status: 'closed',
+                nextStatus: 'extended hours',
+                marketPeriod: 'closed',
+            },
+        },
+    ];
+    for (const { label, date, expected } of testCases) {
+        const result = disco.time.getMarketStatus({ date: new Date(date) });
+        const pass = result.status === expected.status &&
+            result.nextStatus === expected.nextStatus &&
+            result.marketPeriod === expected.marketPeriod;
+        console.log(`\nTest: ${label}`);
+        console.log(`  Input date: ${date}`);
+        console.log(`  Status: ${result.status} ${pass ? '✓' : `✗ (expected ${expected.status})`}`);
+        console.log(`  NextStatus: ${result.nextStatus} ${pass ? '✓' : `✗ (expected ${expected.nextStatus})`}`);
+        console.log(`  MarketPeriod: ${result.marketPeriod} ${pass ? '✓' : `✗ (expected ${expected.marketPeriod})`}`);
+        const nextStatusTimeDifferenceMs = result.nextStatusTimeDifference;
+        // convert that to a string in the form 'xxh xxm'
+        const nextStatusTimeDifferenceStr = `${Math.floor(nextStatusTimeDifferenceMs / (1000 * 60 * 60))}h ${Math.floor((nextStatusTimeDifferenceMs % (1000 * 60 * 60)) / (1000 * 60))}m`;
+        console.log(`  Next market status: ${result.nextStatus} at ${result.nextStatusTime.toLocaleString('en-US', { timeZone: 'America/New_York' })} in ${nextStatusTimeDifferenceStr}`);
+        if (!pass) {
+            console.error(`  FAILED: Expected status=${expected.status}, nextStatus=${expected.nextStatus}, marketPeriod=${expected.marketPeriod}, got status=${result.status}, nextStatus=${result.nextStatus}, marketPeriod=${result.marketPeriod}`);
+        }
+    }
+}
+//testGetPortfolioDailyHistory();
 //testOpenRouter();
-
-export { WebSocket as W, log$1 as l, marketDataAPI as m };
+testGetMarketStatus();
 //# sourceMappingURL=test.js.map