react-native-esc-pos-printer-chunyinli 4.5.2

package/src/discovery/constants.ts

@@ -0,0 +1,101 @@
+import { Platform } from 'react-native';
+import { remapConstants } from '../core/utils';
+
+import { EscPosPrinterDiscovery } from '../specs';
+
+export const DEFAULT_DISCOVERY_TIMEOUT = Platform.OS === 'ios' ? 5000 : 10000;
+
+const DiscoveryModuleConstants = EscPosPrinterDiscovery.getConstants();
+
+export enum DiscoveryDeviceType {
+  TYPE_ALL = DiscoveryModuleConstants.TYPE_ALL,
+  TYPE_PRINTER = DiscoveryModuleConstants.TYPE_PRINTER,
+  TYPE_HYBRID_PRINTER = DiscoveryModuleConstants.TYPE_HYBRID_PRINTER,
+  TYPE_DISPLAY = DiscoveryModuleConstants.TYPE_DISPLAY,
+  TYPE_KEYBOARD = DiscoveryModuleConstants.TYPE_KEYBOARD,
+  TYPE_SCANNER = DiscoveryModuleConstants.TYPE_SCANNER,
+  TYPE_SERIAL = DiscoveryModuleConstants.TYPE_SERIAL,
+  TYPE_POS_KEYBOARD = DiscoveryModuleConstants.TYPE_POS_KEYBOARD,
+  TYPE_MSR = DiscoveryModuleConstants.TYPE_MSR,
+  TYPE_GFE = DiscoveryModuleConstants.TYPE_GFE,
+  TYPE_OTHER_PERIPHERAL = DiscoveryModuleConstants.TYPE_OTHER_PERIPHERAL,
+}
+
+export enum DiscoveryFilterType { // Android only
+  FILTER_NAME = DiscoveryModuleConstants.FILTER_NAME,
+  FILTER_NONE = DiscoveryModuleConstants.FILTER_NONE,
+}
+export enum DiscoveryPortType {
+  PORTTYPE_ALL = DiscoveryModuleConstants.PORTTYPE_ALL,
+  PORTTYPE_TCP = DiscoveryModuleConstants.PORTTYPE_TCP,
+  PORTTYPE_BLUETOOTH = DiscoveryModuleConstants.PORTTYPE_BLUETOOTH,
+  PORTTYPE_USB = DiscoveryModuleConstants.PORTTYPE_USB,
+
+  PORTTYPE_BLUETOOTH_LE = DiscoveryModuleConstants.PORTTYPE_BLUETOOTH_LE, // iOS only
+}
+
+export enum DiscoveryDeviceModel {
+  MODEL_ALL = DiscoveryModuleConstants.MODEL_ALL,
+}
+
+export enum DiscoveryBooleanParams { // Android only
+  TRUE = DiscoveryModuleConstants.PRINTER_TRUE,
+  FALSE = DiscoveryModuleConstants.PRINTER_FALSE,
+}
+
+export enum PrinterPairBluetoothError {
+  BT_ERR_PARAM = DiscoveryModuleConstants.BT_ERR_PARAM,
+  BT_ERR_UNSUPPORTED = DiscoveryModuleConstants.BT_ERR_UNSUPPORTED,
+  BT_ERR_CANCEL = DiscoveryModuleConstants.BT_ERR_CANCEL,
+  BT_ERR_ILLEGAL_DEVICE = DiscoveryModuleConstants.BT_ERR_ILLEGAL_DEVICE,
+  ERR_FAILURE = DiscoveryModuleConstants.ERR_FAILURE,
+}
+
+export const DiscoveryFilterOption = {
+  ...DiscoveryDeviceType,
+  ...DiscoveryFilterType,
+  ...DiscoveryPortType,
+  ...DiscoveryDeviceModel,
+  ...DiscoveryBooleanParams,
+} as const;
+
+export enum DiscoveryErrorResult {
+  ERR_PARAM = DiscoveryModuleConstants.ERR_PARAM,
+  ERR_ILLEGAL = DiscoveryModuleConstants.ERR_ILLEGAL,
+  ERR_MEMORY = DiscoveryModuleConstants.ERR_MEMORY,
+  ERR_FAILURE = DiscoveryModuleConstants.ERR_FAILURE,
+  ERR_PROCESSING = DiscoveryModuleConstants.ERR_PROCESSING,
+  PERMISSION_ERROR = -2,
+}
+
+export const DiscoveryErrorMessageMapping = {
+  [DiscoveryErrorResult.ERR_PARAM]: 'An invalid parameter was passed.',
+  [DiscoveryErrorResult.ERR_ILLEGAL]:
+    'Tried to start search when search had been already done.' +
+    (Platform.OS === 'android'
+      ? '\nBluetooth is OFF\nThere is no permission for the position information'
+      : ''),
+  [DiscoveryErrorResult.ERR_MEMORY]:
+    'Memory necessary for processing could not be allo- cated.',
+  [DiscoveryErrorResult.ERR_FAILURE]: 'An unknown error occurred.',
+  [DiscoveryErrorResult.ERR_PROCESSING]: 'Could not run the process.',
+
+  [DiscoveryErrorResult.PERMISSION_ERROR]: 'Permission error',
+};
+
+export const PrinterPairBluetoothErrorMessageMapping = {
+  [PrinterPairBluetoothError.BT_ERR_CANCEL]: 'Pairing connection was canceled.',
+  [PrinterPairBluetoothError.BT_ERR_PARAM]: 'An invalid parameter was passed.',
+  [PrinterPairBluetoothError.BT_ERR_UNSUPPORTED]:
+    'The function was executed on an unsupported OS.',
+  [PrinterPairBluetoothError.BT_ERR_ILLEGAL_DEVICE]:
+    'An invalid device was selected.',
+  [DiscoveryErrorResult.ERR_FAILURE]: 'An unknown error occurred.',
+};
+
+export const DiscoveryErrorStatusMapping = remapConstants(DiscoveryErrorResult);
+export const PrinterPairBluetoothErrorStatusMapping = remapConstants(
+  PrinterPairBluetoothError
+);
+
+export const DiscoveryDeviceTypeMapping = remapConstants(DiscoveryDeviceType);

package/src/discovery/hooks/index.ts

@@ -0,0 +1 @@
+export { usePrintersDiscovery } from './usePrintersDiscovery';

package/src/discovery/hooks/usePrintersDiscovery.ts

@@ -0,0 +1,69 @@
+import { useCallback, useEffect, useState } from 'react';
+import { PrintersDiscovery } from '../PrintersDiscovery';
+import type { DeviceInfo, DiscoveryStartParams } from '../types';
+import type { PrinterDiscoveryError } from '../../core/errors';
+
+export function usePrintersDiscovery() {
+  const [printers, setPrinters] = useState<DeviceInfo[]>([]);
+  const [isDiscovering, setIsDescovering] = useState<boolean>(false);
+  const [printerError, setPrinterError] =
+    useState<PrinterDiscoveryError | null>(null);
+
+  useEffect(() => {
+    const removeListener = PrintersDiscovery.onDiscovery(
+      (deviceInfo: DeviceInfo[]) => {
+        setPrinters(deviceInfo);
+      }
+    );
+
+    return () => {
+      removeListener();
+    };
+  }, []);
+
+  useEffect(() => {
+    const removeListener = PrintersDiscovery.onStatusChange((status) => {
+      const isNextDiscovering = status === 'discovering';
+      if (isNextDiscovering) {
+        setPrinters([]);
+        setPrinterError(null);
+      }
+      setIsDescovering(isNextDiscovering);
+    });
+
+    return () => {
+      removeListener();
+    };
+  }, []);
+
+  useEffect(() => {
+    const removeListener = PrintersDiscovery.onError((error) => {
+      setPrinterError(error);
+    });
+
+    return () => {
+      removeListener();
+    };
+  }, []);
+
+  const start = useCallback((params?: DiscoveryStartParams) => {
+    PrintersDiscovery.start(params);
+  }, []);
+
+  const stop = useCallback(() => {
+    PrintersDiscovery.stop();
+  }, []);
+
+  const pairBluetoothDevice = useCallback(async (macAddress?: string) => {
+    await PrintersDiscovery.pairBluetoothDevice(macAddress);
+  }, []);
+
+  return {
+    printers,
+    isDiscovering,
+    printerError,
+    start,
+    stop,
+    pairBluetoothDevice,
+  };
+}

package/src/discovery/index.ts

@@ -0,0 +1,4 @@
+export * from './hooks';
+export { PrintersDiscovery } from './PrintersDiscovery';
+export * from './types';
+export * from './constants';

package/src/discovery/types.ts

@@ -0,0 +1,79 @@
+import type {
+  DiscoveryDeviceType,
+  DiscoveryFilterType,
+  DiscoveryPortType,
+  DiscoveryDeviceModel,
+  DiscoveryBooleanParams,
+} from './constants';
+export type DiscoveryStatus = 'discovering' | 'inactive';
+
+export type RawDeviceInfo = {
+  deviceType: number;
+  target: string;
+  deviceName: string;
+  ipAddress: string;
+  macAddress: string;
+  bdAddress: string;
+};
+
+export type DeviceInfo = {
+  deviceType: keyof typeof DiscoveryDeviceType;
+  target: string;
+  deviceName: string;
+  ipAddress: string;
+  macAddress: string;
+  bdAddress: string;
+};
+
+export type FilterOption = {
+  /**
+   * @type {number} - Selects the port to search.
+   */
+  portType?: DiscoveryPortType;
+  /**
+   * @type {string} - Specify a Broadcast Address for TCP search as a string. Defaults to "255.255.255.255"
+   */
+  broadcast?: string;
+  /**
+   * @type {number} - Specifies the device model to search for. Defaults to Discovery.EPOS2_MODEL_ALL
+   */
+  deviceModel?: DiscoveryDeviceModel;
+  /**
+   * @type {number} - Android only. Filters the search result by the Epson printers.
+      Search can be performed for printers connected via Bluetooth or USB.
+   */
+  epsonFilter?: DiscoveryFilterType;
+  /**
+   * @type {number} - Specifies the device type to search for.
+    The device type settings other than "Discovery.TYPE_ALL" can be used for the following systems con- nected using Wi-Fi or Ethernet.
+    • Customer Display Models (SSL/TLS communication only)
+    • TM Printer + DM-D + barcode scanner model
+    • TM Printer + barcode scanner model
+    • POS Terminal Model
+   */
+  deviceType?: DiscoveryDeviceType;
+  /**
+   * @type {number} - Android only. Specifies the search target when searching for a device that can be connected via Bluetooth. Defaults to Discovery.FALSE
+   */
+  bondedDevices?: DiscoveryBooleanParams;
+
+  /**
+   * @type {number} - Android only.  Specifies whether to search USB devices by their names or not.. Defaults to Discovery.FALSE
+   */
+  usbDeviceName?: DiscoveryBooleanParams;
+};
+
+export type DiscoveryStartParams = {
+  /**
+   * @type {boolean} - If true, the search will be automatically stopped after timeout is passed. Defaults to true
+   */
+  autoStop?: boolean;
+  /**
+   * @type {number} - Search will be automatically stopped after timeout is passed. Defaults to 5000ms
+   */
+  timeout?: number;
+  /**
+   * @type {object} - In order to filter the search result, set the filter option in the FilterOption type and specify it in the parameter. When filter is omited, search is run with the default settings.
+   */
+  filterOption?: FilterOption;
+};

package/src/discovery/utils/errors.ts

@@ -0,0 +1,37 @@
+import { PrinterDiscoveryError } from '../../core';
+import {
+  DiscoveryErrorMessageMapping,
+  DiscoveryErrorStatusMapping,
+  PrinterPairBluetoothErrorMessageMapping,
+  PrinterPairBluetoothErrorStatusMapping,
+  DiscoveryErrorResult,
+} from '../constants';
+
+export function getProcessedError({
+  methodName,
+  errorCode,
+  messagesMapping = DiscoveryErrorMessageMapping,
+  statusMapping = DiscoveryErrorStatusMapping,
+}: {
+  methodName: string;
+  errorCode: string;
+  messagesMapping?:
+    | typeof DiscoveryErrorMessageMapping
+    | typeof PrinterPairBluetoothErrorMessageMapping;
+  statusMapping?:
+    | typeof DiscoveryErrorStatusMapping
+    | typeof PrinterPairBluetoothErrorStatusMapping;
+}) {
+  const result = !isNaN(Number(errorCode))
+    ? errorCode
+    : DiscoveryErrorResult.ERR_FAILURE;
+
+  const message = messagesMapping[result];
+  const status = statusMapping[result];
+
+  return new PrinterDiscoveryError({
+    status: status,
+    message: message,
+    methodName,
+  });
+}

package/src/discovery/utils/index.ts

@@ -0,0 +1 @@
+export { getProcessedError } from './errors';

package/src/index.tsx

@@ -0,0 +1,2 @@
+export * from './discovery';
+export * from './printer';

package/src/printer/Printer.ts

@@ -0,0 +1,158 @@
+import type PQueueType from 'p-queue';
+import { PrinterWrapper } from './PrinterWrapper';
+import { PrinterGetSettingsType, PrinterModelLang } from './constants';
+import {
+  addTextLine,
+  addViewShot,
+  monitorPrinter,
+  tryToConnectUntil,
+} from './printHelpers';
+import type {
+  AddBarcodeParams,
+  AddCutTypeParam,
+  AddImageParams,
+  AddPulseParams,
+  AddSymbolParams,
+  AddTextAlignParam,
+  AddTextLangParam,
+  AddTextSizeParams,
+  AddTextSmoothParam,
+  AddTextStyleParams,
+  PrinterParams,
+} from './types';
+
+export class Printer {
+  private static instances: Map<string, Printer> = new Map();
+
+  public readonly deviceName: string;
+  private lang: PrinterModelLang;
+  private printerWrapper: PrinterWrapper;
+
+  public queue: unknown;
+
+  constructor({
+    target,
+    deviceName,
+    lang = PrinterModelLang.MODEL_ANK,
+  }: PrinterParams) {
+    if (Printer.instances.has(target)) {
+      return Printer.instances.get(target);
+    }
+
+    this.deviceName = deviceName;
+    this.lang = lang;
+    this.printerWrapper = new PrinterWrapper(target);
+
+    this.initQueue();
+
+    Printer.instances.set(target, this);
+  }
+
+  initQueue() {
+    const PQueue = require('p-queue/dist').default;
+    this.queue = new PQueue({ concurrency: 1 });
+  }
+
+  addQueueTask<TaskResultType>(
+    task: () => Promise<TaskResultType>
+  ): Promise<TaskResultType | void> {
+    return (this.queue as PQueueType).add(task);
+  }
+
+  static addTextLine = addTextLine;
+  static monitorPrinter = monitorPrinter;
+  static tryToConnectUntil = tryToConnectUntil;
+  static addViewShot = addViewShot;
+
+  get currentFontWidth() {
+    return this.printerWrapper.currentFontWidth;
+  }
+
+  init = () => {
+    return this.printerWrapper.init({
+      deviceName: this.deviceName,
+      lang: this.lang,
+    });
+  };
+
+  connect = async (timeout?: number) => {
+    await this.init();
+    return this.printerWrapper.connect(timeout);
+  };
+
+  disconnect = () => {
+    return this.printerWrapper.disconnect();
+  };
+
+  addText = (data: string) => {
+    return this.printerWrapper.addText(data);
+  };
+
+  addFeedLine = (line?: number) => {
+    return this.printerWrapper.addFeedLine(line);
+  };
+
+  addLineSpace = (linespc: number) => {
+    return this.printerWrapper.addLineSpace(linespc);
+  };
+
+  sendData = (timeout?: number) => {
+    return this.printerWrapper.sendData(timeout);
+  };
+
+  addCut = (type?: AddCutTypeParam) => {
+    return this.printerWrapper.addCut(type);
+  };
+
+  getPrinterSetting = (type: PrinterGetSettingsType, timeout?: number) => {
+    return this.printerWrapper.getPrinterSetting(type, timeout);
+  };
+
+  getStatus = () => {
+    return this.printerWrapper.getStatus();
+  };
+
+  addImage = (params: AddImageParams) => {
+    return this.printerWrapper.addImage(params);
+  };
+
+  addBarcode = (params: AddBarcodeParams) => {
+    return this.printerWrapper.addBarcode(params);
+  };
+
+  addSymbol = (params: AddSymbolParams) => {
+    return this.printerWrapper.addSymbol(params);
+  };
+
+  addCommand = (uint8Array: Uint8Array) => {
+    return this.printerWrapper.addCommand(uint8Array);
+  };
+
+  addPulse = (params: AddPulseParams) => {
+    return this.printerWrapper.addPulse(params);
+  };
+
+  addTextAlign = (params?: AddTextAlignParam) => {
+    return this.printerWrapper.addTextAlign(params);
+  };
+
+  addTextSize = async (params?: AddTextSizeParams) => {
+    await this.printerWrapper.addTextSize(params);
+  };
+
+  addTextSmooth = (smooth?: AddTextSmoothParam) => {
+    return this.printerWrapper.addTextSmooth(smooth);
+  };
+
+  addTextStyle = (params?: AddTextStyleParams) => {
+    return this.printerWrapper.addTextStyle(params);
+  };
+
+  addTextLang = (lang: AddTextLangParam) => {
+    return this.printerWrapper.addTextLang(lang);
+  };
+
+  clearCommandBuffer = () => {
+    return this.printerWrapper.clearCommandBuffer();
+  };
+}