@connexup/react-native-xprinter 0.1.0

package/src/esc/index.ts

@@ -0,0 +1,489 @@
+import {
+  Alignment,
+  BMPModel,
+  BMPType,
+  CharSet,
+  CutModel,
+  DEFAULT_LINE_COUNT,
+  DEFAULT_TEXT_ALIGNMENT,
+  DEFAULT_TEXT_ATTRIBUTE,
+  Direction,
+  FontType,
+  InternationCharacterSet,
+  NativeXPrinterESC,
+  type PrintBarCodeRequest,
+  type PrintBitmapRequest,
+  PrinterCheckType,
+  type PrintPDF417Request,
+  type PrintQRCodeRequest,
+  type PrintTableRequest,
+  type PrintTextRequest,
+  type PrintTextSizeRequest,
+  type SelectBitmapModelRequest,
+  type SetNetAllRequest,
+  type SetPrintAreaRequest,
+  type SetTextStyleRequest,
+  type Spec,
+  TextAttribute,
+  type WifiConfigRequest,
+} from './NativeXPrinterESC';
+import { replaceImagePath } from '../util';
+import { XPrinterPCLExecutor } from '../type';
+
+export class XPrinterESC
+  implements Omit<Spec, 'getConstants' | 'downloadNVImage'>
+{
+  private readonly module: Spec;
+
+  constructor(module: Spec) {
+    this.module = module;
+  }
+  setCharSet = async (connectInfo: string, charSet: CharSet) => {
+    return this.module.setCharSet(connectInfo, charSet);
+  };
+
+  selectInternationCharacterSets = async (
+    connectInfo: string,
+    n: InternationCharacterSet
+  ) => {
+    return this.module.selectInternationCharacterSets(connectInfo, n);
+  };
+
+  isConnect = async (connectInfo: string) => {
+    return this.module.isConnect(connectInfo);
+  };
+
+  initializePrinter = async (connectInfo: string) => {
+    return this.module.initializePrinter(connectInfo);
+  };
+
+  printString = async (connectInfo: string, data: string) => {
+    return this.module.printString(connectInfo, data);
+  };
+
+  printTextSize = async (
+    connectInfo: string,
+    payload: PrintTextSizeRequest
+  ) => {
+    return this.module.printTextSize(connectInfo, payload);
+  };
+
+  printTextAttribute = async (
+    connectInfo: string,
+    data: string,
+    attribute: TextAttribute = DEFAULT_TEXT_ATTRIBUTE
+  ) => {
+    return this.module.printTextAttribute(connectInfo, data, attribute);
+  };
+
+  printTextAlignment = async (
+    connectInfo: string,
+    data: string,
+    alignment: Alignment = DEFAULT_TEXT_ALIGNMENT
+  ) => {
+    return this.module.printTextAlignment(connectInfo, data, alignment);
+  };
+
+  printText = async (connectInfo: string, payload: PrintTextRequest) => {
+    return this.module.printText(connectInfo, payload);
+  };
+
+  printBitmap = async (connectInfo: string, payload: PrintBitmapRequest) => {
+    if (!payload.type) {
+      payload.type = BMPType.DITHERING;
+    }
+    if (payload.bitmapPath) {
+      payload.bitmapPath = replaceImagePath(payload.bitmapPath);
+    }
+    return this.module.printBitmap(connectInfo, payload);
+  };
+
+  compressionPrintBitmap = async (
+    connectInfo: string,
+    payload: PrintBitmapRequest
+  ) => {
+    if (!payload.type) {
+      payload.type = BMPType.DITHERING;
+    }
+    if (payload.bitmapPath) {
+      payload.bitmapPath = replaceImagePath(payload.bitmapPath);
+    }
+    return this.module.compressionPrintBitmap(connectInfo, payload);
+  };
+
+  printBarCode = async (connectInfo: string, payload: PrintBarCodeRequest) => {
+    return this.module.printBarCode(connectInfo, payload);
+  };
+
+  lineFeed = async (
+    connectInfo: string,
+    lineCount: number = DEFAULT_LINE_COUNT
+  ) => {
+    return this.module.lineFeed(connectInfo, lineCount);
+  };
+
+  feedDot = async (connectInfo: string, dotCount: number) => {
+    return this.module.feedDot(connectInfo, dotCount);
+  };
+
+  printerCheck = async (
+    connectInfo: string,
+    type: PrinterCheckType,
+    timeout: number
+  ) => {
+    return this.module.printerCheck(connectInfo, type, timeout);
+  };
+
+  printerStatus = async (connectInfo: string) => {
+    return this.module.printerStatus(connectInfo);
+  };
+
+  //only android
+  printerStatusII = async (connectInfo: string) => {
+    return this.module.printerStatusII(connectInfo);
+  };
+
+  printQRCode = async (connectInfo: string, payload: PrintQRCodeRequest) => {
+    return this.module.printQRCode(connectInfo, payload);
+  };
+
+  cutPaper = async (connectInfo: string, model: CutModel) => {
+    return this.module.cutPaper(connectInfo, model);
+  };
+
+  cutHalfAndFeed = async (connectInfo: string, distance: number) => {
+    return this.module.cutHalfAndFeed(connectInfo, distance);
+  };
+
+  setPrintArea = async (connectInfo: string, payload: SetPrintAreaRequest) => {
+    return this.module.setPrintArea(connectInfo, payload);
+  };
+
+  setPageModel = async (connectInfo: string, isOpen: boolean) => {
+    return this.module.setPageModel(connectInfo, isOpen);
+  };
+
+  printPageModelData = async (connectInfo: string) => {
+    return this.module.printPageModelData(connectInfo);
+  };
+
+  setPrintDirection = async (connectInfo: string, direction: Direction) => {
+    return this.module.setPrintDirection(connectInfo, direction);
+  };
+
+  setAbsoluteHorizontal = async (connectInfo: string, position: number) => {
+    return this.module.setAbsoluteHorizontal(connectInfo, position);
+  };
+
+  setRelativeHorizontal = async (connectInfo: string, position: number) => {
+    return this.module.setRelativeHorizontal(connectInfo, position);
+  };
+
+  setAbsoluteVertical = async (connectInfo: string, position: number) => {
+    return this.module.setAbsoluteVertical(connectInfo, position);
+  };
+
+  setRelativeVertical = async (connectInfo: string, position: number) => {
+    return this.module.setRelativeVertical(connectInfo, position);
+  };
+
+  setTextStyle = async (connectInfo: string, payload: SetTextStyleRequest) => {
+    return this.module.setTextStyle(connectInfo, payload);
+  };
+
+  setAlignment = async (connectInfo: string, alignment: Alignment) => {
+    return this.module.setAlignment(connectInfo, alignment);
+  };
+
+  downloadNVImage = async (
+    connectInfo: string,
+    imagePaths: string[],
+    imageWidth: number
+  ) => {
+    return this.module.downloadNVImage(
+      connectInfo,
+      imagePaths.map((path) => replaceImagePath(path)).join(','),
+      imageWidth
+    );
+  };
+
+  clearNVImage = async (connectInfo: string) => {
+    return this.module.clearNVImage(connectInfo);
+  };
+
+  printNVImage = async (
+    connectInfo: string,
+    index: number,
+    model: BMPModel
+  ) => {
+    return this.module.printNVImage(connectInfo, index, model);
+  };
+
+  selectBitmapModel = async (
+    connectInfo: string,
+    payload: SelectBitmapModelRequest
+  ) => {
+    return this.module.selectBitmapModel(connectInfo, payload);
+  };
+
+  setLineSpacing = async (connectInfo: string, space: number) => {
+    return this.module.setLineSpacing(connectInfo, space);
+  };
+
+  setTurnUpsideDownMode = async (connectInfo: string, on: boolean) => {
+    return this.module.setTurnUpsideDownMode(connectInfo, on);
+  };
+
+  selectCodePage = async (connectInfo: string, page: number) => {
+    return this.module.selectCodePage(connectInfo, page);
+  };
+
+  selectCharacterFont = async (connectInfo: string, font: FontType) => {
+    return this.module.selectCharacterFont(connectInfo, font);
+  };
+
+  printPDF417 = async (connectInfo: string, payload: PrintPDF417Request) => {
+    return this.module.printPDF417(connectInfo, payload);
+  };
+
+  printTable = async (connectInfo: string, payload: PrintTableRequest) => {
+    return this.module.printTable(connectInfo, payload);
+  };
+
+  wifiConfig = async (connectInfo: string, payload: WifiConfigRequest) => {
+    return this.module.wifiConfig(connectInfo, payload);
+  };
+
+  setIp = async (connectInfo: string, ip: string) => {
+    return this.module.setIp(connectInfo, ip);
+  };
+
+  setMask = async (connectInfo: string, mask: string) => {
+    return this.module.setMask(connectInfo, mask);
+  };
+
+  setGateway = async (connectInfo: string, gateway: string) => {
+    return this.module.setGateway(connectInfo, gateway);
+  };
+
+  setNetAll = async (connectInfo: string, payload: SetNetAllRequest) => {
+    return this.module.setNetAll(connectInfo, payload);
+  };
+
+  setBluetooth = async (connectInfo: string, name: string, pin: string) => {
+    return this.module.setBluetooth(connectInfo, name, pin);
+  };
+
+  getSerialNumber = async (connectInfo: string) => {
+    return this.module.getSerialNumber(connectInfo);
+  };
+}
+
+export const xPrinterESC = new XPrinterESC(NativeXPrinterESC);
+
+export class XPrinterESCExecutor extends XPrinterPCLExecutor {
+  setCharSet = async (charSet: CharSet) => {
+    return xPrinterESC.setCharSet(this.connectInfo, charSet);
+  };
+
+  selectInternationCharacterSets = async (n: InternationCharacterSet) => {
+    return xPrinterESC.selectInternationCharacterSets(this.connectInfo, n);
+  };
+
+  isConnect = async () => {
+    return xPrinterESC.isConnect(this.connectInfo);
+  };
+
+  initializePrinter = async () => {
+    return xPrinterESC.initializePrinter(this.connectInfo);
+  };
+
+  printString = async (data: string) => {
+    return xPrinterESC.printString(this.connectInfo, data);
+  };
+
+  printTextSize = async (payload: PrintTextSizeRequest) => {
+    return xPrinterESC.printTextSize(this.connectInfo, payload);
+  };
+
+  printTextAttribute = async (data: string, attribute?: TextAttribute) => {
+    return xPrinterESC.printTextAttribute(this.connectInfo, data, attribute);
+  };
+
+  printTextAlignment = async (data: string, alignment?: Alignment) => {
+    return xPrinterESC.printTextAlignment(this.connectInfo, data, alignment);
+  };
+
+  printText = async (payload: PrintTextRequest) => {
+    return xPrinterESC.printText(this.connectInfo, payload);
+  };
+
+  printBitmap = async (payload: PrintBitmapRequest) => {
+    if (!payload.type) {
+      payload.type = BMPType.DITHERING;
+    }
+    if (payload.bitmapPath) {
+      payload.bitmapPath = replaceImagePath(payload.bitmapPath);
+    }
+    return xPrinterESC.printBitmap(this.connectInfo, payload);
+  };
+
+  compressionPrintBitmap = async (payload: PrintBitmapRequest) => {
+    if (!payload.type) {
+      payload.type = BMPType.DITHERING;
+    }
+    if (payload.bitmapPath) {
+      payload.bitmapPath = replaceImagePath(payload.bitmapPath);
+    }
+    return xPrinterESC.compressionPrintBitmap(this.connectInfo, payload);
+  };
+
+  printBarCode = async (payload: PrintBarCodeRequest) => {
+    return xPrinterESC.printBarCode(this.connectInfo, payload);
+  };
+
+  lineFeed = async (lineCount?: number) => {
+    return xPrinterESC.lineFeed(this.connectInfo, lineCount);
+  };
+
+  feedDot = async (dotCount: number) => {
+    return xPrinterESC.feedDot(this.connectInfo, dotCount);
+  };
+
+  printerCheck = async (type: PrinterCheckType, timeout: number) => {
+    return xPrinterESC.printerCheck(this.connectInfo, type, timeout);
+  };
+
+  printerStatus = async () => {
+    return xPrinterESC.printerStatus(this.connectInfo);
+  };
+
+  //only android
+  printerStatusII = async () => {
+    return xPrinterESC.printerStatusII(this.connectInfo);
+  };
+
+  printQRCode = async (payload: PrintQRCodeRequest) => {
+    return xPrinterESC.printQRCode(this.connectInfo, payload);
+  };
+
+  cutPaper = async (model: CutModel) => {
+    return xPrinterESC.cutPaper(this.connectInfo, model);
+  };
+
+  cutHalfAndFeed = async (distance: number) => {
+    return xPrinterESC.cutHalfAndFeed(this.connectInfo, distance);
+  };
+
+  setPrintArea = async (payload: SetPrintAreaRequest) => {
+    return xPrinterESC.setPrintArea(this.connectInfo, payload);
+  };
+
+  setPageModel = async (isOpen: boolean) => {
+    return xPrinterESC.setPageModel(this.connectInfo, isOpen);
+  };
+
+  printPageModelData = async () => {
+    return xPrinterESC.printPageModelData(this.connectInfo);
+  };
+
+  setPrintDirection = async (direction: Direction) => {
+    return xPrinterESC.setPrintDirection(this.connectInfo, direction);
+  };
+
+  setAbsoluteHorizontal = async (position: number) => {
+    return xPrinterESC.setAbsoluteHorizontal(this.connectInfo, position);
+  };
+
+  setRelativeHorizontal = async (position: number) => {
+    return xPrinterESC.setRelativeHorizontal(this.connectInfo, position);
+  };
+
+  setAbsoluteVertical = async (position: number) => {
+    return xPrinterESC.setAbsoluteVertical(this.connectInfo, position);
+  };
+
+  setRelativeVertical = async (position: number) => {
+    return xPrinterESC.setRelativeVertical(this.connectInfo, position);
+  };
+
+  setTextStyle = async (payload: SetTextStyleRequest) => {
+    return xPrinterESC.setTextStyle(this.connectInfo, payload);
+  };
+
+  setAlignment = async (alignment: Alignment) => {
+    return xPrinterESC.setAlignment(this.connectInfo, alignment);
+  };
+
+  downloadNVImage = async (imagePaths: string[], imageWidth: number) => {
+    return xPrinterESC.downloadNVImage(
+      this.connectInfo,
+      imagePaths,
+      imageWidth
+    );
+  };
+
+  clearNVImage = async () => {
+    return xPrinterESC.clearNVImage(this.connectInfo);
+  };
+
+  printNVImage = async (index: number, model: BMPModel) => {
+    return xPrinterESC.printNVImage(this.connectInfo, index, model);
+  };
+
+  selectBitmapModel = async (payload: SelectBitmapModelRequest) => {
+    return xPrinterESC.selectBitmapModel(this.connectInfo, payload);
+  };
+
+  setLineSpacing = async (space: number) => {
+    return xPrinterESC.setLineSpacing(this.connectInfo, space);
+  };
+
+  setTurnUpsideDownMode = async (on: boolean) => {
+    return xPrinterESC.setTurnUpsideDownMode(this.connectInfo, on);
+  };
+
+  selectCodePage = async (page: number) => {
+    return xPrinterESC.selectCodePage(this.connectInfo, page);
+  };
+
+  selectCharacterFont = async (font: FontType) => {
+    return xPrinterESC.selectCharacterFont(this.connectInfo, font);
+  };
+
+  printPDF417 = async (payload: PrintPDF417Request) => {
+    return xPrinterESC.printPDF417(this.connectInfo, payload);
+  };
+
+  printTable = async (payload: PrintTableRequest) => {
+    return xPrinterESC.printTable(this.connectInfo, payload);
+  };
+
+  wifiConfig = async (payload: WifiConfigRequest) => {
+    return xPrinterESC.wifiConfig(this.connectInfo, payload);
+  };
+
+  setIp = async (ip: string) => {
+    return xPrinterESC.setIp(this.connectInfo, ip);
+  };
+
+  setMask = async (mask: string) => {
+    return xPrinterESC.setMask(this.connectInfo, mask);
+  };
+
+  setGateway = async (gateway: string) => {
+    return xPrinterESC.setGateway(this.connectInfo, gateway);
+  };
+
+  setNetAll = async (payload: SetNetAllRequest) => {
+    return xPrinterESC.setNetAll(this.connectInfo, payload);
+  };
+
+  setBluetooth = async (name: string, pin: string) => {
+    return xPrinterESC.setBluetooth(this.connectInfo, name, pin);
+  };
+
+  getSerialNumber = async () => {
+    return xPrinterESC.getSerialNumber(this.connectInfo);
+  };
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { xPrinterUtils as XPrinterUtils } from './utils';
+export { xPrinterPrinter as XPrinterPrinter, XPrinterDevice } from './printer';
+export { xPrinterESC as XPrinterESC, XPrinterESCExecutor } from './esc';
+export { xPrinterTSPL as XPrinterTSPL, XPrinterTSPLExecutor } from './tspl';
+export { XPrinterPCLExecutor } from './type';

package/src/printer/NativeXPrinterPrinter.ts

@@ -0,0 +1,84 @@
+import {
+  type CodegenTypes,
+  type TurboModule,
+  TurboModuleRegistry,
+} from 'react-native';
+
+export interface Spec extends TurboModule {
+  //only android
+  getUsbDevices: () => Promise<USBDevice[]>;
+  searchNetDevice: () => Promise<void>;
+  udpNetConfig: (request: UpdateUdpNetConfigRequest) => Promise<void>;
+  //serial port,boudrate
+  connect: (
+    connectInfo: string,
+    deviceType: DeviceType,
+    //only android support sync
+    sync: boolean
+  ) => Promise<void>;
+  disconnect: (connectInfo: string) => Promise<void>;
+  isConnect: (connectInfo: string) => Promise<boolean>;
+  getPrinterPCL: (connectInfo: string) => Promise<PCLType>;
+  setPrinterPCL: (connectInfo: string, pcl: PCLType) => Promise<void>;
+  readonly onDeviceConnectStatusChange: CodegenTypes.EventEmitter<DeviceConnectStatusChangeEvent>;
+  readonly onSearchNetDeviceFound: CodegenTypes.EventEmitter<NetDevice>;
+}
+
+export const NativeXPrinterPrinter = TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeXPrinterPrinter'
+);
+
+export enum ConnectStatus {
+  CONNECT_SUCCESS = 'CONNECT_SUCCESS',
+  CONNECT_FAIL = 'CONNECT_FAIL',
+  DISCONNECT = 'DISCONNECT',
+  SEND_FAIL = 'SEND_FAIL',
+  CONNECT_INTERRUPT = 'CONNECT_INTERRUPT',
+  USB_ATTACHED = 'USB_ATTACHED',
+  USB_DETACHED = 'USB_DETACHED',
+  BLUETOOTH_INTERRUPT = 'BLUETOOTH_INTERRUPT',
+  UNKNOWN = 'UNKNOWN',
+}
+
+export enum DeviceType {
+  USB = 'USB',
+  BLUETOOTH = 'BLUETOOTH',
+  ETHERNET = 'ETHERNET',
+  SERIAL = 'SERIAL',
+}
+
+export enum PCLType {
+  ESC = 'ESC',
+  TSPL = 'TSPL',
+  // CPCL = 'CPCL',
+  // ZPL = 'ZPL',
+}
+
+export interface USBDevice {
+  deviceId: number;
+  deviceName: string;
+  manufacturerName: string | null;
+}
+
+export interface UpdateUdpNetConfigRequest {
+  macAddress: string;
+  ipAddress: string;
+  mask: string;
+  gateway: string;
+  dhcp: boolean;
+}
+
+export interface DeviceConnectStatusChangeEvent {
+  code: ConnectStatus;
+  connectInfo: string;
+  msg?: string;
+  debugCode?: number;
+}
+
+export interface NetDevice {
+  macAddress: string;
+  ipAddress: string;
+  mask: string;
+  gateway: string;
+  dhcp: boolean;
+}