label-printer 0.4.6 → 0.4.7

package/README.md

@@ -52,6 +52,6 @@ This layer contains code to interact with printers
 
 # Update package
 
-- Run `pnpm changeset` to create change
-- Run `pnpm changeset version` to create an update with all the versions
+- Run `pnpm changeset` to create change. This change has to be merged into main first
+- Run `pnpm changeset version` to create an update with all the versions. 
 - PR is automatically created on push, merge it to trigger publish

package/dist/index.js

@@ -249,9 +249,9 @@ function pointsToDots(points, dpi) {
 }
 
 // src/helpers/ImageDataParser.ts
-function parsePNG(buffer) {
+function parsePNG(buffer2) {
   const pngSignature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-  if (!buffer.subarray(0, 8).equals(pngSignature)) {
+  if (!buffer2.subarray(0, 8).equals(pngSignature)) {
     throw new Error("Invalid PNG file");
   }
   let width = 0, height = 0, bitDepth = 0, colorType = 0;
@@ -260,10 +260,10 @@ function parsePNG(buffer) {
   let transparency = null;
   let idatChunks = [];
   let offset = 8;
-  while (offset < buffer.length) {
-    const chunkLength = buffer.readUInt32BE(offset);
-    const chunkType = buffer.subarray(offset + 4, offset + 8).toString("ascii");
-    const chunkData = buffer.subarray(offset + 8, offset + 8 + chunkLength);
+  while (offset < buffer2.length) {
+    const chunkLength = buffer2.readUInt32BE(offset);
+    const chunkType = buffer2.subarray(offset + 4, offset + 8).toString("ascii");
+    const chunkData = buffer2.subarray(offset + 8, offset + 8 + chunkLength);
     if (chunkType === "IHDR") {
       width = chunkData.readUInt32BE(0);
       height = chunkData.readUInt32BE(4);
@@ -426,12 +426,12 @@ var ImageProcessor = class {
    * @param image Image to process (local file path, remote URL, data URL, or Blob)
    * @returns Promise with image data including width, height, pixel data, and bits per pixel
    */
-  static getImageData(image) {
+  static getImageData(image2) {
     return __async(this, null, function* () {
       if (typeof window !== "undefined") {
-        return this.getImageDataBrowser(image);
+        return this.getImageDataBrowser(image2);
       } else {
-        return this.getImageDataNode(image);
+        return this.getImageDataNode(image2);
       }
     });
   }
@@ -441,7 +441,7 @@ var ImageProcessor = class {
    * @param image Image to process
    * @returns Promise with image data
    */
-  static getImageDataBrowser(image) {
+  static getImageDataBrowser(image2) {
     return __async(this, null, function* () {
       console.log("Processing image in browser environment");
       return new Promise((resolve, reject) => {
@@ -471,12 +471,12 @@ var ImageProcessor = class {
           }
         };
         img.onerror = () => reject(new Error("Failed to load image"));
-        if (typeof image === "string") {
-          img.src = image;
+        if (typeof image2 === "string") {
+          img.src = image2;
         } else {
-          const url = URL.createObjectURL(image);
+          const url2 = URL.createObjectURL(image2);
           img.onload = () => {
-            URL.revokeObjectURL(url);
+            URL.revokeObjectURL(url2);
             resolve({
               data: new Uint8Array(0),
               // Will be set by the actual onload
@@ -485,7 +485,7 @@ var ImageProcessor = class {
               bitsPerPixel: 4
             });
           };
-          img.src = url;
+          img.src = url2;
         }
       });
     });
@@ -496,18 +496,18 @@ var ImageProcessor = class {
    * @param image Image to process
    * @returns Promise with image data
    */
-  static getImageDataNode(image) {
+  static getImageDataNode(image2) {
     return __async(this, null, function* () {
       console.log("Processing image in Node.js environment");
-      if (image instanceof Blob) {
+      if (image2 instanceof Blob) {
         throw new Error("Blob input not supported in Node.js environment. Use file path or data URL instead.");
       }
-      if (image.startsWith("data:")) {
-        return this.getImageFromData(image);
-      } else if (image.startsWith("http://") || image.startsWith("https://")) {
-        return this.getImageFromUrl(image);
+      if (image2.startsWith("data:")) {
+        return this.getImageFromData(image2);
+      } else if (image2.startsWith("http://") || image2.startsWith("https://")) {
+        return this.getImageFromUrl(image2);
       } else {
-        return this.getImageFromFile(image);
+        return this.getImageFromFile(image2);
       }
     });
   }
@@ -524,9 +524,9 @@ var ImageProcessor = class {
       if (!(mimeType == null ? void 0 : mimeType.startsWith("image/"))) {
         throw new Error("Invalid image data URL");
       }
-      const buffer = Buffer.from(data, "base64");
+      const buffer2 = Buffer.from(data, "base64");
       const extension = mimeType.split("/")[1].toLowerCase();
-      return this.parse(buffer, extension);
+      return this.parse(buffer2, extension);
     });
   }
   /**
@@ -536,8 +536,8 @@ var ImageProcessor = class {
    */
   static getImageFromFile(image) {
     return __async(this, null, function* () {
-      const fs = yield import("fs");
-      const path = yield import("path");
+      const fs = yield eval("require")("fs");
+      const path = yield eval("require")("path");
       if (!fs.existsSync(image)) {
         throw new Error(`Image file not found: ${image}`);
       }
@@ -551,26 +551,26 @@ var ImageProcessor = class {
    * @param url Remote image URL
    * @returns Promise with image data
    */
-  static getImageFromUrl(url) {
+  static getImageFromUrl(url2) {
     return __async(this, null, function* () {
       let fetch;
       try {
         fetch = globalThis.fetch;
       } catch (e) {
-        return this.fetchWithHttps(url);
+        return this.fetchWithHttps(url2);
       }
       if (!fetch) {
-        return this.fetchWithHttps(url);
+        return this.fetchWithHttps(url2);
       }
-      const response = yield fetch(url);
+      const response = yield fetch(url2);
       if (!response.ok) {
         throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
       }
       const arrayBuffer = yield response.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
+      const buffer2 = Buffer.from(arrayBuffer);
       const contentType = response.headers.get("content-type");
-      const imageType = this.getImageType(contentType || "", url);
-      return this.parse(buffer, imageType);
+      const imageType = this.getImageType(contentType || "", url2);
+      return this.parse(buffer2, imageType);
     });
   }
   /**
@@ -580,8 +580,8 @@ var ImageProcessor = class {
    */
   static fetchWithHttps(url) {
     return __async(this, null, function* () {
-      const https = yield import("https");
-      const http = yield import("http");
+      const https = yield eval("require")("https");
+      const http = yield eval("require")("http");
       return new Promise((resolve, reject) => {
         const client = url.startsWith("https:") ? https : http;
         const request = client.get(url, (response) => {
@@ -595,10 +595,10 @@ var ImageProcessor = class {
           });
           response.on("end", () => {
             try {
-              const buffer = Buffer.concat(chunks);
+              const buffer2 = Buffer.concat(chunks);
               const contentType = response.headers["content-type"] || "";
               const imageType = this.getImageType(contentType || "", url);
-              const data = this.parse(buffer, imageType);
+              const data = this.parse(buffer2, imageType);
               resolve(data);
             } catch (error) {
               reject(error);
@@ -621,7 +621,7 @@ var ImageProcessor = class {
   /**
    * Decide content type
    */
-  static getImageType(contentType, url) {
+  static getImageType(contentType, url2) {
     if (contentType) {
       if (contentType.includes("png")) {
         return "png";
@@ -629,7 +629,7 @@ var ImageProcessor = class {
         return "jpeg";
       }
     }
-    const urlLower = url.toLowerCase();
+    const urlLower = url2.toLowerCase();
     if (urlLower.includes(".png")) {
       return "png";
     } else if (urlLower.includes(".jpg") || urlLower.includes(".jpeg")) {
@@ -643,12 +643,12 @@ var ImageProcessor = class {
   * @param extension 
   * @returns 
   */
-  static parse(buffer, extension) {
+  static parse(buffer2, extension) {
     console.log(`Parsing image with extension: ${extension}`);
     if (extension === "png") {
-      return parsePNG(buffer);
+      return parsePNG(buffer2);
     } else if (extension === "jpeg" || extension === "jpg") {
-      return this.parseJPEG(buffer);
+      return this.parseJPEG(buffer2);
     } else {
       throw new Error(`Unsupported image format: ${extension}. Supported formats: PNG, JPEG`);
     }
@@ -660,23 +660,23 @@ var ImageProcessor = class {
    * @param buffer JPEG file buffer
    * @returns Image data
    */
-  static parseJPEG(buffer) {
-    if (buffer[0] !== 255 || buffer[1] !== 216) {
+  static parseJPEG(buffer2) {
+    if (buffer2[0] !== 255 || buffer2[1] !== 216) {
       throw new Error("Invalid JPEG file");
     }
     let offset = 2;
     let width = 0;
     let height = 0;
-    while (offset < buffer.length - 1) {
-      if (buffer[offset] === 255) {
-        const marker = buffer[offset + 1];
+    while (offset < buffer2.length - 1) {
+      if (buffer2[offset] === 255) {
+        const marker = buffer2[offset + 1];
         if (marker >= 192 && marker <= 194) {
-          height = buffer.readUInt16BE(offset + 5);
-          width = buffer.readUInt16BE(offset + 7);
+          height = buffer2.readUInt16BE(offset + 5);
+          width = buffer2.readUInt16BE(offset + 7);
           break;
         }
-        if (offset + 2 < buffer.length) {
-          const segmentLength = buffer.readUInt16BE(offset + 2);
+        if (offset + 2 < buffer2.length) {
+          const segmentLength = buffer2.readUInt16BE(offset + 2);
           offset += 2 + segmentLength;
         } else {
           break;
@@ -691,11 +691,11 @@ var ImageProcessor = class {
     const pixelCount = width * height;
     const data = new Uint8Array(pixelCount * 4);
     let avgR = 0, avgG = 0, avgB = 0;
-    const sampleSize = Math.min(1e3, buffer.length);
+    const sampleSize = Math.min(1e3, buffer2.length);
     for (let i = 0; i < sampleSize; i += 3) {
-      avgR += buffer[i] || 0;
-      avgG += buffer[i + 1] || 0;
-      avgB += buffer[i + 2] || 0;
+      avgR += buffer2[i] || 0;
+      avgG += buffer2[i + 1] || 0;
+      avgB += buffer2[i + 2] || 0;
     }
     avgR = Math.floor(avgR / (sampleSize / 3));
     avgG = Math.floor(avgG / (sampleSize / 3));
@@ -789,9 +789,9 @@ var ImageUtils = class {
    * @param image Image to process
    * @returns 
    */
-  static getPixels(image) {
+  static getPixels(image2) {
     return __async(this, null, function* () {
-      return yield ImageProcessor_default.getImageData(image);
+      return yield ImageProcessor_default.getImageData(image2);
     });
   }
   /**
@@ -804,14 +804,14 @@ var ImageUtils = class {
    * @param destinationHeight Height of the output bitmap
    * @returns 
    */
-  static getBWBitmap(image, destinationWidth, destinationHeight) {
+  static getBWBitmap(image2, destinationWidth, destinationHeight) {
     return __async(this, null, function* () {
       const {
         data,
         width,
         height,
         bitsPerPixel
-      } = yield this.getPixels(image);
+      } = yield this.getPixels(image2);
       const dim = getSizePreserveAspect(width, height, destinationWidth, destinationHeight);
       const dWidth = dim.width;
       const dHeight = dim.height;
@@ -934,9 +934,9 @@ var TSPLBitmapCommand = class _TSPLBitmapCommand extends TSPLVisualCommand {
    * @param mode Graphics mode
    * @returns 
    */
-  static forImageUrl(image, x, y, imageWidth, imageHeight, mode) {
+  static forImageUrl(image2, x, y, imageWidth, imageHeight, mode) {
     return __async(this, null, function* () {
-      const bitmap = yield ImageUtils.getBWBitmap(image, imageWidth, imageHeight);
+      const bitmap = yield ImageUtils.getBWBitmap(image2, imageWidth, imageHeight);
       return new _TSPLBitmapCommand(bitmap, x, y, mode);
     });
   }
@@ -1249,8 +1249,8 @@ var TSPLCommandGenerator = class {
   line(start, end, thickness) {
     return new TSPLDiagonal(start, end, thickness);
   }
-  image(image, x, y, mode) {
-    return new TSPLBitmapCommand(image, x, y, mode);
+  image(image2, x, y, mode) {
+    return new TSPLBitmapCommand(image2, x, y, mode);
   }
   qrCode(content, width, x, y) {
     const cellCount = this.cellCount(content);
@@ -1585,7 +1585,7 @@ var Printable = class {
 };
 
 // src/labels/Label.ts
-var import_fontkit = __toESM(require("fontkit"));
+var fontkit = __toESM(require("fontkit"));
 var DEFAULT_FONT_WEIGHT = 400;
 var DEFAULT_FONT_STYLE = "normal";
 var FONT_PREFIX = "f";
@@ -1647,7 +1647,7 @@ var Label = class extends Printable {
         };
       }
       const fontBuffer = Buffer.from(font.data);
-      const builtFont = import_fontkit.default.create(fontBuffer);
+      const builtFont = fontkit.create(fontBuffer);
       const finalFont = builtFont.fonts ? builtFont.fonts[0] : builtFont;
       this.fonts[font.name].fonts[key] = __spreadProps(__spreadValues({}, font), {
         font: finalFont,
@@ -2084,11 +2084,11 @@ var BarCode = class extends LabelField {
 
 // src/labels/fields/Image.ts
 var Image2 = class _Image extends LabelField {
-  constructor(x, y, image) {
+  constructor(x, y, image2) {
     super();
     this.x = x;
     this.y = y;
-    this.image = image;
+    this.image = image2;
   }
   commandForLanguage(language, _config) {
     return __async(this, null, function* () {
@@ -2104,9 +2104,9 @@ var Image2 = class _Image extends LabelField {
    * @param height 
    * @returns 
    */
-  static create(image, x, y, width, height) {
+  static create(image2, x, y, width, height) {
     return __async(this, null, function* () {
-      const bitmap = yield ImageUtils.getBWBitmap(image, width, height);
+      const bitmap = yield ImageUtils.getBWBitmap(image2, width, height);
       return new _Image(x, y, bitmap);
     });
   }