@discomedia/utils 1.0.18 → 1.0.19

package/dist/index-frontend.mjs

@@ -11,8 +11,6 @@ import require$$0$1 from 'buffer';
 import require$$0$4 from 'fs';
 import require$$1$1 from 'path';
 import require$$2$1 from 'os';
-import { startOfDay, set, endOfDay, add, sub } from 'date-fns';
-import { toZonedTime, fromZonedTime, formatInTimeZone } from 'date-fns-tz';
 
 var Types = /*#__PURE__*/Object.freeze({
     __proto__: null
@@ -13479,64 +13477,90 @@ const marketEarlyCloses = {
     },
 };
 
-// market-time.ts - Refactored for better organization and usability
-// ===== CONFIGURATION =====
-/**
- * Market configuration constants
- */
+// 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 },
         MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 },
-        EXTENDED_END: { hour: 20, minute: 0 },
-        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
-    },
+        EARLY_CLOSE: { hour: 13, minute: 0 }},
 };
-// ===== MARKET CALENDAR SERVICE =====
-/**
- * Service for handling market calendar operations (holidays, early closes, market days)
- */
+// Helper: Get NY offset for a given UTC date (DST rules for US)
+function getNYOffset(date) {
+    // US DST starts 2nd Sunday in March, ends 1st Sunday in November
+    const year = date.getUTCFullYear();
+    const dstStart = getNthWeekdayOfMonth(year, 3, 0, 2); // March, Sunday, 2nd
+    const dstEnd = getNthWeekdayOfMonth(year, 11, 0, 1); // November, Sunday, 1st
+    const utcTime = date.getTime();
+    if (utcTime >= dstStart.getTime() && utcTime < dstEnd.getTime()) {
+        return MARKET_CONFIG.UTC_OFFSET_DST;
+    }
+    return MARKET_CONFIG.UTC_OFFSET_STANDARD;
+}
+// Helper: Get nth weekday of month in UTC
+function getNthWeekdayOfMonth(year, month, weekday, n) {
+    let count = 0;
+    for (let d = 1; d <= 31; d++) {
+        const date = new Date(Date.UTC(year, month - 1, d));
+        if (date.getUTCMonth() !== month - 1)
+            break;
+        if (date.getUTCDay() === weekday) {
+            count++;
+            if (count === n)
+                return date;
+        }
+    }
+    // fallback: last day of month
+    return new Date(Date.UTC(year, month - 1, 28));
+}
+// Helper: Convert UTC date to NY time (returns new Date object)
+function toNYTime(date) {
+    const offset = getNYOffset(date);
+    // NY offset in hours
+    const utcMillis = date.getTime();
+    const nyMillis = utcMillis + offset * 60 * 60 * 1000;
+    return new Date(nyMillis);
+}
+// Helper: Convert NY time to UTC (returns new Date object)
+function fromNYTime(date) {
+    const offset = getNYOffset(date);
+    const nyMillis = date.getTime();
+    const utcMillis = nyMillis - offset * 60 * 60 * 1000;
+    return new Date(utcMillis);
+}
+// Market calendar logic
 class MarketCalendar {
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-    }
-    /**
-     * Check if a date is a weekend
-     */
     isWeekend(date) {
-        const day = date.getDay();
-        return day === 0 || day === 6; // Sunday or Saturday
+        const day = toNYTime(date).getUTCDay();
+        return day === 0 || day === 6;
     }
-    /**
-     * Check if a date is a market holiday
-     */
     isHoliday(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearHolidays = marketHolidays[year];
         if (!yearHolidays)
             return false;
         return Object.values(yearHolidays).some(holiday => holiday.date === formattedDate);
     }
-    /**
-     * Check if a date is an early close day
-     */
     isEarlyCloseDay(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearEarlyCloses = marketEarlyCloses[year];
         return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
     }
-    /**
-     * Get the early close time for a date (in minutes from midnight)
-     */
     getEarlyCloseTime(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearEarlyCloses = marketEarlyCloses[year];
         if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
             const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
@@ -13544,285 +13568,61 @@ class MarketCalendar {
         }
         return null;
     }
-    /**
-     * Check if a date is a market day (not weekend or holiday)
-     */
     isMarketDay(date) {
         return !this.isWeekend(date) && !this.isHoliday(date);
     }
-    /**
-     * Get the next market day from a given date
-     */
     getNextMarketDay(date) {
-        let nextDay = add(date, { days: 1 });
+        let nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
         while (!this.isMarketDay(nextDay)) {
-            nextDay = add(nextDay, { days: 1 });
+            nextDay = new Date(nextDay.getTime() + 24 * 60 * 60 * 1000);
         }
         return nextDay;
     }
-    /**
-     * Get the previous market day from a given date
-     */
     getPreviousMarketDay(date) {
-        let prevDay = sub(date, { days: 1 });
+        let prevDay = new Date(date.getTime() - 24 * 60 * 60 * 1000);
         while (!this.isMarketDay(prevDay)) {
-            prevDay = sub(prevDay, { days: 1 });
+            prevDay = new Date(prevDay.getTime() - 24 * 60 * 60 * 1000);
         }
         return prevDay;
     }
 }
-// ===== TIME FORMATTER SERVICE =====
-/**
- * Service for formatting time outputs
- */
-class TimeFormatter {
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-    }
-    /**
-     * Format a date based on the output format
-     */
-    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 formatInTimeZone(date, this.timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
-        }
-    }
-    /**
-     * Get New York timezone offset
-     */
-    getNYTimeZone(date = new Date()) {
-        const dtf = new Intl.DateTimeFormat('en-US', {
-            timeZone: this.timezone,
-            timeZoneName: 'shortOffset',
-        });
-        const parts = dtf.formatToParts(date);
-        const tz = parts.find(p => p.type === 'timeZoneName')?.value;
-        if (!tz) {
-            throw new Error('Could not determine New York offset');
-        }
-        const shortOffset = tz.replace('GMT', '');
-        if (shortOffset === '-4') {
-            return '-04:00';
-        }
-        else if (shortOffset === '-5') {
-            return '-05:00';
-        }
-        else {
-            throw new Error(`Unexpected timezone offset: ${shortOffset}`);
-        }
-    }
-    /**
-     * Get trading date in YYYY-MM-DD format
-     */
-    getTradingDate(time) {
-        let date;
-        if (typeof time === 'number') {
-            date = new Date(time);
-        }
-        else if (typeof time === 'string') {
-            date = new Date(time);
-        }
-        else {
-            date = time;
-        }
-        return formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-    }
+// Get last full trading date
+function getLastFullTradingDateImpl(currentDate = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(currentDate);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    if (calendar.isEarlyCloseDay(currentDate)) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+    }
+    // If not a market day, or before open, or during market hours, return previous market day's close
+    if (!calendar.isMarketDay(currentDate) || minutes < marketOpenMinutes || (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        const prevMarketDay = calendar.getPreviousMarketDay(currentDate);
+        let prevCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+        if (calendar.isEarlyCloseDay(prevMarketDay)) {
+            prevCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        }
+        const year = prevMarketDay.getUTCFullYear();
+        const month = prevMarketDay.getUTCMonth();
+        const day = prevMarketDay.getUTCDate();
+        const closeHour = Math.floor(prevCloseMinutes / 60);
+        const closeMinute = prevCloseMinutes % 60;
+        return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+    }
+    // After market close or after extended hours, return today's close
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    const closeHour = Math.floor(marketCloseMinutes / 60);
+    const closeMinute = marketCloseMinutes % 60;
+    return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
-// ===== MARKET TIME CALCULATOR =====
 /**
- * Service for core market time calculations
- */
-class MarketTimeCalculator {
-    calendar;
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-        this.calendar = new MarketCalendar(timezone);
-    }
-    /**
-     * Get market open/close times for a date
-     */
-    getMarketTimes(date) {
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Market closed on weekends and holidays
-        if (!this.calendar.isMarketDay(zonedDate)) {
-            return {
-                marketOpen: false,
-                open: null,
-                close: null,
-                openExt: null,
-                closeExt: null,
-            };
-        }
-        const dayStart = startOfDay(zonedDate);
-        // Regular market times
-        const open = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour, minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute }), this.timezone);
-        let close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute }), this.timezone);
-        // Extended hours
-        const openExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute }), this.timezone);
-        let closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute }), this.timezone);
-        // Handle early close days
-        if (this.calendar.isEarlyCloseDay(zonedDate)) {
-            close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute }), this.timezone);
-            closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute }), this.timezone);
-        }
-        return {
-            marketOpen: true,
-            open,
-            close,
-            openExt,
-            closeExt,
-        };
-    }
-    /**
-     * Check if a time is within market hours based on intraday reporting mode
-     */
-    isWithinMarketHours(date, intradayReporting = 'market_hours') {
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Not a market day
-        if (!this.calendar.isMarketDay(zonedDate)) {
-            return false;
-        }
-        const timeInMinutes = zonedDate.getHours() * 60 + zonedDate.getMinutes();
-        switch (intradayReporting) {
-            case 'extended_hours': {
-                const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-                let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-                }
-                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
-            }
-            case 'continuous':
-                return true;
-            default: {
-                // 'market_hours'
-                const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-                let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-                }
-                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
-            }
-        }
-    }
-    /**
-     * Get the last full trading date
-     */
-    getLastFullTradingDate(currentDate = new Date(), extendedHours = true) {
-        const nowET = toZonedTime(currentDate, this.timezone);
-        if (this.calendar.isMarketDay(nowET)) {
-            const timeInMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-            let endMinutes;
-            if (extendedHours) {
-                endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-                if (this.calendar.isEarlyCloseDay(nowET)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-                }
-            }
-            else {
-                endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-                if (this.calendar.isEarlyCloseDay(nowET)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-                }
-            }
-            if (timeInMinutes >= endMinutes) {
-                return fromZonedTime(set(nowET, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
-            }
-        }
-        // Return the last completed trading day
-        const lastMarketDay = this.calendar.getPreviousMarketDay(nowET);
-        return fromZonedTime(set(lastMarketDay, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
-    }
-    /**
-     * Get day boundaries based on intraday reporting mode
-     */
-    getDayBoundaries(date, intradayReporting = 'market_hours') {
-        const zonedDate = toZonedTime(date, this.timezone);
-        let start;
-        let end;
-        switch (intradayReporting) {
-            case 'extended_hours': {
-                start = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
-                    minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
-                    seconds: 0,
-                    milliseconds: 0,
-                });
-                end = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour,
-                    minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute,
-                    seconds: 59,
-                    milliseconds: 999,
-                });
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    end = set(zonedDate, {
-                        hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour,
-                        minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute,
-                        seconds: 59,
-                        milliseconds: 999,
-                    });
-                }
-                break;
-            }
-            case 'continuous': {
-                start = startOfDay(zonedDate);
-                end = endOfDay(zonedDate);
-                break;
-            }
-            default: {
-                // 'market_hours'
-                start = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour,
-                    minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute,
-                    seconds: 0,
-                    milliseconds: 0,
-                });
-                end = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour,
-                    minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute,
-                    seconds: 59,
-                    milliseconds: 999,
-                });
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    end = set(zonedDate, {
-                        hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour,
-                        minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute,
-                        seconds: 59,
-                        milliseconds: 999,
-                    });
-                }
-                break;
-            }
-        }
-        return {
-            start: fromZonedTime(start, this.timezone),
-            end: fromZonedTime(end, this.timezone),
-        };
-    }
-}
-const marketTimeCalculator = new MarketTimeCalculator();
-const timeFormatter = new TimeFormatter();
-/**
- * Get the last full trading date
+ * Returns the last full trading date as a Date object.
  */
 function getLastFullTradingDate(currentDate = new Date()) {
-    const date = marketTimeCalculator.getLastFullTradingDate(currentDate);
-    return {
-        date,
-        YYYYMMDD: timeFormatter.getTradingDate(date),
-    };
+    return getLastFullTradingDateImpl(currentDate);
 }
 
 const log = (message, options = { type: 'info' }) => {
@@ -14222,8 +14022,8 @@ class AlpacaMarketDataAPI extends EventEmitter {
         const response = await this.getHistoricalBars({
             symbols: [symbol],
             timeframe: '1Day',
-            start: prevMarketDate.date.toISOString(),
-            end: prevMarketDate.date.toISOString(),
+            start: prevMarketDate.toISOString(),
+            end: prevMarketDate.toISOString(),
             limit: 1,
         });
         if (!response.bars[symbol] || response.bars[symbol].length === 0) {