label-printer 0.7.5 → 0.7.7

package/dist/index.js

@@ -330,12 +330,13 @@ function parsePNG(buffer2) {
   }
   const scanlineLength = width * bytesPerPixel;
   const data = new Uint8Array(width * height * outputChannels);
+  let prevUnfilteredScanline = Buffer.alloc(scanlineLength);
   for (let y = 0; y < height; y++) {
     const scanlineStart = y * (scanlineLength + 1);
     const filterType = decompressedData[scanlineStart];
     const scanline = decompressedData.subarray(scanlineStart + 1, scanlineStart + 1 + scanlineLength);
-    const prevScanline = y > 0 ? decompressedData.subarray((y - 1) * (scanlineLength + 1) + 1, (y - 1) * (scanlineLength + 1) + 1 + scanlineLength) : Buffer.alloc(scanlineLength);
-    const unfilteredScanline = applyPNGFilter(filterType, scanline, prevScanline, bytesPerPixel);
+    const unfilteredScanline = applyPNGFilter(filterType, scanline, prevUnfilteredScanline, bytesPerPixel);
+    prevUnfilteredScanline = unfilteredScanline;
     for (let x = 0; x < width; x++) {
       const outIdx = (y * width + x) * outputChannels;
       if (colorType === 0) {
@@ -829,7 +830,8 @@ var ImageProcessor_default = ImageProcessor;
 // src/helpers/ImageUtils.ts
 var BLACK_PIXEL = 0;
 var WHITE_PIXEL = 1;
-var DEFAULT_THRESHOLD = 200;
+var DEFAULT_THRESHOLD = 240;
+var DEFAULT_CROP_ALPHA_THRESHOLD = 16;
 var ImageUtils = class {
   /**
    * Get pixel information about an image
@@ -848,11 +850,11 @@ var ImageUtils = class {
    * input size as only downscaling is performed
    * 
    * @param image Image to process  
-   * @param destinationWidth Width of the ouput bitmap
+   * @param destinationWidth Width of the output bitmap
    * @param destinationHeight Height of the output bitmap
    * @returns 
    */
-  static getBWBitmap(image2, destinationWidth, destinationHeight) {
+  static getBWBitmap(image2, destinationWidth, destinationHeight, threshold, lsbFirst = false) {
     return __async(this, null, function* () {
       const {
         data,
@@ -863,43 +865,103 @@ var ImageUtils = class {
         image2,
         destinationWidth != null && destinationHeight != null ? { width: destinationWidth, height: destinationHeight } : void 0
       );
-      const dim = getSizePreserveAspect(width, height, destinationWidth, destinationHeight);
+      let cropX0 = 0;
+      let cropY0 = 0;
+      let cropX1 = width - 1;
+      let cropY1 = height - 1;
+      if (bitsPerPixel > 3) {
+        let found = false;
+        let minX = width;
+        let minY = height;
+        let maxX = -1;
+        let maxY = -1;
+        for (let y = 0; y < height; y++) {
+          for (let x = 0; x < width; x++) {
+            const a = data[y * width * bitsPerPixel + x * bitsPerPixel + 3];
+            if (a >= DEFAULT_CROP_ALPHA_THRESHOLD) {
+              found = true;
+              if (x < minX) minX = x;
+              if (y < minY) minY = y;
+              if (x > maxX) maxX = x;
+              if (y > maxY) maxY = y;
+            }
+          }
+        }
+        if (found) {
+          cropX0 = minX;
+          cropY0 = minY;
+          cropX1 = maxX;
+          cropY1 = maxY;
+        }
+      }
+      const cropWidth = cropX1 - cropX0 + 1;
+      const cropHeight = cropY1 - cropY0 + 1;
+      const dim = getSizePreserveAspect(cropWidth, cropHeight, destinationWidth, destinationHeight);
       const dWidth = dim.width;
       const dHeight = dim.height;
       const differenceToDividable = dWidth % 8 == 0 ? 0 : 8 - dWidth % 8;
       const dividableDWidth = dWidth + differenceToDividable;
-      const bitmapData = new Uint8Array(dividableDWidth * dHeight);
+      const luminances = new Uint8Array(dividableDWidth * dHeight);
       let destinationIndex = 0;
       for (let h = 0; h < dHeight; h++) {
-        const originalHeight = Math.round(h * (height - 1) / (dHeight - 1));
+        const srcY0 = cropY0 + Math.floor(h * cropHeight / dHeight);
+        const srcY1 = Math.max(srcY0, cropY0 + Math.floor((h + 1) * cropHeight / dHeight) - 1);
         for (let w = 0; w < dWidth; w++) {
-          const originalWidth = Math.round(w * (width - 1) / (dWidth - 1));
-          const baseIndex = originalHeight * width * bitsPerPixel + originalWidth * bitsPerPixel;
-          const r = data[baseIndex];
-          const g = data[baseIndex + 1];
-          const b = data[baseIndex + 2];
-          const a = bitsPerPixel > 3 ? data[baseIndex + 3] : 255;
-          const alpha = a / 255;
-          const rC = r * alpha + 255 * (1 - alpha);
-          const gC = g * alpha + 255 * (1 - alpha);
-          const bC = b * alpha + 255 * (1 - alpha);
-          const luminance = 0.299 * rC + 0.587 * gC + 0.114 * bC;
-          if (luminance > DEFAULT_THRESHOLD) {
-            bitmapData[destinationIndex] = WHITE_PIXEL;
-          } else {
-            bitmapData[destinationIndex] = BLACK_PIXEL;
+          const srcX0 = cropX0 + Math.floor(w * cropWidth / dWidth);
+          const srcX1 = Math.max(srcX0, cropX0 + Math.floor((w + 1) * cropWidth / dWidth) - 1);
+          let lumSum = 0;
+          let count = 0;
+          let opaqueCount = 0;
+          let opaqueLumSum = 0;
+          let opaqueWeightSum = 0;
+          let minOpaqueLum = 255;
+          for (let sy = srcY0; sy <= srcY1; sy++) {
+            for (let sx = srcX0; sx <= srcX1; sx++) {
+              const baseIndex = sy * width * bitsPerPixel + sx * bitsPerPixel;
+              const r = data[baseIndex];
+              const g = data[baseIndex + 1];
+              const b = data[baseIndex + 2];
+              const a = bitsPerPixel > 3 ? data[baseIndex + 3] : 255;
+              const alpha = a / 255;
+              const rC = r * alpha + 255 * (1 - alpha);
+              const gC = g * alpha + 255 * (1 - alpha);
+              const bC = b * alpha + 255 * (1 - alpha);
+              lumSum += 0.299 * rC + 0.587 * gC + 0.114 * bC;
+              count += 1;
+              if (a > 0) {
+                opaqueCount += 1;
+                const lum = 0.299 * r + 0.587 * g + 0.114 * b;
+                opaqueLumSum += lum * alpha;
+                opaqueWeightSum += alpha;
+                if (lum < minOpaqueLum) minOpaqueLum = lum;
+              }
+            }
           }
+          const avgLum = count > 0 ? lumSum / count : 255;
+          const avgOpaqueLum = opaqueWeightSum > 0 ? opaqueLumSum / opaqueWeightSum : 255;
+          const opaqueRatio = count > 0 ? opaqueCount / count : 0;
+          const luminance = opaqueCount === 0 ? 255 : opaqueRatio < 0.25 ? minOpaqueLum : avgOpaqueLum;
+          luminances[destinationIndex] = Math.max(0, Math.min(255, Math.round(luminance)));
           destinationIndex += 1;
         }
         for (let i = 0; i < differenceToDividable; i++) {
-          bitmapData[destinationIndex] = WHITE_PIXEL;
+          luminances[destinationIndex] = 255;
           destinationIndex += 1;
         }
       }
+      const thresholdValue = threshold != null ? threshold : this.otsuThreshold(luminances, dWidth, dividableDWidth, dHeight);
+      const bitmapData = new Uint8Array(dividableDWidth * dHeight);
+      for (let h = 0; h < dHeight; h++) {
+        const rowOffset = h * dividableDWidth;
+        for (let w = 0; w < dividableDWidth; w++) {
+          const idx = rowOffset + w;
+          bitmapData[idx] = luminances[idx] > thresholdValue ? WHITE_PIXEL : BLACK_PIXEL;
+        }
+      }
       const byteArrays = this.chunk(bitmapData, 8);
       const widthInBytes = dividableDWidth / 8;
-      const bytes = byteArrays.map(this.bitsToByte);
-      const finalBytes = new Uint8Array(bytes);
+      const bytes2 = byteArrays.map((b) => this.bitsToByte(b, lsbFirst));
+      const finalBytes = new Uint8Array(bytes2);
       return {
         width: widthInBytes,
         height: dHeight,
@@ -907,6 +969,40 @@ var ImageUtils = class {
       };
     });
   }
+  static otsuThreshold(luminances, contentWidth, rowWidth, height) {
+    const hist = new Uint32Array(256);
+    let total = 0;
+    for (let y = 0; y < height; y++) {
+      const rowOffset = y * rowWidth;
+      for (let x = 0; x < contentWidth; x++) {
+        hist[luminances[rowOffset + x]] += 1;
+        total += 1;
+      }
+    }
+    if (total === 0) return DEFAULT_THRESHOLD;
+    let sum = 0;
+    for (let t = 0; t < 256; t++) sum += t * hist[t];
+    let sumB = 0;
+    let wB = 0;
+    let wF = 0;
+    let maxBetween = -1;
+    let threshold = DEFAULT_THRESHOLD;
+    for (let t = 0; t < 256; t++) {
+      wB += hist[t];
+      if (wB === 0) continue;
+      wF = total - wB;
+      if (wF === 0) break;
+      sumB += t * hist[t];
+      const mB = sumB / wB;
+      const mF = (sum - sumB) / wF;
+      const between = wB * wF * (mB - mF) * (mB - mF);
+      if (between > maxBetween) {
+        maxBetween = between;
+        threshold = t;
+      }
+    }
+    return threshold;
+  }
   /**
    * Splits an array into chunks.
    * @param originalArray
@@ -926,13 +1022,95 @@ var ImageUtils = class {
    * @param bits
    * @returns
    */
-  static bitsToByte(bits) {
+  static bitsToByte(bits, lsbFirst) {
     let byteValue = 0;
+    if (lsbFirst) {
+      for (let i = 0; i < bits.length; i++) {
+        byteValue |= (bits[i] & 1) << i;
+      }
+      return byteValue;
+    }
     for (let i = 0; i < bits.length; i++) {
-      byteValue = byteValue << 1 | bits[i];
+      byteValue = byteValue << 1 | bits[i] & 1;
     }
     return byteValue;
   }
+  static dilateBWBitmap(bitmap2, iterations = 1) {
+    let current = bitmap2;
+    for (let i = 0; i < iterations; i++) {
+      current = this.dilateOnce(current);
+    }
+    return current;
+  }
+  static bwBitmapToPBM(bitmap2, widthDots2) {
+    var _a;
+    const widthBytes = bitmap2.width;
+    const height = bitmap2.height;
+    const widthBits = widthDots2 != null ? widthDots2 : widthBytes * 8;
+    const header = `P4
+${widthBits} ${height}
+`;
+    const headerBytes = new TextEncoder().encode(header);
+    const rowBytes = Math.ceil(widthBits / 8);
+    const out = new Uint8Array(headerBytes.length + rowBytes * height);
+    out.set(headerBytes, 0);
+    const src = bitmap2.bytes;
+    let offset = headerBytes.length;
+    for (let y = 0; y < height; y++) {
+      const rowStart = y * widthBytes;
+      for (let xb = 0; xb < rowBytes; xb++) {
+        const b = (_a = src[rowStart + xb]) != null ? _a : 255;
+        out[offset++] = ~b & 255;
+      }
+      const extraBits = rowBytes * 8 - widthBits;
+      if (extraBits > 0) {
+        const mask = 255 << extraBits;
+        out[offset - 1] = out[offset - 1] & mask;
+      }
+    }
+    return out;
+  }
+  static saveBWBitmapAsPBM(bitmap, filePath, widthDots) {
+    return __async(this, null, function* () {
+      if (typeof window !== "undefined") {
+        throw new Error("pbm-export-not-supported-in-browser");
+      }
+      const fs = yield eval("require")("fs");
+      const bytes = this.bwBitmapToPBM(bitmap, widthDots);
+      fs.writeFileSync(filePath, bytes);
+    });
+  }
+  static dilateOnce(bitmap2) {
+    const widthBytes = bitmap2.width;
+    const widthBits = widthBytes * 8;
+    const height = bitmap2.height;
+    const src = bitmap2.bytes;
+    const dst = new Uint8Array(src.length);
+    const getBit = (x, y) => {
+      if (x < 0 || y < 0 || x >= widthBits || y >= height) return 1;
+      const byteIndex = y * widthBytes + (x >> 3);
+      const bitIndex = 7 - (x & 7);
+      return src[byteIndex] >> bitIndex & 1;
+    };
+    const setBit = (x, y, value) => {
+      if (x < 0 || y < 0 || x >= widthBits || y >= height) return;
+      const byteIndex = y * widthBytes + (x >> 3);
+      const mask = 1 << 7 - (x & 7);
+      if (value === 1) dst[byteIndex] |= mask;
+      else dst[byteIndex] &= ~mask & 255;
+    };
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < widthBits; x++) {
+        const isBlack = getBit(x, y) === 0 || getBit(x - 1, y) === 0 || getBit(x + 1, y) === 0 || getBit(x, y - 1) === 0 || getBit(x, y + 1) === 0 || getBit(x - 1, y - 1) === 0 || getBit(x + 1, y - 1) === 0 || getBit(x - 1, y + 1) === 0 || getBit(x + 1, y + 1) === 0;
+        setBit(x, y, isBlack ? 0 : 1);
+      }
+    }
+    return {
+      width: widthBytes,
+      height,
+      bytes: dst
+    };
+  }
 };
 
 // src/commands/tspl/commands/basic/TSPLBitmapCommand.ts
@@ -944,9 +1122,9 @@ var TSPLBitmapCommand = class _TSPLBitmapCommand extends TSPLVisualCommand {
    * @param mode Represents the strategy to use when two bitmaps overlap. The final value will be determined by
    * either overwriting the first bitmap's value with the second one or performing an 'or' or 'xor' operation on the values
    */
-  constructor(bitmap, x, y, mode) {
+  constructor(bitmap2, x, y, mode) {
     super(x, y);
-    this.bitmap = bitmap;
+    this.bitmap = bitmap2;
     this.mode = mode != null ? mode : "overwrite";
   }
   get commandString() {
@@ -987,8 +1165,8 @@ var TSPLBitmapCommand = class _TSPLBitmapCommand extends TSPLVisualCommand {
    */
   static forImageUrl(image2, x, y, imageWidth, imageHeight, mode) {
     return __async(this, null, function* () {
-      const bitmap = yield ImageUtils.getBWBitmap(image2, imageWidth, imageHeight);
-      return new _TSPLBitmapCommand(bitmap, x, y, mode);
+      const bitmap2 = yield ImageUtils.getBWBitmap(image2, imageWidth, imageHeight);
+      return new _TSPLBitmapCommand(bitmap2, x, y, mode);
     });
   }
 };
@@ -1407,9 +1585,9 @@ var StringUtils = class {
    * @param bytes Bytes to decode
    * @returns A string
    */
-  toString(bytes) {
+  toString(bytes2) {
     let decoder = new TextDecoder();
-    return decoder.decode(bytes);
+    return decoder.decode(bytes2);
   }
 };
 var isWhitespace = (text) => text.trim() === "";
@@ -1482,6 +1660,10 @@ var UsbDevice = class {
     var _a;
     return (_a = this.endpoints.find((e) => e.direction == "out")) == null ? void 0 : _a.endpointNumber;
   }
+  get outEndpointPacketSize() {
+    var _a;
+    return (_a = this.endpoints.find((e) => e.direction == "out")) == null ? void 0 : _a.packetSize;
+  }
   /**
    * Endpoint for reading
    */
@@ -1530,8 +1712,8 @@ var UsbDevice = class {
    */
   writeString(text) {
     return __async(this, null, function* () {
-      const bytes = stringHelper.toUTF8Array(text);
-      yield this.writeData(bytes);
+      const bytes2 = stringHelper.toUTF8Array(text);
+      yield this.writeData(bytes2);
     });
   }
   /**
@@ -1559,8 +1741,8 @@ var UsbDevice = class {
    */
   readString(length) {
     return __async(this, null, function* () {
-      const bytes = yield this.readData(length);
-      if (bytes) return stringHelper.toString(bytes);
+      const bytes2 = yield this.readData(length);
+      if (bytes2) return stringHelper.toString(bytes2);
       return void 0;
     });
   }
@@ -1671,8 +1853,8 @@ var NetworkDevice = class {
   }
   writeString(text) {
     return __async(this, null, function* () {
-      const bytes = stringHelper2.toUTF8Array(text);
-      yield this.writeData(bytes);
+      const bytes2 = stringHelper2.toUTF8Array(text);
+      yield this.writeData(bytes2);
     });
   }
   readData(length) {
@@ -1716,8 +1898,8 @@ var NetworkDevice = class {
   }
   readString(length) {
     return __async(this, null, function* () {
-      const bytes = yield this.readData(length);
-      if (bytes) return stringHelper2.toString(bytes);
+      const bytes2 = yield this.readData(length);
+      if (bytes2) return stringHelper2.toString(bytes2);
       return void 0;
     });
   }
@@ -2365,7 +2547,9 @@ var BOLD_WEIGTH = 700;
 var BOLD_TAG = "b";
 var ITALIC_TAG = "i";
 var UNDERLINE_TAG = "u";
-var STRIKE_TAG = "s";
+var STRIKE_TAG = ["s", "del", "strike"];
+var PARAGRAPH_TAG = "p";
+var BREAK_TAG = "br";
 var Text = class extends LabelField {
   constructor(content, x, y, formatted = true) {
     super();
@@ -2450,6 +2634,13 @@ var Text = class extends LabelField {
     } else {
       const elementNode = rootNode;
       const tag = elementNode.rawTagName;
+      if (tag == BREAK_TAG) {
+        return {
+          x: this.x,
+          y: initialY + font.size + this.lineSpacing,
+          command: this.context.generator.commandGroup([])
+        };
+      }
       let commands = [];
       let currentX = initialX;
       let currentY = initialY;
@@ -2457,19 +2648,45 @@ var Text = class extends LabelField {
       let baseFeatures = [...features];
       if (tag == UNDERLINE_TAG) {
         baseFeatures.push("underline");
-      } else if (tag == STRIKE_TAG) {
+      } else if (STRIKE_TAG.includes(tag)) {
         baseFeatures.push("strike");
       } else if (tag == BOLD_TAG) {
         baseFont.weight = BOLD_WEIGTH;
       } else if (tag == ITALIC_TAG) {
         baseFont.style = "italic";
       }
+      if (tag == PARAGRAPH_TAG) {
+        const isAtFieldOrigin = initialX == this.x && initialY == this.y;
+        if (!isAtFieldOrigin) {
+          currentX = this.x;
+          currentY = initialY + baseFont.size + this.lineSpacing;
+        }
+      }
       elementNode.childNodes.forEach((node) => {
         const { x, y, command } = this.generateFormattedRecursive(currentX, currentY, node, baseFont, baseFeatures);
         currentX = x;
         currentY = y;
         commands.push(command);
       });
+      if (tag == PARAGRAPH_TAG) {
+        let paragraphEndsWithBreak = false;
+        for (let i = elementNode.childNodes.length - 1; i >= 0; i--) {
+          const node = elementNode.childNodes[i];
+          if (node.nodeType == import_node_html_parser.NodeType.TEXT_NODE) {
+            if (node.innerText.trim() == "") continue;
+            break;
+          }
+          const childElement = node;
+          if (childElement.rawTagName == BREAK_TAG) {
+            paragraphEndsWithBreak = true;
+          }
+          break;
+        }
+        if (!paragraphEndsWithBreak) {
+          currentX = this.x;
+          currentY += baseFont.size + this.lineSpacing;
+        }
+      }
       return {
         x: currentX,
         y: currentY,
@@ -2682,8 +2899,8 @@ var Image2 = class _Image extends LabelField {
    */
   static create(image2, x, y, width, height) {
     return __async(this, null, function* () {
-      const bitmap = yield ImageUtils.getBWBitmap(image2, width, height);
-      return new _Image(x, y, bitmap);
+      const bitmap2 = yield ImageUtils.getBWBitmap(image2, width, height);
+      return new _Image(x, y, bitmap2);
     });
   }
 };