@discomedia/utils 1.0.51 → 1.0.53

package/dist/index.cjs

@@ -969,10 +969,13 @@ function countTradingDays(startDate, endDate = new Date()) {
 /**
  * Returns the trading day N days back from a reference date, along with its market open time.
  * Trading days are counted as full or half trading days (days that end count as 1 full trading day).
+ * By default, the most recent completed trading day counts as day 1.
+ * Set includeMostRecentFullDay to false to count strictly before that day.
  *
  * @param options - Object with:
  *   - referenceDate: Date to count back from (default: now)
- *   - days: Number of trading days to go back (must be >= 1)
+ *   - days: Number of trading days to go back (must be an integer >= 1)
+ *   - includeMostRecentFullDay: Whether to include the most recent completed trading day (default: true)
  * @returns Object containing:
  *   - date: Trading date in YYYY-MM-DD format
  *   - marketOpenISO: Market open time as ISO string (e.g., "2025-11-15T13:30:00.000Z")
@@ -994,13 +997,17 @@ function countTradingDays(startDate, endDate = new Date()) {
  */
 function getTradingDaysBack(options) {
     const calendar = new MarketCalendar();
-    const refDate = options.referenceDate || new Date();
-    const daysBack = options.days;
-    if (daysBack < 1) {
-        throw new Error('days must be at least 1');
+    const { referenceDate, days, includeMostRecentFullDay = true } = options;
+    const refDate = referenceDate || new Date();
+    const daysBack = days;
+    if (!Number.isInteger(daysBack) || daysBack < 1) {
+        throw new Error('days must be an integer >= 1');
     }
     // Start from the last full trading date relative to reference
     let targetDate = getLastFullTradingDateImpl(refDate);
+    if (!includeMostRecentFullDay) {
+        targetDate = calendar.getPreviousMarketDay(targetDate);
+    }
     // Go back the specified number of days (we're already at day 1, so go back days-1 more)
     for (let i = 1; i < daysBack; i++) {
         targetDate = calendar.getPreviousMarketDay(targetDate);
@@ -11376,6 +11383,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -14146,6 +14154,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -14160,7 +14169,6 @@ function requireWebsocket () {
 	const { format, parse } = requireExtension();
 	const { toBuffer } = requireBufferUtil();
 
-	const closeTimeout = 30 * 1000;
 	const kAborted = Symbol('kAborted');
 	const protocolVersions = [8, 13];
 	const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -14216,6 +14224,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -14757,6 +14766,8 @@ function requireWebsocket () {
 	 *     times in the same tick
 	 * @param {Boolean} [options.autoPong=true] Specifies whether or not to
 	 *     automatically send a pong in response to a ping
+	 * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+	 *     for the closing handshake to finish after `websocket.close()` is called
 	 * @param {Function} [options.finishRequest] A function which can be used to
 	 *     customize the headers of each http request before it is sent
 	 * @param {Boolean} [options.followRedirects=false] Whether or not to follow
@@ -14783,6 +14794,7 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
@@ -14801,6 +14813,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -15418,7 +15431,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -15436,23 +15449,23 @@ function requireWebsocket () {
 
 	  websocket._readyState = WebSocket.CLOSING;
 
-	  let chunk;
-
 	  //
 	  // The close frame might not have been received or the `'end'` event emitted,
 	  // for example, if the socket was destroyed due to an error. Ensure that the
 	  // `receiver` stream is closed after writing any remaining buffered data to
 	  // it. If the readable side of the socket is in flowing mode then there is no
-	  // buffered data as everything has been already written and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
+	  // buffered data as everything has been already written. If instead, the
+	  // socket is paused, any possible buffered data will be read as a single
+	  // chunk.
 	  //
 	  if (
 	    !this._readableState.endEmitted &&
 	    !websocket._closeFrameReceived &&
 	    !websocket._receiver._writableState.errorEmitted &&
-	    (chunk = websocket._socket.read()) !== null
+	    this._readableState.length !== 0
 	  ) {
+	    const chunk = this.read(this._readableState.length);
+
 	    websocket._receiver.write(chunk);
 	  }
 
@@ -15784,7 +15797,7 @@ function requireWebsocketServer () {
 	const PerMessageDeflate = requirePermessageDeflate();
 	const subprotocol = requireSubprotocol();
 	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = requireConstants();
 
 	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -15811,6 +15824,9 @@ function requireWebsocketServer () {
 	   *     pending connections
 	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
 	   *     track clients
+	   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+	   *     wait for the closing handshake to finish after `websocket.close()` is
+	   *     called
 	   * @param {Function} [options.handleProtocols] A hook to handle protocols
 	   * @param {String} [options.host] The hostname where to bind the server
 	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
@@ -15840,6 +15856,7 @@ function requireWebsocketServer () {
 	      perMessageDeflate: false,
 	      handleProtocols: null,
 	      clientTracking: true,
+	      closeTimeout: CLOSE_TIMEOUT,
 	      verifyClient: null,
 	      noServer: false,
 	      backlog: null, // use default (511 as implemented in net.js)
@@ -18459,6 +18476,7 @@ class AlpacaTradingAPI {
      * @param qty (number) - the quantity of the order
      * @param side (string) - the side of the order
      * @param position_intent (string) - the position intent of the order. Important for knowing if a position needs a trailing stop.
+     * @param client_order_id (string) - optional client order id
      */
     async createMarketOrder(symbol, qty, side, position_intent, client_order_id) {
         this.log(`Creating market order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
@@ -18484,6 +18502,86 @@ class AlpacaTradingAPI {
             throw error;
         }
     }
+    /**
+     * Create a Market on Open (MOO) order - executes in the opening auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET and before 9:28am ET
+     * - Orders submitted between 9:28am and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's opening auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market open (9:30am)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOOOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Open order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'opg',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOO order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a Market on Close (MOC) order - executes in the closing auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET (previous day) and before 3:50pm ET (same day)
+     * - Orders submitted between 3:50pm and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's closing auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market close (4:00pm)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOCOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Close order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'cls',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOC order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
     /**
      * Get the current trail percent for a symbol, assuming that it has an open position and a trailing stop order to close it. Because this relies on an orders request for one symbol, you can't do it too often.
      * @param symbol (string) - the symbol of the order