@uploadcare/upload-client 6.17.0 → 6.18.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Uploadcare Inc.
+Copyright (c) 2025 Uploadcare Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cjs/index.browser.cjs

@@ -405,7 +405,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1689,7 +1689,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1706,18 +1707,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1728,7 +1741,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/cjs/index.browser.d.cts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/cjs/index.node.cjs

@@ -435,7 +435,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1720,7 +1720,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1737,18 +1738,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1759,7 +1772,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/cjs/index.node.d.cts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/cjs/index.react-native.cjs

@@ -413,7 +413,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1717,7 +1717,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1734,18 +1735,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1756,7 +1769,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/cjs/index.react-native.d.cts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/esm/index.browser.d.mts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/esm/index.browser.mjs

@@ -403,7 +403,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1687,7 +1687,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1704,18 +1705,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1726,7 +1739,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/esm/index.node.d.mts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/esm/index.node.mjs

@@ -433,7 +433,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1718,7 +1718,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1735,18 +1736,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1757,7 +1770,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/esm/index.react-native.d.mts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/dist/esm/index.react-native.mjs

@@ -411,7 +411,7 @@ const getUrl = (base, path, query) => {
     return url.toString();
 };
 
-var version = '6.17.0';
+var version = '6.18.2';
 
 const LIBRARY_NAME = 'UploadcareUploadClient';
 const LIBRARY_VERSION = version;
@@ -1715,7 +1715,8 @@ class Queue {
     constructor(concurrency) {
         this._concurrency = concurrency;
     }
-    _run() {
+    /** Run tasks from the queue up to the concurrency limit */
+    run() {
         const tasksLeft = this._concurrency - this._running;
         for (let i = 0; i < tasksLeft; i++) {
             const task = this._pending.shift();
@@ -1732,18 +1733,30 @@ class Queue {
                 this._resolvers.delete(task);
                 this._rejectors.delete(task);
                 this._running -= 1;
-                this._run();
+                this.run();
             })
                 .then((value) => resolver(value))
                 .catch((error) => rejector(error));
         }
     }
-    add(task) {
+    /**
+     * Add a task to the queue
+     *
+     * If you want to add a lot of tasks at once, consider setting `autoRun` to
+     * false and calling `run()` manually after adding all tasks to avoid multiple
+     * redundant calls to `run()`.
+     *
+     * @param task The task to add
+     * @param autoRun Whether to automatically run the queue after adding the task
+     *   (default: true)
+     * @returns A promise that resolves or rejects with the task's result
+     */
+    add(task, { autoRun } = { autoRun: true }) {
         return new Promise((resolve, reject) => {
             this._resolvers.set(task, resolve);
             this._rejectors.set(task, reject);
             this._pending.push(task);
-            this._run();
+            autoRun && this.run();
         });
     }
     get pending() {
@@ -1754,7 +1767,7 @@ class Queue {
     }
     set concurrency(value) {
         this._concurrency = value;
-        this._run();
+        this.run();
     }
     get concurrency() {
         return this._concurrency;

package/dist/index.d.ts

@@ -507,8 +507,23 @@ export declare class Queue {
 	private _resolvers;
 	private _rejectors;
 	constructor(concurrency: number);
-	private _run;
-	add<T>(task: Task<T>): Promise<T>;
+	/** Run tasks from the queue up to the concurrency limit */
+	run(): void;
+	/**
+	 * Add a task to the queue
+	 *
+	 * If you want to add a lot of tasks at once, consider setting `autoRun` to
+	 * false and calling `run()` manually after adding all tasks to avoid multiple
+	 * redundant calls to `run()`.
+	 *
+	 * @param task The task to add
+	 * @param autoRun Whether to automatically run the queue after adding the task
+	 *   (default: true)
+	 * @returns A promise that resolves or rejects with the task's result
+	 */
+	add<T>(task: Task<T>, { autoRun }?: {
+		autoRun?: boolean;
+	}): Promise<T>;
 	get pending(): number;
 	get running(): number;
 	set concurrency(value: number);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uploadcare/upload-client",
-  "version": "6.17.0",
+  "version": "6.18.2",
   "description": "Library for work with Uploadcare Upload API",
   "type": "module",
   "module": "./dist/esm/index.node.mjs",
@@ -83,7 +83,7 @@
     "@types/koa__cors": "^5.0.0",
     "@types/koa__router": "^12.0.4",
     "@types/ws": "8.5.3",
-    "@uploadcare/api-client-utils": "^6.17.0",
+    "@uploadcare/api-client-utils": "^6.18.2",
     "chalk": "^4.1.2",
     "data-uri-to-buffer": "3.0.1",
     "dataurl-to-blob": "0.0.1",