@discomedia/utils 1.0.55 → 1.0.57

package/dist/index.cjs

@@ -1491,8 +1491,18 @@ class Queue {
 }
 
 function pLimit(concurrency) {
+	let rejectOnClear = false;
+
+	if (typeof concurrency === 'object') {
+		({concurrency, rejectOnClear = false} = concurrency);
+	}
+
 	validateConcurrency(concurrency);
 
+	if (typeof rejectOnClear !== 'boolean') {
+		throw new TypeError('Expected `rejectOnClear` to be a boolean');
+	}
+
 	const queue = new Queue();
 	let activeCount = 0;
 
@@ -1500,7 +1510,7 @@ function pLimit(concurrency) {
 		// Process the next queued function if we're under the concurrency limit
 		if (activeCount < concurrency && queue.size > 0) {
 			activeCount++;
-			queue.dequeue()();
+			queue.dequeue().run();
 		}
 	};
 
@@ -1527,11 +1537,14 @@ function pLimit(concurrency) {
 		next();
 	};
 
-	const enqueue = (function_, resolve, arguments_) => {
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = {reject};
+
 		// 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);
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
 		}).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
@@ -1540,8 +1553,8 @@ function pLimit(concurrency) {
 		}
 	};
 
-	const generator = (function_, ...arguments_) => new Promise(resolve => {
-		enqueue(function_, resolve, arguments_);
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
 	});
 
 	Object.defineProperties(generator, {
@@ -1553,7 +1566,16 @@ function pLimit(concurrency) {
 		},
 		clearQueue: {
 			value() {
-				queue.clear();
+				if (!rejectOnClear) {
+					queue.clear();
+					return;
+				}
+
+				const abortError = AbortSignal.abort().reason;
+
+				while (queue.size > 0) {
+					queue.dequeue().reject(abortError);
+				}
 			},
 		},
 		concurrency: {
@@ -2519,7 +2541,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 = '6.16.0'; // x-release-please-version
+const VERSION = '6.17.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -5812,12 +5834,7 @@ class Assistants extends APIResource {
     /**
      * Create an assistant with a model and instructions.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.create({
-     *   model: 'gpt-4o',
-     * });
-     * ```
+     * @deprecated
      */
     create(body, options) {
         return this._client.post('/assistants', {
@@ -5829,12 +5846,7 @@ class Assistants extends APIResource {
     /**
      * Retrieves an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.retrieve(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     retrieve(assistantID, options) {
         return this._client.get(path `/assistants/${assistantID}`, {
@@ -5845,12 +5857,7 @@ class Assistants extends APIResource {
     /**
      * Modifies an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.update(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     update(assistantID, body, options) {
         return this._client.post(path `/assistants/${assistantID}`, {
@@ -5862,13 +5869,7 @@ class Assistants extends APIResource {
     /**
      * Returns a list of assistants.
      *
-     * @example
-     * ```ts
-     * // Automatically fetches more pages as needed.
-     * for await (const assistant of client.beta.assistants.list()) {
-     *   // ...
-     * }
-     * ```
+     * @deprecated
      */
     list(query = {}, options) {
         return this._client.getAPIList('/assistants', (CursorPage), {
@@ -5880,11 +5881,7 @@ class Assistants extends APIResource {
     /**
      * Delete an assistant.
      *
-     * @example
-     * ```ts
-     * const assistantDeleted =
-     *   await client.beta.assistants.delete('assistant_id');
-     * ```
+     * @deprecated
      */
     delete(assistantID, options) {
         return this._client.delete(path `/assistants/${assistantID}`, {
@@ -7358,8 +7355,8 @@ Evals.Runs = Runs;
 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 1 TB.
+     * up to 512 MB, and each project can store up to 2.5 TB of files in total. There
+     * is no organization-wide storage limit.
      *
      * - The Assistants API supports files up to 2 million tokens and of specific file
      *   types. See the
@@ -18536,25 +18533,75 @@ class AlpacaTradingAPI {
      * @param side (string) - the side of the order
      * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
      * @param position_intent (string) - the position intent of the order
+     * @param client_order_id (string) - optional client order id
+     * @returns The created trailing stop order
      */
-    async createTrailingStop(symbol, qty, side, trailPercent100, position_intent) {
+    async createTrailingStop(symbol, qty, side, trailPercent100, position_intent, client_order_id) {
         this.log(`Creating trailing stop ${side.toUpperCase()} ${qty} shares for ${symbol} with trail percent ${trailPercent100}%`, {
             symbol,
         });
+        const body = {
+            symbol,
+            qty: Math.abs(qty),
+            side,
+            position_intent,
+            order_class: 'simple',
+            type: 'trailing_stop',
+            trail_percent: trailPercent100, // Already in decimal form (e.g., 4 for 4%)
+            time_in_force: 'gtc',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
         try {
-            await this.makeRequest(`/orders`, 'POST', {
+            return await this.makeRequest(`/orders`, 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating trailing stop: ${error}`, {
                 symbol,
-                qty: Math.abs(qty),
-                side,
-                position_intent,
-                order_class: 'simple',
-                type: 'trailing_stop',
-                trail_percent: trailPercent100, // Already in decimal form (e.g., 4 for 4%)
-                time_in_force: 'gtc',
+                type: 'error',
             });
+            throw error;
+        }
+    }
+    /**
+     * Create a stop order (stop or stop-limit)
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order
+     * @param stopPrice (number) - the stop price that triggers the order
+     * @param position_intent (string) - the position intent of the order
+     * @param limitPrice (number) - optional limit price (if provided, creates a stop-limit order)
+     * @param client_order_id (string) - optional client order id
+     * @returns The created stop order
+     */
+    async createStopOrder(symbol, qty, side, stopPrice, position_intent, limitPrice, client_order_id) {
+        const isStopLimit = limitPrice !== undefined;
+        const orderType = isStopLimit ? 'stop-limit' : 'stop';
+        this.log(`Creating ${orderType} ${side.toUpperCase()} ${qty} shares for ${symbol} with stop price ${stopPrice}${isStopLimit ? ` and limit price ${limitPrice}` : ''}`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            order_class: 'simple',
+            type: isStopLimit ? 'stop_limit' : 'stop',
+            stop_price: this.roundPriceForAlpaca(stopPrice),
+            time_in_force: 'gtc',
+        };
+        if (isStopLimit) {
+            body.limit_price = this.roundPriceForAlpaca(limitPrice);
+        }
+        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 trailing stop: ${error}`, {
+            this.log(`Error creating ${orderType} order: ${error}`, {
                 symbol,
                 type: 'error',
             });
@@ -18673,6 +18720,57 @@ class AlpacaTradingAPI {
             throw error;
         }
     }
+    /**
+     * Create an OCO (One-Cancels-Other) order with take profit and stop loss
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order (buy or sell)
+     * @param position_intent (string) - the position intent of the order
+     * @param limitPrice (number) - the limit price for the entry order (OCO orders must be limit orders)
+     * @param takeProfitPrice (number) - the take profit price
+     * @param stopLossPrice (number) - the stop loss price
+     * @param stopLossLimitPrice (number) - optional limit price for stop loss (creates stop-limit instead of stop)
+     * @param client_order_id (string) - optional client order id
+     * @returns The created OCO order
+     */
+    async createOCOOrder(symbol, qty, side, position_intent, limitPrice, takeProfitPrice, stopLossPrice, stopLossLimitPrice, client_order_id) {
+        this.log(`Creating OCO order ${side.toUpperCase()} ${qty} shares for ${symbol} at limit ${limitPrice} with take profit ${takeProfitPrice} and stop loss ${stopLossPrice}`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            order_class: 'oco',
+            type: 'limit',
+            limit_price: this.roundPriceForAlpaca(limitPrice),
+            time_in_force: 'gtc',
+            take_profit: {
+                limit_price: this.roundPriceForAlpaca(takeProfitPrice),
+            },
+            stop_loss: {
+                stop_price: this.roundPriceForAlpaca(stopLossPrice),
+            },
+        };
+        // If stop loss limit price is provided, create stop-limit order
+        if (stopLossLimitPrice !== undefined) {
+            body.stop_loss.limit_price = this.roundPriceForAlpaca(stopLossLimitPrice);
+        }
+        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 OCO order: ${error}`, {
+                symbol,
+                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