taro-bluetooth-print 2.1.0 → 2.1.1

package/src/services/CommandBuilder.ts

@@ -0,0 +1,135 @@
+/**
+ * Command Builder Service
+ *
+ * Builds print commands using the printer driver
+ */
+
+import { Service } from 'typedi';
+import type { IPrinterDriver, IQrOptions } from '@/types';
+import { ICommandBuilder } from './interfaces';
+import { Logger } from '@/utils/logger';
+import { EscPos } from '@/drivers/EscPos';
+
+/**
+ * Command Builder implementation
+ */
+@Service()
+export class CommandBuilder implements ICommandBuilder {
+  private driver: IPrinterDriver;
+  private buffer: Uint8Array[] = [];
+  private readonly logger = Logger.scope('CommandBuilder');
+
+  /**
+   * Creates a new CommandBuilder instance
+   *
+   * @param driver - Printer driver instance
+   */
+  constructor(driver?: IPrinterDriver) {
+    this.driver = driver || new EscPos();
+
+    // Initialize printer with ESC/POS init command
+    this.buffer.push(...this.driver.init());
+  }
+
+  /**
+   * Adds text to the print queue
+   *
+   * @param content - Text content
+   * @param encoding - Text encoding
+   * @returns this - For method chaining
+   */
+  text(content: string, encoding?: string): this {
+    this.logger.debug('Adding text:', content.substring(0, 50));
+    this.buffer.push(...this.driver.text(content, encoding));
+    return this;
+  }
+
+  /**
+   * Adds line feeds to the print queue
+   *
+   * @param lines - Number of lines to feed
+   * @returns this - For method chaining
+   */
+  feed(lines = 1): this {
+    this.logger.debug('Adding feed:', lines);
+    this.buffer.push(...this.driver.feed(lines));
+    return this;
+  }
+
+  /**
+   * Adds a paper cut command to the print queue
+   *
+   * @returns this - For method chaining
+   */
+  cut(): this {
+    this.logger.debug('Adding cut command');
+    this.buffer.push(...this.driver.cut());
+    return this;
+  }
+
+  /**
+   * Adds an image to the print queue
+   *
+   * @param data - Image data as Uint8Array
+   * @param width - Image width
+   * @param height - Image height
+   * @returns this - For method chaining
+   */
+  image(data: Uint8Array, width: number, height: number): this {
+    this.logger.debug(`Adding image: ${width}x${height}`);
+    this.buffer.push(...this.driver.image(data, width, height));
+    return this;
+  }
+
+  /**
+   * Adds a QR code to the print queue
+   *
+   * @param content - QR code content
+   * @param options - QR code options
+   * @returns this - For method chaining
+   */
+  qr(content: string, options?: IQrOptions): this {
+    this.logger.debug('Adding QR code:', content.substring(0, 50));
+    this.buffer.push(...this.driver.qr(content, options));
+    return this;
+  }
+
+  /**
+   * Clears the print queue
+   *
+   * @returns this - For method chaining
+   */
+  clear(): this {
+    this.logger.debug('Clearing buffer');
+    this.buffer = [];
+    // Re-initialize printer
+    this.buffer.push(...this.driver.init());
+    return this;
+  }
+
+  /**
+   * Gets the current buffer
+   *
+   * @returns Uint8Array - Current print buffer
+   */
+  getBuffer(): Uint8Array {
+    // Combine all buffers
+    const totalLength = this.buffer.reduce((acc, b) => acc + b.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const b of this.buffer) {
+      combined.set(b, offset);
+      offset += b.length;
+    }
+    return combined;
+  }
+
+  /**
+   * Gets the total number of bytes in the buffer
+   *
+   * @returns number - Total bytes
+   */
+  getTotalBytes(): number {
+    return this.buffer.reduce((acc, b) => acc + b.length, 0);
+  }
+}

package/src/services/ConnectionManager.ts

@@ -0,0 +1,133 @@
+/**
+ * Connection Manager Service
+ *
+ * Manages Bluetooth device connections
+ */
+
+import { Service } from 'typedi';
+import type { IPrinterAdapter } from '@/types';
+import { PrinterState } from '@/types';
+import { IConnectionManager } from './interfaces';
+import { AdapterFactory } from '@/adapters/AdapterFactory';
+import { Logger } from '@/utils/logger';
+import { BluetoothPrintError, ErrorCode } from '@/errors/BluetoothError';
+
+/**
+ * Connection Manager implementation
+ */
+@Service()
+export class ConnectionManager implements IConnectionManager {
+  private adapter: IPrinterAdapter;
+  private deviceId: string | null = null;
+  private state: PrinterState = PrinterState.DISCONNECTED;
+  private readonly logger = Logger.scope('ConnectionManager');
+
+  /**
+   * Creates a new ConnectionManager instance
+   */
+  constructor(adapter?: IPrinterAdapter) {
+    this.adapter = adapter || AdapterFactory.create();
+
+    // Listen to adapter state changes
+    this.adapter.onStateChange?.(state => {
+      this.state = state;
+      this.logger.debug('State changed:', state);
+    });
+  }
+
+  /**
+   * Connects to a Bluetooth device
+   *
+   * @param deviceId - Bluetooth device ID
+   * @returns Promise<void>
+   */
+  async connect(deviceId: string): Promise<void> {
+    this.logger.info('Connecting to device:', deviceId);
+
+    try {
+      this.deviceId = deviceId;
+      await this.adapter.connect(deviceId);
+      this.state = PrinterState.CONNECTED;
+      this.logger.info('Connected successfully');
+    } catch (error) {
+      this.deviceId = null;
+      this.state = PrinterState.DISCONNECTED;
+      const printError =
+        error instanceof BluetoothPrintError
+          ? error
+          : new BluetoothPrintError(
+              ErrorCode.CONNECTION_FAILED,
+              'Connection failed',
+              error as Error
+            );
+      this.logger.error('Connection failed:', printError);
+      throw printError;
+    }
+  }
+
+  /**
+   * Disconnects from the current device
+   *
+   * @returns Promise<void>
+   */
+  async disconnect(): Promise<void> {
+    if (!this.deviceId) {
+      this.logger.warn('Disconnect called but no device connected');
+      return;
+    }
+
+    const deviceId = this.deviceId;
+    this.logger.info('Disconnecting from device:', deviceId);
+
+    try {
+      await this.adapter.disconnect(deviceId);
+      this.deviceId = null;
+      this.state = PrinterState.DISCONNECTED;
+      this.logger.info('Disconnected successfully');
+    } catch (error) {
+      const printError = new BluetoothPrintError(
+        ErrorCode.DEVICE_DISCONNECTED,
+        'Disconnect failed',
+        error as Error
+      );
+      this.logger.error('Disconnect failed:', printError);
+      throw printError;
+    }
+  }
+
+  /**
+   * Checks if a device is connected
+   *
+   * @returns boolean - True if connected, false otherwise
+   */
+  isConnected(): boolean {
+    return this.state === PrinterState.CONNECTED;
+  }
+
+  /**
+   * Gets the current device ID
+   *
+   * @returns string | null - Device ID or null if not connected
+   */
+  getDeviceId(): string | null {
+    return this.deviceId;
+  }
+
+  /**
+   * Gets the current connection state
+   *
+   * @returns PrinterState - Current state
+   */
+  getState(): PrinterState {
+    return this.state;
+  }
+
+  /**
+   * Gets the printer adapter instance
+   *
+   * @returns IPrinterAdapter - Printer adapter
+   */
+  getAdapter(): IPrinterAdapter {
+    return this.adapter;
+  }
+}

package/src/services/PrintJobManager.ts

@@ -0,0 +1,300 @@
+/**
+ * Print Job Manager Service
+ *
+ * Manages print jobs, including pause/resume/cancel functionality
+ */
+
+import { Service } from 'typedi';
+import type { IPrinterAdapter } from '@/types';
+import { IAdapterOptions, PrinterState } from '@/types';
+import { IPrintJobManager, IConnectionManager } from './interfaces';
+import { Logger } from '@/utils/logger';
+import { BluetoothPrintError, ErrorCode } from '@/errors/BluetoothError';
+
+/**
+ * Print Job Manager implementation
+ */
+@Service()
+export class PrintJobManager implements IPrintJobManager {
+  private adapter: IPrinterAdapter;
+  private connectionManager: IConnectionManager;
+  private jobBuffer: Uint8Array | null = null;
+  private jobOffset = 0;
+  private _isPaused = false;
+  private _isInProgress = false;
+  private adapterOptions: IAdapterOptions = {};
+  private readonly logger = Logger.scope('PrintJobManager');
+
+  /**
+   * Creates a new PrintJobManager instance
+   *
+   * @param connectionManagerOrAdapter - Connection manager instance or adapter instance (for backward compatibility)
+   * @param adapter - Printer adapter instance (optional, will be taken from connectionManager if not provided)
+   */
+  constructor(
+    connectionManagerOrAdapter?: IConnectionManager | IPrinterAdapter,
+    adapter?: IPrinterAdapter
+  ) {
+    // Handle case where adapter is explicitly provided
+    if (adapter) {
+      // New API: new PrintJobManager(connectionManager, adapter)
+      this.connectionManager = connectionManagerOrAdapter as IConnectionManager;
+      this.adapter = adapter;
+    }
+    // Handle backward compatibility for old API: new PrintJobManager(adapter, driver)
+    else if (
+      connectionManagerOrAdapter &&
+      typeof (connectionManagerOrAdapter as IPrinterAdapter).connect === 'function'
+    ) {
+      // Old API: new PrintJobManager(adapter)
+      this.adapter = connectionManagerOrAdapter as IPrinterAdapter;
+      // Create a minimal connection manager for backward compatibility
+      this.connectionManager = {
+        getDeviceId: () => 'test-device', // Default device ID for backward compatibility
+        isConnected: () => true,
+        getState: () => PrinterState.CONNECTED, // Default to CONNECTED
+        connect: () => Promise.resolve(),
+        disconnect: () => Promise.resolve(),
+        getAdapter: () => this.adapter,
+      };
+    }
+    // Handle new API: new PrintJobManager(connectionManager)
+    else {
+      // New API: dependency injection or manual service creation
+      this.connectionManager = connectionManagerOrAdapter as IConnectionManager;
+      // Try to get adapter from connectionManager
+      if (
+        this.connectionManager &&
+        typeof (
+          this.connectionManager as IConnectionManager & { getAdapter?: () => IPrinterAdapter }
+        ).getAdapter === 'function'
+      ) {
+        this.adapter = (
+          this.connectionManager as IConnectionManager & { getAdapter: () => IPrinterAdapter }
+        ).getAdapter();
+      } else {
+        throw new Error(
+          'Printer adapter not provided and could not be retrieved from connection manager'
+        );
+      }
+    }
+  }
+
+  /**
+   * Starts a print job
+   *
+   * @param buffer - Print data buffer
+   * @returns Promise<void>
+   */
+  async start(buffer: Uint8Array): Promise<void> {
+    if (this._isInProgress) {
+      throw new BluetoothPrintError(
+        ErrorCode.PRINT_JOB_IN_PROGRESS,
+        'A print job is already in progress. Wait for completion or cancel it.'
+      );
+    }
+
+    this.logger.info(`Starting print job: ${buffer.length} bytes`);
+
+    this.jobBuffer = buffer;
+    this.jobOffset = 0;
+    this._isPaused = false;
+    this._isInProgress = true;
+
+    try {
+      await this.processJob();
+
+      // Check if the job was paused
+      if (this._isPaused) {
+        this.logger.info('Print job paused');
+        // Don't reset _isInProgress when paused, so resume() and cancel() can still work
+      } else {
+        // Print job completed successfully
+        this.logger.info('Print job completed successfully');
+        this._isInProgress = false;
+        this.jobBuffer = null;
+        this.jobOffset = 0;
+      }
+    } catch (error) {
+      this.logger.error('Print job failed:', error);
+      this._isInProgress = false;
+      this.jobBuffer = null;
+      this.jobOffset = 0;
+
+      const printError =
+        error instanceof BluetoothPrintError
+          ? error
+          : new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, 'Print job failed', error as Error);
+      throw printError;
+    }
+  }
+
+  /**
+   * Pauses the current print job
+   */
+  pause(): void {
+    if (!this._isInProgress) {
+      this.logger.warn('Pause called but no print job in progress');
+      return;
+    }
+
+    this._isPaused = true;
+    this.logger.info('Print job paused');
+  }
+
+  /**
+   * Resumes a paused print job
+   *
+   * @returns Promise<void>
+   */
+  async resume(): Promise<void> {
+    if (!this._isInProgress || !this._isPaused) {
+      this.logger.warn('Resume called but no paused print job');
+      return;
+    }
+
+    this._isPaused = false;
+    this.logger.info('Print job resumed');
+
+    try {
+      await this.processJob();
+
+      if (!this._isPaused) {
+        // Print job completed successfully
+        this.logger.info('Print job completed successfully');
+        this._isInProgress = false;
+        this.jobBuffer = null;
+        this.jobOffset = 0;
+      }
+    } catch (error) {
+      this.logger.error('Print job failed after resume:', error);
+      this._isInProgress = false;
+      this.jobBuffer = null;
+      this.jobOffset = 0;
+
+      const printError =
+        error instanceof BluetoothPrintError
+          ? error
+          : new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, 'Print job failed', error as Error);
+      throw printError;
+    }
+  }
+
+  /**
+   * Cancels the current print job
+   */
+  cancel(): void {
+    if (!this._isInProgress) {
+      this.logger.warn('Cancel called but no print job in progress');
+      return;
+    }
+
+    this._isPaused = false;
+    this._isInProgress = false;
+    this.jobBuffer = null;
+    this.jobOffset = 0;
+    this.logger.info('Print job cancelled');
+  }
+
+  /**
+   * Gets the number of bytes remaining to print
+   *
+   * @returns number - Bytes remaining
+   */
+  remaining(): number {
+    if (this.jobBuffer) {
+      return this.jobBuffer.length - this.jobOffset;
+    }
+    return 0;
+  }
+
+  /**
+   * Checks if the print job is paused
+   *
+   * @returns boolean - True if paused, false otherwise
+   */
+  isPaused(): boolean {
+    return this._isPaused;
+  }
+
+  /**
+   * Checks if a print job is in progress
+   *
+   * @returns boolean - True if in progress, false otherwise
+   */
+  isInProgress(): boolean {
+    return this._isInProgress;
+  }
+
+  /**
+   * Sets adapter options for write operations
+   *
+   * @param options - Adapter options
+   */
+  setOptions(options: IAdapterOptions): void {
+    this.adapterOptions = { ...this.adapterOptions, ...options };
+    this.logger.debug('Adapter options updated:', this.adapterOptions);
+  }
+
+  /**
+   * Processes the print job in chunks
+   * Supports pause/resume functionality
+   *
+   * @returns Promise<void>
+   */
+  private async processJob(): Promise<void> {
+    if (!this.jobBuffer) {
+      return;
+    }
+
+    // Check if adapter has write method
+    if (!this.adapter || typeof this.adapter.write !== 'function') {
+      throw new BluetoothPrintError(
+        ErrorCode.INVALID_CONFIGURATION,
+        'Printer adapter does not support write operation'
+      );
+    }
+
+    const printerChunkSize = 512;
+    const total = this.jobBuffer.length;
+    const jobBuffer = this.jobBuffer; // Cache to avoid closure issues
+
+    try {
+      while (this.jobOffset < jobBuffer.length) {
+        if (this._isPaused) {
+          this.logger.debug('Job paused at offset:', this.jobOffset);
+          return;
+        }
+
+        // Check device connection state
+        // Note: We rely on the adapter to handle connection state changes
+
+        const end = Math.min(this.jobOffset + printerChunkSize, jobBuffer.length);
+        const chunk = jobBuffer.slice(this.jobOffset, end);
+
+        await this.adapter.write(this.getDeviceId(), chunk.buffer, this.adapterOptions);
+
+        this.jobOffset = end;
+
+        this.logger.debug(`Processed ${this.jobOffset}/${total} bytes`);
+      }
+    } catch (error) {
+      this.logger.error('Error processing job:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets the current device ID from the connection manager
+   *
+   * @returns string - Device ID
+   * @throws BluetoothPrintError if no device is connected
+   */
+  private getDeviceId(): string {
+    const deviceId = this.connectionManager.getDeviceId();
+    if (!deviceId) {
+      throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, 'Device ID not available');
+    }
+    return deviceId;
+  }
+}