taro-bluetooth-print 2.3.0 → 2.4.0

package/src/adapters/BaiduAdapter.ts

@@ -6,6 +6,7 @@
 import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
 
 // Declare Baidu global for TypeScript
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface BaiduGlobal extends MiniProgramBLEApi {}
 
 declare const swan: BaiduGlobal;

package/src/adapters/BaseAdapter.ts

@@ -242,15 +242,13 @@ export abstract class MiniProgramAdapter extends BaseAdapter {
       this.logger.info('Device connected successfully');
 
       // Listen for connection state changes
-      this.getApi().onBLEConnectionStateChange(
-        (res: { deviceId: string; connected: boolean }) => {
-          if (res.deviceId === deviceId && !res.connected) {
-            this.logger.warn('Device disconnected unexpectedly');
-            this.updateState(PrinterState.DISCONNECTED);
-            this.cleanupDevice(deviceId);
-          }
+      this.getApi().onBLEConnectionStateChange((res: { deviceId: string; connected: boolean }) => {
+        if (res.deviceId === deviceId && !res.connected) {
+          this.logger.warn('Device disconnected unexpectedly');
+          this.updateState(PrinterState.DISCONNECTED);
+          this.cleanupDevice(deviceId);
         }
-      );
+      });
     } catch (error) {
       this.updateState(PrinterState.DISCONNECTED);
       this.logger.error('Connection failed:', error);

package/src/adapters/ByteDanceAdapter.ts

@@ -6,6 +6,7 @@
 import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
 
 // Declare ByteDance global for TypeScript
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface ByteDanceGlobal extends MiniProgramBLEApi {}
 
 declare const tt: ByteDanceGlobal;

package/src/adapters/TaroAdapter.ts

@@ -6,6 +6,7 @@
 import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
 
 // Declare Taro global for TypeScript
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface TaroGlobal extends MiniProgramBLEApi {}
 
 declare const Taro: TaroGlobal;

package/src/adapters/WebBluetoothAdapter.ts

@@ -359,7 +359,7 @@ export class WebBluetoothAdapter extends BaseAdapter {
         })
         .catch(error => {
           clearTimeout(timeoutId);
-          reject(error);
+          reject(error instanceof Error ? error : new Error(String(error)));
         });
     });
   }

package/src/config/PrinterConfigManager.ts

@@ -0,0 +1,519 @@
+/**
+ * Printer Configuration Manager
+ *
+ * Manages persistent printer configurations including:
+ * - Saved devices and their settings
+ * - Default print parameters
+ * - User preferences
+ *
+ * Supports localStorage and file-based storage backends.
+ *
+ * @example
+ * ```typescript
+ * const configManager = new PrinterConfigManager();
+ *
+ * // Save a printer configuration
+ * configManager.savePrinter({
+ *   id: 'my-printer',
+ *   deviceId: 'XX:XX:XX:XX:XX:XX',
+ *   name: 'Kitchen Printer',
+ *   isDefault: true
+ * });
+ *
+ * // Get all saved printers
+ * const printers = configManager.getSavedPrinters();
+ *
+ * // Load configuration for a printer
+ * const config = configManager.loadPrinterConfig('my-printer');
+ * ```
+ */
+
+import { Logger } from '@/utils/logger';
+
+/**
+ * Print configuration for a device
+ */
+export interface PrintConfig {
+  /** Encoding (default: 'GBK') */
+  encoding?: string;
+  /** Chunk size for data transfer */
+  chunkSize?: number;
+  /** Delay between chunks in ms */
+  chunkDelay?: number;
+  /** Number of retries */
+  retries?: number;
+}
+
+/**
+ * Saved printer configuration
+ */
+export interface SavedPrinter {
+  /** Unique printer ID */
+  id: string;
+  /** Bluetooth device ID */
+  deviceId: string;
+  /** Friendly name */
+  name: string;
+  /** Printer model/type */
+  model?: string;
+  /** Whether this is the default printer */
+  isDefault?: boolean;
+  /** Print configuration */
+  printConfig?: PrintConfig;
+  /** Auto-reconnect on disconnect */
+  autoReconnect?: boolean;
+  /** Last connected timestamp */
+  lastConnected?: number;
+  /** Creation timestamp */
+  createdAt: number;
+  /** Update timestamp */
+  updatedAt: number;
+}
+
+/**
+ * Global configuration
+ */
+export interface GlobalConfig {
+  /** Default encoding */
+  defaultEncoding: string;
+  /** Default chunk size */
+  defaultChunkSize: number;
+  /** Default chunk delay */
+  defaultChunkDelay: number;
+  /** Default retries */
+  defaultRetries: number;
+  /** Auto-reconnect by default */
+  defaultAutoReconnect: boolean;
+  /** Scan timeout in ms */
+  scanTimeout: number;
+  /** Enable logging */
+  enableLogging: boolean;
+}
+
+/**
+ * Configuration storage interface
+ */
+export interface IConfigStorage {
+  get<T>(key: string, defaultValue: T): T;
+  set<T>(key: string, value: T): void;
+  remove(key: string): void;
+  clear(): void;
+}
+
+/**
+ * LocalStorage-based implementation
+ */
+export class LocalStorage implements IConfigStorage {
+  private prefix: string;
+
+  constructor(prefix = 'taro_bt_print_') {
+    this.prefix = prefix;
+  }
+
+  get<T>(key: string, defaultValue: T): T {
+    try {
+      const stored = localStorage.getItem(this.prefix + key);
+      if (stored === null) {
+        return defaultValue;
+      }
+      return JSON.parse(stored) as T;
+    } catch {
+      return defaultValue;
+    }
+  }
+
+  set<T>(key: string, value: T): void {
+    try {
+      localStorage.setItem(this.prefix + key, JSON.stringify(value));
+    } catch (error) {
+      Logger.scope('ConfigStorage').error(`Failed to save "${key}":`, error);
+    }
+  }
+
+  remove(key: string): void {
+    try {
+      localStorage.removeItem(this.prefix + key);
+    } catch (error) {
+      Logger.scope('ConfigStorage').error(`Failed to remove "${key}":`, error);
+    }
+  }
+
+  clear(): void {
+    try {
+      const keysToRemove: string[] = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach(key => localStorage.removeItem(key));
+    } catch (error) {
+      Logger.scope('ConfigStorage').error('Failed to clear storage:', error);
+    }
+  }
+}
+
+/**
+ * Default global configuration
+ */
+const DEFAULT_GLOBAL_CONFIG: GlobalConfig = {
+  defaultEncoding: 'GBK',
+  defaultChunkSize: 20,
+  defaultChunkDelay: 20,
+  defaultRetries: 3,
+  defaultAutoReconnect: true,
+  scanTimeout: 15000,
+  enableLogging: true,
+};
+
+/**
+ * Storage keys
+ */
+const KEYS = {
+  PRINTERS: 'printers',
+  GLOBAL_CONFIG: 'global_config',
+  LAST_USED_PRINTER: 'last_used_printer',
+} as const;
+
+/**
+ * Printer Configuration Manager
+ */
+export class PrinterConfigManager {
+  private readonly logger = Logger.scope('PrinterConfigManager');
+  private readonly storage: IConfigStorage;
+  private printers: Map<string, SavedPrinter> = new Map();
+  private globalConfig: GlobalConfig;
+  private lastUsedPrinterId: string | null = null;
+
+  /**
+   * Creates a new PrinterConfigManager instance
+   *
+   * @param storage - Storage backend (defaults to LocalStorage)
+   */
+  constructor(storage?: IConfigStorage) {
+    this.storage = storage || new LocalStorage();
+    this.globalConfig = { ...DEFAULT_GLOBAL_CONFIG };
+    this.load();
+  }
+
+  /**
+   * Load configuration from storage
+   */
+  private load(): void {
+    try {
+      // Load printers
+      const printers = this.storage.get<SavedPrinter[]>(KEYS.PRINTERS, []);
+      this.printers.clear();
+      for (const printer of printers) {
+        if (printer.id) {
+          this.printers.set(printer.id, printer);
+        }
+      }
+
+      // Load global config
+      const globalConfig = this.storage.get<GlobalConfig | null>(KEYS.GLOBAL_CONFIG, null);
+      if (globalConfig) {
+        this.globalConfig = { ...DEFAULT_GLOBAL_CONFIG, ...globalConfig };
+      }
+
+      // Load last used
+      this.lastUsedPrinterId = this.storage.get<string | null>(KEYS.LAST_USED_PRINTER, null);
+
+      this.logger.debug(`Loaded ${this.printers.size} saved printers`);
+    } catch (error) {
+      this.logger.error('Failed to load configuration:', error);
+    }
+  }
+
+  /**
+   * Save configuration to storage
+   */
+  private save(): void {
+    try {
+      // Save printers
+      const printersArray = Array.from(this.printers.values());
+      this.storage.set(KEYS.PRINTERS, printersArray);
+
+      // Save global config
+      this.storage.set(KEYS.GLOBAL_CONFIG, this.globalConfig);
+
+      // Save last used
+      if (this.lastUsedPrinterId) {
+        this.storage.set(KEYS.LAST_USED_PRINTER, this.lastUsedPrinterId);
+      } else {
+        this.storage.remove(KEYS.LAST_USED_PRINTER);
+      }
+    } catch (error) {
+      this.logger.error('Failed to save configuration:', error);
+    }
+  }
+
+  /**
+   * Save a printer configuration
+   *
+   * @param printer - Printer configuration to save
+   * @returns The saved printer ID
+   */
+  savePrinter(printer: SavedPrinter): string {
+    const now = Date.now();
+    const existing = this.printers.get(printer.id);
+
+    const savedPrinter: SavedPrinter = {
+      ...printer,
+      id: printer.id,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+    };
+
+    // If setting as default, unset other defaults
+    if (savedPrinter.isDefault) {
+      for (const [id, p] of this.printers.entries()) {
+        if (id !== printer.id && p.isDefault) {
+          this.printers.set(id, { ...p, isDefault: false });
+        }
+      }
+    }
+
+    this.printers.set(printer.id, savedPrinter);
+    this.save();
+
+    this.logger.info(`Saved printer: ${printer.id} (${printer.name})`);
+    return printer.id;
+  }
+
+  /**
+   * Get a saved printer by ID
+   */
+  getPrinter(id: string): SavedPrinter | undefined {
+    return this.printers.get(id);
+  }
+
+  /**
+   * Get all saved printers
+   */
+  getSavedPrinters(): SavedPrinter[] {
+    return Array.from(this.printers.values());
+  }
+
+  /**
+   * Get default printer
+   */
+  getDefaultPrinter(): SavedPrinter | undefined {
+    for (const printer of this.printers.values()) {
+      if (printer.isDefault) {
+        return printer;
+      }
+    }
+
+    // Fall back to last used
+    if (this.lastUsedPrinterId) {
+      return this.printers.get(this.lastUsedPrinterId);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Remove a saved printer
+   */
+  removePrinter(id: string): boolean {
+    const deleted = this.printers.delete(id);
+    if (deleted) {
+      this.save();
+      this.logger.info(`Removed printer: ${id}`);
+
+      if (this.lastUsedPrinterId === id) {
+        this.lastUsedPrinterId = null;
+        this.save();
+      }
+    }
+    return deleted;
+  }
+
+  /**
+   * Set printer as default
+   */
+  setDefaultPrinter(id: string): void {
+    const printer = this.printers.get(id);
+    if (!printer) {
+      throw new Error(`Printer not found: ${id}`);
+    }
+
+    // Unset other defaults
+    for (const [pid, p] of this.printers.entries()) {
+      if (p.isDefault && pid !== id) {
+        this.printers.set(pid, { ...p, isDefault: false });
+      }
+    }
+
+    // Set this one as default
+    this.printers.set(id, { ...printer, isDefault: true });
+    this.save();
+
+    this.logger.info(`Set default printer: ${id}`);
+  }
+
+  /**
+   * Update last used printer
+   */
+  setLastUsed(id: string): void {
+    if (!this.printers.has(id)) {
+      this.logger.warn(`Cannot set last used: printer not found ${id}`);
+      return;
+    }
+
+    this.lastUsedPrinterId = id;
+
+    // Also update lastConnected timestamp
+    const printer = this.printers.get(id);
+    if (printer) {
+      this.printers.set(id, { ...printer, lastConnected: Date.now() });
+    }
+
+    this.save();
+  }
+
+  /**
+   * Get last used printer ID
+   */
+  getLastUsedId(): string | null {
+    return this.lastUsedPrinterId;
+  }
+
+  /**
+   * Get global configuration
+   */
+  getGlobalConfig(): GlobalConfig {
+    return { ...this.globalConfig };
+  }
+
+  /**
+   * Update global configuration
+   */
+  updateGlobalConfig(updates: Partial<GlobalConfig>): void {
+    this.globalConfig = { ...this.globalConfig, ...updates };
+    this.save();
+    this.logger.debug('Global config updated');
+  }
+
+  /**
+   * Reset global config to defaults
+   */
+  resetGlobalConfig(): void {
+    this.globalConfig = { ...DEFAULT_GLOBAL_CONFIG };
+    this.save();
+    this.logger.info('Global config reset to defaults');
+  }
+
+  /**
+   * Load print config for a printer (with defaults applied)
+   */
+  loadPrinterConfig(printerId: string): PrintConfig {
+    const printer = this.printers.get(printerId);
+    const printConfig = printer?.printConfig || {};
+
+    return {
+      encoding: printConfig.encoding ?? this.globalConfig.defaultEncoding,
+      chunkSize: printConfig.chunkSize ?? this.globalConfig.defaultChunkSize,
+      chunkDelay: printConfig.chunkDelay ?? this.globalConfig.defaultChunkDelay,
+      retries: printConfig.retries ?? this.globalConfig.defaultRetries,
+    };
+  }
+
+  /**
+   * Export all configuration as JSON
+   */
+  export(): string {
+    return JSON.stringify({
+      printers: Array.from(this.printers.values()),
+      globalConfig: this.globalConfig,
+      lastUsedPrinterId: this.lastUsedPrinterId,
+      exportedAt: Date.now(),
+    }, null, 2);
+  }
+
+  /**
+   * Import configuration from JSON
+   *
+   * @param json - JSON string to import
+   * @param merge - If true, merge with existing config; if false, replace
+   * @returns Number of printers imported
+   */
+  import(json: string, merge = false): number {
+    try {
+      const data = JSON.parse(json) as {
+        printers?: SavedPrinter[];
+        globalConfig?: GlobalConfig;
+        lastUsedPrinterId?: string;
+      };
+
+      let imported = 0;
+
+      if (!merge) {
+        this.printers.clear();
+      }
+
+      if (data.printers && Array.isArray(data.printers)) {
+        for (const printer of data.printers) {
+          if (printer.id) {
+            this.printers.set(printer.id, printer);
+            imported++;
+          }
+        }
+      }
+
+      if (data.globalConfig) {
+        this.globalConfig = { ...DEFAULT_GLOBAL_CONFIG, ...data.globalConfig };
+      }
+
+      if (data.lastUsedPrinterId && this.printers.has(data.lastUsedPrinterId)) {
+        this.lastUsedPrinterId = data.lastUsedPrinterId;
+      }
+
+      this.save();
+      this.logger.info(`Imported ${imported} printers`);
+
+      return imported;
+    } catch (error) {
+      this.logger.error('Failed to import configuration:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Clear all configuration
+   */
+  clear(): void {
+    this.printers.clear();
+    this.lastUsedPrinterId = null;
+    this.storage.clear();
+    this.logger.info('All configuration cleared');
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    printerCount: number;
+    hasDefault: boolean;
+    lastUsed: string | null;
+  } {
+    let hasDefault = false;
+    for (const printer of this.printers.values()) {
+      if (printer.isDefault) {
+        hasDefault = true;
+        break;
+      }
+    }
+
+    return {
+      printerCount: this.printers.size,
+      hasDefault,
+      lastUsed: this.lastUsedPrinterId,
+    };
+  }
+}
+
+// Export singleton for convenience
+export const printerConfigManager = new PrinterConfigManager();

package/src/config/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Config Module
+ * 配置模块 - 提供打印机配置管理
+ */
+
+export { PrinterConfigManager, printerConfigManager } from './PrinterConfigManager';
+export type {
+  SavedPrinter,
+  PrintConfig,
+  GlobalConfig,
+  IConfigStorage,
+} from './PrinterConfigManager';
+
+export { DEFAULT_CONFIG, mergeConfig } from './PrinterConfig';
+export type { PrinterConfig, AdapterConfig, DriverConfig, LoggingConfig } from './PrinterConfig';

package/src/core/BluetoothPrinter.ts

@@ -60,7 +60,7 @@ export interface PrinterEvents {
  * ```
  */
 export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
-  private readonly logger = Logger.scope('BluetoothPrinter');
+  private readonly printerLogger = Logger.scope('BluetoothPrinter');
 
   /** Current printer state */
   public state: PrinterState = PrinterState.DISCONNECTED;
@@ -155,7 +155,7 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
     }
 
     this.emit('state-change', this.state);
-    this.logger.debug('State updated:', this.state);
+    this.printerLogger.debug('State updated:', this.state);
   }
 
   /**
@@ -171,13 +171,13 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
    * ```
    */
   async connect(deviceId: string): Promise<this> {
-    this.logger.info('Connecting to device:', deviceId);
+    this.printerLogger.info('Connecting to device:', deviceId);
 
     try {
       await this.connectionManager.connect(deviceId);
       this.updateState();
       this.emit('connected', deviceId);
-      this.logger.info('Connected successfully');
+      this.printerLogger.info('Connected successfully');
 
       return this;
     } catch (error) {
@@ -208,18 +208,18 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
   async disconnect(): Promise<void> {
     const deviceId = this.connectionManager.getDeviceId();
     if (!deviceId) {
-      this.logger.warn('Disconnect called but no device connected');
+      this.printerLogger.warn('Disconnect called but no device connected');
       return;
     }
 
-    this.logger.info('Disconnecting from device:', deviceId);
+    this.printerLogger.info('Disconnecting from device:', deviceId);
 
     try {
       await this.connectionManager.disconnect();
       this.printJobManager.cancel();
       this.updateState();
       this.emit('disconnected', deviceId);
-      this.logger.info('Disconnected successfully');
+      this.printerLogger.info('Disconnected successfully');
     } catch (error) {
       const printError = new BluetoothPrintError(
         ErrorCode.DEVICE_DISCONNECTED,
@@ -346,7 +346,7 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
   pause(): void {
     this.printJobManager.pause();
     this.updateState();
-    this.logger.info('Print job paused');
+    this.printerLogger.info('Print job paused');
   }
 
   /**
@@ -360,12 +360,12 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
    * ```
    */
   async resume(): Promise<void> {
-    this.logger.info('Resuming print job');
+    this.printerLogger.info('Resuming print job');
 
     try {
       await this.printJobManager.resume();
       this.updateState();
-      this.logger.info('Print job resumed');
+      this.printerLogger.info('Print job resumed');
     } catch (error) {
       const printError = new BluetoothPrintError(
         ErrorCode.PRINT_JOB_FAILED,
@@ -390,7 +390,7 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
     this.printJobManager.cancel();
     this.commandBuilder.clear();
     this.updateState();
-    this.logger.info('Print job cancelled');
+    this.printerLogger.info('Print job cancelled');
   }
 
   /**
@@ -439,7 +439,7 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
     }
 
     const buffer = this.commandBuilder.getBuffer();
-    this.logger.info(`Starting print job: ${buffer.length} bytes`);
+    this.printerLogger.info(`Starting print job: ${buffer.length} bytes`);
 
     // Clear the command buffer after getting the buffer for printing
     this.commandBuilder.clear();
@@ -462,14 +462,14 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
 
       if (isPaused) {
         // Print job was paused
-        this.logger.info('Print job paused');
+        this.printerLogger.info('Print job paused');
       } else {
         // Print job completed successfully
         this.emit('print-complete');
-        this.logger.info('Print job completed successfully');
+        this.printerLogger.info('Print job completed successfully');
       }
     } catch (error) {
-      this.logger.error('Print job failed with error:', error);
+      this.printerLogger.error('Print job failed with error:', error);
       const printError =
         error instanceof BluetoothPrintError
           ? error