@connexup/react-native-xprinter 0.1.0

package/src/tspl/index.ts

@@ -0,0 +1,535 @@
+import {
+  type BarcodeRequest,
+  type BarRequest,
+  BitmapAlgorithmType,
+  type BitmapCompressionRequest,
+  type BitmapRequest,
+  type BoxRequest,
+  DEFAULT_BITMAP_ALGORITHM_TYPE,
+  DEFAULT_EC_LEVEL,
+  DEFAULT_NARROW,
+  DEFAULT_PRINT_STATUS_TIMEOUT,
+  DEFAULT_QR_MASK,
+  DEFAULT_QR_MODE,
+  DEFAULT_QR_MODEL,
+  DEFAULT_READABLE,
+  DEFAULT_ROTATION,
+  DEFAULT_WIDE,
+  Direction,
+  type EraseRequest,
+  NativeXPrinterTSPL,
+  type PDFBase64Request,
+  PrinterStatus,
+  type PutBMPRequest,
+  type QRCodeRequest,
+  type ReverseRequest,
+  type Spec,
+  type TextRequest,
+} from './NativeXPrinterTSPL';
+import { XPrinterPCLExecutor } from '../type';
+
+export class XPrinterTSPL
+  implements Omit<Spec, 'getConstants' | 'printerStatus'>
+{
+  private readonly module: Spec;
+
+  constructor(module: Spec) {
+    this.module = module;
+  }
+
+  sizeInch = async (connectInfo: string, width: number, height: number) => {
+    return this.module.sizeInch(connectInfo, width, height);
+  };
+
+  sizeMm = async (connectInfo: string, width: number, height: number) => {
+    return this.module.sizeMm(connectInfo, width, height);
+  };
+
+  gapInch = async (connectInfo: string, m: number, n: number) => {
+    return this.module.gapInch(connectInfo, m, n);
+  };
+
+  gapMm = async (connectInfo: string, m: number, n: number) => {
+    return this.module.gapMm(connectInfo, m, n);
+  };
+
+  speed = async (connectInfo: string, speed: number) => {
+    return this.module.speed(connectInfo, speed);
+  };
+
+  density = async (connectInfo: string, density: number) => {
+    return this.module.density(connectInfo, density);
+  };
+
+  direction = async (
+    connectInfo: string,
+    direction: Direction,
+    isMirror: boolean
+  ) => {
+    return this.module.direction(connectInfo, direction, isMirror);
+  };
+
+  cls = async (connectInfo: string) => {
+    return this.module.cls(connectInfo);
+  };
+
+  box = async (connectInfo: string, payload: BoxRequest) => {
+    return this.module.box(connectInfo, payload);
+  };
+
+  bar = async (connectInfo: string, payload: BarRequest) => {
+    return this.module.bar(connectInfo, payload);
+  };
+
+  barcode = async (
+    connectInfo: string,
+    payload: Omit<
+      BarcodeRequest,
+      'readable' | 'rotation' | 'narrow' | 'wide'
+    > & {
+      readable?: BarcodeRequest['readable'];
+      rotation?: BarcodeRequest['rotation'];
+      narrow?: BarcodeRequest['narrow'];
+      wide?: BarcodeRequest['wide'];
+    }
+  ) => {
+    return this.module.barcode(connectInfo, {
+      ...payload,
+      readable: payload.readable ?? DEFAULT_READABLE,
+      rotation: payload.rotation ?? DEFAULT_ROTATION,
+      narrow: payload.narrow ?? DEFAULT_NARROW,
+      wide: payload.wide ?? DEFAULT_WIDE,
+    });
+  };
+
+  text = async (
+    connectInfo: string,
+    payload: Omit<TextRequest, 'rotation'> & {
+      rotation?: BarcodeRequest['rotation'];
+    }
+  ) => {
+    return this.module.text(connectInfo, {
+      ...payload,
+      rotation: payload.rotation ?? DEFAULT_ROTATION,
+    });
+  };
+
+  offsetInch = async (connectInfo: string, offset: number) => {
+    return await this.module.offsetInch(connectInfo, offset);
+  };
+
+  offsetMm = async (connectInfo: string, offset: number) => {
+    return this.module.offsetMm(connectInfo, offset);
+  };
+
+  reference = async (connectInfo: string, x: number, y: number) => {
+    return this.module.reference(connectInfo, x, y);
+  };
+
+  qrcode = async (
+    connectInfo: string,
+    payload: Omit<
+      QRCodeRequest,
+      'ecLevel' | 'mode' | 'rotation' | 'model' | 'mask'
+    > & {
+      ecLevel?: QRCodeRequest['ecLevel'];
+      mode?: QRCodeRequest['mode'];
+      rotation?: QRCodeRequest['rotation'];
+      model?: QRCodeRequest['model'];
+      mask?: QRCodeRequest['mask'];
+    }
+  ) => {
+    return this.module.qrcode(connectInfo, {
+      ...payload,
+      ecLevel: payload.ecLevel ?? DEFAULT_EC_LEVEL,
+      mode: payload.mode ?? DEFAULT_QR_MODE,
+      rotation: payload.rotation ?? DEFAULT_ROTATION,
+      model: payload.model ?? DEFAULT_QR_MODEL,
+      mask: payload.mask ?? DEFAULT_QR_MASK,
+    });
+  };
+
+  print = async (connectInfo: string, count: number) => {
+    return this.module.print(connectInfo, count);
+  };
+
+  printWithResponse = async (
+    connectInfo: string,
+    count: number,
+    timeout: number
+  ) => {
+    return this.module.printWithResponse(connectInfo, count, timeout);
+  };
+
+  feed = async (connectInfo: string, length: number) => {
+    return this.module.feed(connectInfo, length);
+  };
+
+  backFeed = async (connectInfo: string, length: number) => {
+    return this.module.backFeed(connectInfo, length);
+  };
+
+  formFeed = async (connectInfo: string) => {
+    return this.module.formFeed(connectInfo);
+  };
+
+  limitFeedMm = async (connectInfo: string, length: number) => {
+    return this.module.limitFeedMm(connectInfo, length);
+  };
+
+  limitFeedInch = async (connectInfo: string, length: number) => {
+    return this.module.limitFeedInch(connectInfo, length);
+  };
+
+  home = async (connectInfo: string) => {
+    return this.module.home(connectInfo);
+  };
+
+  codePage = async (connectInfo: string, page: string) => {
+    return this.module.codePage(connectInfo, page);
+  };
+
+  sound = async (connectInfo: string, level: number, interval: number) => {
+    return this.module.sound(connectInfo, level, interval);
+  };
+
+  bitmap = async (connectInfo: string, payload: BitmapRequest) => {
+    if (!payload.algorithmType) {
+      payload.algorithmType = DEFAULT_BITMAP_ALGORITHM_TYPE;
+    }
+    return this.module.bitmap(connectInfo, payload);
+  };
+
+  bitmapCompression = async (
+    connectInfo: string,
+    payload: BitmapCompressionRequest
+  ) => {
+    if (!payload.algorithmType) {
+      payload.algorithmType = DEFAULT_BITMAP_ALGORITHM_TYPE;
+    }
+    return this.module.bitmapCompression(connectInfo, payload);
+  };
+
+  pdfBase64 = async (
+    connectInfo: string,
+    payload: Omit<PDFBase64Request, 'algorithmType'> & {
+      algorithmType?: PDFBase64Request['algorithmType'];
+    }
+  ) => {
+    return this.module.pdfBase64(connectInfo, {
+      ...payload,
+      algorithmType: payload.algorithmType ?? BitmapAlgorithmType.THRESHOLD,
+    });
+  };
+
+  erase = async (connectInfo: string, payload: EraseRequest) => {
+    return this.module.erase(connectInfo, payload);
+  };
+
+  reverse = async (connectInfo: string, payload: ReverseRequest) => {
+    return this.module.reverse(connectInfo, payload);
+  };
+
+  cut = async (connectInfo: string) => {
+    return this.module.cut(connectInfo);
+  };
+
+  setPeel = async (connectInfo: string, isOpen: boolean) => {
+    return this.module.setPeel(connectInfo, isOpen);
+  };
+
+  setTear = async (connectInfo: string, isOpen: boolean) => {
+    return this.module.setTear(connectInfo, isOpen);
+  };
+
+  setCutter = async (connectInfo: string, pieces: number) => {
+    return this.module.setCutter(connectInfo, pieces);
+  };
+
+  putBMP = async (connectInfo: string, payload: PutBMPRequest) => {
+    return this.module.putBMP(connectInfo, payload);
+  };
+
+  blineInch = async (connectInfo: string, m: number, n: number) => {
+    return this.module.blineInch(connectInfo, m, n);
+  };
+
+  blineMm = async (connectInfo: string, m: number, n: number) => {
+    return this.module.blineMm(connectInfo, m, n);
+  };
+
+  setPrinterModel = async (connectInfo: string, model: string) => {
+    return this.module.setPrinterModel(connectInfo, model);
+  };
+
+  getPrinterModel = async (connectInfo: string) => {
+    return this.module.getPrinterModel(connectInfo);
+  };
+
+  printerStatus = async (
+    connectInfo: string,
+    timeout: number = DEFAULT_PRINT_STATUS_TIMEOUT
+  ) => {
+    const { status } = await this.module.printerStatus(connectInfo, timeout);
+    let _status: PrinterStatus;
+    switch (status) {
+      case 0x00:
+        _status = PrinterStatus.PRINTER_STATUS_NORMAL;
+        break;
+      case 0x01:
+        _status = PrinterStatus.PRINTER_STATUS_COVER_OPEN;
+        break;
+      case 0x02:
+        _status = PrinterStatus.PRINTER_STATUS_PAPER_JAM;
+        break;
+      case 0x03:
+        _status = PrinterStatus.PRINTER_STATUS_PAPER_JAM_AND_COVER_OPEN;
+        break;
+      case 0x04:
+        _status = PrinterStatus.PRINTER_STATUS_OUT_OF_PAPER;
+        break;
+      case 0x05:
+        _status = PrinterStatus.PRINTER_STATUS_OUT_OF_PAPER_AND_COVER_OPEN;
+        break;
+      case 0x08:
+        _status = PrinterStatus.PRINTER_STATUS_NO_RIBBON;
+        break;
+      case 0x09:
+        _status = PrinterStatus.PRINTER_STATUS_NO_RIBBON_AND_COVER_OPEN;
+        break;
+      case 0x0a:
+        _status = PrinterStatus.PRINTER_STATUS_NO_RIBBON_AND_PAPER_JAM;
+        break;
+      case 0x0b:
+        _status =
+          PrinterStatus.PRINTER_STATUS_NO_RIBBON_AND_PAPER_JAM_AND_COVER_OPEN;
+        break;
+      case 0x0c:
+        _status = PrinterStatus.PRINTER_STATUS_NO_RIBBON_AND_OUT_OF_PAPER;
+        break;
+      case 0x0d:
+        _status =
+          PrinterStatus.PRINTER_STATUS_NO_RIBBON_AND_OUT_OF_PAPER_AND_COVER_OPEN;
+        break;
+      case 0x10:
+        _status = PrinterStatus.PRINTER_STATUS_PAUSED;
+        break;
+      case 0x20:
+        _status = PrinterStatus.PRINTER_STATUS_PRINTING;
+        break;
+      case 0x80:
+        _status = PrinterStatus.PRINTER_STATUS_OTHER_ERROR;
+        break;
+      case -1:
+        _status = PrinterStatus.PRINTER_STATUS_TIMOUT_OR_DATA_ERROR;
+        break;
+      default:
+        _status = PrinterStatus.PRINTER_STATUS_UNKNOWN;
+        break;
+    }
+    return {
+      debugCode: status,
+      status: _status,
+    };
+  };
+}
+
+export const xPrinterTSPL = new XPrinterTSPL(NativeXPrinterTSPL);
+
+export class XPrinterTSPLExecutor extends XPrinterPCLExecutor {
+  sizeInch = async (width: number, height: number) => {
+    return xPrinterTSPL.sizeInch(this.connectInfo, width, height);
+  };
+
+  sizeMm = async (width: number, height: number) => {
+    return xPrinterTSPL.sizeMm(this.connectInfo, width, height);
+  };
+
+  gapInch = async (m: number, n: number) => {
+    return xPrinterTSPL.gapInch(this.connectInfo, m, n);
+  };
+
+  gapMm = async (m: number, n: number) => {
+    return xPrinterTSPL.gapMm(this.connectInfo, m, n);
+  };
+
+  speed = async (speed: number) => {
+    return xPrinterTSPL.speed(this.connectInfo, speed);
+  };
+
+  density = async (density: number) => {
+    return xPrinterTSPL.density(this.connectInfo, density);
+  };
+
+  direction = async (direction: Direction, isMirror: boolean) => {
+    return xPrinterTSPL.direction(this.connectInfo, direction, isMirror);
+  };
+
+  cls = async () => {
+    return xPrinterTSPL.cls(this.connectInfo);
+  };
+
+  box = async (payload: BoxRequest) => {
+    return xPrinterTSPL.box(this.connectInfo, payload);
+  };
+
+  bar = async (payload: BarRequest) => {
+    return xPrinterTSPL.bar(this.connectInfo, payload);
+  };
+
+  barcode = async (
+    payload: Omit<
+      BarcodeRequest,
+      'readable' | 'rotation' | 'narrow' | 'wide'
+    > & {
+      readable?: BarcodeRequest['readable'];
+      rotation?: BarcodeRequest['rotation'];
+      narrow?: BarcodeRequest['narrow'];
+      wide?: BarcodeRequest['wide'];
+    }
+  ) => {
+    return xPrinterTSPL.barcode(this.connectInfo, payload);
+  };
+
+  text = async (
+    payload: Omit<TextRequest, 'rotation'> & {
+      rotation?: BarcodeRequest['rotation'];
+    }
+  ) => {
+    return xPrinterTSPL.text(this.connectInfo, payload);
+  };
+
+  offsetInch = async (offset: number) => {
+    return await xPrinterTSPL.offsetInch(this.connectInfo, offset);
+  };
+
+  offsetMm = async (offset: number) => {
+    return xPrinterTSPL.offsetMm(this.connectInfo, offset);
+  };
+
+  reference = async (x: number, y: number) => {
+    return xPrinterTSPL.reference(this.connectInfo, x, y);
+  };
+
+  qrcode = async (
+    payload: Omit<
+      QRCodeRequest,
+      'ecLevel' | 'mode' | 'rotation' | 'model' | 'mask'
+    > & {
+      ecLevel?: QRCodeRequest['ecLevel'];
+      mode?: QRCodeRequest['mode'];
+      rotation?: QRCodeRequest['rotation'];
+      model?: QRCodeRequest['model'];
+      mask?: QRCodeRequest['mask'];
+    }
+  ) => {
+    return xPrinterTSPL.qrcode(this.connectInfo, payload);
+  };
+
+  print = async (count: number) => {
+    return xPrinterTSPL.print(this.connectInfo, count);
+  };
+
+  printWithResponse = async (count: number, timeout: number) => {
+    return xPrinterTSPL.printWithResponse(this.connectInfo, count, timeout);
+  };
+
+  feed = async (length: number) => {
+    return xPrinterTSPL.feed(this.connectInfo, length);
+  };
+
+  backFeed = async (length: number) => {
+    return xPrinterTSPL.backFeed(this.connectInfo, length);
+  };
+
+  formFeed = async () => {
+    return xPrinterTSPL.formFeed(this.connectInfo);
+  };
+
+  limitFeedMm = async (length: number) => {
+    return xPrinterTSPL.limitFeedMm(this.connectInfo, length);
+  };
+
+  limitFeedInch = async (length: number) => {
+    return xPrinterTSPL.limitFeedInch(this.connectInfo, length);
+  };
+
+  home = async () => {
+    return xPrinterTSPL.home(this.connectInfo);
+  };
+
+  codePage = async (page: string) => {
+    return xPrinterTSPL.codePage(this.connectInfo, page);
+  };
+
+  sound = async (level: number, interval: number) => {
+    return xPrinterTSPL.sound(this.connectInfo, level, interval);
+  };
+
+  bitmap = async (payload: BitmapRequest) => {
+    return xPrinterTSPL.bitmap(this.connectInfo, payload);
+  };
+
+  bitmapCompression = async (payload: BitmapCompressionRequest) => {
+    return xPrinterTSPL.bitmapCompression(this.connectInfo, payload);
+  };
+
+  pdfBase64 = async (
+    payload: Omit<PDFBase64Request, 'algorithmType'> & {
+      algorithmType?: PDFBase64Request['algorithmType'];
+    }
+  ) => {
+    return xPrinterTSPL.pdfBase64(this.connectInfo, {
+      ...payload,
+      algorithmType: payload.algorithmType ?? BitmapAlgorithmType.THRESHOLD,
+    });
+  };
+
+  erase = async (payload: EraseRequest) => {
+    return xPrinterTSPL.erase(this.connectInfo, payload);
+  };
+
+  reverse = async (payload: ReverseRequest) => {
+    return xPrinterTSPL.reverse(this.connectInfo, payload);
+  };
+
+  cut = async () => {
+    return xPrinterTSPL.cut(this.connectInfo);
+  };
+
+  setPeel = async (isOpen: boolean) => {
+    return xPrinterTSPL.setPeel(this.connectInfo, isOpen);
+  };
+
+  setTear = async (isOpen: boolean) => {
+    return xPrinterTSPL.setTear(this.connectInfo, isOpen);
+  };
+
+  setCutter = async (pieces: number) => {
+    return xPrinterTSPL.setCutter(this.connectInfo, pieces);
+  };
+
+  putBMP = async (payload: PutBMPRequest) => {
+    return xPrinterTSPL.putBMP(this.connectInfo, payload);
+  };
+
+  blineInch = async (m: number, n: number) => {
+    return xPrinterTSPL.blineInch(this.connectInfo, m, n);
+  };
+
+  blineMm = async (m: number, n: number) => {
+    return xPrinterTSPL.blineMm(this.connectInfo, m, n);
+  };
+
+  setPrinterModel = async (model: string) => {
+    return xPrinterTSPL.setPrinterModel(this.connectInfo, model);
+  };
+
+  getPrinterModel = async () => {
+    return xPrinterTSPL.getPrinterModel(this.connectInfo);
+  };
+
+  printerStatus = async (timeout?: number) => {
+    return xPrinterTSPL.printerStatus(this.connectInfo, timeout);
+  };
+}

package/src/type.ts

@@ -0,0 +1,11 @@
+export const PARAMS_ERROR = 'PARAMS_ERROR';
+export const COMMON_ERROR = 'COMMON_ERROR';
+export const PRINTER_NOT_FOUND_ERROR = 'PRINTER_NOT_FOUND_ERROR';
+export const NOT_YET_IMPLEMENTED_ERROR = 'NOT_YET_IMPLEMENTED_ERROR';
+
+export class XPrinterPCLExecutor {
+  readonly connectInfo: string;
+  constructor(connectInfo: string) {
+    this.connectInfo = connectInfo;
+  }
+}

package/src/util.ts

@@ -0,0 +1 @@
+export const replaceImagePath = (path: string) => path.replace('file://', '');

package/src/utils/NativeXPrinterUtils.ts

@@ -0,0 +1,14 @@
+import { type TurboModule, TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  isPureWhiteImage: (payload: CheckIsPureWhiteImageRequest) => Promise<boolean>;
+}
+
+export const NativeXPrinterUtils = TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeXPrinterUtils'
+);
+
+export interface CheckIsPureWhiteImageRequest {
+  bitmapPath: string | null;
+  bitmapContent: string | null;
+}

package/src/utils/index.ts

@@ -0,0 +1,27 @@
+import {
+  type CheckIsPureWhiteImageRequest,
+  NativeXPrinterUtils,
+  type Spec,
+} from './NativeXPrinterUtils';
+import { replaceImagePath } from '../util';
+
+class XPrinterUtils implements Omit<Spec, 'getConstants'> {
+  private readonly module: Spec;
+
+  constructor(module: Spec) {
+    this.module = module;
+  }
+
+  async isPureWhiteImage(
+    payload: CheckIsPureWhiteImageRequest
+  ): Promise<boolean> {
+    return await this.module.isPureWhiteImage({
+      ...payload,
+      bitmapPath: payload.bitmapPath
+        ? replaceImagePath(payload.bitmapPath)
+        : null,
+    });
+  }
+}
+
+export const xPrinterUtils = new XPrinterUtils(NativeXPrinterUtils);