taro-bluetooth-print 2.3.1 → 2.4.1

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/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): 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';

package/dist/types/index.d.ts

@@ -17,8 +17,10 @@ export { AdapterFactory } from './adapters/AdapterFactory';
 export { BaseAdapter } from './adapters/BaseAdapter';
 export type { WebBluetoothRequestOptions } from './adapters/WebBluetoothAdapter';
 export * from './services';
-export { DeviceManager } from './device/DeviceManager';
+export { DeviceManager, deviceManager } from './device/DeviceManager';
 export type { BluetoothDevice, ScanOptions, DeviceManagerEvents } from './device/DeviceManager';
+export { MultiPrinterManager, multiPrinterManager } from './device/MultiPrinterManager';
+export type { PrinterConnection, MultiConnectOptions, BroadcastOptions, MultiPrinterManagerEvents, } from './device/MultiPrinterManager';
 export { PrintQueue } from './queue/PrintQueue';
 export type { PrintJob, PrintJobStatus, PrintJobPriority, QueueConfig, PrintQueueEvents, } from './queue/PrintQueue';
 export { OfflineCache } from './cache/OfflineCache';
@@ -40,6 +42,8 @@ export { PlatformType, detectPlatform, isPlatformSupported } from './utils/platf
 export { BluetoothPrintError, ErrorCode } from './errors/BluetoothError';
 export { DEFAULT_CONFIG, mergeConfig } from './config/PrinterConfig';
 export type { PrinterConfig, AdapterConfig, DriverConfig, LoggingConfig, } from './config/PrinterConfig';
+export { PrinterConfigManager, printerConfigManager } from './config/PrinterConfigManager';
+export type { SavedPrinter, GlobalConfig, IConfigStorage } from './config/PrinterConfigManager';
 export { PluginManager } from './plugins/PluginManager';
 export { createLoggingPlugin, createRetryPlugin } from './plugins';
 export type { Plugin, PluginHooks, PluginOptions, PluginFactory } from './plugins/types';

package/dist/types/services/BatchPrintManager.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Batch Print Manager
+ *
+ * Optimizes printing multiple jobs by:
+ * - Merging small jobs into larger chunks
+ * - Reducing Bluetooth communication overhead
+ * - Prioritizing urgent jobs
+ * - Batching similar content for efficiency
+ *
+ * @example
+ * ```typescript
+ * const batchManager = new BatchPrintManager();
+ *
+ * // Add print jobs
+ * batchManager.addJob({ data: buffer1, priority: 1 });
+ * batchManager.addJob({ data: buffer2, priority: 2 });
+ *
+ * // Process batch when ready
+ * await batchManager.processBatch();
+ * ```
+ */
+/**
+ * Batch job entry
+ */
+export interface BatchJob {
+    /** Unique job ID */
+    id: string;
+    /** Print data */
+    data: Uint8Array;
+    /** Priority (higher = more urgent) */
+    priority: number;
+    /** Timestamp when added */
+    addedAt: number;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Batch configuration
+ */
+export interface BatchConfig {
+    /** Maximum batch size in bytes */
+    maxBatchSize: number;
+    /** Maximum wait time before processing in ms */
+    maxWaitTime: number;
+    /** Minimum jobs before batching */
+    minBatchSize: number;
+    /** Merge similar content */
+    enableMerging: boolean;
+    /** Auto-process interval in ms (0 = disabled) */
+    autoProcessInterval: number;
+}
+/**
+ * Batch statistics
+ */
+export interface BatchStats {
+    /** Total jobs added */
+    totalJobs: number;
+    /** Total bytes processed */
+    totalBytes: number;
+    /** Batches processed */
+    batchesProcessed: number;
+    /** Average batch size */
+    avgBatchSize: number;
+    /** Merged jobs count */
+    mergedJobs: number;
+}
+/**
+ * Batch events
+ */
+export interface BatchEvents {
+    'batch-ready': (data: BatchJob[]) => void;
+    'batch-processed': (data: {
+        jobCount: number;
+        bytes: number;
+    }) => void;
+    'job-added': (data: BatchJob) => void;
+    'job-rejected': (data: {
+        reason: string;
+    }) => void;
+}
+/**
+ * Batch Print Manager
+ *
+ * Collects print jobs and processes them in optimized batches.
+ * Reduces Bluetooth communication overhead by combining small jobs.
+ */
+export declare class BatchPrintManager {
+    private readonly logger;
+    private readonly jobs;
+    private readonly listeners;
+    private config;
+    private isProcessing;
+    private waitTimer;
+    private autoProcessTimer;
+    private stats;
+    /**
+     * Creates a new BatchPrintManager instance
+     */
+    constructor(config?: Partial<BatchConfig>);
+    /**
+     * Register event listener
+     */
+    on<K extends keyof BatchEvents>(event: K, callback: BatchEvents[K]): void;
+    /**
+     * Remove event listener
+     */
+    off<K extends keyof BatchEvents>(event: K, callback: BatchEvents[K]): void;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Add a job to the batch queue
+     *
+     * @param data - Print data
+     * @param priority - Job priority (higher = more urgent)
+     * @param metadata - Optional metadata
+     * @returns Job ID
+     */
+    addJob(data: Uint8Array, priority?: number, metadata?: Record<string, unknown>): string;
+    /**
+     * Add multiple jobs at once
+     */
+    addJobs(jobs: Array<{
+        data: Uint8Array;
+        priority?: number;
+        metadata?: Record<string, unknown>;
+    }>): string[];
+    /**
+     * Cancel a job by ID
+     */
+    cancelJob(id: string): boolean;
+    /**
+     * Cancel all jobs
+     */
+    cancelAll(): void;
+    /**
+     * Get pending job count
+     */
+    get pendingCount(): number;
+    /**
+     * Get pending jobs
+     */
+    getPendingJobs(): BatchJob[];
+    /**
+     * Get current statistics
+     */
+    getStats(): BatchStats;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<BatchConfig>): void;
+    /**
+     * Process the current batch
+     *
+     * @param processor - Function to send batch data to printer
+     * @returns Number of jobs processed
+     */
+    processBatch(processor: (data: Uint8Array) => Promise<void>): Promise<number>;
+    /**
+     * Prepare batch from pending jobs
+     */
+    private prepareBatch;
+    /**
+     * Merge multiple jobs into a single buffer
+     */
+    private mergeJobs;
+    /**
+     * Check if we should process immediately
+     */
+    private shouldProcessImmediately;
+    /**
+     * Start the wait timer
+     */
+    private startWaitTimer;
+    /**
+     * Clear wait timer
+     */
+    private clearWaitTimer;
+    /**
+     * Start auto-process timer
+     */
+    private startAutoProcess;
+    /**
+     * Stop auto-process timer
+     */
+    private stopAutoProcess;
+    /**
+     * Clear all timers
+     */
+    private clearTimers;
+    /**
+     * Generate unique job ID
+     */
+    private generateId;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Destroy the manager
+     */
+    destroy(): void;
+}
+export declare const batchPrintManager: BatchPrintManager;