jc-printer-sdk-ts 0.1.0

package/src/transport.ts

@@ -0,0 +1,526 @@
+import type {
+  BitmapLike,
+  BundleLike,
+  IAtBitmapDocument,
+  MaybePromise,
+  PaperInfo,
+  PrintCallback,
+  PrintDocument,
+  PrinterDevice,
+  PrinterInfo,
+  PrinterSdkCallback,
+  PrinterState,
+  ScanCallback,
+} from "./types.js";
+
+type PrintEventState = {
+  callback: PrintCallback | undefined;
+  jobStarted: boolean;
+};
+
+export interface PrinterTransport {
+  getSdkVersion?(): MaybePromise<string>;
+  init?(application: unknown): MaybePromise<boolean>;
+  initSdk?(application: unknown): MaybePromise<boolean>;
+  setSdkCallback?(callback?: PrinterSdkCallback): void;
+  initDefaultImageLibrarySettings?(
+    fontDirectory: string,
+    extra: string,
+  ): MaybePromise<number>;
+  initImageProcessingDefault?(
+    fontDirectory: string,
+    extra: string,
+  ): MaybePromise<number>;
+  openPrinterByAddress?(address: string): MaybePromise<number>;
+  openPrinterSync?(address: string): MaybePromise<number>;
+  connectBluetoothPrinter?(address: string): MaybePromise<number>;
+  connectWifiPrinter?(host: string, port: number): MaybePromise<number>;
+  configurationWifi?(ssid: string, password: string): MaybePromise<number>;
+  getConfigurationWifiName?(): MaybePromise<string>;
+  scanWifiPrinter?(callback: ScanCallback): MaybePromise<void>;
+  setPrinterAutoShutdownTime?(minutes: number): MaybePromise<number>;
+  setTotalPrintQuantity?(quantity: number): MaybePromise<void>;
+  setTotalQuantityOfPrints?(quantity: number): MaybePromise<void>;
+  startPrintJob?(
+    density: number,
+    paperType: number,
+    printMode: number,
+    callback: PrintCallback,
+  ): MaybePromise<void>;
+  commitData?(jsonPages: string[], infoPages: string[]): MaybePromise<void>;
+  commitDocument?(
+    document: PrintDocument,
+    infoPages: string[],
+  ): MaybePromise<void>;
+  endJob?(): MaybePromise<boolean>;
+  endPrintJob?(): MaybePromise<boolean>;
+  cancelJob?(): MaybePromise<boolean>;
+  cancel?(): MaybePromise<void>;
+  reopenPrinter?(): MaybePromise<boolean>;
+  reopenPrinterSync?(): MaybePromise<boolean>;
+  close?(): MaybePromise<void>;
+  quit?(): MaybePromise<void>;
+  printBitmap?(bitmap: BitmapLike, bundle?: BundleLike): MaybePromise<boolean>;
+  printATBitmap?(
+    bitmap: IAtBitmapDocument,
+    bundle?: BundleLike,
+  ): MaybePromise<boolean>;
+  getPaperInfo?(): MaybePromise<PaperInfo | null>;
+  isConnection?(): MaybePromise<number>;
+  getPrintScaleMultiplier?(): MaybePromise<number>;
+  getPrinterName?(): MaybePromise<string>;
+  getPrinterInfo?(): MaybePromise<PrinterInfo | null>;
+  getPrinterState?(): MaybePromise<PrinterState>;
+  waitPrinterState?(
+    state: PrinterState,
+    timeoutMs: number,
+  ): MaybePromise<boolean>;
+  measureFontHeight?(
+    text: string,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    rotation: number,
+    fontSize: number,
+  ): MaybePromise<number>;
+  generatePreviewImage?(json: string, info: string): MaybePromise<BitmapLike>;
+  generatePrintPreviewImage?(
+    json: string,
+    widthMm: number,
+    heightMm: number,
+    orientation: number,
+  ): MaybePromise<BitmapLike>;
+
+  setPrinterState?(state: PrinterState): void;
+  setPrinterInfo?(info: PrinterInfo): void;
+  setPaperInfo?(info: PaperInfo): void;
+  setScanResults?(results: PrinterDevice[]): void;
+  emitPrintProgress?(
+    pageIndex: number,
+    quantityIndex: number,
+    meta?: Record<string, unknown>,
+  ): void;
+  emitPrintError?(errorCode: number, printState?: number): void;
+  emitBufferFree?(pageIndex: number, bufferSize: number): void;
+  emitCancel?(success: boolean): void;
+  lastDocument?: PrintDocument | undefined;
+}
+
+function clone<T>(value: T): T {
+  if (typeof globalThis.structuredClone === "function") {
+    return globalThis.structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function defaultPrinterInfo(): PrinterInfo {
+  return {
+    deviceType: 0,
+    deviceName: "",
+    deviceVersion: "",
+    softwareVersion: "",
+    deviceAddress: "",
+    deviceAddrType: 0,
+    deviceDPI: 0,
+    deviceWidth: 0,
+    manufacturer: "",
+    seriesName: "",
+    devIntName: "",
+    peripheralFlags: 0,
+    hardwareFlags: 0,
+    softwareFlags: 0,
+  };
+}
+
+function defaultPaperInfo(): PaperInfo {
+  return {
+    state: 0,
+    gapHeightPixel: 0,
+    totalHeightPixel: 0,
+    paperType: 0,
+    gapHeight: 0,
+    totalHeight: 0,
+    paperWidthPixel: 0,
+    paperWidth: 0,
+    direction: 0,
+    tailLengthPixel: 0,
+    tailLength: 0,
+  };
+}
+
+function dimensionsFromInfo(info: string): Pick<BitmapLike, "width" | "height"> {
+  try {
+    const parsed = JSON.parse(info) as {
+      printerImageProcessingInfo?: { width?: unknown; height?: unknown };
+    };
+    const imageInfo = parsed.printerImageProcessingInfo;
+    const width = Number(imageInfo?.width ?? 0);
+    const height = Number(imageInfo?.height ?? 0);
+    return {
+      width: Number.isFinite(width) ? width : 0,
+      height: Number.isFinite(height) ? height : 0,
+    };
+  } catch {
+    return { width: 0, height: 0 };
+  }
+}
+
+export class MemoryPrinterTransport implements PrinterTransport {
+  private sdkVersion = "ts-mock";
+  private configurationWifiName = "";
+  private printerInfo: PrinterInfo = defaultPrinterInfo();
+  private paperInfo: PaperInfo = defaultPaperInfo();
+  private printerState: PrinterState = "Disconnected";
+  private printerName = "";
+  private connectedAddress = "";
+  private connectedType = -1;
+  private lastConnectedAddress = "";
+  private lastConnectedType = -1;
+  private sdkCallback: PrinterSdkCallback | undefined;
+  private connectionResult = 0;
+  private wifiConfigurationResult = 0;
+  private shutdownResult = 0;
+  private scanResults: PrinterDevice[] = [];
+  private printState: PrintEventState = { callback: undefined, jobStarted: false };
+  private totalPrintQuantity = 0;
+  lastDocument: PrintDocument | undefined;
+  lastBitmap?: BitmapLike;
+  lastAtBitmap?: IAtBitmapDocument;
+  lastCommitPayload: { jsonPages: string[]; infoPages: string[] } | undefined;
+  lastPreview: BitmapLike | undefined;
+
+  getSdkVersion(): string {
+    return this.sdkVersion;
+  }
+
+  setSdkVersion(version: string): void {
+    this.sdkVersion = version;
+  }
+
+  initSdk(): boolean {
+    return true;
+  }
+
+  init(): boolean {
+    return true;
+  }
+
+  setSdkCallback(callback?: PrinterSdkCallback): void {
+    this.sdkCallback = callback;
+    if (callback && this.printerState !== "Disconnected" && this.connectedAddress) {
+      callback.onConnectSuccess(this.connectedAddress, this.connectedType);
+    }
+  }
+
+  initDefaultImageLibrarySettings(): number {
+    return 0;
+  }
+
+  initImageProcessingDefault(): number {
+    return 0;
+  }
+
+  private syncPrinterInfo(address: string, type: number): void {
+    this.printerInfo = {
+      ...this.printerInfo,
+      deviceName: address,
+      deviceAddress: address,
+      deviceAddrType: type,
+    };
+  }
+
+  openPrinterByAddress(address: string): number {
+    if (this.connectionResult === 0) {
+      this.connectedAddress = address;
+      this.connectedType = 0;
+      this.lastConnectedAddress = address;
+      this.lastConnectedType = this.connectedType;
+      this.printerName = address;
+      this.syncPrinterInfo(address, this.connectedType);
+      this.printerState = "Connected";
+      this.sdkCallback?.onConnectSuccess(address, this.connectedType);
+    }
+    return this.connectionResult;
+  }
+
+  openPrinterSync(address: string): number {
+    return this.openPrinterByAddress(address);
+  }
+
+  connectBluetoothPrinter(address: string): number {
+    if (this.connectionResult === 0) {
+      this.connectedAddress = address;
+      this.connectedType = 0;
+      this.lastConnectedAddress = address;
+      this.lastConnectedType = this.connectedType;
+      this.printerName = address;
+      this.syncPrinterInfo(address, this.connectedType);
+      this.printerState = "Connected";
+      this.sdkCallback?.onConnectSuccess(address, this.connectedType);
+    }
+    return this.connectionResult;
+  }
+
+  connectWifiPrinter(host: string, _port: number): number {
+    if (this.connectionResult === 0) {
+      this.connectedAddress = host;
+      this.connectedType = 1;
+      this.lastConnectedAddress = host;
+      this.lastConnectedType = this.connectedType;
+      this.printerName = host;
+      this.syncPrinterInfo(host, this.connectedType);
+      this.printerState = "Connected";
+      this.sdkCallback?.onConnectSuccess(host, this.connectedType);
+    }
+    return this.connectionResult;
+  }
+
+  configurationWifi(ssid: string, _password: string): number {
+    this.configurationWifiName = ssid;
+    return this.wifiConfigurationResult;
+  }
+
+  getConfigurationWifiName(): string {
+    return this.configurationWifiName;
+  }
+
+  scanWifiPrinter(callback: ScanCallback): void {
+    for (const device of this.scanResults) {
+      callback.onScan(clone(device));
+    }
+    callback.onFinish();
+  }
+
+  setPrinterAutoShutdownTime(minutes: number): number {
+    this.shutdownResult = minutes >= 0 ? 0 : -1;
+    return this.shutdownResult;
+  }
+
+  setTotalPrintQuantity(quantity: number): void {
+    this.totalPrintQuantity = quantity;
+  }
+
+  setTotalQuantityOfPrints(quantity: number): void {
+    this.totalPrintQuantity = quantity;
+  }
+
+  startPrintJob(
+    _density: number,
+    _paperType: number,
+    _printMode: number,
+    callback: PrintCallback,
+  ): void {
+    this.printState = { callback, jobStarted: true };
+    if (this.connectedAddress) {
+      this.printerState = "Printing";
+    }
+    this.lastDocument = undefined;
+    this.lastCommitPayload = undefined;
+    this.lastPreview = undefined;
+  }
+
+  commitData(jsonPages: string[], infoPages: string[]): void {
+    this.lastCommitPayload = {
+      jsonPages: clone(jsonPages),
+      infoPages: clone(infoPages),
+    };
+  }
+
+  commitDocument(document: PrintDocument, infoPages: string[]): void {
+    this.lastDocument = clone(document);
+    this.lastCommitPayload = {
+      jsonPages: document.pages.map((page) => JSON.stringify(page)),
+      infoPages: clone(infoPages),
+    };
+  }
+
+  endJob(): boolean {
+    this.printState.jobStarted = false;
+    this.printState.callback = undefined;
+    this.printerState = this.connectedAddress ? "Connected" : "Disconnected";
+    return true;
+  }
+
+  endPrintJob(): boolean {
+    this.printState.jobStarted = false;
+    this.printState.callback = undefined;
+    this.printerState = this.connectedAddress ? "Connected" : "Disconnected";
+    return true;
+  }
+
+  cancelJob(): boolean {
+    this.printState.jobStarted = false;
+    this.printState.callback?.onCancelJob(true);
+    this.printState.callback = undefined;
+    this.printerState = this.connectedAddress ? "Connected" : "Disconnected";
+    return true;
+  }
+
+  cancel(): void {
+    this.cancelJob();
+  }
+
+  close(): void {
+    const wasConnected = this.printerState !== "Disconnected";
+    this.printState.jobStarted = false;
+    this.printState.callback = undefined;
+    this.printerState = "Disconnected";
+    this.connectedAddress = "";
+    this.connectedType = -1;
+    this.printerName = "";
+    if (wasConnected) {
+      this.sdkCallback?.onDisConnect();
+    }
+  }
+
+  quit(): void {
+    this.close();
+  }
+
+  reopenPrinter(): boolean {
+    if (!this.lastConnectedAddress) {
+      return false;
+    }
+    this.connectedAddress = this.lastConnectedAddress;
+    this.connectedType = this.lastConnectedType;
+    this.printerName = this.connectedAddress;
+    this.syncPrinterInfo(this.connectedAddress, this.connectedType);
+    this.printerState = "Connected";
+    this.sdkCallback?.onConnectSuccess(this.connectedAddress, this.connectedType);
+    return true;
+  }
+
+  reopenPrinterSync(): boolean {
+    return this.reopenPrinter();
+  }
+
+  printBitmap(bitmap: BitmapLike): boolean {
+    this.lastBitmap = clone(bitmap);
+    return true;
+  }
+
+  printATBitmap(bitmap: IAtBitmapDocument): boolean {
+    this.lastAtBitmap = clone(bitmap);
+    return true;
+  }
+
+  getPaperInfo(): PaperInfo {
+    return clone(this.paperInfo);
+  }
+
+  isConnection(): number {
+    return this.printerState === "Disconnected" ? -1 : 0;
+  }
+
+  getPrintScaleMultiplier(): number {
+    return 1;
+  }
+
+  getPrinterName(): string {
+    return this.printerName;
+  }
+
+  getPrinterInfo(): PrinterInfo {
+    return clone(this.printerInfo);
+  }
+
+  getPrinterState(): PrinterState {
+    return this.printerState;
+  }
+
+  waitPrinterState(state: PrinterState): boolean {
+    return this.printerState === state;
+  }
+
+  measureFontHeight(
+    text: string,
+    _x: number,
+    _y: number,
+    _width: number,
+    _height: number,
+    _rotation: number,
+    fontSize: number,
+  ): number {
+    const lines = text.split(/\r?\n/).length;
+    return Math.max(fontSize, Math.ceil(fontSize * 1.2 * lines));
+  }
+
+  generatePreviewImage(json: string, info: string): BitmapLike {
+    const { width, height } = dimensionsFromInfo(info);
+    this.lastPreview = {
+      width,
+      height,
+      description: "preview",
+      meta: { json, info },
+    };
+    return clone(this.lastPreview);
+  }
+
+  generatePrintPreviewImage(
+    json: string,
+    widthMm: number,
+    heightMm: number,
+    orientation: number,
+  ): BitmapLike {
+    this.lastPreview = {
+      width: widthMm,
+      height: heightMm,
+      description: "print-preview",
+      meta: { json, orientation },
+    };
+    return clone(this.lastPreview);
+  }
+
+  setPrinterState(state: PrinterState): void {
+    this.printerState = state;
+  }
+
+  setPrinterInfo(info: PrinterInfo): void {
+    this.printerInfo = clone(info);
+  }
+
+  setPaperInfo(info: PaperInfo): void {
+    this.paperInfo = clone(info);
+  }
+
+  setScanResults(results: PrinterDevice[]): void {
+    this.scanResults = clone(results);
+  }
+
+  emitPrintProgress(
+    pageIndex: number,
+    quantityIndex: number,
+    meta: Record<string, unknown> = {},
+  ): void {
+    this.printState.callback?.onProgress(pageIndex, quantityIndex, meta);
+  }
+
+  emitPrintError(errorCode: number, printState = 0): void {
+    this.printState.callback?.onError(errorCode, printState);
+  }
+
+  emitBufferFree(pageIndex: number, bufferSize: number): void {
+    this.printState.callback?.onBufferFree(pageIndex, bufferSize);
+  }
+
+  emitCancel(success: boolean): void {
+    this.printState.callback?.onCancelJob(success);
+  }
+
+  setConnectionResult(result: number): void {
+    this.connectionResult = result;
+  }
+
+  setWifiConfigurationResult(result: number): void {
+    this.wifiConfigurationResult = result;
+  }
+
+  setShutdownResult(result: number): void {
+    this.shutdownResult = result;
+  }
+}
+
+export function createMemoryPrinterTransport(): MemoryPrinterTransport {
+  return new MemoryPrinterTransport();
+}