@bobfrankston/brother-label 1.0.1

package/api.ts

@@ -0,0 +1,488 @@
+/**
+ * Brother Label Printer API
+ * Programmatic interface for printing labels on Brother P-touch printers
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { renderHtmlFile, renderHtmlString, closeBrowser } from "./render.js";
+import { Jimp, loadFont, measureText, measureTextHeight } from "jimp";
+import { spawn } from "child_process";
+import QRCode from "qrcode";
+
+// Types
+export type TapeSize = 6 | 9 | 12 | 18 | 24;
+export type Orientation = "landscape" | "portrait";
+
+export interface PrinterConfig {
+    defaultTape?: TapeSize;
+    defaultPrinter?: string;
+}
+
+export interface PrinterInfo {
+    name: string;
+}
+
+export interface PrintOptions {
+    // Content (exactly one required)
+    text?: string;
+    html?: string;
+    htmlPath?: string;
+    textFile?: string;
+    imagePath?: string;
+    imageBuffer?: Buffer;
+    qr?: string;                // QR code data to encode
+
+    // Settings
+    tape?: TapeSize;
+    printer?: string;
+    orientation?: Orientation;
+    length?: number;            // explicit length in mm
+    basePath?: string;          // base path for inline HTML resources
+    aspect?: string;            // width:height ratio for HTML (e.g., "3.5:2")
+    qrLabel?: string;           // optional text label beside QR code
+}
+
+export interface PrintResult {
+    image: Buffer;
+}
+
+// Constants
+const CONFIG_PATH = path.join(os.homedir(), ".brother-label.json");
+const DEFAULT_PRINTER = "Brother PT-P710BT";
+const PRINT_DPI = 300;  // High resolution for quality output
+
+// Tape sizes: height is printable area in pixels at 300 DPI
+const TAPE_SIZES: Record<TapeSize, { width: number; height: number }> = {
+    6: { width: 1137, height: 56 },     // 3.79" x 0.19" @ 300 DPI
+    9: { width: 1137, height: 84 },     // 3.79" x 0.28" @ 300 DPI
+    12: { width: 1137, height: 113 },   // 3.79" x 0.38" @ 300 DPI
+    18: { width: 1137, height: 169 },   // 3.79" x 0.56" @ 300 DPI
+    24: { width: 1137, height: 213 },   // 3.79" x 0.71" @ 300 DPI
+};
+
+// Brother CustomMediaSize names and widths in microns
+const MEDIA_OPTIONS: Record<TapeSize, { name: string; width: number }> = {
+    6: { name: "CustomMediaSize257", width: 5900 },
+    9: { name: "CustomMediaSize258", width: 9000 },
+    12: { name: "CustomMediaSize259", width: 11900 },
+    18: { name: "CustomMediaSize260", width: 18100 },
+    24: { name: "CustomMediaSize261", width: 24000 },
+};
+
+// Config functions
+export function getConfig(): PrinterConfig {
+    try {
+        if (fs.existsSync(CONFIG_PATH)) {
+            const raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+            // Handle legacy format where tape was stored as "24mm" string
+            if (typeof raw.defaultTape === "string") {
+                raw.defaultTape = parseInt(raw.defaultTape.replace("mm", ""), 10) as TapeSize;
+            }
+            return raw;
+        }
+    } catch {
+        // Ignore config errors
+    }
+    return {};
+}
+
+export function setConfig(config: Partial<PrinterConfig>): void {
+    const current = getConfig();
+    const merged = { ...current, ...config };
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
+}
+
+export function getConfigPath(): string {
+    return CONFIG_PATH;
+}
+
+// Printer listing
+export async function listPrinters(): Promise<PrinterInfo[]> {
+    return new Promise((resolve, reject) => {
+        const ps = spawn("powershell", [
+            "-Command",
+            "Get-Printer | Where-Object { $_.Name -like '*Brother*' -or $_.Name -like '*PT*' -or $_.Name -like '*QL*' } | Select-Object -ExpandProperty Name"
+        ], { stdio: "pipe" });
+
+        let stdout = "";
+        let stderr = "";
+        ps.stdout.on("data", (data) => { stdout += data.toString(); });
+        ps.stderr.on("data", (data) => { stderr += data.toString(); });
+
+        ps.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Failed to list printers: ${stderr}`));
+                return;
+            }
+            const printers = stdout.trim().split("\n")
+                .filter(p => p.trim())
+                .map(name => ({ name: name.trim() }));
+            resolve(printers);
+        });
+    });
+}
+
+// Calculate HTML viewport dimensions from tape height and optional aspect ratio
+function getHtmlDimensions(tapeHeight: number, aspect?: string): { width: number; height: number } {
+    if (!aspect) {
+        // Default: square viewport
+        return { width: tapeHeight, height: tapeHeight };
+    }
+
+    // Parse aspect ratio "width:height" or "width/height" (e.g., "3.5:2" or "3.5/2")
+    const separator = aspect.includes("/") ? "/" : ":";
+    const parts = aspect.split(separator);
+    if (parts.length !== 2) {
+        throw new Error(`Invalid aspect ratio: ${aspect}. Use format "width:height" or "width/height"`);
+    }
+    const aspectWidth = parseFloat(parts[0]);
+    const aspectHeight = parseFloat(parts[1]);
+    if (isNaN(aspectWidth) || isNaN(aspectHeight) || aspectHeight === 0) {
+        throw new Error(`Invalid aspect ratio: ${aspect}. Use format "width:height" (e.g., "3.5:2")`);
+    }
+
+    // Scale so height fits tape, width is proportional
+    const height = tapeHeight;
+    const width = Math.round(tapeHeight * (aspectWidth / aspectHeight));
+    return { width, height };
+}
+
+// Validation
+function validateOptions(options: PrintOptions): void {
+    const contentFields = [
+        options.text,
+        options.html,
+        options.htmlPath,
+        options.textFile,
+        options.imagePath,
+        options.imageBuffer,
+        options.qr,
+    ].filter(f => f !== undefined);
+
+    if (contentFields.length === 0) {
+        throw new Error("No content provided. Specify one of: text, html, htmlPath, textFile, imagePath, imageBuffer, qr");
+    }
+    if (contentFields.length > 1) {
+        throw new Error("Multiple content options provided. Specify exactly one.");
+    }
+
+    if (options.tape !== undefined && !TAPE_SIZES[options.tape]) {
+        throw new Error(`Invalid tape size: ${options.tape}. Valid sizes: 6, 9, 12, 18, 24`);
+    }
+}
+
+// Resolve effective settings from options + config + defaults
+function resolveSettings(options: PrintOptions): { tape: TapeSize; printer: string } {
+    const config = getConfig();
+    return {
+        tape: options.tape ?? config.defaultTape ?? 24,
+        printer: options.printer ?? config.defaultPrinter ?? DEFAULT_PRINTER,
+    };
+}
+
+// Render text to image buffer
+async function renderText(text: string, tape: TapeSize): Promise<Buffer> {
+    const tapeSize = TAPE_SIZES[tape];
+    const targetHeight = tapeSize.height;
+    const lines = text.split("\\n").join("\n");
+
+    // Load largest font for quality
+    const fontDir = path.join(path.dirname(new URL(import.meta.url).pathname).replace(/^\/([A-Z]:)/, "$1"), "node_modules/@jimp/plugin-print/fonts/open-sans");
+    const fontPath = path.join(fontDir, "open-sans-128-black", "open-sans-128-black.fnt");
+    const font = await loadFont(fontPath);
+
+    // Measure text
+    const textWidth = measureText(font, lines);
+    const textHeight = measureTextHeight(font, lines, textWidth + 100);
+
+    // Create temp image for text
+    const padding = 10;
+    const imgWidth = textWidth + padding * 2;
+    const imgHeight = textHeight + padding * 2;
+
+    const tempImage = new Jimp({ width: imgWidth, height: imgHeight, color: 0xffffffff });
+    tempImage.print({ font, x: padding, y: padding, text: lines });
+
+    // Scale to fit tape height
+    const scale = targetHeight / imgHeight;
+    const finalWidth = Math.round(imgWidth * scale);
+    const finalHeight = Math.round(imgHeight * scale);
+    tempImage.resize({ w: finalWidth, h: finalHeight });
+
+    // Create final image with padding
+    const hPadding = Math.round(targetHeight * 0.2);
+    const outputWidth = finalWidth + hPadding * 2;
+    const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+
+    const xOffset = hPadding;
+    const yOffset = Math.round((targetHeight - finalHeight) / 2);
+    image.composite(tempImage, xOffset, yOffset);
+
+    return image.getBuffer("image/png");
+}
+
+// Render QR code to image buffer
+async function renderQr(data: string, tape: TapeSize, labelText?: string): Promise<Buffer> {
+    const tapeSize = TAPE_SIZES[tape];
+    const targetHeight = tapeSize.height;
+    const qrSize = Math.floor(targetHeight * 0.95);
+
+    // Margins in pixels at PRINT_DPI (3mm left, 4mm right)
+    const pxPerMm = PRINT_DPI / 25.4;
+    const leftMargin = Math.round(3 * pxPerMm);
+    const rightMargin = Math.round(4 * pxPerMm);
+
+    // Generate QR code at high resolution
+    const qrBuffer = await QRCode.toBuffer(data, {
+        type: "png",
+        width: qrSize,
+        margin: 0,
+        errorCorrectionLevel: "M",
+        color: { dark: "#000000", light: "#ffffff" },
+    });
+
+    const qrImage = await Jimp.read(qrBuffer);
+
+    if (!labelText) {
+        // QR only
+        const outputWidth = leftMargin + qrSize + rightMargin;
+        const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+        const yOffset = Math.floor((targetHeight - qrSize) / 2);
+        image.composite(qrImage, leftMargin, yOffset);
+        return image.getBuffer("image/png");
+    }
+
+    // QR + text label
+    const fontDir = path.join(path.dirname(new URL(import.meta.url).pathname).replace(/^\/([A-Z]:)/, "$1"), "node_modules/@jimp/plugin-print/fonts/open-sans");
+    const fontPath = path.join(fontDir, "open-sans-64-black", "open-sans-64-black.fnt");
+    const font = await loadFont(fontPath);
+
+    const textWidth = measureText(font, labelText);
+    const textHeight = measureTextHeight(font, labelText, textWidth + 50);
+
+    // Scale text to fit beside QR
+    const maxTextHeight = targetHeight * 0.8;
+    const textScale = Math.min(1, maxTextHeight / textHeight);
+    const scaledTextWidth = Math.round(textWidth * textScale);
+    const scaledTextHeight = Math.round(textHeight * textScale);
+
+    // Create text image
+    const textImg = new Jimp({ width: textWidth + 20, height: textHeight + 20, color: 0xffffffff });
+    textImg.print({ font, x: 10, y: 10, text: labelText });
+    if (textScale < 1) {
+        textImg.resize({ w: scaledTextWidth, h: scaledTextHeight });
+    }
+
+    // Compose: QR on left, text on right
+    const gap = Math.floor(targetHeight * 0.15);
+    const outputWidth = leftMargin + qrSize + gap + scaledTextWidth + rightMargin;
+    const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+
+    const qrY = Math.floor((targetHeight - qrSize) / 2);
+    image.composite(qrImage, leftMargin, qrY);
+
+    const textY = Math.floor((targetHeight - scaledTextHeight) / 2);
+    image.composite(textImg, leftMargin + qrSize + gap, textY);
+
+    return image.getBuffer("image/png");
+}
+
+// Render content to image buffer
+async function renderContent(options: PrintOptions, tape: TapeSize): Promise<Buffer> {
+    const tapeSize = TAPE_SIZES[tape];
+
+    if (options.text !== undefined) {
+        return renderText(options.text, tape);
+    }
+
+    if (options.textFile !== undefined) {
+        const text = fs.readFileSync(options.textFile, "utf-8");
+        return renderText(text, tape);
+    }
+
+    if (options.html !== undefined) {
+        const { width, height } = getHtmlDimensions(tapeSize.height, options.aspect);
+        const buffer = await renderHtmlString(options.html, { width, height }, options.basePath);
+        await closeBrowser();
+        return buffer;
+    }
+
+    if (options.htmlPath !== undefined) {
+        const { width, height } = getHtmlDimensions(tapeSize.height, options.aspect);
+        const buffer = await renderHtmlFile(options.htmlPath, { width, height });
+        await closeBrowser();
+        return buffer;
+    }
+
+    if (options.imagePath !== undefined) {
+        return fs.readFileSync(options.imagePath);
+    }
+
+    if (options.imageBuffer !== undefined) {
+        return options.imageBuffer;
+    }
+
+    if (options.qr !== undefined) {
+        return renderQr(options.qr, tape, options.qrLabel);
+    }
+
+    throw new Error("No content to render");
+}
+
+// Print single image buffer to printer
+async function printBuffer(imageBuffer: Buffer, printer: string, tape: TapeSize): Promise<void> {
+    const media = MEDIA_OPTIONS[tape];
+
+    const tempPath = path.join(os.tmpdir(), `label-${Date.now()}.png`);
+    fs.writeFileSync(tempPath, imageBuffer);
+
+    try {
+        await new Promise<void>((resolve, reject) => {
+            const psScript = `
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Printing
+Add-Type -AssemblyName ReachFramework
+Add-Type -AssemblyName PresentationCore
+
+$img = [System.Drawing.Image]::FromFile('${tempPath.replace(/\\/g, "\\\\")}')
+
+$DPI = ${PRINT_DPI}
+$MICRONS_PER_INCH = 25400
+
+$labelLengthMicrons = [int]($img.Width / $DPI * $MICRONS_PER_INCH) + 1000
+$tapeWidthMicrons = ${media.width}
+
+$imgWidthWpf = $img.Width / $DPI * 96
+$imgHeightWpf = $img.Height / $DPI * 96
+
+$ticketXml = @"
+<?xml version="1.0" encoding="UTF-8"?>
+<psf:PrintTicket xmlns:psf="http://schemas.microsoft.com/windows/2003/08/printing/printschemaframework"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" version="1"
+    xmlns:psk="http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords"
+    xmlns:ns0001="http://schemas.brother.info/mfc/printing/2006/11/printschemakeywords">
+  <psf:Feature name="psk:PageMediaSize">
+    <psf:Option name="ns0001:${media.name}">
+      <psf:ScoredProperty name="psk:MediaSizeWidth">
+        <psf:Value xsi:type="xsd:integer">${media.width}</psf:Value>
+      </psf:ScoredProperty>
+      <psf:ScoredProperty name="psk:MediaSizeHeight">
+        <psf:ParameterRef name="psk:PageMediaSizeMediaSizeHeight" />
+      </psf:ScoredProperty>
+    </psf:Option>
+  </psf:Feature>
+  <psf:ParameterInit name="psk:PageMediaSizeMediaSizeHeight">
+    <psf:Value xsi:type="xsd:integer">$labelLengthMicrons</psf:Value>
+  </psf:ParameterInit>
+  <psf:Feature name="psk:PageOrientation">
+    <psf:Option name="psk:Landscape" />
+  </psf:Feature>
+  <psf:Feature name="ns0001:PageRollFeedToEndOfSheet">
+    <psf:Option name="ns0001:FeedToImageEdge" />
+  </psf:Feature>
+  <psf:Feature name="psk:PageMediaType">
+    <psf:Option name="psk:Label" />
+  </psf:Feature>
+  <psf:Feature name="psk:JobRollCutAtEndOfJob">
+    <psf:Option name="psk:CutSheetAtStandardMediaSize" />
+  </psf:Feature>
+  <psf:Feature name="ns0001:JobRollCutSheet">
+    <psf:Option name="ns0001:CutSheet">
+      <psf:ScoredProperty name="ns0001:CutSheetCount">
+        <psf:ParameterRef name="ns0001:JobCutSheetCount" />
+      </psf:ScoredProperty>
+    </psf:Option>
+  </psf:Feature>
+  <psf:ParameterInit name="ns0001:JobCutSheetCount">
+    <psf:Value xsi:type="xsd:integer">1</psf:Value>
+  </psf:ParameterInit>
+</psf:PrintTicket>
+"@
+
+$xmlBytes = [System.Text.Encoding]::UTF8.GetBytes($ticketXml)
+$memStream = New-Object System.IO.MemoryStream(,$xmlBytes)
+$ticket = New-Object System.Printing.PrintTicket($memStream)
+
+$server = New-Object System.Printing.LocalPrintServer
+$queue = $server.GetPrintQueue('${printer}')
+
+$xpsPath = [System.IO.Path]::GetTempFileName() + ".xps"
+
+$pageWidth = $labelLengthMicrons / $MICRONS_PER_INCH * 96
+$pageHeight = $tapeWidthMicrons / $MICRONS_PER_INCH * 96
+
+$package = [System.IO.Packaging.Package]::Open($xpsPath, [System.IO.FileMode]::Create)
+$xpsDoc = New-Object System.Windows.Xps.Packaging.XpsDocument($package)
+$writer = [System.Windows.Xps.Packaging.XpsDocument]::CreateXpsDocumentWriter($xpsDoc)
+
+$visual = New-Object System.Windows.Media.DrawingVisual
+$dc = $visual.RenderOpen()
+
+$bitmapImg = New-Object System.Windows.Media.Imaging.BitmapImage
+$bitmapImg.BeginInit()
+$bitmapImg.UriSource = New-Object System.Uri('${tempPath.replace(/\\/g, "\\\\")}')
+$bitmapImg.EndInit()
+
+$yOffset = ($pageHeight - $imgHeightWpf) / 2
+$rect = New-Object System.Windows.Rect(0, $yOffset, $imgWidthWpf, $imgHeightWpf)
+$dc.DrawImage($bitmapImg, $rect)
+$dc.Close()
+
+$writer.Write($visual, $ticket)
+
+$xpsDoc.Close()
+$package.Close()
+$img.Dispose()
+
+$xpsDocForPrint = New-Object System.Windows.Xps.Packaging.XpsDocument($xpsPath, [System.IO.FileAccess]::Read)
+$seq = $xpsDocForPrint.GetFixedDocumentSequence()
+
+$xpsWriter = [System.Printing.PrintQueue]::CreateXpsDocumentWriter($queue)
+$xpsWriter.Write($seq, $ticket)
+
+$xpsDocForPrint.Close()
+Remove-Item $xpsPath -ErrorAction SilentlyContinue
+`;
+
+            const ps = spawn("powershell", ["-Command", psScript], { stdio: "pipe" });
+
+            let stdout = "";
+            let stderr = "";
+            ps.stdout.on("data", (data) => { stdout += data.toString(); });
+            ps.stderr.on("data", (data) => { stderr += data.toString(); });
+
+            ps.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`Print failed: ${stderr}`));
+                }
+            });
+
+            ps.on("error", (err) => {
+                reject(new Error(`Failed to print: ${err.message}`));
+            });
+        });
+    } finally {
+        if (fs.existsSync(tempPath)) {
+            fs.unlinkSync(tempPath);
+        }
+    }
+}
+
+// Main API functions
+export async function render(options: PrintOptions): Promise<Buffer> {
+    validateOptions(options);
+    const { tape } = resolveSettings(options);
+    return renderContent(options, tape);
+}
+
+export async function print(options: PrintOptions): Promise<PrintResult> {
+    validateOptions(options);
+    const { tape, printer } = resolveSettings(options);
+    const image = await renderContent(options, tape);
+    await printBuffer(image, printer, tape);
+    return { image };
+}

package/brother-print.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=brother-print.d.ts.map

package/brother-print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brother-print.d.ts","sourceRoot":"","sources":["brother-print.ts"],"names":[],"mappings":""}