image-exporter 1.2.2 → 1.3.0

package/dist/index.cjs

@@ -4,39 +4,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -53,7 +74,7 @@ __export(exports_buffer, {
   default: () => buffer_default,
   constants: () => constants,
   btoa: () => btoa,
-  atob: () => atob,
+  atob: () => atob2,
   INSPECT_MAX_BYTES: () => INSPECT_MAX_BYTES,
   File: () => File,
   Buffer: () => Buffer2,
@@ -726,7 +747,7 @@ function notimpl(name) {
     throw Error(name + " is not implemented for node:buffer browser polyfill");
   };
 }
-var lookup, revLookup, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len, customInspectSymbol, INSPECT_MAX_BYTES = 50, kMaxLength = 2147483647, kStringMaxLength = 536870888, btoa, atob, File, Blob2, constants, ERR_BUFFER_OUT_OF_BOUNDS, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, MAX_ARGUMENTS_LENGTH = 4096, INVALID_BASE64_RE, hexSliceLookupTable, resolveObjectURL, isUtf8, isAscii = (str) => {
+var lookup, revLookup, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len, customInspectSymbol, INSPECT_MAX_BYTES = 50, kMaxLength = 2147483647, kStringMaxLength = 536870888, btoa, atob2, File, Blob2, constants, ERR_BUFFER_OUT_OF_BOUNDS, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, MAX_ARGUMENTS_LENGTH = 4096, INVALID_BASE64_RE, hexSliceLookupTable, resolveObjectURL, isUtf8, isAscii = (str) => {
   for (let char of str)
     if (char.charCodeAt(0) > 127)
       return false;
@@ -741,7 +762,7 @@ var init_buffer = __esm(() => {
   revLookup[95] = 63;
   customInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
   btoa = globalThis.btoa;
-  atob = globalThis.atob;
+  atob2 = globalThis.atob;
   File = globalThis.File;
   Blob2 = globalThis.Blob;
   constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
@@ -12537,7 +12558,7 @@ var require_zipEntries = __commonJS((exports2, module2) => {
       if (this.centralDirRecords !== this.files.length) {
         if (this.centralDirRecords !== 0 && this.files.length === 0) {
           throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
-        } else {}
+        }
       }
     },
     readEndOfCentral: function() {
@@ -12714,42 +12735,43 @@ var require_lib = __commonJS((exports2, module2) => {
 var exports_src = {};
 __export(exports_src, {
   downloadImages: () => downloadImages,
+  copyImageToClipboard: () => copyImageToClipboard,
   capture: () => capture
 });
 module.exports = __toCommonJS(exports_src);
 
+// src/capture/make-unique.ts
+function makeUnique(fileName, seen) {
+  if (!seen.has(fileName)) {
+    seen.add(fileName);
+    return fileName;
+  }
+  const lastDot = fileName.lastIndexOf(".");
+  const base = lastDot !== -1 ? fileName.slice(0, lastDot) : fileName;
+  const extension = lastDot !== -1 ? fileName.slice(lastDot) : "";
+  const match = base.match(/-(\d+)$/);
+  let stem = base;
+  let counter = 2;
+  if (match) {
+    stem = base.slice(0, -match[0].length);
+    counter = parseInt(match[1], 10) + 1;
+  }
+  let candidate = `${stem}-${counter}${extension}`;
+  while (seen.has(candidate)) {
+    counter++;
+    candidate = `${stem}-${counter}${extension}`;
+  }
+  seen.add(candidate);
+  return candidate;
+}
+
 // src/capture/handle-filenames.ts
-function handleFileNames(imageOptions, filenames) {
+function handleFileNames(imageOptions, seen) {
   let proposedFilename = imageOptions.label;
   if (imageOptions.includeScaleInLabel)
     proposedFilename += `_@${imageOptions.scale}x`;
-  const extension = `.${imageOptions.format}`;
-  proposedFilename += extension;
-  if (!filenames.includes(proposedFilename)) {
-    filenames.push(proposedFilename);
-    return proposedFilename;
-  }
-  const numberPattern = /-(\d+)$/;
-  const match = proposedFilename.match(numberPattern);
-  if (match) {
-    const baseFilename = proposedFilename.replace(numberPattern, "");
-    let counter = parseInt(match[1], 10);
-    while (filenames.includes(`${baseFilename}-${counter}${extension}`)) {
-      counter++;
-    }
-    const newFilename = `${baseFilename}-${counter}${extension}`;
-    filenames.push(newFilename);
-    return newFilename;
-  } else {
-    const baseFilename = proposedFilename.replace(extension, "");
-    let counter = 2;
-    while (filenames.includes(`${baseFilename}-${counter}${extension}`)) {
-      counter++;
-    }
-    const newFilename = `${baseFilename}-${counter}${extension}`;
-    filenames.push(newFilename);
-    return newFilename;
-  }
+  proposedFilename += `.${imageOptions.format}`;
+  return makeUnique(proposedFilename, seen);
 }
 
 // node_modules/modern-screenshot/dist/index.mjs
@@ -14251,18 +14273,20 @@ async function domToWebp(node, options) {
 }
 
 // src/capture/capture-element.ts
-async function captureElement(element, imageOptions, filenames) {
+async function captureElement(element, imageOptions, seen, screenshotOptions) {
+  let cleanUpBackground = false;
   try {
     let dataURL = "";
-    let htmlToImageOptions = {
+    const userFilter = screenshotOptions?.filter;
+    const htmlToImageOptions = {
+      ...screenshotOptions,
       quality: imageOptions.quality,
       scale: imageOptions.scale,
-      filter
+      filter: (node) => filter(node) && (userFilter ? userFilter(node) : true)
     };
     const styles = getComputedStyle(element);
     const backgroundColor = styles.backgroundColor;
     const backgroundImage = styles.backgroundImage;
-    let cleanUpBackground = false;
     if (backgroundColor === "rgba(0, 0, 0, 0)" && backgroundImage === "none" && imageOptions.format === "jpg") {
       element.style.backgroundColor = "#FFFFFF";
       cleanUpBackground = true;
@@ -14281,17 +14305,17 @@ async function captureElement(element, imageOptions, filenames) {
         dataURL = await domToWebp(element, htmlToImageOptions);
         break;
     }
-    if (cleanUpBackground) {
-      element.style.backgroundColor = "";
-      element.style.backgroundImage = "";
-    }
     return {
       dataURL,
-      fileName: handleFileNames(imageOptions, filenames)
+      fileName: handleFileNames(imageOptions, seen)
     };
   } catch (error) {
-    console.error("ImageExporter: Error in captureImage", error);
-    return { dataURL: "", fileName: "" };
+    throw new Error(`ImageExporter: failed to capture element as ${imageOptions.format}`, { cause: error });
+  } finally {
+    if (cleanUpBackground) {
+      element.style.backgroundColor = "";
+      element.style.backgroundImage = "";
+    }
   }
 }
 var filter = (node) => {
@@ -14328,7 +14352,7 @@ async function downloadImages(images, userConfig = defaultConfig) {
   const uniqueImages = ensureUniqueFileNames(images);
   if (uniqueImages.length === 1) {
     const image = uniqueImages[0];
-    triggerDownload(image.dataURL, image.fileName);
+    triggerDownload(image.blob ?? image.dataURL, image.fileName);
   } else if (uniqueImages.length > 1) {
     const imagesBlob = await zipUpImages(uniqueImages);
     if (imagesBlob)
@@ -14352,8 +14376,12 @@ async function zipUpImages(images) {
   const zip = new import_jszip.default;
   try {
     images.forEach((image) => {
-      const content = image.dataURL.split(",")[1];
-      zip.file(image.fileName, content, { base64: true });
+      if (image.blob) {
+        zip.file(image.fileName, image.blob);
+      } else {
+        const content = image.dataURL.split(",")[1];
+        zip.file(image.fileName, content, { base64: true });
+      }
     });
   } catch (error) {
     console.error("Image Exporter - Error adding images to ZIP:", error);
@@ -14378,27 +14406,15 @@ function parseLabel(config) {
   }
 }
 function ensureUniqueFileNames(images) {
-  const fileNameMap = new Map;
+  const seen = new Set;
   return images.map((image) => {
-    const { fileName } = image;
-    const lastDotIndex = fileName.lastIndexOf(".");
-    const baseName = lastDotIndex !== -1 ? fileName.substring(0, lastDotIndex) : fileName;
-    const extension = lastDotIndex !== -1 ? fileName.substring(lastDotIndex) : "";
-    if (!fileNameMap.has(fileName)) {
-      fileNameMap.set(fileName, 1);
-      return image;
-    }
-    const count = fileNameMap.get(fileName) + 1;
-    fileNameMap.set(fileName, count);
-    const newFileName = `${baseName}-${count}${extension}`;
-    return {
-      ...image,
-      fileName: newFileName
-    };
+    const fileName = makeUnique(image.fileName, seen);
+    return fileName === image.fileName ? image : { ...image, fileName };
   });
 }
 
 // src/logger.ts
+var hasWindow = typeof window !== "undefined";
 var log = {
   info: (...messages) => logAction(messages, "info"),
   error: (...messages) => logAction(messages, "error"),
@@ -14434,16 +14450,18 @@ async function logAction(messages, type = "info") {
       console.groupEnd();
       break;
   }
-  if (windowLogging)
+  if (windowLogging && hasWindow)
     window.imageExporterLogs.push({ message: combinedMessage, type });
 }
 async function logProgress(progress, total) {
-  if (windowLogging) {
+  if (windowLogging && hasWindow) {
     window.imageExporterProgress.push([progress, total]);
   }
 }
-window.imageExporterLogs = [];
-window.imageExporterProgress = [];
+if (hasWindow) {
+  window.imageExporterLogs = [];
+  window.imageExporterProgress = [];
+}
 
 // src/cors-proxy/is-valid-url.ts
 function isValidUrl(string) {
@@ -14456,7 +14474,7 @@ function isValidUrl(string) {
       return false;
     }
     return true;
-  } catch (_) {
+  } catch {
     return false;
   }
 }
@@ -14465,7 +14483,7 @@ function isValidUrl(string) {
 async function proxyCSS(config) {
   const stylesheetElements = document.querySelectorAll('link[rel="stylesheet"]');
   log.verbose("stylesheet elements to proxy", stylesheetElements.length);
-  for (let stylesheetElement of stylesheetElements) {
+  for (const stylesheetElement of stylesheetElements) {
     const stylesheetURL = stylesheetElement.getAttribute("href");
     if (!stylesheetURL)
       continue;
@@ -14479,7 +14497,7 @@ async function proxyCSS(config) {
     const proxiedURL = config.corsProxyBaseUrl + encodeURIComponent(stylesheetURL);
     try {
       const response = await fetch(proxiedURL);
-      let cssContent = await response.text();
+      const cssContent = await response.text();
       const styleElement = document.createElement("style");
       styleElement.textContent = cssContent;
       styleElement.setAttribute("original-link-element", encodeURIComponent(stylesheetElement.outerHTML));
@@ -14535,7 +14553,7 @@ async function cleanUpCorsProxy() {
 }
 async function restoreCSS() {
   const styleElements = document.querySelectorAll("style[original-link-element]");
-  for (let styleElement of styleElements) {
+  for (const styleElement of styleElements) {
     const originalLinkElementHTML = decodeURIComponent(styleElement.getAttribute("original-link-element"));
     const tempContainer = document.createElement("div");
     tempContainer.innerHTML = originalLinkElementHTML;
@@ -14546,7 +14564,7 @@ async function restoreCSS() {
 }
 async function restoreImages() {
   const imageElements = document.querySelectorAll("img[original-src]");
-  for (let imageElement of imageElements) {
+  for (const imageElement of imageElements) {
     const originalSrc = imageElement.getAttribute("original-src");
     imageElement.src = originalSrc;
     imageElement.removeAttribute("original-src");
@@ -14560,6 +14578,23 @@ var corsProxy = {
   cleanUp: cleanUpCorsProxy
 };
 
+// src/capture/data-url-to-blob.ts
+function dataUrlToBlob(dataURL) {
+  const commaIndex = dataURL.indexOf(",");
+  const meta = dataURL.slice(0, commaIndex);
+  const data = dataURL.slice(commaIndex + 1);
+  const mimeMatch = meta.match(/^data:([^;]+)/);
+  const mime = mimeMatch ? mimeMatch[1] : "";
+  if (meta.includes(";base64")) {
+    const binary = atob(data);
+    const bytes = new Uint8Array(binary.length);
+    for (let i2 = 0;i2 < binary.length; i2++)
+      bytes[i2] = binary.charCodeAt(i2);
+    return new Blob([bytes], { type: mime });
+  }
+  return new Blob([decodeURIComponent(data)], { type: mime });
+}
+
 // src/capture/get-image-options.ts
 async function getImageOptions(element, config) {
   return {
@@ -14601,7 +14636,7 @@ async function getImageOptions(element, config) {
         throw new Error(`ImageExporter: provided format is not valid.
             Provided: ${format}
             Element: ${element}
-            Accepted values: jpg, png, svg, 
+            Accepted values: jpg, png, svg, webp
             Defaulting to: ${config.format}`);
       }
     } catch (error) {
@@ -14692,32 +14727,35 @@ function isVisible(element) {
 }
 
 // src/capture/determine-total-elements.ts
-async function determineTotalElements(elements) {
+async function determineTotalElements(elements, config) {
   try {
     let totalElements = 0;
-    for (const element of elements) {
-      const scaleAsString = element.dataset.scale;
-      if (!scaleAsString)
-        continue;
-      if (scaleAsString.includes(",")) {
-        const scales = scaleAsString.trim().split(",").map((scale) => parseFloat(scale));
-        if (scales.some((scale) => isNaN(scale)))
-          continue;
-        totalElements += scales.length;
-      } else {
-        const scaleAsNumber = parseFloat(scaleAsString.trim());
-        if (isNaN(scaleAsNumber)) {
-          continue;
-        } else {
-          totalElements++;
-        }
-      }
+    for (const element of Array.from(elements)) {
+      totalElements += countScalesForElement(element, config);
     }
     return totalElements;
-  } catch (error) {
+  } catch {
     return 1;
   }
 }
+function countScalesForElement(element, config) {
+  const scaleAsString = element.dataset.scale;
+  if (!scaleAsString)
+    return countConfigScale(config);
+  if (scaleAsString.includes(",")) {
+    const scales = scaleAsString.trim().split(",").map((scale) => parseFloat(scale));
+    if (scales.some((scale) => isNaN(scale)))
+      return countConfigScale(config);
+    return scales.length;
+  }
+  const scaleAsNumber = parseFloat(scaleAsString.trim());
+  if (isNaN(scaleAsNumber))
+    return countConfigScale(config);
+  return 1;
+}
+function countConfigScale(config) {
+  return Array.isArray(config.scale) ? config.scale.length : 1;
+}
 
 // src/capture/index.ts
 var windowLogging = true;
@@ -14733,50 +14771,85 @@ async function capture(elements, userConfig = defaultConfig) {
       elements = [elements];
     const originalLength = elements.length;
     elements = removeHiddenElements(elements);
-    const totalElements = await determineTotalElements(elements);
+    const totalElements = await determineTotalElements(elements, config);
     if (originalLength !== elements.length)
       log.verbose("Skipping capture of hidden elements: ", originalLength - elements.length);
     log.verbose("Element to capture", elements.length);
     if (userConfig.corsProxyBaseUrl)
       await corsProxy.run(config, elements);
-    let images = [];
-    let filenames = [];
+    const images = [];
+    const seen = new Set;
     let imageNumber = 1;
-    for (const element of elements) {
-      const imageOptions = await getImageOptions(element, config);
-      log.verbose("Image options", imageOptions);
-      if (imageOptions.scale instanceof Array) {
-        log.verbose("Multi-scale capture");
-        imageOptions.includeScaleInLabel = true;
-        for (const scale of imageOptions.scale) {
-          log.progress(imageNumber++, totalElements);
-          const image = await captureElement(element, { ...imageOptions, scale }, filenames);
-          images.push(image);
-        }
-      } else if (typeof imageOptions.scale === "number") {
-        log.progress(imageNumber++, totalElements);
-        log.verbose("Single-scale capture");
-        const image = await captureElement(element, imageOptions, filenames);
-        images.push(image);
-      }
-    }
-    if (userConfig.downloadImages)
+    const tryCapture = async (element, options) => {
+      try {
+        const image = await captureElement(element, options, seen, config.screenshotOptions);
+        images.push(applyOutput(image, config.output));
+      } catch (error) {
+        log.error(error);
+      } finally {
+        const completed = imageNumber++;
+        log.progress(completed, totalElements);
+        config.onProgress?.(completed, totalElements);
+      }
+    };
+    captureLoop:
+      for (const element of elements) {
+        if (config.signal?.aborted)
+          break;
+        const imageOptions = await getImageOptions(element, config);
+        log.verbose("Image options", imageOptions);
+        if (imageOptions.scale instanceof Array) {
+          log.verbose("Multi-scale capture");
+          imageOptions.includeScaleInLabel = true;
+          for (const scale of imageOptions.scale) {
+            if (config.signal?.aborted)
+              break captureLoop;
+            await tryCapture(element, {
+              ...imageOptions,
+              scale
+            });
+          }
+        } else if (typeof imageOptions.scale === "number") {
+          log.verbose("Single-scale capture");
+          await tryCapture(element, imageOptions);
+        }
+      }
+    if (config.signal?.aborted) {
+      log.verbose("Capture aborted; returning", images.length, "image(s)");
+      return images;
+    }
+    if (config.downloadImages)
       await downloadImages(images, config);
-    if (userConfig.corsProxyBaseUrl)
-      await corsProxy.cleanUp();
     return images;
   } catch (error) {
     log.error(error);
     return null;
   } finally {
+    if (userConfig.corsProxyBaseUrl)
+      await corsProxy.cleanUp();
     log.group.close();
   }
 }
+function applyOutput(image, output) {
+  if (!output || output === "dataurl")
+    return image;
+  const blob = dataUrlToBlob(image.dataURL);
+  if (output === "blob")
+    return { ...image, dataURL: "", blob };
+  return { ...image, blob };
+}
+
+// src/capture/copy-to-clipboard.ts
+async function copyImageToClipboard(image) {
+  const blob = image.blob ?? dataUrlToBlob(image.dataURL);
+  await navigator.clipboard.write([new ClipboardItem({ [blob.type]: blob })]);
+}
 
 // src/index.ts
 if (typeof window !== "undefined") {
   window.imageExporter = capture;
   window.imageExporterDownload = downloadImages;
+  window.imageExporterCopyToClipboard = copyImageToClipboard;
 }
 
-//# debugId=28EE3D9412C9BAAF64756E2164756E21
+//# debugId=E8C5F97C6B31AA5264756E2164756E21