label-printer 0.2.0

package/README.md

@@ -0,0 +1,38 @@
+# Label Print
+
+This package provides a js based implementation for variouse languages used for label printers
+
+## Layers
+
+The packages is logacally divided into multiple sub layers. These are not separate modules per say, but separated parts of the code that serve different purposes
+
+### 1. Command Layer
+
+This layer provides a low lever wrapper for the different languages commands. Using this module, you can create commands that suite your needs the best or you can integrate this pacakge in your codebase
+
+#### TODO
+
+- Finish implementing basic commands
+- Add example code
+
+### 2. Label layer
+
+This layer provides a language independent API to construct a label (object representation) without any knowledge of the fine details of the printer the label will be printed on.
+
+#### TODO
+
+- Add example code
+- Implement layer
+
+### 3. Printer layer
+
+This layer contains code to interact with printers
+
+#### TODO
+
+- Add example code
+- Implement layer
+
+## Documentation of supported languages
+
+- [TSPL](documentations/TSPL.pdf)

package/dist/index.d.mts

@@ -0,0 +1,457 @@
+/**
+ * Convenience wrapper for a web usb device
+ * Its main purpose is to hide the details of the usb library from client code so in case
+ * it needs to be switched, compatibility can be retained
+ */
+declare class UsbDevice {
+    private readonly device;
+    get opened(): boolean;
+    /**
+     * All available endpoints
+     */
+    private get endpoints();
+    /**
+     * Endpoint for writing
+     */
+    private get outEndpoint();
+    /**
+     * Endpoint for reading
+     */
+    private get inEndpoint();
+    constructor(device: USBDevice);
+    /**
+     * Open the device and claim its interface
+     */
+    openAndConfigure(): Promise<void>;
+    /**
+     * Closes the device
+     */
+    close(): Promise<void>;
+    /**
+     * Write data to an USB device
+     * @param data Data to write
+     */
+    writeData(data: Uint8Array): Promise<void>;
+    /**
+     * Writes a text to a device
+     * @param text Text to write
+     */
+    writeString(text: string): Promise<void>;
+    /**
+     * Reads bytes from the usb device
+     * @param length The max length of the incoming data.
+     * @returns Bytes received as a DataView or undefined. If data is longer then `length`, undefined will be returned
+     */
+    readData(length: number): Promise<DataView | undefined>;
+    /**
+     * Reads data from the usb device and converts it to string
+     * {@see readData}
+     */
+    readString(length: number): Promise<string | undefined>;
+}
+
+/**
+ * Base implementation for all types of command
+ * Represents a command to be send to the printer to execute, such as print
+ */
+declare abstract class Command {
+    /**
+     * Returns a string representation of the command
+     */
+    abstract get commandString(): string;
+    /**
+     * Write the command data to a USB device
+     * @param device Device to write to
+     */
+    write(device: UsbDevice): Promise<void>;
+    /**
+     * Byte representation of a newline
+     */
+    protected get commandTerminatorBytes(): Uint8Array;
+    /**
+     * Writes a string to a device
+     * @param data String representation of data
+     * @param device Device to write to
+     */
+    protected writeString(data: string, device: UsbDevice): Promise<void>;
+    /**
+     * Writes bytes to a device. It will automatically end a command with @see{commandTerminatorBytes}
+     * @param data Byte array to send
+     * @param device Device to write to
+     */
+    protected writeBytes(data: Uint8Array, device: UsbDevice): Promise<void>;
+    /**
+     * Write the command terminator to the device
+     * @param device
+     */
+    protected terminateCommand(device: UsbDevice): Promise<void>;
+}
+
+/**
+ * A utility class that helps groupping commands together
+ * Should be implemnted with a specific command type to ensure only commands for the same lagnuage are
+ * groupped together
+ */
+declare abstract class CommandGroup<T extends Command> extends Command {
+    private commands;
+    constructor(commands: T[]);
+    write(device: UsbDevice): Promise<void>;
+    get commandString(): string;
+}
+
+/**
+ * Base for TSPL specific commands
+ */
+declare abstract class TSPLCommand extends Command {
+}
+
+/**
+ * A raw TSPL command. Can be used to use a command that is not yet supported
+ */
+declare class TSPLRawCommand extends TSPLCommand {
+    /**
+     * Raw command string
+     */
+    private readonly commandBody;
+    /**
+     * Initialize a command with a raw body
+     * @param body
+     */
+    constructor(body: string);
+    get commandString(): string;
+}
+
+/**
+ * Command group for tspl commands
+ */
+declare class TSPLCommandGroup extends CommandGroup<TSPLCommand> {
+}
+
+/**
+ * Base for all TSPL commands that have a visual effect on the final label
+ */
+declare abstract class TSPLVisualCommand extends TSPLCommand {
+    protected readonly x: number;
+    protected readonly y: number;
+    constructor(x: number, y: number);
+}
+
+/**
+ * Helper type to transmit black and white bitmap data
+ */
+type BWBitmap = {
+    width: number;
+    height: number;
+    bytes: Uint8Array;
+};
+
+type Rotation = 0 | 90 | 180 | 270;
+type Alignment = undefined | "left" | "center" | "right";
+/**
+ * Convert an alignemnt string to its number value
+ * @param alignment
+ * @returns
+ */
+declare const alignmentToNumber: (alignment: Alignment) => 0 | 1 | 2 | 3;
+/**
+ * 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
+ */
+type GraphicMode = "overwrite" | "or" | "xor";
+type UnitSystem = "imperial" | "metric" | "dot";
+type ECCLevel = "L" | "M" | "Q" | "H";
+type AutoManual = "A" | "M";
+type QRModel = "M1" | "M2";
+type BarcodeType = "CODE128" | "EAN13" | "EAN8" | "EAN5" | "EAN2" | "UPC" | "CODE39" | "ITF14" | "MSI10" | "MSI11" | "MSI1010" | "MSI1110" | "pharmacode" | "codabar";
+type BarcodeHumanReable = "none" | "left" | "right" | "center";
+
+/**
+ * Represents a bitmap command. Can be used to draw an image to the label
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLBitmapCommand extends TSPLVisualCommand {
+    /**
+     * Bitmap to present.
+     * TSPL only supports black and write printing so this bitmap contains a matrix of 1 (White pixel)
+     * and 0 (Black pixel) values
+     */
+    private readonly bitmap;
+    private readonly mode;
+    /**
+     *
+     * @param bitmap Bitmap to present.
+     * @param x X coordinates in dots
+     * @param y Y Coordinates in dots
+     * @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: BWBitmap, x: number, y: number, mode?: GraphicMode);
+    get commandString(): string;
+    private get commandWithoutBytes();
+    private get modeValue();
+    write(device: UsbDevice): Promise<void>;
+}
+
+/**
+ * Prints a single line text on the label
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLTextCommand extends TSPLVisualCommand {
+    /**
+     * Name of the font to use. Consult documentation for more info
+     */
+    protected readonly font: string;
+    /**
+     * Angle of rotation of the text. 0, 90, 180 or 270
+     */
+    protected readonly rotatation: Rotation;
+    /**
+     * Multiplication of the font size in x axis
+     */
+    protected readonly xMultiplication: number;
+    /**
+     * Multiplication of the font size in y axis
+     */
+    protected readonly yMultiplication: number;
+    /**
+     * Text alignment. Left, Center or Right. The default alignmnet is left
+     */
+    protected readonly alignment: number;
+    /**
+     * Text to print
+     */
+    protected readonly content: string;
+    constructor(content: string, x: number, y: number, font: string, rotation?: Rotation, xMultiplication?: number, yMultiplication?: number, alignment?: Alignment);
+    get commandString(): string;
+}
+
+/**
+ * Defines the gap between two labels
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLGapCommand extends TSPLCommand {
+    private readonly gap;
+    private readonly offset;
+    /**
+     * This controls what unit the {@link width} and {@link height} will be
+     * - For imperial, the unit is inches
+     * - For metric, the unit is milimeters
+     * - For dots, the unit is dots
+     */
+    private readonly unitSystem;
+    constructor(gap: number, offset: number, unitSystem: UnitSystem);
+    get commandString(): string;
+    private valueWithUnit;
+}
+
+/**
+ * Defines the size of the label to rpint
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLSizeCommand extends TSPLCommand {
+    private readonly width;
+    private readonly height;
+    /**
+     * This controls what unit the {@link width} and {@link height} will be
+     * - For imperial, the unit is inches
+     * - For metric, the unit is milimeters
+     * - For dots, the unit is dots
+     */
+    private readonly unitSystem;
+    constructor(width: number, height: number, unitSystem: UnitSystem);
+    get commandString(): string;
+    private valueWithUnit;
+}
+
+/**
+ * Clear the image buffer
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLCLSCommand extends TSPLCommand {
+    get commandString(): string;
+}
+
+/**
+ * This command defines in which direction will the label be printed and wether or not to mirror the image
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLDirectionCommand extends TSPLCommand {
+    private readonly direction;
+    private readonly mirror;
+    /**
+     * @param direction Controls the orientation of the resulting label compared to the printer
+     * @param mirror Controls mirroring relative to the center line of the label perpendicular to the printhead. See the documentsion for examples
+     */
+    constructor(direction: "normal" | "inverse", mirror?: boolean);
+    get commandString(): string;
+}
+
+/**
+ * Prints the current image buffer
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLPrintCommand extends TSPLCommand {
+    /**
+     * The number of set to print.
+     */
+    private readonly sets;
+    /**
+     * The number of copies to print of each set.
+     * The difference between a set and a copy is that if you have a counter for example,
+     * the counter will be incremented for each set but not for each copy
+     */
+    private readonly copies;
+    constructor(sets: number, copies?: number);
+    get commandString(): string;
+}
+
+/**
+ * Draws a black bar
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLBarCommand extends TSPLVisualCommand {
+    private readonly width;
+    private readonly height;
+    /**
+     * @param x X coordinates in dots
+     * @param y  Y coordinates in dots
+     * @param width Width of tha bar in dots
+     * @param height Height of the bar in dots
+     */
+    constructor(x: number, y: number, width: number, height: number);
+    get commandString(): string;
+}
+
+/**
+ * Prints a QR code
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLQRCommand extends TSPLVisualCommand {
+    private readonly ecc;
+    private readonly cellWidth;
+    private readonly mode;
+    private readonly rotation;
+    private readonly model;
+    /**
+     * Should be between 0 and 7
+     */
+    private readonly mask;
+    private readonly content;
+    constructor(content: string, x: number, y: number, cellWidth: number, ecc?: ECCLevel, mode?: AutoManual, rotation?: Rotation, model?: QRModel, mask?: number);
+    get commandString(): string;
+}
+
+declare class TSPLBlockCommand extends TSPLTextCommand {
+    private readonly width;
+    private readonly height;
+    private readonly lineSpacing;
+    constructor(content: string, x: number, y: number, width: number, height: number, font: string, rotation?: Rotation, xMultiplication?: number, yMultiplication?: number, lineSpacing?: number, alignment?: Alignment);
+    get commandString(): string;
+}
+
+type index$2_Alignment = Alignment;
+type index$2_AutoManual = AutoManual;
+type index$2_BarcodeHumanReable = BarcodeHumanReable;
+type index$2_BarcodeType = BarcodeType;
+type index$2_ECCLevel = ECCLevel;
+type index$2_GraphicMode = GraphicMode;
+type index$2_QRModel = QRModel;
+type index$2_Rotation = Rotation;
+type index$2_TSPLBarCommand = TSPLBarCommand;
+declare const index$2_TSPLBarCommand: typeof TSPLBarCommand;
+type index$2_TSPLBitmapCommand = TSPLBitmapCommand;
+declare const index$2_TSPLBitmapCommand: typeof TSPLBitmapCommand;
+type index$2_TSPLBlockCommand = TSPLBlockCommand;
+declare const index$2_TSPLBlockCommand: typeof TSPLBlockCommand;
+type index$2_TSPLCLSCommand = TSPLCLSCommand;
+declare const index$2_TSPLCLSCommand: typeof TSPLCLSCommand;
+type index$2_TSPLCommand = TSPLCommand;
+declare const index$2_TSPLCommand: typeof TSPLCommand;
+type index$2_TSPLCommandGroup = TSPLCommandGroup;
+declare const index$2_TSPLCommandGroup: typeof TSPLCommandGroup;
+type index$2_TSPLDirectionCommand = TSPLDirectionCommand;
+declare const index$2_TSPLDirectionCommand: typeof TSPLDirectionCommand;
+type index$2_TSPLGapCommand = TSPLGapCommand;
+declare const index$2_TSPLGapCommand: typeof TSPLGapCommand;
+type index$2_TSPLPrintCommand = TSPLPrintCommand;
+declare const index$2_TSPLPrintCommand: typeof TSPLPrintCommand;
+type index$2_TSPLQRCommand = TSPLQRCommand;
+declare const index$2_TSPLQRCommand: typeof TSPLQRCommand;
+type index$2_TSPLRawCommand = TSPLRawCommand;
+declare const index$2_TSPLRawCommand: typeof TSPLRawCommand;
+type index$2_TSPLSizeCommand = TSPLSizeCommand;
+declare const index$2_TSPLSizeCommand: typeof TSPLSizeCommand;
+type index$2_TSPLTextCommand = TSPLTextCommand;
+declare const index$2_TSPLTextCommand: typeof TSPLTextCommand;
+type index$2_TSPLVisualCommand = TSPLVisualCommand;
+declare const index$2_TSPLVisualCommand: typeof TSPLVisualCommand;
+type index$2_UnitSystem = UnitSystem;
+declare const index$2_alignmentToNumber: typeof alignmentToNumber;
+declare namespace index$2 {
+  export { type index$2_Alignment as Alignment, type index$2_AutoManual as AutoManual, type index$2_BarcodeHumanReable as BarcodeHumanReable, type index$2_BarcodeType as BarcodeType, type index$2_ECCLevel as ECCLevel, type index$2_GraphicMode as GraphicMode, type index$2_QRModel as QRModel, type index$2_Rotation as Rotation, index$2_TSPLBarCommand as TSPLBarCommand, index$2_TSPLBitmapCommand as TSPLBitmapCommand, index$2_TSPLBlockCommand as TSPLBlockCommand, index$2_TSPLCLSCommand as TSPLCLSCommand, index$2_TSPLCommand as TSPLCommand, index$2_TSPLCommandGroup as TSPLCommandGroup, index$2_TSPLDirectionCommand as TSPLDirectionCommand, index$2_TSPLGapCommand as TSPLGapCommand, index$2_TSPLPrintCommand as TSPLPrintCommand, index$2_TSPLQRCommand as TSPLQRCommand, index$2_TSPLRawCommand as TSPLRawCommand, index$2_TSPLSizeCommand as TSPLSizeCommand, index$2_TSPLTextCommand as TSPLTextCommand, index$2_TSPLVisualCommand as TSPLVisualCommand, type index$2_UnitSystem as UnitSystem, index$2_alignmentToNumber as alignmentToNumber };
+}
+
+type PrinterLanguage = "tspl";
+
+type index$1_Command = Command;
+declare const index$1_Command: typeof Command;
+type index$1_CommandGroup<T extends Command> = CommandGroup<T>;
+declare const index$1_CommandGroup: typeof CommandGroup;
+type index$1_PrinterLanguage = PrinterLanguage;
+declare namespace index$1 {
+  export { index$1_Command as Command, index$1_CommandGroup as CommandGroup, type index$1_PrinterLanguage as PrinterLanguage, index$2 as tspl };
+}
+
+/**
+ * Base class that encapsulates functionality of all printers
+ */
+declare abstract class Printer {
+    private readonly usbDevice;
+    /**
+     * Printer language used by the type of printer the subclass represents
+     */
+    abstract get language(): PrinterLanguage;
+    /**
+     * When called, it will feed the labels to the beginig of the next label
+     */
+    abstract feedLabel(): Promise<void>;
+    constructor(device: UsbDevice);
+    /**
+     * Close the printer USB
+     */
+    close(): Promise<void>;
+    /**
+     * Writes a command to the printers usb
+     * @param command Command to send to the usb
+     */
+    protected writeCommand(command: Command): Promise<void>;
+    /**
+     * Check if the device is indeed a printer
+     * @param device
+     */
+    static try(_device: UsbDevice): Promise<boolean>;
+}
+
+declare class PrinterService {
+    /**
+     * Try each type of printer and return the one that mathces the usb device
+     * @param device
+     * @returns
+     */
+    static printerForDevice(device: UsbDevice): Promise<Printer | undefined>;
+    /**
+     * @returns List of available printers
+     */
+    static getPrinters(): Promise<Printer[]>;
+}
+
+type index_Printer = Printer;
+declare const index_Printer: typeof Printer;
+type index_PrinterService = PrinterService;
+declare const index_PrinterService: typeof PrinterService;
+declare namespace index {
+  export { index_Printer as Printer, index_PrinterService as PrinterService };
+}
+
+export { index$1 as commands, index as printers };