label-printer 0.4.7 → 0.5.2

package/dist/index.mjs

@@ -418,7 +418,6 @@ var ImageProcessor = class {
    */
   static getImageDataBrowser(image2) {
     return __async(this, null, function* () {
-      console.log("Processing image in browser environment");
       return new Promise((resolve, reject) => {
         const img = new Image();
         img.crossOrigin = "anonymous";
@@ -1414,6 +1413,9 @@ var UsbDevice = class {
   writeData(data) {
     return __async(this, null, function* () {
       const endpointNumber = this.outEndpoint;
+      if (endpointNumber == null) {
+        throw new Error("usb-no-out-endpoint");
+      }
       yield this.device.transferOut(endpointNumber, data);
     });
   }
@@ -1435,6 +1437,9 @@ var UsbDevice = class {
   readData(length) {
     return __async(this, null, function* () {
       const endpointNumber = this.inEndpoint;
+      if (endpointNumber == null) {
+        throw new Error("usb-no-in-endpoint");
+      }
       const result = yield this.device.transferIn(endpointNumber, length);
       if (result.status == "ok" && result.data) {
         return result.data;
@@ -1490,8 +1495,12 @@ var PrinterService = class _PrinterService {
     return __async(this, null, function* () {
       const classes = [TSPLPrinter];
       for (const key in classes) {
-        if (yield classes[key].try(device)) {
-          return new classes[key](device);
+        try {
+          if (yield classes[key].try(device)) {
+            return new classes[key](device);
+          }
+        } catch (_e) {
+          return void 0;
         }
       }
       return void 0;
@@ -1530,9 +1539,11 @@ __export(labels_exports, {
   BarCode: () => BarCode,
   Image: () => Image2,
   Label: () => Label,
+  LabelField: () => LabelField,
   Line: () => Line,
-  Text: () => Text,
-  qrCode: () => QRCode
+  QRCode: () => QRCode,
+  Table: () => Table,
+  Text: () => Text
 });
 
 // src/labels/Printable.ts
@@ -1585,11 +1596,16 @@ var Label = class extends Printable {
     return {
       dpi: this.dpi,
       textWidth: (text, font) => {
-        const size = dotToPoint(font.size, this.dpi);
-        const fontObject = this.getIndexedFont(font).font;
-        const run = fontObject.layout(text);
-        const scaledWidth = size * run.advanceWidth / fontObject.unitsPerEm;
-        return pointsToDots(scaledWidth, this.dpi);
+        const indexedFont = this.getIndexedFont(font);
+        if (indexedFont == null) {
+          return text.length * font.size;
+        } else {
+          const size = dotToPoint(font.size, this.dpi);
+          const fontObject = indexedFont.font;
+          const run = fontObject.layout(text);
+          const scaledWidth = size * run.advanceWidth / fontObject.unitsPerEm;
+          return pointsToDots(scaledWidth, this.dpi);
+        }
       },
       getFontName: this.getFontName.bind(this)
     };
@@ -1663,8 +1679,7 @@ var Label = class extends Printable {
       const generator = this.commandGeneratorFor(language);
       const commands = yield this.fullCommand(language, 0, direction, mirror, 0, generator);
       commands.push(generator.display());
-      const group = generator.commandGroup(commands);
-      return group;
+      return generator.commandGroup(commands);
     });
   }
   /**
@@ -1696,6 +1711,7 @@ var Label = class extends Printable {
   getIndexedFont(font) {
     var _a, _b;
     const family = this.fonts[font.name];
+    if (!family) return null;
     const style = (_a = font.style) != null ? _a : DEFAULT_FONT_STYLE;
     const weigth = (_b = font.weight) != null ? _b : DEFAULT_FONT_WEIGHT;
     const fontKeys = Object.keys(family.fonts);
@@ -1724,6 +1740,9 @@ var Label = class extends Printable {
   }
   getFontName(font) {
     const indexedFont = this.getIndexedFont(font);
+    if (indexedFont == null) {
+      return font.name;
+    }
     return indexedFont.alias;
   }
   /// This can be extended when we want support multiple fonts
@@ -1772,7 +1791,7 @@ var Text = class extends LabelField {
     this.type = "singleline";
     this.context = void 0;
     this.lineSpacing = 1;
-    this.content = content.replace("\n", "");
+    this.content = content.replace("\n", "").replace('"', '\\"');
     this.x = x;
     this.y = y;
     this.formatted = formatted;
@@ -1883,7 +1902,7 @@ var Text = class extends LabelField {
    */
   generatePlainTextCore(content, initialX, initialY, font, features = []) {
     if (!this.context) throw "context-not-set";
-    const textWidhtFunction = this.textWithFunction;
+    const textWidhtFunction = this.textWidthFunction;
     let fullWidth = textWidhtFunction(content, font);
     if (this.width) {
       const initialPadding = initialX - this.x;
@@ -1985,7 +2004,7 @@ var Text = class extends LabelField {
       return textCommand;
     } else {
       let lineHeight = font.size * 0.1;
-      let textWidth = this.textWithFunction(text, font);
+      let textWidth = this.textWidthFunction(text, font);
       if (features.includes("strike")) {
         commands.push(this.textLineCommand(textWidth, x, y, lineHeight, 0.5, font.size));
       }
@@ -2014,7 +2033,7 @@ var Text = class extends LabelField {
       return (_a = this.context.config) == null ? void 0 : _a.getFontName(font);
     }
   }
-  get textWithFunction() {
+  get textWidthFunction() {
     var _a, _b, _c;
     if (this.font.name == "default") {
       return this.defaultTextWidth;
@@ -2102,6 +2121,210 @@ var QRCode = class extends LabelField {
     });
   }
 };
+
+// src/labels/fields/Table.ts
+var Table = class extends LabelField {
+  constructor(x, y, rows, options = {}) {
+    var _a, _b, _c, _d;
+    super();
+    this.x = x;
+    this.y = y;
+    this.rows = rows;
+    this.size = options.size;
+    this.columnWidths = options.columnWidths;
+    this.rowHeights = options.rowHeights;
+    this.lineThickness = (_a = options.lineThickness) != null ? _a : 2;
+    this.cellPadding = (_b = options.cellPadding) != null ? _b : 4;
+    this.formatted = (_c = options.formatted) != null ? _c : true;
+    this.font = (_d = options.font) != null ? _d : { name: "default", size: 10 };
+  }
+  setSize(size) {
+    this.size = size;
+  }
+  setColumnWidths(widths) {
+    this.columnWidths = widths;
+  }
+  setRowHeights(heights) {
+    this.rowHeights = heights;
+  }
+  setLineThickness(thickness) {
+    this.lineThickness = thickness;
+  }
+  setCellPadding(padding) {
+    this.cellPadding = padding;
+  }
+  setFormatted(formatted) {
+    this.formatted = formatted;
+  }
+  setFont(font) {
+    this.font = font;
+  }
+  commandForLanguage(language, config) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const generator = this.commandGeneratorFor(language);
+      const rowCount = this.rows.length;
+      const colCount = Math.max(0, ...this.rows.map((r) => r.length));
+      const resolvedColumnWidths = this.resolveTrackSizes({
+        trackCount: colCount,
+        explicitSizes: this.columnWidths,
+        total: (_a = this.size) == null ? void 0 : _a.width,
+        measure: (i) => this.measureAutoColumnWidth(i, colCount, config)
+      });
+      const resolvedRowHeights = this.resolveTrackSizes({
+        trackCount: rowCount,
+        explicitSizes: this.rowHeights,
+        total: (_b = this.size) == null ? void 0 : _b.height,
+        measure: (i) => this.measureAutoRowHeight(i, resolvedColumnWidths, config)
+      });
+      const xPositions = this.accumulatePositions(this.x, resolvedColumnWidths);
+      const yPositions = this.accumulatePositions(this.y, resolvedRowHeights);
+      const fields = [];
+      for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        for (let colIndex = 0; colIndex < colCount; colIndex++) {
+          const cellContent = (_d = (_c = this.rows[rowIndex]) == null ? void 0 : _c[colIndex]) != null ? _d : "";
+          const cellX = xPositions[colIndex];
+          const cellY = yPositions[rowIndex];
+          const cellWidth = resolvedColumnWidths[colIndex];
+          const cellHeight = resolvedRowHeights[rowIndex];
+          const textX = cellX + this.cellPadding;
+          const textY = cellY + this.cellPadding;
+          const textWidth = Math.max(1, cellWidth - this.cellPadding * 2);
+          const textHeight = Math.max(1, cellHeight - this.cellPadding * 2);
+          const text = new Text(cellContent, textX, textY, this.formatted);
+          text.setFont(this.font);
+          text.setMultiLine(textWidth, textHeight);
+          fields.push(text);
+        }
+      }
+      const totalWidth = resolvedColumnWidths.reduce((a, b) => a + b, 0);
+      const totalHeight = resolvedRowHeights.reduce((a, b) => a + b, 0);
+      for (let colIndex = 0; colIndex <= colCount; colIndex++) {
+        const sx = colIndex == colCount ? this.x + totalWidth : xPositions[colIndex];
+        fields.push(new Line(
+          { x: sx, y: this.y },
+          { x: sx, y: this.y + totalHeight },
+          this.lineThickness
+        ));
+      }
+      for (let rowIndex = 0; rowIndex <= rowCount; rowIndex++) {
+        const sy = rowIndex == rowCount ? this.y + totalHeight : yPositions[rowIndex];
+        fields.push(new Line(
+          { x: this.x, y: sy },
+          { x: this.x + totalWidth, y: sy },
+          this.lineThickness
+        ));
+      }
+      const commandList = yield Promise.all(fields.map((field) => field.commandForLanguage(language, config)));
+      return generator.commandGroup(commandList);
+    });
+  }
+  accumulatePositions(start, sizes) {
+    const positions = [];
+    let current = start;
+    for (const s of sizes) {
+      positions.push(current);
+      current += s;
+    }
+    return positions;
+  }
+  resolveTrackSizes(params) {
+    if (params.trackCount == 0) return [];
+    const sizes = new Array(params.trackCount).fill(void 0);
+    if (params.explicitSizes) {
+      for (let i = 0; i < Math.min(params.trackCount, params.explicitSizes.length); i++) {
+        sizes[i] = params.explicitSizes[i];
+      }
+    }
+    if (params.total != void 0) {
+      const fixedTotal = sizes.reduce((sum, s) => sum + (s != null ? s : 0), 0);
+      const flexibleCount = sizes.filter((s) => s == void 0).length;
+      const remaining = Math.max(0, params.total - fixedTotal);
+      const flexSize = flexibleCount == 0 ? 0 : remaining / flexibleCount;
+      return sizes.map((s, i) => {
+        var _a;
+        return Math.max(1, (_a = s != null ? s : flexSize) != null ? _a : params.measure(i));
+      });
+    }
+    return sizes.map((s, i) => Math.max(1, s != null ? s : params.measure(i)));
+  }
+  measureAutoColumnWidth(columnIndex, colCount, config) {
+    var _a;
+    const contentWidths = [];
+    for (const row of this.rows) {
+      const content = (_a = row == null ? void 0 : row[columnIndex]) != null ? _a : "";
+      const plain = this.toPlainText(content);
+      const w = this.textWidth(plain, config);
+      contentWidths.push(w);
+    }
+    const maxContentWidth = contentWidths.length == 0 ? 0 : Math.max(...contentWidths);
+    const minWidth = this.font.size;
+    const measured = Math.max(minWidth, maxContentWidth) + this.cellPadding * 2;
+    if (colCount == 0) return measured;
+    return measured;
+  }
+  measureAutoRowHeight(rowIndex, columnWidths, config) {
+    var _a, _b;
+    const row = (_a = this.rows[rowIndex]) != null ? _a : [];
+    const contentHeights = [];
+    for (let colIndex = 0; colIndex < columnWidths.length; colIndex++) {
+      const content = (_b = row[colIndex]) != null ? _b : "";
+      const plain = this.toPlainText(content);
+      const availableWidth = Math.max(1, columnWidths[colIndex] - this.cellPadding * 2);
+      const lineCount = this.estimateLineCount(plain, availableWidth, config);
+      const lineHeight = this.font.size + 1;
+      contentHeights.push(lineCount * lineHeight);
+    }
+    const maxContentHeight = contentHeights.length == 0 ? this.font.size : Math.max(...contentHeights);
+    return maxContentHeight + this.cellPadding * 2;
+  }
+  estimateLineCount(content, width, config) {
+    const normalized = content.replace("\n", " ");
+    if (normalized.trim() == "") return 1;
+    const words = [];
+    let buffer2 = "";
+    for (let i = 0; i < normalized.length; i++) {
+      const ch = normalized.charAt(i);
+      if (isWhitespace(ch)) {
+        if (buffer2 != "") {
+          words.push(buffer2);
+          buffer2 = "";
+        }
+        continue;
+      }
+      buffer2 += ch;
+    }
+    if (buffer2 != "") words.push(buffer2);
+    let lines = 1;
+    let currentLine = "";
+    for (const word of words) {
+      const candidate = currentLine == "" ? word : `${currentLine} ${word}`;
+      if (this.textWidth(candidate, config) <= width) {
+        currentLine = candidate;
+      } else {
+        if (currentLine == "") {
+          const charsPerLine = Math.max(1, Math.floor(width / Math.max(1, this.font.size)));
+          const neededLines = Math.ceil(word.length / charsPerLine);
+          lines += neededLines - 1;
+          currentLine = word.substring((neededLines - 1) * charsPerLine);
+        } else {
+          lines += 1;
+          currentLine = word;
+        }
+      }
+    }
+    return Math.max(1, lines);
+  }
+  textWidth(text, config) {
+    if (this.font.name == "default" || !config) {
+      return text.length * this.font.size;
+    }
+    return config.textWidth(text, this.font);
+  }
+  toPlainText(content) {
+    return content.replace(/<[^>]*>/g, "");
+  }
+};
 export {
   commands_exports as commands,
   labels_exports as labels,