imgdl now returns nothing (void)

Author: fityannugroho

README.md

@@ -124,7 +124,12 @@ imgdl https://example.com/image-{i}.jpg --increment --start=1 --end=10
 ```js
 import imgdl from 'img-dl';
 
-const image = await imgdl('https://example.com/image.jpg');
+const image = await new Promise((resolve, reject) => {
+  imgdl('https://example.com/image.jpg', {
+    onSuccess: resolve,
+    onError: reject,
+  });
+});
 console.log(image);
 /*
 {
@@ -144,16 +149,31 @@ console.log(image);
 ```js
 import imgdl from 'img-dl';
 
-const images = await imgdl([
+const urls = [
   'https://example.com/image.jpg',
   'https://example.com/image2.jpg',
-]);
+];
+
+await imgdl(urls, {
+  onSuccess: (image) => {
+    // Do something with the downloaded image
+    console.log(image);
+  },
+  onError: (error, url) => {
+    // Do something when the image fails to download
+    console.error(`Failed to download ${url}: ${error.message}`);
+  },
+});
+
+console.log('Download completed');
 ```
 
 ## API
 
 ### imgdl(url, ?options)
 
+Returns: `Promise<void>`
+
 Download image(s) from the given URL(s).
 
 #### `url`
@@ -215,14 +235,14 @@ Set the maximum number of times to retry the request if it fails.
 Type: `(image: Image) => void`<br>
 Default: `undefined`
 
-The callback function to be called when the image is successfully downloaded. Only available when downloading multiple images.
+The callback function to be called when the image is successfully downloaded.
 
 ##### `onError`
 
 Type: `(error: Error, url: string) => void`<br>
 Default: `undefined`
 
-The callback function to be called when the image fails to download. Only available when downloading multiple images.
+The callback function to be called when the image fails to download.
 
 ##### `signal`
 

src/index.ts

@@ -1,6 +1,5 @@
 import PQueue from 'p-queue';
 import { setMaxListeners } from 'node:events';
-import { CancelError } from 'got';
 import { DEFAULT_INTERVAL, DEFAULT_STEP } from './constanta.js';
 import {
   DownloadOptions,
@@ -43,19 +42,13 @@ export type Image = {
 
 export type Options = (ImageOptions & DownloadOptions) & {
   /**
-   * Do something when the image is successfully downloaded.
-   * For example, counting the number of successful downloads.
-   *
-   * Only called when downloading multiple images.
+   * Do something when an image is successfully downloaded.
    *
    * @param image The downloaded image.
    */
   onSuccess?: (image: Image) => void;
   /**
-   * Do something when the image download failed.
-   * For example, counting the number of failed downloads.
-   *
-   * Only called when downloading multiple images.
+   * Do something when an image fails to download.
    *
    * @param error The error that caused the download to fail.
    * @param url The URL of the image that failed to download.
@@ -79,98 +72,65 @@ export type Options = (ImageOptions & DownloadOptions) & {
   signal?: AbortSignal;
 };
 
-async function imgdl(url: string, options?: Options): Promise<Image>;
-async function imgdl(url: string[], options?: Options): Promise<Image[]>;
-async function imgdl(
-  url: string | string[],
-  options?: Options,
-): Promise<Image | Image[]>;
-async function imgdl(
-  url: string | string[],
-  options?: Options,
-): Promise<Image | Image[]> {
-  if (Array.isArray(url)) {
-    const queue = new PQueue({
-      concurrency: options?.step ?? DEFAULT_STEP,
-      interval: options?.interval ?? DEFAULT_INTERVAL,
-      intervalCap: options?.step ?? DEFAULT_STEP,
-    });
+async function imgdl(url: string | string[], options?: Options): Promise<void> {
+  const {
+    directory,
+    name,
+    extension,
+    onSuccess,
+    onError,
+    step,
+    interval,
+    ...downloadOptions
+  } = options ?? {};
 
-    // Set max listeners to infinity to prevent memory leak warning
-    if (options?.signal) {
-      setMaxListeners(Infinity, options.signal);
-    }
+  const urls = Array.isArray(url) ? url : [url];
+  const queue = new PQueue({
+    concurrency: step ?? DEFAULT_STEP,
+    interval: interval ?? DEFAULT_INTERVAL,
+    intervalCap: step ?? DEFAULT_STEP,
+  });
 
-    return new Promise<Image[]>((resolve, reject) => {
-      const images: Image[] = [];
-      const countNames = new Map<string, number>();
+  // Set max listeners to infinity to prevent memory leak warning
+  if (downloadOptions?.signal) {
+    setMaxListeners(Infinity, downloadOptions.signal);
+  }
 
-      url.forEach((_url) => {
-        const img = parseImageParams(_url, options);
+  const countNames = new Map<string, number>();
 
-        // Make sure the name is unique
-        const nameKey = `${img.name}.${img.extension}`;
-        const count = countNames.get(nameKey);
-        if (count) {
-          img.name = `${img.name} (${count})`;
-          img.path = path.resolve(
-            img.directory,
-            `${img.name}.${img.extension}`,
-          );
-        }
-        countNames.set(nameKey, (count || 0) + 1);
+  for (const _url of urls) {
+    const img = parseImageParams(_url, { directory, name, extension });
 
-        // Add the download task to queue
-        queue
-          .add(
-            async ({ signal }) => {
-              try {
-                return await download(img, {
-                  ...options,
-                  signal,
-                });
-              } catch (error) {
-                options?.onError?.(
-                  error instanceof Error
-                    ? error
-                    : new Error('Unknown error', { cause: error }),
-                  _url,
-                );
-                return undefined;
-              }
-            },
-            { signal: options?.signal },
-          )
-          .then((image) => {
-            if (image) {
-              options?.onSuccess?.(image);
-              images.push(image);
-            }
-          })
-          .catch((error) => {
-            if (!(error instanceof CancelError)) {
-              reject(error);
-            }
-          });
-      });
+    // Make sure the name is unique
+    const nameKey = `${img.name}.${img.extension}`;
+    const count = countNames.get(nameKey);
+    if (count) {
+      img.name = `${img.name} (${count})`;
+      img.path = path.resolve(img.directory, `${img.name}.${img.extension}`);
+    }
+    countNames.set(nameKey, (count || 0) + 1);
+
+    // Add the download task to queue
+    try {
+      const image = await queue.add(
+        ({ signal }) => download(img, { ...downloadOptions, signal }),
+        { signal: downloadOptions?.signal },
+      );
 
-      // Resolve/reject when all task is finished
-      queue
-        .onIdle()
-        .then(() => {
-          resolve(images);
-        })
-        .catch((error) => {
-          reject(error);
-        });
-    });
+      if (image) {
+        onSuccess?.(image);
+      }
+    } catch (error) {
+      onError?.(
+        error instanceof Error
+          ? error
+          : new Error('Unknown error', { cause: error }),
+        _url,
+      );
+    }
   }
 
-  // TODO: implement `onSuccess` and `onError` for single download
-  return download(parseImageParams(url, options), {
-    ...options,
-    signal: options?.signal,
-  });
+  await queue.onIdle();
 }
 
 export default imgdl;