@discomedia/utils 1.0.26 → 1.0.27

package/dist/index.cjs

@@ -1372,51 +1372,47 @@ function pLimit(concurrency) {
 	let activeCount = 0;
 
 	const resumeNext = () => {
+		// Process the next queued function if we're under the concurrency limit
 		if (activeCount < concurrency && queue.size > 0) {
-			queue.dequeue()();
-			// Since `pendingCount` has been decreased by one, increase `activeCount` by one.
 			activeCount++;
+			queue.dequeue()();
 		}
 	};
 
 	const next = () => {
 		activeCount--;
-
 		resumeNext();
 	};
 
 	const run = async (function_, resolve, arguments_) => {
+		// Execute the function and capture the result promise
 		const result = (async () => function_(...arguments_))();
 
+		// Resolve immediately with the promise (don't wait for completion)
 		resolve(result);
 
+		// Wait for the function to complete (success or failure)
+		// We catch errors here to prevent unhandled rejections,
+		// but the original promise rejection is preserved for the caller
 		try {
 			await result;
 		} catch {}
 
+		// Decrement active count and process next queued function
 		next();
 	};
 
 	const enqueue = (function_, resolve, arguments_) => {
-		// Queue `internalResolve` instead of the `run` function
-		// to preserve asynchronous context.
-		new Promise(internalResolve => {
+		// Queue the internal resolve function instead of the run function
+		// to preserve the asynchronous execution context.
+		new Promise(internalResolve => { // eslint-disable-line promise/param-names
 			queue.enqueue(internalResolve);
-		}).then(
-			run.bind(undefined, function_, resolve, arguments_),
-		);
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// after the `internalResolve` function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency) {
-				resumeNext();
-			}
-		})();
+		}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
+
+		// Start processing immediately if we haven't reached the concurrency limit
+		if (activeCount < concurrency) {
+			resumeNext();
+		}
 	};
 
 	const generator = (function_, ...arguments_) => new Promise(resolve => {
@@ -1450,6 +1446,12 @@ function pLimit(concurrency) {
 				});
 			},
 		},
+		map: {
+			async value(array, function_) {
+				const promises = array.map(value => this(function_, value));
+				return Promise.all(promises);
+			},
+		},
 	});
 
 	return generator;
@@ -17111,6 +17113,18 @@ Websocket example
    this.log(`Received trade update: event ${update.event} for an order to ${update.order.side} ${update.order.qty} of ${update.order.symbol}`);
   });
   alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
+
+Portfolio History examples
+  // Get standard portfolio history
+  const portfolioHistory = await alpacaAPI.getPortfolioHistory({
+    timeframe: '1D',
+    period: '1M'
+  });
+
+  // Get daily portfolio history with current day included (if available from hourly data)
+  const dailyHistory = await alpacaAPI.getPortfolioDailyHistory({
+    period: '1M'
+  });
 */
 class AlpacaTradingAPI {
     static new(credentials) {
@@ -17810,6 +17824,57 @@ class AlpacaTradingAPI {
         const response = await this.makeRequest(`/account/portfolio/history?${queryParams.toString()}`);
         return response;
     }
+    /**
+     * Get portfolio daily history for the account, ensuring the most recent day is included
+     * by combining daily and hourly history if needed.
+     *
+     * This function performs two API calls:
+     * 1. Retrieves daily portfolio history
+     * 2. Retrieves hourly portfolio history to check for more recent data
+     *
+     * If hourly history has timestamps more recent than the last timestamp in daily history,
+     * it appends one additional day to the daily history using the most recent hourly values.
+     *
+     * @param params Parameters for the portfolio history request (same as getPortfolioHistory except timeframe is forced to '1D')
+     * @returns Portfolio history data with daily timeframe, including the most recent day if available from hourly data
+     */
+    async getPortfolioDailyHistory(params) {
+        // Get daily history
+        const dailyParams = { ...params, timeframe: '1D' };
+        const dailyHistory = await this.getPortfolioHistory(dailyParams);
+        // Get hourly history for the last day to check for more recent data
+        const hourlyParams = { timeframe: '1H', period: '1D' };
+        const hourlyHistory = await this.getPortfolioHistory(hourlyParams);
+        // If no hourly history, return daily as-is
+        if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {
+            return dailyHistory;
+        }
+        // Get the last timestamp from daily history
+        const lastDailyTimestamp = dailyHistory.timestamp[dailyHistory.timestamp.length - 1];
+        // Check if hourly history has more recent data
+        const recentHourlyData = hourlyHistory.timestamp
+            .map((timestamp, index) => ({ timestamp, index }))
+            .filter(({ timestamp }) => timestamp > lastDailyTimestamp);
+        // If no more recent hourly data, return daily history as-is
+        if (recentHourlyData.length === 0) {
+            return dailyHistory;
+        }
+        // Get the most recent hourly data point
+        const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
+        const mostRecentIndex = mostRecentHourly.index;
+        // Calculate the timestamp for the new daily entry (most recent day + 1 day worth of seconds)
+        const oneDayInSeconds = 24 * 60 * 60;
+        const newDailyTimestamp = mostRecentHourly.timestamp + oneDayInSeconds;
+        // Create a new daily history entry with the most recent hourly values
+        const updatedDailyHistory = {
+            ...dailyHistory,
+            timestamp: [...dailyHistory.timestamp, newDailyTimestamp],
+            equity: [...dailyHistory.equity, hourlyHistory.equity[mostRecentIndex]],
+            profit_loss: [...dailyHistory.profit_loss, hourlyHistory.profit_loss[mostRecentIndex]],
+            profit_loss_pct: [...dailyHistory.profit_loss_pct, hourlyHistory.profit_loss_pct[mostRecentIndex]],
+        };
+        return updatedDailyHistory;
+    }
     /**
      * Get option contracts based on specified parameters
      * @param params Parameters to filter option contracts