jc-printer-sdk-ts 0.1.0

package/src/client.ts

@@ -0,0 +1,588 @@
+import { AddressType, AddressTypeCode } from "./constants.js";
+import {
+  createAtBitmapDocument,
+  createLabelBuilder,
+  LabelBuilder,
+} from "./builder.js";
+import type {
+  BitmapLike,
+  BluetoothDeviceLike,
+  BundleLike,
+  IAtBitmapDocument,
+  LabelBarcodeOptions,
+  LabelGraphOptions,
+  LabelImageOptions,
+  LabelLineOptions,
+  LabelQrCodeOptions,
+  LabelTextOptions,
+  MaybePromise,
+  PaperInfo,
+  PrintCallback,
+  PrintDocument,
+  PrinterSdkCallback,
+  PrinterAddress,
+  PrinterInfo,
+  PrinterState,
+  Point,
+  ScanCallback,
+} from "./types.js";
+import type { PrinterTransport } from "./transport.js";
+import { createMemoryPrinterTransport } from "./transport.js";
+
+function clone<T>(value: T): T {
+  if (typeof globalThis.structuredClone === "function") {
+    return globalThis.structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function isPromise<T>(value: MaybePromise<T>): value is Promise<T> {
+  return !!value && typeof (value as Promise<T>).then === "function";
+}
+
+function resolveBoolean(result: MaybePromise<boolean | void> | undefined): MaybePromise<boolean> {
+  if (isPromise(result)) {
+    return result.then((value) => (typeof value === "boolean" ? value : true));
+  }
+  return typeof result === "boolean" ? result : true;
+}
+
+function toPrinterAddress(device: BluetoothDeviceLike): PrinterAddress {
+  return {
+    macAddress: device.address,
+    addressType: inferAddressType(device.type),
+    shownName: device.name ?? device.address,
+  };
+}
+
+export function inferAddressType(code?: number): AddressType {
+  if (typeof code !== "number") {
+    return AddressType.SPP;
+  }
+  switch (code) {
+    case 2:
+    case AddressTypeCode.BLE:
+      return AddressType.BLE;
+    case 3:
+    case AddressTypeCode.DUAL:
+      return AddressType.DUAL;
+    case 1:
+    case AddressTypeCode.SPP:
+      return AddressType.SPP;
+    case AddressTypeCode.WiFi:
+      return AddressType.WiFi;
+    default:
+      return AddressType.SPP;
+  }
+}
+
+export function encodeAddressType(type: AddressType | undefined): number {
+  switch (type) {
+    case AddressType.BLE:
+      return AddressTypeCode.BLE;
+    case AddressType.DUAL:
+      return AddressTypeCode.DUAL;
+    case AddressType.WiFi:
+      return AddressTypeCode.WiFi;
+    default:
+      return AddressTypeCode.SPP;
+  }
+}
+
+export function isBluetoothAddressType(type: AddressType | undefined): boolean {
+  return type === AddressType.SPP || type === AddressType.BLE || type === AddressType.DUAL;
+}
+
+export function createPrinterAddress(
+  macAddress: string,
+  addressType: AddressType = AddressType.SPP,
+  shownName = macAddress,
+): PrinterAddress {
+  return { macAddress, addressType, shownName };
+}
+
+export function createPrinterAddressFromDevice(
+  device: BluetoothDeviceLike,
+): PrinterAddress {
+  return toPrinterAddress(device);
+}
+
+export function printerStateGroup(state: PrinterState): number {
+  switch (state) {
+    case "Connecting":
+      return 1;
+    case "Disconnected":
+      return 0;
+    default:
+      return 2;
+  }
+}
+
+function buildCommitInfoPayload(document: PrintDocument): string[] {
+  return document.pages.map((page) =>
+    JSON.stringify({
+      printerImageProcessingInfo: {
+        orientation: page.orientation,
+        margin: [0, 0, 0, 0],
+        printQuantity: page.printQuantity || document.job.totalQuantity || 1,
+        horizontalOffset: 0,
+        verticalOffset: 0,
+        width: page.width,
+        height: page.height,
+        printMultiple: document.job.printMultiple ?? 1,
+        epc: document.job.epc ?? "",
+      },
+    }),
+  );
+}
+
+export class PrinterClient {
+  readonly transport: PrinterTransport;
+  readonly builder: LabelBuilder;
+
+  private lastPrintCallback: PrintCallback | undefined;
+  private sdkCallback: PrinterSdkCallback | undefined;
+  private currentDocument: PrintDocument | null = null;
+  private currentAtBitmap: IAtBitmapDocument | null = null;
+  private pendingApplication: unknown;
+
+  constructor(
+    transport: PrinterTransport = createMemoryPrinterTransport(),
+    sdkCallback?: PrinterSdkCallback,
+  ) {
+    this.transport = transport;
+    this.builder = createLabelBuilder("mm");
+    if (sdkCallback) {
+      this.setSdkCallback(sdkCallback);
+    }
+  }
+
+  getSdkVersion(): MaybePromise<string> {
+    return this.transport.getSdkVersion?.() ?? "ts";
+  }
+
+  init(application: unknown): MaybePromise<boolean> {
+    return this.initSdk(application);
+  }
+
+  initSdk(application: unknown): MaybePromise<boolean> {
+    this.pendingApplication = application;
+    return this.transport.initSdk?.(application) ?? this.transport.init?.(application) ?? true;
+  }
+
+  setSdkCallback(callback?: PrinterSdkCallback): void {
+    this.sdkCallback = callback;
+    this.transport.setSdkCallback?.(callback);
+  }
+
+  getSdkCallback(): PrinterSdkCallback | undefined {
+    return this.sdkCallback;
+  }
+
+  initDefaultImageLibrarySettings(
+    fontDirectory: string,
+    extra = "",
+  ): MaybePromise<number> {
+    return this.transport.initDefaultImageLibrarySettings?.(fontDirectory, extra) ?? 0;
+  }
+
+  initImageProcessingDefault(
+    fontDirectory: string,
+    extra = "",
+  ): MaybePromise<number> {
+    return this.transport.initImageProcessingDefault?.(fontDirectory, extra) ?? 0;
+  }
+
+  openPrinterByAddress(address: string): MaybePromise<number> {
+    return this.transport.openPrinterByAddress?.(address) ?? this.transport.connectBluetoothPrinter?.(address) ?? 0;
+  }
+
+  openPrinterSync(address: string): MaybePromise<number> {
+    return this.transport.openPrinterSync?.(address) ?? this.openPrinterByAddress(address);
+  }
+
+  connectBluetoothPrinter(address: string): MaybePromise<number> {
+    return this.transport.connectBluetoothPrinter?.(address) ?? this.transport.openPrinterByAddress?.(address) ?? 0;
+  }
+
+  connectWifiPrinter(host: string, port: number): MaybePromise<number> {
+    return this.transport.connectWifiPrinter?.(host, port) ?? 0;
+  }
+
+  configurationWifi(ssid: string, password: string): MaybePromise<number> {
+    return this.transport.configurationWifi?.(ssid, password) ?? 0;
+  }
+
+  getConfigurationWifiName(): MaybePromise<string> {
+    return this.transport.getConfigurationWifiName?.() ?? "";
+  }
+
+  scanWifiPrinter(callback: ScanCallback): MaybePromise<void> {
+    return this.transport.scanWifiPrinter?.(callback);
+  }
+
+  setPrinterAutoShutdownTime(minutes: number): MaybePromise<number> {
+    return this.transport.setPrinterAutoShutdownTime?.(minutes) ?? 0;
+  }
+
+  setTotalPrintQuantity(quantity: number): MaybePromise<void> {
+    this.builder.setTotalPrintQuantity(quantity);
+    return this.transport.setTotalPrintQuantity?.(quantity);
+  }
+
+  setTotalQuantityOfPrints(quantity: number): MaybePromise<void> {
+    this.builder.setTotalQuantityOfPrints(quantity);
+    return this.transport.setTotalQuantityOfPrints?.(quantity);
+  }
+
+  startPrintJob(
+    density: number,
+    paperType: number,
+    printMode: number,
+    callback: PrintCallback,
+  ): MaybePromise<void> {
+    this.lastPrintCallback = callback;
+    this.builder.startJob(density, paperType, printMode);
+    this.currentDocument = null;
+    return this.transport.startPrintJob?.(density, paperType, printMode, callback);
+  }
+
+  commitData(jsonPages: string[], infoPages: string[]): MaybePromise<void> {
+    this.currentDocument = clone(this.builder.toDocument());
+    return this.transport.commitData?.(jsonPages, infoPages);
+  }
+
+  commitDocument(document: PrintDocument): MaybePromise<void> {
+    const infoPages = buildCommitInfoPayload(document);
+    this.currentDocument = clone(document);
+    if (this.transport.commitDocument) {
+      return this.transport.commitDocument(document, infoPages);
+    }
+    return this.transport.commitData?.(
+      document.pages.map((page) => JSON.stringify(page)),
+      infoPages,
+    );
+  }
+
+  endJob(): MaybePromise<boolean> {
+    this.lastPrintCallback = undefined;
+    return resolveBoolean(this.transport.endJob?.());
+  }
+
+  endPrintJob(): MaybePromise<boolean> {
+    this.lastPrintCallback = undefined;
+    return resolveBoolean(this.transport.endPrintJob?.());
+  }
+
+  cancelJob(): MaybePromise<boolean> {
+    this.builder.abortJob();
+    this.currentDocument = null;
+    this.lastPrintCallback = undefined;
+    return resolveBoolean(this.transport.cancelJob?.());
+  }
+
+  cancel(): MaybePromise<void> {
+    this.builder.abortJob();
+    this.currentDocument = null;
+    this.lastPrintCallback = undefined;
+    if (this.transport.cancel) {
+      return this.transport.cancel();
+    }
+    const result = this.transport.cancelJob?.();
+    if (isPromise(result)) {
+      return result.then(() => undefined);
+    }
+    return undefined;
+  }
+
+  reopenPrinter(): MaybePromise<boolean> {
+    if (this.transport.reopenPrinter) {
+      return resolveBoolean(this.transport.reopenPrinter());
+    }
+    if (this.transport.reopenPrinterSync) {
+      return resolveBoolean(this.transport.reopenPrinterSync());
+    }
+    return false;
+  }
+
+  reopenPrinterSync(): MaybePromise<boolean> {
+    if (this.transport.reopenPrinterSync) {
+      return resolveBoolean(this.transport.reopenPrinterSync());
+    }
+    if (this.transport.reopenPrinter) {
+      return resolveBoolean(this.transport.reopenPrinter());
+    }
+    return false;
+  }
+
+  close(): MaybePromise<void> {
+    this.builder.abortJob();
+    this.currentDocument = null;
+    this.lastPrintCallback = undefined;
+    return this.transport.close?.();
+  }
+
+  quit(): MaybePromise<void> {
+    this.builder.abortJob();
+    this.currentDocument = null;
+    this.lastPrintCallback = undefined;
+    if (this.transport.quit) {
+      return this.transport.quit();
+    }
+    return this.transport.close?.();
+  }
+
+  printBitmap(bitmap: BitmapLike, bundle: BundleLike = {}): MaybePromise<boolean> {
+    return this.transport.printBitmap?.(bitmap, bundle) ?? true;
+  }
+
+  printATBitmap(
+    bitmap: IAtBitmapDocument,
+    bundle: BundleLike = {},
+  ): MaybePromise<boolean> {
+    this.currentAtBitmap = clone(bitmap);
+    return this.transport.printATBitmap?.(bitmap, bundle) ?? true;
+  }
+
+  getPaperInfo(): MaybePromise<PaperInfo | null> {
+    return this.transport.getPaperInfo?.() ?? null;
+  }
+
+  isConnection(): MaybePromise<number> {
+    return this.transport.isConnection?.() ?? -1;
+  }
+
+  getPrintScaleMultiplier(): MaybePromise<number> {
+    return this.transport.getPrintScaleMultiplier?.() ?? this.builder.getPrintMultiple();
+  }
+
+  measureFontHeight(
+    text: string,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    rotation: number,
+    fontSize: number,
+  ): MaybePromise<number> {
+    return this.transport.measureFontHeight?.(
+      text,
+      x,
+      y,
+      width,
+      height,
+      rotation,
+      fontSize,
+    ) ?? this.builder.measureFontHeight(text, x, y, width, height, rotation, fontSize);
+  }
+
+  getStrPrintSize(text: string, fontStyle: number, fontSize: number): Point {
+    return this.builder.getStrPrintSize(text, fontStyle, fontSize);
+  }
+
+  getMin1DBarcode(text: string, codeType: number): BitmapLike {
+    return this.builder.getMin1DBarcode(text, codeType);
+  }
+
+  getMin2DQRCode(text: string): BitmapLike {
+    return this.builder.getMin2DQRCode(text);
+  }
+
+  getPrinterName(): MaybePromise<string> {
+    return this.transport.getPrinterName?.() ?? "";
+  }
+
+  getPrinterInfo(): MaybePromise<PrinterInfo | null> {
+    return this.transport.getPrinterInfo?.() ?? null;
+  }
+
+  getPrinterState(): MaybePromise<PrinterState> {
+    return this.transport.getPrinterState?.() ?? "Disconnected";
+  }
+
+  waitPrinterState(state: PrinterState, timeoutMs: number): MaybePromise<boolean> {
+    return this.transport.waitPrinterState?.(state, timeoutMs) ?? false;
+  }
+
+  drawEmptyLabel(
+    width: number,
+    height: number,
+    orientation: number,
+    fonts: string | string[],
+  ): void {
+    this.builder.drawEmptyLabel(width, height, orientation, fonts);
+  }
+
+  drawLabelText(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    text: string,
+    fontName: string,
+    fontSize: number,
+    options: LabelTextOptions = {},
+  ): void {
+    this.builder.drawLabelText(x, y, width, height, text, fontName, fontSize, options);
+  }
+
+  drawLabelBarCode(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    codeType: number,
+    text: string,
+    options: LabelBarcodeOptions = {},
+  ): void {
+    this.builder.drawLabelBarCode(x, y, width, height, codeType, text, options);
+  }
+
+  drawLabelQrCode(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    text: string,
+    options: LabelQrCodeOptions = {},
+  ): void {
+    this.builder.drawLabelQrCode(x, y, width, height, text, options);
+  }
+
+  drawLabelGraph(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    graphType: number,
+    options: LabelGraphOptions = {},
+  ): void {
+    this.builder.drawLabelGraph(x, y, width, height, graphType, options);
+  }
+
+  drawLabelImage(
+    source: string | BitmapLike,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    options: LabelImageOptions = {},
+  ): void {
+    this.builder.drawLabelImage(source, x, y, width, height, options);
+  }
+
+  drawLabelLine(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    options: LabelLineOptions = {},
+  ): void {
+    this.builder.drawLabelLine(x, y, width, height, options);
+  }
+
+  generateLabelJson(): Uint8Array {
+    return this.builder.generateLabelJson();
+  }
+
+  commitImageData(
+    orientation: number,
+    bitmap: BitmapLike,
+    width: number,
+    height: number,
+    printQuantity: number,
+    marginLeft: number,
+    marginTop: number,
+    marginRight: number,
+    marginBottom: number,
+    rfid: string,
+  ): MaybePromise<void> {
+    this.builder.commitImageData(
+      orientation,
+      bitmap,
+      width,
+      height,
+      printQuantity,
+      marginLeft,
+      marginTop,
+      marginRight,
+      marginBottom,
+      rfid,
+    );
+    this.currentDocument = clone(this.builder.toDocument());
+    return undefined;
+  }
+
+  generatePreviewImage(json: string, info: string): MaybePromise<BitmapLike> {
+    const preview = this.transport.generatePreviewImage?.(json, info);
+    return preview ?? this.builder.generatePreviewImage(json, info);
+  }
+
+  static generatePrintPreviewImage(
+    json: string,
+    widthMm: number,
+    heightMm: number,
+    orientation: number,
+  ): BitmapLike {
+    return {
+      width: widthMm,
+      height: heightMm,
+      description: "print-preview",
+      meta: { json, orientation },
+    };
+  }
+
+  getMultiple(): MaybePromise<number> {
+    return this.transport.getPrintScaleMultiplier?.() ?? this.builder.getMultiple();
+  }
+
+  getDocument(): PrintDocument {
+    return this.builder.toDocument();
+  }
+
+  getLastCommittedDocument(): PrintDocument | null {
+    return this.currentDocument ? clone(this.currentDocument) : null;
+  }
+
+  getLastCommittedAtBitmap(): IAtBitmapDocument | null {
+    return this.currentAtBitmap ? clone(this.currentAtBitmap) : null;
+  }
+
+  createAtBitmapDocument(job: PrintDocument["job"] = {}): IAtBitmapDocument {
+    return createAtBitmapDocument(job);
+  }
+
+  createLabelBuilder(): LabelBuilder {
+    return createLabelBuilder("mm");
+  }
+
+  getPendingApplication(): unknown {
+    return this.pendingApplication;
+  }
+}
+
+export class JCPrintApi extends PrinterClient {
+  private static instance?: JCPrintApi;
+
+  static getInstance(
+    callback?: PrinterSdkCallback,
+    transport?: PrinterTransport,
+  ): JCPrintApi {
+    if (!JCPrintApi.instance) {
+      JCPrintApi.instance = new JCPrintApi(
+        transport ?? createMemoryPrinterTransport(),
+        callback,
+      );
+    } else if (callback) {
+      JCPrintApi.instance.setSdkCallback(callback);
+    }
+    return JCPrintApi.instance;
+  }
+}
+
+export function createPrinterClient(
+  transport: PrinterTransport = createMemoryPrinterTransport(),
+  sdkCallback?: PrinterSdkCallback,
+): PrinterClient {
+  return new PrinterClient(transport, sdkCallback);
+}