taro-bluetooth-print 2.3.0 → 2.4.0

package/dist/types/config/PrinterConfigManager.d.ts

@@ -0,0 +1,206 @@
+/**
+ * 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');
+ * ```
+ */
+/**
+ * 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 declare class LocalStorage implements IConfigStorage {
+    private prefix;
+    constructor(prefix?: string);
+    get<T>(key: string, defaultValue: T): T;
+    set<T>(key: string, value: T): void;
+    remove(key: string): void;
+    clear(): void;
+}
+/**
+ * Printer Configuration Manager
+ */
+export declare class PrinterConfigManager {
+    private readonly logger;
+    private readonly storage;
+    private printers;
+    private globalConfig;
+    private lastUsedPrinterId;
+    /**
+     * Creates a new PrinterConfigManager instance
+     *
+     * @param storage - Storage backend (defaults to LocalStorage)
+     */
+    constructor(storage?: IConfigStorage);
+    /**
+     * Load configuration from storage
+     */
+    private load;
+    /**
+     * Save configuration to storage
+     */
+    private save;
+    /**
+     * Save a printer configuration
+     *
+     * @param printer - Printer configuration to save
+     * @returns The saved printer ID
+     */
+    savePrinter(printer: SavedPrinter): string;
+    /**
+     * Get a saved printer by ID
+     */
+    getPrinter(id: string): SavedPrinter | undefined;
+    /**
+     * Get all saved printers
+     */
+    getSavedPrinters(): SavedPrinter[];
+    /**
+     * Get default printer
+     */
+    getDefaultPrinter(): SavedPrinter | undefined;
+    /**
+     * Remove a saved printer
+     */
+    removePrinter(id: string): boolean;
+    /**
+     * Set printer as default
+     */
+    setDefaultPrinter(id: string): void;
+    /**
+     * Update last used printer
+     */
+    setLastUsed(id: string): void;
+    /**
+     * Get last used printer ID
+     */
+    getLastUsedId(): string | null;
+    /**
+     * Get global configuration
+     */
+    getGlobalConfig(): GlobalConfig;
+    /**
+     * Update global configuration
+     */
+    updateGlobalConfig(updates: Partial<GlobalConfig>): void;
+    /**
+     * Reset global config to defaults
+     */
+    resetGlobalConfig(): void;
+    /**
+     * Load print config for a printer (with defaults applied)
+     */
+    loadPrinterConfig(printerId: string): PrintConfig;
+    /**
+     * Export all configuration as JSON
+     */
+    export(): string;
+    /**
+     * 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?: boolean): number;
+    /**
+     * Clear all configuration
+     */
+    clear(): void;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        printerCount: number;
+        hasDefault: boolean;
+        lastUsed: string | null;
+    };
+}
+export declare const printerConfigManager: PrinterConfigManager;

package/dist/types/config/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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/dist/types/core/BluetoothPrinter.d.ts

@@ -50,7 +50,7 @@ export interface PrinterEvents {
  * ```
  */
 export declare class BluetoothPrinter extends EventEmitter<PrinterEvents> {
-    private readonly logger;
+    private readonly printerLogger;
     /** Current printer state */
     state: PrinterState;
     /** Connection manager instance */

package/dist/types/core/EventEmitter.d.ts

@@ -1,32 +1,12 @@
-/**
- * Type-safe event emitter for pub/sub pattern
- *
- * @template T - Event map type with event names as keys and payload types as values
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   'connected': { deviceId: string };
- *   'error': Error;
- *   'progress': { current: number; total: number };
- *   'ready': void;
- * }
- *
- * class MyClass extends EventEmitter<MyEvents> {
- *   connect() {
- *     this.emit('connected', { deviceId: '123' });
- *   }
- * }
- *
- * const instance = new MyClass();
- * const unsubscribe = instance.on('connected', (data) => {
- *   console.log('Connected to:', data.deviceId);
- * });
- * ```
- */
 export declare class EventEmitter<T> {
     private listeners;
     private debugMode;
+    protected readonly logger: {
+        debug: (message: string, ...args: unknown[]) => void;
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+    };
     /**
      * Subscribe to an event
      *

package/dist/types/core/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core Module - 核心模块
+ */
+export { BluetoothPrinter } from './BluetoothPrinter';
+export type { PrinterEvents } from './BluetoothPrinter';
+export { EventEmitter } from './EventEmitter';

package/dist/types/device/MultiPrinterManager.d.ts

@@ -0,0 +1,164 @@
+import { BluetoothPrinter } from '../core/BluetoothPrinter';
+/**
+ * Printer connection info
+ */
+export interface PrinterConnection {
+    /** Custom printer ID */
+    printerId: string;
+    /** Device ID */
+    deviceId: string;
+    /** Device name */
+    name: string;
+    /** BluetoothPrinter instance */
+    printer: BluetoothPrinter;
+    /** Connection timestamp */
+    connectedAt: number;
+    /** Last activity timestamp */
+    lastActivity?: number;
+}
+/**
+ * Connection options
+ */
+export interface MultiConnectOptions {
+    /** Custom printer ID (optional, auto-generated if not provided) */
+    printerId?: string;
+    /** Device ID to connect */
+    deviceId: string;
+    /** Connection timeout in ms */
+    timeout?: number;
+}
+/**
+ * Broadcast options
+ */
+export interface BroadcastOptions {
+    /** Parallel or sequential broadcast */
+    parallel?: boolean;
+    /** Continue on individual failure */
+    continueOnError?: boolean;
+}
+/**
+ * Multi Printer Manager Events
+ */
+export interface MultiPrinterManagerEvents {
+    /** Emitted when a printer connects */
+    'printer-connected': (data: PrinterConnection) => void;
+    /** Emitted when a printer disconnects */
+    'printer-disconnected': (data: {
+        printerId: string;
+        deviceId: string;
+    }) => void;
+    /** Emitted when a printer has an error */
+    'printer-error': (data: {
+        printerId: string;
+        error: Error;
+    }) => void;
+    /** Emitted when broadcast completes */
+    'broadcast-complete': (data: {
+        success: number;
+        failed: number;
+    }) => void;
+}
+/**
+ * Multi Printer Manager
+ *
+ * Manages multiple Bluetooth printer connections and supports:
+ * - Concurrent connections to multiple printers
+ * - Broadcasting print jobs to all printers
+ * - Individual printer control
+ * - Automatic reconnection
+ */
+export declare class MultiPrinterManager {
+    private readonly logger;
+    private readonly printers;
+    private readonly deviceToPrinter;
+    private readonly listeners;
+    /**
+     * Creates a new MultiPrinterManager instance
+     */
+    constructor();
+    /**
+     * Register event listener
+     */
+    on<K extends keyof MultiPrinterManagerEvents>(event: K, callback: MultiPrinterManagerEvents[K]): void;
+    /**
+     * Remove event listener
+     */
+    off<K extends keyof MultiPrinterManagerEvents>(event: K, callback: MultiPrinterManagerEvents[K]): void;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Connect to a printer
+     *
+     * @param printerId - Custom ID for this printer (will be auto-generated if not provided)
+     * @param deviceId - Bluetooth device ID
+     * @param deviceName - Optional device name
+     * @returns The printer ID used
+     */
+    connect(printerIdOrDeviceId: string, deviceId?: string, deviceName?: string): Promise<string>;
+    /**
+     * Disconnect a printer
+     */
+    disconnect(printerId: string): Promise<void>;
+    /**
+     * Disconnect all printers
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Get a printer by ID
+     */
+    getPrinter(printerId: string): BluetoothPrinter | undefined;
+    /**
+     * Get connection info for a printer
+     */
+    getConnection(printerId: string): PrinterConnection | undefined;
+    /**
+     * Get all connected printers
+     */
+    getAllPrinters(): PrinterConnection[];
+    /**
+     * Get printer count
+     */
+    get count(): number;
+    /**
+     * Check if a printer is connected
+     */
+    isConnected(printerId: string): boolean;
+    /**
+     * Update last activity timestamp for a printer
+     */
+    touch(printerId: string): void;
+    /**
+     * Print to a specific printer
+     */
+    print(printerId: string, data: Uint8Array): Promise<void>;
+    /**
+     * Broadcast data to all connected printers
+     */
+    broadcast(data: Uint8Array, options?: BroadcastOptions): Promise<{
+        success: number;
+        failed: number;
+    }>;
+    /**
+     * Find idle printers (for load balancing)
+     */
+    getIdlePrinters(): PrinterConnection[];
+    /**
+     * Get printer statistics
+     */
+    getStats(): {
+        total: number;
+        connected: number;
+        byName: Record<string, number>;
+    };
+    /**
+     * Clean up inactive printers (based on last activity)
+     */
+    cleanupInactive(maxIdleMs?: number): Promise<number>;
+    /**
+     * Destroy the manager and disconnect all printers
+     */
+    destroy(): Promise<void>;
+}
+export declare const multiPrinterManager: MultiPrinterManager;

package/dist/types/device/index.d.ts

@@ -4,3 +4,5 @@
  */
 export { DeviceManager, deviceManager } from './DeviceManager';
 export type { BluetoothDevice, ScanOptions, DeviceManagerEvents, IDeviceManager, } from './DeviceManager';
+export { MultiPrinterManager, multiPrinterManager } from './MultiPrinterManager';
+export type { PrinterConnection, MultiConnectOptions, BroadcastOptions, MultiPrinterManagerEvents, } from './MultiPrinterManager';