taro-bluetooth-print 2.5.0 → 2.6.0

package/dist/logo.svg

@@ -0,0 +1,17 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Background circle -->
+  <circle cx="32" cy="32" r="30" fill="#10b981" opacity="0.1"/>
+  <circle cx="32" cy="32" r="28" fill="#10b981" opacity="0.2"/>
+  <!-- Printer body -->
+  <rect x="12" y="20" width="40" height="28" rx="4" fill="#10b981"/>
+  <!-- Paper slot -->
+  <rect x="16" y="8" width="32" height="16" rx="2" fill="#ffffff" stroke="#10b981" stroke-width="2"/>
+  <!-- Paper lines -->
+  <line x1="20" y1="14" x2="36" y2="14" stroke="#10b981" stroke-width="2" stroke-linecap="round"/>
+  <line x1="20" y1="18" x2="30" y2="18" stroke="#10b981" stroke-width="2" stroke-linecap="round"/>
+  <!-- Bluetooth symbol -->
+  <path d="M32 26 L36 30 L32 34 L28 30 Z" fill="#ffffff"/>
+  <line x1="32" y1="30" x2="32" y2="38" stroke="#ffffff" stroke-width="2" stroke-linecap="round"/>
+  <!-- Feed button -->
+  <rect x="46" y="36" width="4" height="6" rx="1" fill="#ffffff" opacity="0.6"/>
+</svg>

package/dist/manifest.webmanifest

@@ -0,0 +1,17 @@
+{
+  "name": "taro-bluetooth-print",
+  "short_name": "蓝牙打印",
+  "description": "轻量级、高性能的热敏/标签蓝牙打印库",
+  "start_url": "/taro-bluetooth-print/",
+  "display": "standalone",
+  "background_color": "#ffffff",
+  "theme_color": "#10b981",
+  "icons": [
+    {
+      "src": "/logo.svg",
+      "sizes": "any",
+      "type": "image/svg+xml"
+    }
+  ],
+  "categories": ["developer tools", "utilities"]
+}

package/dist/types/adapters/WebBluetoothAdapter.d.ts

@@ -12,6 +12,47 @@ export interface WebBluetoothRequestOptions {
     acceptAllDevices?: boolean;
     /** Optional services to access */
     optionalServices?: string[];
+    /** Minimum RSSI signal strength (dBm) to accept device */
+    minRSSI?: number;
+    /** Filter by device name (exact or partial match) */
+    name?: string;
+    /** Filter by manufacturer data patterns */
+    manufacturerDataFilter?: Array<{
+        companyIdentifier: number;
+        dataPrefix?: Uint8Array;
+    }>;
+}
+/**
+ * Discovered device information
+ */
+export interface DiscoveredDevice {
+    /** Device instance */
+    device: BluetoothDevice;
+    /** Device name */
+    name: string;
+    /** Device ID */
+    deviceId: string;
+    /** RSSI signal strength (dBm) */
+    rssi?: number;
+    /** Timestamp when device was discovered */
+    discoveredAt: number;
+    /** Manufacturer data if available */
+    manufacturerData?: Map<number, Uint8Array>;
+}
+/**
+ * Device filter options for scanning
+ */
+export interface DeviceFilterOptions {
+    /** Minimum RSSI threshold (dBm) */
+    minRSSI?: number;
+    /** Maximum RSSI threshold (dBm) */
+    maxRSSI?: number;
+    /** Name prefix filter */
+    namePrefix?: string;
+    /** Name exact match filter */
+    name?: string;
+    /** Service UUIDs to filter */
+    serviceUUIDs?: string[];
 }
 /**
  * Web Bluetooth adapter for H5 environment
@@ -29,6 +70,8 @@ export interface WebBluetoothRequestOptions {
  */
 export declare class WebBluetoothAdapter extends BaseAdapter {
     private devices;
+    private discoveredDevices;
+    private connectionCleanupTimeout;
     /**
      * Check if Web Bluetooth API is supported in the current browser
      * @returns True if Web Bluetooth is supported
@@ -52,10 +95,12 @@ export declare class WebBluetoothAdapter extends BaseAdapter {
     connect(deviceId: string): Promise<void>;
     /**
      * Disconnect from a Bluetooth device
+     * Enhanced to properly clean up all resources and event listeners
      *
      * @param deviceId - Bluetooth device ID
+     * @param force - If true, force disconnection even if device not found in cache
      */
-    disconnect(deviceId: string): Promise<void>;
+    disconnect(deviceId: string, force?: boolean): void;
     /**
      * Write data to the Bluetooth device
      *
@@ -65,6 +110,42 @@ export declare class WebBluetoothAdapter extends BaseAdapter {
      * @throws {BluetoothPrintError} When write fails
      */
     write(deviceId: string, buffer: ArrayBuffer, options?: IAdapterOptions): Promise<void>;
+    /**
+     * Get device ID from a BluetoothDevice instance
+     * Handles different browser implementations
+     *
+     * @param device - BluetoothDevice instance
+     * @returns Device ID string
+     */
+    getDeviceId(device: BluetoothDevice): string;
+    /**
+     * Get device information including RSSI
+     *
+     * @param deviceId - Bluetooth device ID
+     * @returns Device info object with RSSI and metadata
+     */
+    getDeviceInfo(deviceId: string): {
+        deviceId: string;
+        name: string;
+        rssi?: number;
+        connected: boolean;
+    } | null;
+    /**
+     * Filter discovered devices by criteria
+     *
+     * @param devices - Array of discovered devices
+     * @param filter - Filter criteria
+     * @returns Filtered array of devices
+     */
+    filterDevices(devices: DiscoveredDevice[], filter: DeviceFilterOptions): DiscoveredDevice[];
+    /**
+     * Sort devices by signal strength (RSSI)
+     *
+     * @param devices - Array of discovered devices
+     * @param ascending - Sort in ascending order (weakest first), default false (strongest first)
+     * @returns Sorted array
+     */
+    sortByRSSI(devices: DiscoveredDevice[], ascending?: boolean): DiscoveredDevice[];
     /**
      * Build request options for navigator.bluetooth.requestDevice
      */
@@ -89,4 +170,9 @@ export declare class WebBluetoothAdapter extends BaseAdapter {
      * Clean up device information
      */
     private cleanupDeviceInfo;
+    /**
+     * Generate a fallback device ID when device.id is not available
+     * Uses device name + first seen timestamp as identifier
+     */
+    private generateFallbackDeviceId;
 }

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

@@ -2,7 +2,7 @@
  * Adapters barrel export
  */
 export { BaseAdapter, MiniProgramAdapter } from './BaseAdapter';
-export type { MiniProgramBLEApi, ServiceInfo, BLECharacteristic, BLECharacteristicProperties } from './BaseAdapter';
+export type { MiniProgramBLEApi, ServiceInfo, BLECharacteristic, BLECharacteristicProperties, } from './BaseAdapter';
 export { TaroAdapter } from './TaroAdapter';
 export { AlipayAdapter } from './AlipayAdapter';
 export { BaiduAdapter } from './BaiduAdapter';

package/dist/types/barcode/BarcodeGenerator.d.ts

@@ -1,8 +1,8 @@
 /**
  * Barcode Generator
  *
- * Generates ESC/POS commands for printing 1D barcodes.
- * Supports Code128, Code39, EAN-13, EAN-8, UPC-A, ITF, and CODABAR formats.
+ * Generates ESC/POS commands for printing 1D barcodes and 2D codes.
+ * Supports Code128, Code39, EAN-13, EAN-8, UPC-A, ITF, CODABAR, QR_CODE, and PDF417 formats.
  *
  * @example
  * ```typescript
@@ -31,7 +31,11 @@ export declare enum BarcodeFormat {
     /** ITF (Interleaved 2 of 5) - Even number of digits */
     ITF = "ITF",
     /** CODABAR - Numeric with special start/stop chars */
-    CODABAR = "CODABAR"
+    CODABAR = "CODABAR",
+    /** QR Code - 2D matrix code */
+    QR_CODE = "QR_CODE",
+    /** PDF417 - 2D stacked barcode */
+    PDF417 = "PDF417"
 }
 /**
  * Barcode configuration options
@@ -47,6 +51,16 @@ export interface BarcodeOptions {
     showText?: boolean;
     /** Text position */
     textPosition?: 'above' | 'below' | 'both' | 'none';
+    /** QR code error correction level (L/M/Q/H, default: M) */
+    errorCorrection?: 'L' | 'M' | 'Q' | 'H';
+    /** QR code model (1 or 2, default: 2) */
+    qrModel?: 1 | 2;
+    /** PDF417 compression mode (0-3, default: 2) */
+    pdf417Compression?: 0 | 1 | 2 | 3;
+    /** PDF417 security level (0-8, default: 2) */
+    pdf417Security?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    /** PDF417 columns (1-30, default: 2) */
+    pdf417Columns?: number;
 }
 /**
  * Validation result
@@ -74,7 +88,7 @@ export interface IBarcodeGenerator {
 }
 /**
  * Barcode Generator class
- * Generates ESC/POS commands for 1D barcodes
+ * Generates ESC/POS commands for 1D barcodes and 2D codes
  */
 export declare class BarcodeGenerator implements IBarcodeGenerator {
     /**
@@ -85,6 +99,29 @@ export declare class BarcodeGenerator implements IBarcodeGenerator {
      * @returns Array of ESC/POS command buffers
      */
     generate(content: string, options: BarcodeOptions): Uint8Array[];
+    /**
+     * Generate 1D barcode commands
+     */
+    private generate1DBarcode;
+    /**
+     * Generate QR code commands using ESC/POS GS k 80-83
+     *
+     * @param content - QR code content
+     * @param options - QR code options
+     * @returns Array of ESC/POS command buffers
+     */
+    private generateQRCode;
+    /**
+     * Generate PDF417 commands using ESC/POS GS k 81
+     *
+     * PDF417 is a 2D stacked barcode format supported by many thermal printers.
+     * The printer will handle the actual encoding and generation of the PDF417 symbol.
+     *
+     * @param content - PDF417 content (text data)
+     * @param options - PDF417 options
+     * @returns Array of ESC/POS command buffers
+     */
+    private generatePDF417;
     /**
      * Validate barcode content for the specified format
      *
@@ -93,6 +130,14 @@ export declare class BarcodeGenerator implements IBarcodeGenerator {
      * @returns Validation result
      */
     validate(content: string, format: BarcodeFormat): ValidationResult;
+    /**
+     * Validate QR code content
+     */
+    private validateQRCode;
+    /**
+     * Validate PDF417 content
+     */
+    private validatePDF417;
     /**
      * Get list of supported barcode formats
      *
@@ -139,6 +184,10 @@ export declare class BarcodeGenerator implements IBarcodeGenerator {
      * Encode content for ESC/POS barcode command
      */
     private encodeContent;
+    /**
+     * Encode string to UTF-8 bytes
+     */
+    private encodeUTF8;
     /**
      * Get text position code
      */
@@ -151,5 +200,13 @@ export declare class BarcodeGenerator implements IBarcodeGenerator {
      * Clamp width to valid range (2-6)
      */
     private clampWidth;
+    /**
+     * Clamp QR code size to valid range (1-16)
+     */
+    private clampQRSize;
+    /**
+     * Clamp PDF417 columns to valid range (1-30)
+     */
+    private clampPDF417Columns;
 }
 export declare const barcodeGenerator: BarcodeGenerator;

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

@@ -1,6 +1,6 @@
 /**
  * Barcode Generator Module
- * 条码生成模块 - 负责一维条码生成
+ * 条码生成模块 - 负责一维条码和二维条码生成
  */
 export { BarcodeGenerator, barcodeGenerator, BarcodeFormat } from './BarcodeGenerator';
 export type { BarcodeOptions, ValidationResult, IBarcodeGenerator } from './BarcodeGenerator';

package/dist/types/template/TemplateEngine.d.ts

@@ -69,6 +69,117 @@ export interface LabelData {
     productionDate?: string;
     expiryDate?: string;
 }
+/**
+ * Loop element for iterating over arrays
+ */
+export interface LoopElement {
+    /** Element type identifier */
+    type: 'loop';
+    /** Variable name to iterate over (array) */
+    items: string;
+    /** Item variable name for each iteration */
+    itemVar: string;
+    /** Index variable name (optional) */
+    indexVar?: string;
+    /** Template elements to render for each item */
+    elements: TemplateElement[];
+    /** Separator between iterations (optional) */
+    separator?: string;
+}
+/**
+ * Condition element for conditional rendering
+ */
+export interface ConditionElement {
+    /** Element type identifier */
+    type: 'condition';
+    /** Variable name to evaluate */
+    variable: string;
+    /** Operator for comparison */
+    operator: 'exists' | 'not_exists' | 'equals' | 'not_equals' | 'gt' | 'gte' | 'lt' | 'lte' | 'truthy' | 'falsy';
+    /** Value to compare against (for binary operators) */
+    value?: unknown;
+    /** Elements to render when condition is true */
+    then: TemplateElement[];
+    /** Elements to render when condition is false (optional) */
+    else?: TemplateElement[];
+}
+/**
+ * Border style for box/table drawing
+ */
+export type BorderStyle = 'single' | 'double' | 'thick' | 'rounded' | 'dashed' | 'none';
+/**
+ * Border element for drawing boxes/lines
+ */
+export interface BorderElement {
+    /** Element type identifier */
+    type: 'border';
+    /** Border style */
+    style?: BorderStyle;
+    /** Top-left corner character */
+    topLeft?: string;
+    /** Top-right corner character */
+    topRight?: string;
+    /** Bottom-left corner character */
+    bottomLeft?: string;
+    /** Bottom-right corner character */
+    bottomRight?: string;
+    /** Top border character */
+    top?: string;
+    /** Bottom border character */
+    bottom?: string;
+    /** Left border character */
+    left?: string;
+    /** Right border character */
+    right?: string;
+    /** Intersection character */
+    cross?: string;
+    /** Whether to draw top border */
+    drawTop?: boolean;
+    /** Whether to draw bottom border */
+    drawBottom?: boolean;
+    /** Whether to draw left border */
+    drawLeft?: boolean;
+    /** Whether to draw right border */
+    drawRight?: boolean;
+    /** Whether to fill inside with spaces */
+    filled?: boolean;
+    /** Inner padding (default: 0) */
+    padding?: number;
+}
+/**
+ * Table column definition
+ */
+export interface TableColumn {
+    /** Column header text */
+    header: string;
+    /** Width of column in characters */
+    width: number;
+    /** Text alignment for header */
+    headerAlign?: TextAlign;
+    /** Text alignment for cells */
+    cellAlign?: TextAlign;
+}
+/**
+ * Table row data
+ */
+export type TableRowData = Record<string, string | number>;
+/**
+ * Table element for drawing table-like structures
+ */
+export interface TableElement {
+    /** Element type identifier */
+    type: 'table';
+    /** Table columns definition */
+    columns: TableColumn[];
+    /** Variable name of array to render as rows */
+    rowsVar: string;
+    /** Whether to draw header row */
+    showHeader?: boolean;
+    /** Border style for table */
+    borderStyle?: BorderStyle;
+    /** Whether to alternate row shading */
+    alternateRows?: boolean;
+}
 /**
  * Template element types
  */
@@ -103,7 +214,7 @@ export type TemplateElement = {
     type: 'variable';
     name: string;
     format?: string;
-};
+} | LoopElement | ConditionElement | BorderElement | TableElement;
 /**
  * Template definition
  */
@@ -177,6 +288,34 @@ export declare class TemplateEngine implements ITemplateEngine {
      * Render a single template element
      */
     private renderElement;
+    /**
+     * Render a loop element
+     */
+    private renderLoop;
+    /**
+     * Render a condition element
+     */
+    private renderCondition;
+    /**
+     * Evaluate a condition
+     */
+    private evaluateCondition;
+    /**
+     * Render a border element
+     */
+    private renderBorder;
+    /**
+     * Render a table element
+     */
+    private renderTable;
+    /**
+     * Align text within a specified width
+     */
+    private alignText;
+    /**
+     * Render standard elements (text, line, image, qrcode, barcode, feed, variable)
+     */
+    private renderStandardElement;
     /**
      * Render a separator line
      */

package/dist/types/utils/uuid.d.ts

@@ -0,0 +1,191 @@
+/**
+ * UUID Utility Module
+ *
+ * Provides UUID generation and parsing utilities for device identification,
+ * job tracking, and unique identifier generation.
+ *
+ * @example
+ * ```typescript
+ * import { generateUUID, parseUUID, isValidUUID } from '@/utils/uuid';
+ *
+ * const id = generateUUID(); // v4 UUID
+ * const parsed = parseUUID(id);
+ * const valid = isValidUUID(id);
+ * ```
+ */
+/**
+ * UUID version numbers
+ */
+export declare enum UUIDVersion {
+    /** Version 1: Timestamp-based */
+    V1 = 1,
+    /** Version 4: Random */
+    V4 = 4,
+    /** Version 7: Unix Epoch time-based (recommended) */
+    V7 = 7
+}
+/**
+ * Parsed UUID structure
+ */
+export interface ParsedUUID {
+    /** Raw UUID string */
+    raw: string;
+    /** UUID version */
+    version: UUIDVersion;
+    /** Variant bits */
+    variant: number;
+    /** Time component (for V1, V7) in milliseconds since epoch */
+    timestamp?: number;
+    /** Node identifier bytes (for V1) */
+    node?: string;
+    /** Random bytes (for V4) */
+    random?: string;
+    /** Whether the UUID is valid */
+    valid: boolean;
+}
+/**
+ * UUID format options
+ */
+export interface UUIDOptions {
+    /** Uppercase hex output */
+    uppercase?: boolean;
+    /** Include hyphens (default: true) */
+    hyphenated?: boolean;
+    /** UUID version to generate (default: V4) */
+    version?: UUIDVersion;
+}
+/**
+ * UUID validation result
+ */
+export interface UUIDValidationResult {
+    /** Whether the UUID is valid */
+    valid: boolean;
+    /** Version of the UUID if valid */
+    version?: UUIDVersion;
+    /** Error message if invalid */
+    error?: string;
+}
+/**
+ * UUID namespace for generating namespaced UUIDs (V5)
+ */
+export interface UUIDNamespace {
+    /** Namespace UUID */
+    uuid: string;
+    /** Namespace name */
+    name: string;
+}
+/**
+ * Predefined namespaces for namespaced UUIDs (RFC 4122)
+ */
+export declare const UUID_NAMESPACES: Record<string, UUIDNamespace>;
+/**
+ * Generate a random UUID
+ *
+ * @param version - UUID version to generate (default: V4)
+ * @param options - Generation options
+ * @returns Generated UUID string
+ *
+ * @example
+ * ```typescript
+ * const uuid = generateUUID();
+ * const uuidV7 = generateUUID(UUIDVersion.V7, { uppercase: true });
+ * ```
+ */
+export declare function generateUUID(version?: UUIDVersion, options?: UUIDOptions): string;
+/**
+ * Parse a UUID string into its components
+ *
+ * @param uuid - UUID string to parse
+ * @returns Parsed UUID structure
+ *
+ * @example
+ * ```typescript
+ * const parsed = parseUUID('550e8400-e29b-41d4-a716-446655440000');
+ * console.log(parsed.version); // 4
+ * console.log(parsed.valid); // true
+ * ```
+ */
+export declare function parseUUID(uuid: string): ParsedUUID;
+/**
+ * Validate a UUID string
+ *
+ * @param uuid - UUID string to validate
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = isValidUUID('550e8400-e29b-41d4-a716-446655440000');
+ * if (result.valid) {
+ *   console.log(`Valid UUID v${result.version}`);
+ * }
+ * ```
+ */
+export declare function isValidUUID(uuid: string): UUIDValidationResult;
+/**
+ * Extract timestamp from a time-based UUID (v1 or v7)
+ *
+ * @param uuid - UUID string
+ * @returns Timestamp in milliseconds, or null if not a time-based UUID
+ *
+ * @example
+ * ```typescript
+ * const timestamp = getUUIDTimestamp('07c450b0-7d4a-11ed-a1eb-0242ac120002');
+ * console.log(new Date(timestamp ?? 0));
+ * ```
+ */
+export declare function getUUIDTimestamp(uuid: string): number | null;
+/**
+ * Compare two UUIDs chronologically (for time-based UUIDs)
+ *
+ * @param uuidA - First UUID
+ * @param uuidB - Second UUID
+ * @returns -1 if A < B, 0 if equal, 1 if A > B
+ *
+ * @example
+ * ```typescript
+ * const order = compareUUIDs(uuid1, uuid2);
+ * ```
+ */
+export declare function compareUUIDs(uuidA: string, uuidB: string): number;
+/**
+ * Convert UUID to bytes (Uint8Array)
+ *
+ * @param uuid - UUID string
+ * @returns UUID as 16-byte array
+ */
+export declare function uuidToBytes(uuid: string): Uint8Array;
+/**
+ * Convert bytes to UUID string
+ *
+ * @param bytes - 16-byte array
+ * @param hyphenated - Include hyphens (default: true)
+ * @returns UUID string
+ */
+export declare function bytesToUUID(bytes: Uint8Array, hyphenated?: boolean): string;
+/**
+ * Generate a short ID (8-12 character hex string)
+ * Useful for display purposes like job IDs
+ *
+ * @param length - Length of ID (default: 8)
+ * @returns Short hex ID
+ *
+ * @example
+ * ```typescript
+ * const shortId = generateShortId(8); // e.g., 'a3f2b1c9'
+ * ```
+ */
+export declare function generateShortId(length?: number): string;
+/**
+ * Generate a namespaced UUID (v5)
+ *
+ * @param namespace - Namespace UUID
+ * @param name - Name within namespace
+ * @param options - Generation options
+ * @returns Namespaced UUID
+ *
+ * @example
+ * ```typescript
+ * const uuid = generateNamespacedUUID(UUID_NAMESPACES.NAMESPACE_DNS, 'example.com');
+ * ```
+ */
+export declare function generateNamespacedUUID(namespace: string, name: string, options?: UUIDOptions): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taro-bluetooth-print",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Taro 蓝牙打印库 v2.4 - 轻量级、高性能、跨平台支持微信、支付宝、百度、字节跳动小程序及H5 Web Bluetooth",
   "type": "module",
   "main": "dist/index.cjs.js",