label-printer 0.2.6 → 0.3.1

package/dist/index.js

@@ -1,10 +1,27 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -51,6 +68,7 @@ var __async = (__this, __arguments, generator) => {
 var src_exports = {};
 __export(src_exports, {
   commands: () => commands_exports,
+  labels: () => labels_exports,
   printers: () => printers_exports
 });
 module.exports = __toCommonJS(src_exports);
@@ -65,6 +83,9 @@ __export(commands_exports, {
 
 // src/commands/Command.ts
 var Command = class {
+  print(fn) {
+    fn(this.commandString);
+  }
   /**
    * Write the command data to a USB device
    * @param device Device to write to
@@ -118,6 +139,11 @@ var CommandGroup = class extends Command {
     super();
     this.commands = commands;
   }
+  print(fn) {
+    for (let commandIndex in this.commands) {
+      this.commands[commandIndex].print(fn);
+    }
+  }
   write(device) {
     return __async(this, null, function* () {
       for (let commandIndex in this.commands) {
@@ -139,7 +165,10 @@ __export(tspl_exports, {
   TSPLCLSCommand: () => TSPLCLSCommand,
   TSPLCommand: () => TSPLCommand,
   TSPLCommandGroup: () => TSPLCommandGroup,
+  TSPLDiagonal: () => TSPLDiagonal,
   TSPLDirectionCommand: () => TSPLDirectionCommand,
+  TSPLDisplay: () => TSPLDisplay,
+  TSPLDownload: () => TSPLDownload,
   TSPLGapCommand: () => TSPLGapCommand,
   TSPLPrintCommand: () => TSPLPrintCommand,
   TSPLQRCommand: () => TSPLQRCommand,
@@ -147,7 +176,8 @@ __export(tspl_exports, {
   TSPLSizeCommand: () => TSPLSizeCommand,
   TSPLTextCommand: () => TSPLTextCommand,
   TSPLVisualCommand: () => TSPLVisualCommand,
-  alignmentToNumber: () => alignmentToNumber
+  alignmentToNumber: () => alignmentToNumber,
+  commandGenerator: () => TSPLCommandGenerator_default
 });
 
 // src/commands/tspl/TSPLCommand.ts
@@ -184,6 +214,44 @@ var TSPLVisualCommand = class extends TSPLCommand {
 
 // src/helpers/ImageUtils.ts
 var import_image_pixels = __toESM(require("image-pixels"));
+
+// src/helpers/UnitUtils.ts
+var pointsPerInch = 72;
+function getSizePreserveAspect(width, height, desiredWidth, desiredHeight) {
+  if (desiredHeight && desiredWidth) {
+    return { width: desiredWidth, height: desiredHeight };
+  }
+  if (desiredHeight) {
+    const scaleFactor = desiredHeight / height;
+    return { width: width * scaleFactor, height: desiredHeight };
+  } else if (desiredWidth) {
+    const scaleFactor = desiredWidth / width;
+    return { width: desiredWidth, height: height * scaleFactor };
+  } else {
+    return { width, height };
+  }
+}
+function valueWithUnit(value, unitSystem) {
+  switch (unitSystem) {
+    case "dot":
+      return `${value} dot`;
+    case "imperial":
+      return value;
+    case "metric":
+      return `${value} mm`;
+  }
+}
+function dotToPoint(dots, dpi) {
+  const inch = dots / dpi;
+  return Math.round(inch * pointsPerInch);
+}
+function pointsToDots(points, dpi) {
+  const pointsPerInch2 = 72;
+  const dots = points * dpi / pointsPerInch2;
+  return dots;
+}
+
+// src/helpers/ImageUtils.ts
 var BLACK_PIXEL = 0;
 var WHITE_PIXEL = 1;
 var ImageUtils = class {
@@ -222,8 +290,9 @@ var ImageUtils = class {
         height,
         bitsPerPixel
       } = yield this.getPixels(image);
-      const dWidth = destinationWidth != null ? destinationWidth : width;
-      const dHeight = destinationHeight != null ? destinationHeight : height;
+      const dim = getSizePreserveAspect(width, height, 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);
@@ -390,17 +459,7 @@ var TSPLGapCommand = class extends TSPLCommand {
     this.unitSystem = unitSystem;
   }
   get commandString() {
-    return `GAP ${this.valueWithUnit(this.gap)}, ${this.valueWithUnit(this.offset)}`;
-  }
-  valueWithUnit(value) {
-    switch (this.unitSystem) {
-      case "dot":
-        return `${value} dot`;
-      case "imperial":
-        return value;
-      case "metric":
-        return `${value} mm`;
-    }
+    return `GAP ${valueWithUnit(this.gap, this.unitSystem)}, ${valueWithUnit(this.offset, this.unitSystem)}`;
   }
 };
 
@@ -413,17 +472,7 @@ var TSPLSizeCommand = class extends TSPLCommand {
     this.unitSystem = unitSystem;
   }
   get commandString() {
-    return `SIZE ${this.valueWithUnit(this.width)}, ${this.valueWithUnit(this.height)}`;
-  }
-  valueWithUnit(value) {
-    switch (this.unitSystem) {
-      case "dot":
-        return `${value} dot`;
-      case "imperial":
-        return value;
-      case "metric":
-        return `${value} mm`;
-    }
+    return `SIZE ${valueWithUnit(this.width, this.unitSystem)}, ${valueWithUnit(this.height, this.unitSystem)}`;
   }
 };
 
@@ -496,7 +545,7 @@ var TSPLQRCommand = class extends TSPLVisualCommand {
     }
   }
   get commandString() {
-    return `QRCODE ${this.x}, ${this.y}, ${this.ecc}, ${this.cellWidth}, ${this.mode}, ${this.rotation}, ${this.model}, ${this.mask}, "${this.content}"`;
+    return `QRCODE ${this.x}, ${this.y}, ${this.ecc}, ${this.cellWidth}, ${this.mode}, ${this.rotation}, ${this.model}, "${this.content}"`;
   }
 };
 
@@ -513,6 +562,194 @@ var TSPLBlockCommand = class extends TSPLTextCommand {
   }
 };
 
+// src/commands/tspl/commands/basic/TSPLDownload.ts
+var TSPLDownload = class extends TSPLCommand {
+  /**
+   * Initialize a command with a raw body
+   * @param body
+   */
+  constructor(fileName, data) {
+    super();
+    this.fileName = fileName;
+    this.data = data;
+  }
+  get commandString() {
+    return `DOWNLOAD "${this.fileName}", ${this.data.byteLength},`;
+  }
+  write(device) {
+    return __async(this, null, function* () {
+      yield this.writeString(this.commandString, device);
+      yield this.writeBytes(this.data, device);
+      yield this.terminateCommand(device);
+    });
+  }
+};
+
+// src/commands/tspl/commands/basic/TSPLDisplay.ts
+var TSPLDisplay = class extends TSPLCommand {
+  constructor(type) {
+    super();
+    this.type = type;
+  }
+  get commandString() {
+    return `DISPLAY ${this.type}`;
+  }
+};
+
+// src/commands/tspl/commands/basic/TSPLDiagonal.ts
+var TSPLDiagonal = class extends TSPLCommand {
+  constructor(start, end, thickness = 3) {
+    super();
+    this.start = start;
+    this.end = end;
+    this.thickness = thickness;
+  }
+  get commandString() {
+    return `DIAGONAL ${this.start.x}, ${this.start.y}, ${this.end.x}, ${this.end.y}, ${this.thickness}`;
+  }
+};
+
+// src/commands/tspl/commands/basic/TSPLBarcodeCommand.ts
+var TSPLBarcodeCommand = class _TSPLBarcodeCommand extends TSPLVisualCommand {
+  /**
+   * @param x X coordinate in dots
+   * @param y Y Coordinate in dots
+   * @param type Type of the barcode
+   * @param height Height of the barcode in dots
+   * @param narrow Width of narrow elements in dots
+   * @param wide Width of the wide elements in dots
+   * @param content Content of the barcode. Supported content depends on the barcode type
+   * @param rotation Rotation 
+   * @param alignment Alignment of the barcode
+   */
+  constructor(x, y, type, height, narrow, wide, content, rotation = 0, humanReadable = "left", alignment = "left") {
+    super(x, y);
+    this.type = type;
+    this.height = height;
+    this.narrow = narrow;
+    this.wide = wide;
+    this.content = content;
+    this.rotation = rotation;
+    this.humanReadable = _TSPLBarcodeCommand.humanReadableValue(humanReadable);
+    this.alignment = alignmentToNumber(alignment);
+  }
+  get commandString() {
+    return `BARCODE ${this.x}, ${this.y}, "${this.type}", ${this.height}, ${this.humanReadable},${this.rotation}, ${this.narrow}, ${this.wide},${this.alignment}, "${this.content}"`;
+  }
+  static humanReadableValue(hr) {
+    switch (hr) {
+      case "none":
+        return 0;
+      case "left":
+        return 1;
+      case "center":
+        return 2;
+      case "right":
+        return 3;
+    }
+  }
+};
+
+// src/helpers/QRCodeUtils.ts
+var QRLengthMapping = {
+  10: 21,
+  20: 25,
+  35: 29,
+  50: 33,
+  64: 37,
+  84: 41,
+  93: 45,
+  122: 49,
+  143: 53,
+  174: 57,
+  200: 61,
+  227: 65,
+  259: 69,
+  283: 73,
+  321: 77,
+  365: 81,
+  408: 85,
+  452: 89,
+  493: 93,
+  557: 97,
+  587: 101,
+  640: 105,
+  672: 109,
+  744: 113,
+  779: 117,
+  864: 121,
+  910: 125,
+  958: 129,
+  1016: 133,
+  1080: 137,
+  1150: 141,
+  1226: 145,
+  1307: 149,
+  1394: 153,
+  1431: 157,
+  1530: 161,
+  1591: 165,
+  1658: 169,
+  1774: 173,
+  1852: 177
+};
+
+// src/commands/tspl/TSPLCommandGenerator.ts
+var TSPLCommandGenerator = class {
+  commandGroup(commands) {
+    return new TSPLCommandGroup(commands);
+  }
+  print(sets, copiesPerSet) {
+    return new TSPLPrintCommand(sets, copiesPerSet);
+  }
+  text(content, x, y, font, size) {
+    const fontName = font == "default" ? "0" : font;
+    return new TSPLTextCommand(content, x, y, fontName, 0, size, size, "left");
+  }
+  upload(name, data) {
+    return new TSPLDownload(name, data);
+  }
+  setUp(width, height, gap, offset, direction, mirror = false, unitSystem) {
+    const commands = [
+      new TSPLSizeCommand(width, height, unitSystem),
+      new TSPLGapCommand(gap, offset, unitSystem),
+      new TSPLDirectionCommand(direction, mirror),
+      new TSPLCLSCommand()
+    ];
+    return new TSPLCommandGroup(commands);
+  }
+  display() {
+    return new TSPLCommandGroup([
+      new TSPLDisplay("CLS"),
+      new TSPLDisplay("IMAGE")
+    ]);
+  }
+  line(start, end, thickness) {
+    return new TSPLDiagonal(start, end, thickness);
+  }
+  image(image, x, y, mode) {
+    return new TSPLBitmapCommand(image, x, y, mode);
+  }
+  qrCode(content, width, x, y) {
+    const cellCount = this.cellCount(content);
+    const cellWidth = Math.round(width / cellCount);
+    return new TSPLQRCommand(`A${content}`, x, y, cellWidth, "H", "M");
+  }
+  barCode(content, x, y, type, height, rotation, humanReadable, alignment) {
+    return new TSPLBarcodeCommand(x, y, type, height, 1, 1, content, rotation, humanReadable, alignment);
+  }
+  cellCount(content) {
+    const limits = Object.keys(QRLengthMapping).map((limit) => Number(limit)).sort((a, b) => a - b);
+    const contentLength = content.length;
+    let i = 0;
+    while (limits[i] < contentLength && i < limits.length - 1) {
+      i++;
+    }
+    return QRLengthMapping[limits[i]];
+  }
+};
+var TSPLCommandGenerator_default = new TSPLCommandGenerator();
+
 // src/printers/index.ts
 var printers_exports = {};
 __export(printers_exports, {
@@ -533,6 +770,26 @@ var Printer = class {
       yield this.usbDevice.close();
     });
   }
+  /**
+   * Prints a label
+   * @param label 
+   */
+  print(label, sets, gap, copiesPerSet = 1, direction = "normal", mirror = false, gapOffset = 0) {
+    return __async(this, null, function* () {
+      const commands = yield label.fullPrintCommand(this.language, gap, direction, sets, copiesPerSet, mirror, gapOffset);
+      yield this.writeCommand(commands);
+    });
+  }
+  /**
+   * Display label on the printer's screen
+   * @param label 
+   */
+  display(label, direction = "normal", mirror = false) {
+    return __async(this, null, function* () {
+      const command = yield label.fullDisplayCommand(this.language, direction, mirror);
+      yield this.writeCommand(command);
+    });
+  }
   /**
    * Writes a command to the printers usb
    * @param command Command to send to the usb
@@ -573,6 +830,7 @@ var StringUtils = class {
     return decoder.decode(bytes);
   }
 };
+var isWhitespace = (text) => text.trim() === "";
 
 // src/helpers/USBUtils.ts
 var unsupportedUsbError = "usb-unsupported";
@@ -772,9 +1030,592 @@ var PrinterService = class _PrinterService {
     });
   }
 };
+
+// src/labels/index.ts
+var labels_exports = {};
+__export(labels_exports, {
+  BarCode: () => BarCode,
+  Image: () => Image,
+  Label: () => Label,
+  Line: () => Line,
+  Text: () => Text,
+  qrCode: () => QRCode
+});
+
+// src/labels/Printable.ts
+var Printable = class {
+  /**
+   * Generates printable command for the given printer. Can be used to obtain a command for fields supported by the package then customizing it before printing
+   * @param printer Printer to generate the command. Important because the command is printer language specific
+   * @returns A promise for a command. Most commands are syncronouse but some may require to access async resources
+   */
+  commandForPrinter(printer, config) {
+    return __async(this, null, function* () {
+      return yield this.commandForLanguage(printer.language, config);
+    });
+  }
+  /**
+   * Obtain a command generator for the given language
+   * @param language Language to get generator for
+   */
+  commandGeneratorFor(language) {
+    switch (language) {
+      case "tspl":
+        return tspl_exports.commandGenerator;
+    }
+  }
+};
+
+// src/labels/Label.ts
+var import_fontkit = __toESM(require("fontkit"));
+var DEFAULT_FONT_WEIGHT = 400;
+var DEFAULT_FONT_STYLE = "normal";
+var FONT_PREFIX = "f";
+var Label = class extends Printable {
+  constructor(width, height, dimensionUnit = "metric", dpi = 203) {
+    super();
+    this.fonts = {};
+    /**
+    * List of fields on the label
+    */
+    this.fields = [];
+    this.fontCounter = 0;
+    this.width = width;
+    this.height = height;
+    this.unitSystem = dimensionUnit;
+    this.dpi = dpi;
+  }
+  /**
+   * Configuration used when generating commands
+   */
+  get printConfig() {
+    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);
+      },
+      getFontName: this.getFontName.bind(this)
+    };
+  }
+  commandForLanguage(language, config) {
+    return __async(this, null, function* () {
+      const commandList = yield Promise.all(this.fields.map((field) => field.commandForLanguage(language, config)));
+      return this.commandGeneratorFor(language).commandGroup(commandList);
+    });
+  }
+  /**
+   * Place fields to a label
+   * @param fields 
+   */
+  add(...fields) {
+    this.fields.push(...fields);
+  }
+  /**
+   * Register a font to be used. Use the name provided in components to use the font. 
+   * For example: textField.setFont('myFont.ttf', 12)
+   * @param file Font file. Can be a blob or a url
+   * @param name Name to be used to reference the font
+   */
+  registerFont(font) {
+    return __async(this, null, function* () {
+      const key = this.fontKey(font.weight, font.style);
+      if (!this.fonts[font.name]) {
+        this.fonts[font.name] = {
+          fonts: {}
+        };
+      }
+      const fontBuffer = Buffer.from(font.data);
+      this.fonts[font.name].fonts[key] = __spreadProps(__spreadValues({}, font), {
+        font: import_fontkit.default.create(fontBuffer),
+        alias: `${FONT_PREFIX}${this.fontCounter}.${this.fontExtension}`
+      });
+      this.fontCounter += 1;
+    });
+  }
+  /**
+   * Generate a command that is complete for printing
+   * @param language Printing language to use
+   * @param gap Distance between two labels. It is measured between the two points where the sensor 
+   * leaves the label and enters the next one
+   * @param direction Direction relative to printing direction. See documentation for more details
+   * @param sets Number of sets to print. If you have counters for example, it will not change in a set
+   * @param copiesPerSet Number of labels per set
+   * @param mirror Mirror the label along the vertical axis
+   * @param gapOffset Used with non uniform shaped labels. Is the distance between the point where the sensor leaves the label and the 
+   * furthest point of the label in the direction of printing. Check documentation for more info
+   * TODO: Is this too TSPL Specific?
+   */
+  fullPrintCommand(language, gap, direction, sets, copiesPerSet = 1, mirror = false, gapOffset = 0) {
+    return __async(this, null, function* () {
+      const generator = this.commandGeneratorFor(language);
+      const commands = yield this.fullCommand(language, gap, direction, mirror, gapOffset, generator);
+      commands.push(generator.print(sets, copiesPerSet));
+      return generator.commandGroup(commands);
+    });
+  }
+  /**
+   * Generate commands needed to display the label on the printer screen
+   * @param language Printing language to use
+   * @param direction Direction relative to printing direction. See documentation for more details
+   * @param mirror Mirror the label along the vertical axis
+   */
+  fullDisplayCommand(language, direction, mirror = false) {
+    return __async(this, null, function* () {
+      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);
+      group.print(console.log);
+      return group;
+    });
+  }
+  /**
+   * Helper function that generates common commands for print and display
+   */
+  fullCommand(language, gap, direction, mirror = false, gapOffset = 0, generator) {
+    return __async(this, null, function* () {
+      const commands = [
+        this.fontUploadCommands(generator),
+        generator.setUp(this.width, this.height, gap, gapOffset, direction, mirror, this.unitSystem),
+        yield this.commandForLanguage(language, this.printConfig)
+      ];
+      return commands;
+    });
+  }
+  fontUploadCommands(generator) {
+    const families = Object.keys(this.fonts);
+    const commands = families.flatMap((family) => {
+      const familyFonts = this.fonts[family].fonts;
+      const fontNames = Object.keys(familyFonts);
+      return fontNames.map((name) => {
+        const font = familyFonts[name];
+        const fileName = font.alias;
+        return generator.upload(fileName, font.data);
+      });
+    });
+    return generator.commandGroup(commands);
+  }
+  getIndexedFont(font) {
+    var _a, _b;
+    const family = this.fonts[font.name];
+    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);
+    const exactMatch = fontKeys.find(
+      (key) => family.fonts[key].style == style && family.fonts[key].weight == weigth
+    );
+    if (exactMatch) {
+      return family.fonts[exactMatch];
+    } else {
+      const sameStyleKeys = fontKeys.filter((key) => family.fonts[key].style == style);
+      if (sameStyleKeys.length > 0) {
+        let weigthDiff = 99999999;
+        let selectedKey = "";
+        sameStyleKeys.forEach((key) => {
+          const diff = Math.abs(weigth - family.fonts[key].weight);
+          if (diff < weigthDiff) {
+            weigthDiff = diff;
+            selectedKey = key;
+          }
+        });
+        return family.fonts[selectedKey];
+      } else {
+        return family.fonts[fontKeys[0]];
+      }
+    }
+  }
+  getFontName(font) {
+    const indexedFont = this.getIndexedFont(font);
+    return indexedFont.alias;
+  }
+  /// This can be extended when we want support multiple fonts
+  get fontExtension() {
+    return "TTF";
+  }
+  fontKey(weight, style) {
+    return `${weight}${style != null ? style : DEFAULT_FONT_STYLE}`;
+  }
+};
+
+// src/labels/fields/LabelField.ts
+var LabelField = class extends Printable {
+};
+
+// src/labels/fields/Line.ts
+var Line = class extends LabelField {
+  /**
+   * 
+   * @param start Start point of the line. Values are in dots
+   * @param end End point of the line. Values are in dots
+   * @param thickness Thickness of the line in dots 
+   */
+  constructor(start, end, thickness = 3) {
+    super();
+    this.start = start;
+    this.end = end;
+    this.thickness = thickness;
+  }
+  commandForLanguage(language) {
+    return this.commandGeneratorFor(language).line(this.start, this.end, this.thickness);
+  }
+};
+
+// src/labels/fields/Text.ts
+var import_node_html_parser = require("node-html-parser");
+var BOLD_WEIGTH = 700;
+var BOLD_TAG = "b";
+var ITALIC_TAG = "i";
+var UNDERLINE_TAG = "u";
+var STRIKE_TAG = "s";
+var Text = class extends LabelField {
+  constructor(content, x, y, formatted = true) {
+    super();
+    this.font = { name: "default", size: 10 };
+    this.type = "singleline";
+    this.context = void 0;
+    this.lineSpacing = 1;
+    this.content = content.replace("\n", "");
+    this.x = x;
+    this.y = y;
+    this.formatted = formatted;
+  }
+  /**
+   * Sets the field to single line
+   * @param width Max width of the text. Leave it undefined to allow the field to grow 
+   */
+  setSingleLine(width) {
+    this.type = "singleline";
+    this.width = width;
+    this.height = void 0;
+  }
+  /**
+   * Sets the field to multi line
+   * @param width Max width of text before it gets wrapped to a new line
+   * @param height Max height of the text box, leave undefined to allow the text box to grow infinitly
+   */
+  setMultiLine(width, height) {
+    this.type = "multiline";
+    this.width = width;
+    this.height = height;
+  }
+  /**
+   * Set a font to use as a base. If no formatting is set on the text with a html tag, this will be used 
+   * Note: The font name either has to be a built in font on your printer or a font
+   * that is registered on the label using 'registerFont'.
+   */
+  setFont(font) {
+    this.font = font;
+  }
+  commandForLanguage(language, config) {
+    return __async(this, null, function* () {
+      this.context = {
+        config,
+        language,
+        generator: this.commandGeneratorFor(language)
+      };
+      let command;
+      if (this.formatted) {
+        command = this.generateFormattedText();
+      } else {
+        command = this.generatePlainText();
+      }
+      this.context = void 0;
+      return command;
+    });
+  }
+  /**
+   * Generate commands for formatted text
+   * @returns 
+   */
+  generateFormattedText() {
+    if (!this.context)
+      throw "context-not-set";
+    const rootNode = (0, import_node_html_parser.parse)(this.content);
+    const { command } = this.generateFormattedRecursive(this.x, this.y, rootNode, this.font, []);
+    return command;
+  }
+  /**
+   * Generate commands for plain text
+   * @returns 
+   */
+  generatePlainText() {
+    const { command } = this.generatePlainTextCore(this.content, this.x, this.y, this.font);
+    return command;
+  }
+  /**
+   * Iterats the nodes in a html text and generates text commands for it
+   */
+  generateFormattedRecursive(initialX, initialY, rootNode, font, features) {
+    if (rootNode.nodeType == import_node_html_parser.NodeType.TEXT_NODE) {
+      const result = this.generatePlainTextCore(rootNode.innerText, initialX, initialY, font, features);
+      return result;
+    } else {
+      const elementNode = rootNode;
+      const tag = elementNode.rawTagName;
+      let commands = [];
+      let currentX = initialX;
+      let currentY = initialY;
+      let baseFont = __spreadValues({}, font);
+      let baseFeatures = [...features];
+      if (tag == UNDERLINE_TAG) {
+        baseFeatures.push("underline");
+      } else if (tag == STRIKE_TAG) {
+        baseFeatures.push("strike");
+      } else if (tag == BOLD_TAG) {
+        baseFont.weight = BOLD_WEIGTH;
+      } else if (tag == ITALIC_TAG) {
+        baseFont.style = "italic";
+      }
+      elementNode.childNodes.forEach((node) => {
+        const { x, y, command } = this.generateFormattedRecursive(currentX, currentY, node, baseFont, baseFeatures);
+        currentX = x;
+        currentY = y;
+        commands.push(command);
+      });
+      return {
+        x: currentX,
+        y: currentY,
+        command: this.context.generator.commandGroup(commands)
+      };
+    }
+  }
+  /**
+   * Generate commands for plain text
+   * @param config 
+   * @returns 
+   */
+  generatePlainTextCore(content, initialX, initialY, font, features = []) {
+    if (!this.context)
+      throw "context-not-set";
+    const textWidhtFunction = this.textWithFunction;
+    let fullWidth = textWidhtFunction(content, font);
+    if (this.width) {
+      const initialPadding = initialX - this.x;
+      let rowWidth = this.width - initialPadding;
+      if (rowWidth <= 0) {
+        rowWidth = this.width;
+        initialX = this.x;
+        initialY += font.size + this.lineSpacing;
+      }
+      if (initialX == this.x) {
+        content = content.trimStart();
+        fullWidth = textWidhtFunction(content, font);
+      }
+      if (fullWidth <= rowWidth) {
+        return {
+          x: initialX + fullWidth,
+          y: initialY,
+          command: this.textCommand(content, initialX, initialY, font, features)
+        };
+      } else {
+        const commands = [];
+        let x = initialX;
+        let y = initialY;
+        let remainingContent = content;
+        let remainingWidth = fullWidth;
+        let currentHeight = 0;
+        let finalX = x;
+        let finalY = y;
+        do {
+          if (remainingWidth < rowWidth) {
+            finalX = x + remainingWidth;
+            finalY = y;
+            commands.push(this.textCommand(remainingContent, x, y, font, features));
+            remainingContent = "";
+          } else {
+            let rows = remainingWidth / rowWidth;
+            rowWidth = this.width;
+            let rowEndIndex = Math.floor(remainingContent.length / rows);
+            let originalRowEndIndex = rowEndIndex;
+            if (rowEndIndex == 0) {
+              x = this.x;
+              y += font.size + this.lineSpacing;
+              continue;
+            }
+            while (!(!isWhitespace(remainingContent.charAt(rowEndIndex)) && (rowEndIndex == remainingContent.length - 1 || isWhitespace(remainingContent.charAt(rowEndIndex + 1)))) && rowEndIndex > 0) {
+              rowEndIndex--;
+            }
+            let nextRowStartIndex = rowEndIndex + 1;
+            if (rowEndIndex == 0) {
+              rowEndIndex = originalRowEndIndex;
+              nextRowStartIndex = originalRowEndIndex + 1;
+            } else {
+              while (isWhitespace(remainingContent.charAt(nextRowStartIndex)) && nextRowStartIndex < remainingContent.length) {
+                nextRowStartIndex++;
+              }
+            }
+            const thisRow = remainingContent.substring(0, rowEndIndex + 1);
+            commands.push(this.textCommand(thisRow, x, y, font, features));
+            if (nextRowStartIndex == remainingContent.length) {
+              finalX = x + remainingWidth;
+              finalY = y;
+            }
+            x = this.x;
+            y += font.size + this.lineSpacing;
+            currentHeight = y - this.y;
+            remainingContent = remainingContent.substring(nextRowStartIndex);
+            remainingWidth = textWidhtFunction(remainingContent, font);
+          }
+        } while (
+          // We don't have a height constraint or we are still within bounds 
+          // and there is still content 
+          // and we are supporting multiline
+          (this.height == void 0 || currentHeight + font.size <= this.height) && remainingContent != "" && this.type == "multiline"
+        );
+        return {
+          x: finalX,
+          y: finalY,
+          command: this.context.generator.commandGroup(commands)
+        };
+      }
+    } else {
+      return {
+        x: initialX + fullWidth,
+        y: initialY,
+        command: this.textCommand(content, initialX, initialY, font, features)
+      };
+    }
+  }
+  textCommand(text, x, y, font, features) {
+    var _a, _b;
+    if (!this.context)
+      throw "no-context";
+    const finalFontSize = dotToPoint(font.size, (_b = (_a = this.context.config) == null ? void 0 : _a.dpi) != null ? _b : 203);
+    const finalFont = this.getFontName(font);
+    const finalX = Math.round(x);
+    const finalY = Math.round(y);
+    let commands = [];
+    const textCommand = this.context.generator.text(text, finalX, finalY, finalFont, finalFontSize);
+    if (features.length == 0) {
+      return textCommand;
+    } else {
+      let lineHeight = font.size * 0.1;
+      let textWidth = this.textWithFunction(text, font);
+      if (features.includes("strike")) {
+        commands.push(this.textLineCommand(textWidth, x, y, lineHeight, 0.5, font.size));
+      }
+      if (features.includes("underline")) {
+        commands.push(this.textLineCommand(textWidth, x, y, lineHeight, 0.9, font.size));
+      }
+      commands.push(textCommand);
+    }
+    return this.context.generator.commandGroup(commands);
+  }
+  textLineCommand(width, x, y, lineHeight, linePercentage, fontSize) {
+    const sy = Math.round(y + fontSize * linePercentage - lineHeight / 2);
+    const sx = Math.round(x);
+    return this.context.generator.line(
+      { x: sx, y: sy },
+      { x: sx + width, y: sy },
+      lineHeight
+    );
+  }
+  getFontName(font) {
+    var _a;
+    if (!this.context)
+      throw "no-context";
+    if (font.name == "default") {
+      return "default";
+    } else {
+      return (_a = this.context.config) == null ? void 0 : _a.getFontName(font);
+    }
+  }
+  get textWithFunction() {
+    var _a, _b, _c;
+    if (this.font.name == "default") {
+      return this.defaultTextWidth;
+    } else {
+      return (_c = (_b = (_a = this.context) == null ? void 0 : _a.config) == null ? void 0 : _b.textWidth) != null ? _c : this.defaultTextWidth;
+    }
+  }
+  /**
+   * This function is used to calculate the font size if no
+   * print config is provided. This will asume that the font has square characters
+   */
+  defaultTextWidth(text, font) {
+    return text.length * font.size;
+  }
+};
+
+// src/labels/fields/BarCode.ts
+var BarCode = class extends LabelField {
+  constructor(content, x, y, type, height) {
+    super();
+    this.content = content;
+    this.x = x;
+    this.y = y;
+    this.type = type;
+    this.height = height;
+    this.rotation = 0;
+    this.humanReadable = "none";
+    this.alignment = "left";
+  }
+  setRotation(rotation) {
+    this.rotation = rotation;
+  }
+  setHumanReadable(humanReadable) {
+    this.humanReadable = humanReadable;
+  }
+  commandForLanguage(language, _config) {
+    return __async(this, null, function* () {
+      return yield this.commandGeneratorFor(language).barCode(this.content, this.x, this.y, this.type, this.height, this.rotation, this.humanReadable, this.alignment);
+    });
+  }
+};
+
+// src/labels/fields/Image.ts
+var Image = class _Image extends LabelField {
+  constructor(x, y, image) {
+    super();
+    this.x = x;
+    this.y = y;
+    this.image = image;
+  }
+  commandForLanguage(language, _config) {
+    return __async(this, null, function* () {
+      return yield this.commandGeneratorFor(language).image(this.image, this.x, this.y);
+    });
+  }
+  /**
+   * Create an image field for an image
+   * @param image 
+   * @param x 
+   * @param y 
+   * @param width 
+   * @param height 
+   * @returns 
+   */
+  static create(image, x, y, width, height) {
+    return __async(this, null, function* () {
+      const bitmap = yield ImageUtils.getBWBitmap(image, width, height);
+      return new _Image(x, y, bitmap);
+    });
+  }
+};
+
+// src/labels/fields/QRCode.ts
+var QRCode = class extends LabelField {
+  constructor(content, x, y, width) {
+    super();
+    this.content = content;
+    this.x = x;
+    this.y = y;
+    this.width = width;
+  }
+  commandForLanguage(language, config) {
+    return __async(this, null, function* () {
+      return yield this.commandGeneratorFor(language).qrCode(this.content, this.width, this.x, this.y);
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   commands,
+  labels,
   printers
 });
 //# sourceMappingURL=index.js.map