taro-bluetooth-print 2.4.1 → 2.6.0

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

@@ -0,0 +1,213 @@
+import { OfflineCache } from '../cache/OfflineCache';
+import { PrintQueue } from '../queue/PrintQueue';
+/**
+ * Scheduled retry entry
+ */
+export interface ScheduledRetry {
+    /** Job ID to retry */
+    jobId: string;
+    /** Scheduled execution time */
+    runAt: Date;
+    /** Current attempt count */
+    attemptCount: number;
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Base delay in ms for exponential backoff */
+    baseDelay: number;
+    /** Maximum delay in ms for exponential backoff */
+    maxDelay: number;
+    /** Last error message */
+    lastError?: string;
+    /** Scheduled timeout reference (internal, not serialized) */
+    timeout?: ReturnType<typeof setTimeout>;
+}
+/**
+ * Retry options
+ */
+export interface RetryOptions {
+    /** Base delay in ms (default: 1000) */
+    baseDelay?: number;
+    /** Maximum delay in ms (default: 60000) */
+    maxDelay?: number;
+    /** Maximum attempts (default: 5) */
+    maxAttempts?: number;
+}
+/**
+ * Scheduler events
+ */
+export interface ScheduledRetryEvents {
+    'retry-due': {
+        entry: ScheduledRetry;
+    };
+    'retry-executed': {
+        entry: ScheduledRetry;
+        success: boolean;
+    };
+    'retry-cancelled': {
+        jobId: string;
+    };
+    'retry-exhausted': {
+        jobId: string;
+    };
+    'schedule-restored': {
+        count: number;
+    };
+}
+/**
+ * Event handler type
+ */
+type EventHandler<T> = (data: T) => void;
+/**
+ * Scheduled retry configuration
+ */
+export interface ScheduledRetryManagerConfig {
+    /** Default base delay in ms */
+    baseDelay: number;
+    /** Default max delay in ms */
+    maxDelay: number;
+    /** Default max attempts */
+    maxAttempts: number;
+    /** Persist scheduled retries to OfflineCache */
+    persistEnabled: boolean;
+    /** Restore pending retries on startup */
+    autoRestore: boolean;
+}
+/**
+ * Scheduled Retry Manager
+ *
+ * Manages time-based retries for failed print jobs with support for:
+ * - Scheduled execution at specific times
+ * - Exponential backoff between retries
+ * - Persistence across process restarts via OfflineCache
+ * - Event-driven callbacks for retry execution
+ */
+export declare class ScheduledRetryManager {
+    private readonly logger;
+    /** Scheduled retries map: jobId -> ScheduledRetry */
+    private readonly scheduledRetries;
+    /** Event listeners */
+    private readonly listeners;
+    /** Configuration */
+    private readonly config;
+    /** Offline cache instance for persistence */
+    private readonly offlineCache;
+    /** Print queue reference for requeueing jobs */
+    private printQueue;
+    /** Retry executor function */
+    private retryExecutor;
+    /**
+     * Creates a new ScheduledRetryManager instance
+     *
+     * @param config - Optional configuration overrides
+     * @param offlineCache - Optional OfflineCache instance (uses singleton if not provided)
+     */
+    constructor(config?: Partial<ScheduledRetryManagerConfig>, offlineCache?: OfflineCache);
+    /**
+     * Set the print queue for job requeuing
+     *
+     * @param queue - PrintQueue instance
+     */
+    setPrintQueue(queue: PrintQueue): void;
+    /**
+     * Set the retry executor function
+     *
+     * @param executor - Async function that executes the retry
+     */
+    setRetryExecutor(executor: (jobId: string) => Promise<void>): void;
+    /**
+     * Schedule a retry for a specific job at a given time
+     *
+     * @param jobId - Job identifier to retry
+     * @param runAt - Date/time to execute the retry
+     * @param options - Optional retry configuration
+     */
+    scheduleRetry(jobId: string, runAt: Date, options?: RetryOptions): void;
+    /**
+     * Schedule a retry with exponential backoff starting from now
+     *
+     * @param jobId - Job identifier to retry
+     * @param options - Retry options including baseDelay, maxDelay, maxAttempts
+     */
+    scheduleRetryWithBackoff(jobId: string, options?: RetryOptions): void;
+    /**
+     * Cancel a scheduled retry
+     *
+     * @param jobId - Job identifier to cancel
+     * @returns true if a retry was cancelled, false if not found
+     */
+    cancelRetry(jobId: string): boolean;
+    /**
+     * Get all scheduled retries
+     *
+     * @returns Array of scheduled retry entries (without timeout refs)
+     */
+    getScheduledRetries(): Array<{
+        jobId: string;
+        runAt: Date;
+    }>;
+    /**
+     * Get a specific scheduled retry entry
+     *
+     * @param jobId - Job identifier
+     * @returns Scheduled retry entry or undefined
+     */
+    getScheduledRetry(jobId: string): ScheduledRetry | undefined;
+    /**
+     * Check if a job has a scheduled retry
+     *
+     * @param jobId - Job identifier
+     * @returns true if retry is scheduled
+     */
+    hasScheduledRetry(jobId: string): boolean;
+    /**
+     * Get count of scheduled retries
+     *
+     * @returns Number of pending scheduled retries
+     */
+    get pendingCount(): number;
+    /**
+     * Register event listener
+     *
+     * @param event - Event name
+     * @param callback - Event handler
+     */
+    on<K extends keyof ScheduledRetryEvents>(event: K, callback: EventHandler<ScheduledRetryEvents[K]>): void;
+    /**
+     * Remove event listener
+     *
+     * @param event - Event name
+     * @param callback - Event handler to remove
+     */
+    off<K extends keyof ScheduledRetryEvents>(event: K, callback: EventHandler<ScheduledRetryEvents[K]>): void;
+    /**
+     * Clear all scheduled retries
+     */
+    clearAll(): void;
+    /**
+     * Destroy the manager
+     */
+    destroy(): void;
+    /**
+     * Execute a scheduled retry
+     */
+    private executeRetry;
+    /**
+     * Persist a scheduled retry to OfflineCache
+     */
+    private persistRetry;
+    /**
+     * Remove a persisted retry from OfflineCache
+     */
+    private removePersistedRetry;
+    /**
+     * Restore scheduled retries from OfflineCache on startup
+     */
+    private restoreScheduledRetries;
+    /**
+     * Emit an event
+     */
+    private emit;
+}
+/** Singleton instance */
+export declare const scheduledRetryManager: ScheduledRetryManager;
+export {};

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

@@ -8,4 +8,6 @@ export { PrintJobManager } from './PrintJobManager';
 export { PrintHistory, printHistory, type PrintHistoryEntry, type PrintHistoryStats, type HistoryQueryOptions, } from './PrintHistory';
 export { PrinterStatus, printerStatus, type PrinterStatusInfo, type StatusQueryOptions, type PaperStatus, } from './PrinterStatus';
 export { BatchPrintManager, batchPrintManager, type BatchJob, type BatchConfig, type BatchStats, type BatchEvents, } from './BatchPrintManager';
+export { PrintStatistics, printStatistics, type PrintStatisticsData, type JobTrackingMeta, } from './PrintStatistics';
+export { ScheduledRetryManager, scheduledRetryManager, type ScheduledRetry, type RetryOptions, type ScheduledRetryEvents, type ScheduledRetryManagerConfig, } from './ScheduledRetryManager';
 export * from './interfaces';

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/image.d.ts

@@ -2,155 +2,76 @@
  * Image Processing Utilities
  *
  * Provides methods for converting images to printer-compatible formats.
- * Currently supports converting RGBA images to monochrome bitmaps using various dithering algorithms.
+ * Supports multiple dithering algorithms and image preprocessing.
  */
 export declare class ImageProcessing {
+    private static readonly BAYER_MATRIX_2;
+    private static readonly BAYER_MATRIX_4;
+    private static readonly BAYER_MATRIX_8;
+    private static readonly QUALITY_PRESETS;
     /**
      * Convert RGBA data to monochrome bitmap (1 bit per pixel)
      * suitable for ESC/POS GS v 0 command.
-     * Uses Floyd-Steinberg dithering for better quality by default.
-     *
-     * @param data - RGBA pixel data as Uint8Array
-     * @param width - Image width in pixels
-     * @param height - Image height in pixels
-     * @param options - Additional options for image processing
-     * @returns Monochrome bitmap data as Uint8Array
      *
      * @example
      * ```typescript
-     * const imageData = new Uint8Array(width * height * 4); // RGBA
-     * const bitmap = ImageProcessing.toBitmap(imageData, width, height, {
+     * const bitmap = ImageProcessing.toBitmap(rgbaData, width, height, {
      *   targetWidth: 384,
-     *   ditheringAlgorithm: 'atkinson',
+     *   ditheringAlgorithm: 'ordered',
      *   contrast: 1.2,
      *   brightness: 0.1
      * });
      * ```
      */
     static toBitmap(data: Uint8Array, width: number, height: number, options?: {
-        /** Target width for scaling (optional) */
         targetWidth?: number;
-        /** Target height for scaling (optional) */
         targetHeight?: number;
-        /** Whether to use dithering (default: true) */
         useDithering?: boolean;
-        /** Dithering algorithm to use: 'floyd-steinberg' | 'atkinson' (default: 'floyd-steinberg') */
-        ditheringAlgorithm?: 'floyd-steinberg' | 'atkinson';
-        /** Scaling algorithm to use: 'nearest' for nearest neighbor, 'bilinear' for bilinear interpolation (default: 'nearest') */
+        /** 'floyd-steinberg' | 'atkinson' | 'ordered' | 'halftone' | 'sierra' | 'stucki' (default: 'floyd-steinberg') */
+        ditheringAlgorithm?: 'floyd-steinberg' | 'atkinson' | 'ordered' | 'halftone' | 'sierra' | 'stucki';
         scalingAlgorithm?: 'nearest' | 'bilinear';
-        /** Contrast adjustment factor (1.0 = no adjustment) */
         contrast?: number;
-        /** Brightness adjustment factor (0.0 = no adjustment, negative = darker, positive = brighter) */
         brightness?: number;
-        /** Threshold value for binarization (0-255, default: 128) */
         threshold?: number;
+        orderedMatrixSize?: 2 | 4 | 8;
+        halftoneDotType?: 'round' | 'diamond' | 'square';
+        qualityPreset?: 'draft' | 'normal' | 'high';
     }): Uint8Array;
     /**
-     * Convert RGBA data to grayscale using optimized formula
-     *
-     * @param data - RGBA pixel data as Uint8Array
-     * @param width - Image width in pixels
-     * @param height - Image height in pixels
-     * @returns Grayscale image data as Float32Array
+     * Image preprocessing pipeline
+     * @example
+     * ```typescript
+     * const processed = ImageProcessing.preprocessImage(data, w, h, {
+     *   denoise: true,
+     *   sharpen: true,
+     *   gamma: 1.2,
+     *   posterize: 4
+     * });
+     * ```
      */
+    static preprocessImage(data: Uint8Array, width: number, height: number, options?: {
+        denoise?: boolean;
+        sharpen?: boolean;
+        gamma?: number;
+        posterize?: number;
+    }): Uint8Array;
     private static toGrayscale;
-    /**
-     * Adjust contrast and brightness of grayscale image
-     *
-     * @param grayscale - Grayscale image data
-     * @param contrast - Contrast adjustment factor (1.0 = no adjustment)
-     * @param brightness - Brightness adjustment factor (0.0 = no adjustment)
-     * @returns Adjusted grayscale image data
-     */
     private static adjustContrastBrightness;
-    /**
-     * Apply dithering to grayscale image using specified algorithm
-     *
-     * @param grayscale - Grayscale image data
-     * @param width - Image width
-     * @param height - Image height
-     * @param bitmap - Output bitmap buffer
-     * @param bytesPerLine - Number of bytes per line in the bitmap
-     * @param algorithm - Dithering algorithm to use
-     * @param threshold - Threshold value for binarization
-     */
     private static applyDithering;
-    /**
-     * Apply simple thresholding to grayscale image with adjustable threshold
-     *
-     * @param grayscale - Grayscale image data
-     * @param width - Image width
-     * @param height - Image height
-     * @param bitmap - Output bitmap buffer
-     * @param bytesPerLine - Number of bytes per line in the bitmap
-     * @param threshold - Threshold value for binarization (0-255)
-     */
+    private static applyFloydSteinbergDithering;
+    private static applyAtkinsonDithering;
+    private static applyOrderedDithering;
+    private static applyHalftone;
+    private static computeHalftoneThresholds;
+    private static applySierraDithering;
+    private static applyStuckiDithering;
     private static applyThreshold;
-    /**
-     * Scale an image to new dimensions
-     *
-     * @param data - RGBA pixel data as Uint8Array
-     * @param width - Original image width in pixels
-     * @param height - Original image height in pixels
-     * @param targetWidth - Target width in pixels
-     * @param targetHeight - Target height in pixels
-     * @param options - Additional scaling options
-     * @returns Scaled image data and dimensions
-     */
+    private static distributeErr;
     private static scaleImage;
-    /**
-     * Apply nearest neighbor scaling to an image
-     *
-     * @param srcData - Source RGBA pixel data
-     * @param srcWidth - Source image width
-     * @param srcHeight - Source image height
-     * @param destData - Destination RGBA pixel data
-     * @param destWidth - Destination image width
-     * @param destHeight - Destination image height
-     */
     private static applyNearestNeighbor;
-    /**
-     * Apply bilinear interpolation scaling to an image
-     *
-     * @param srcData - Source RGBA pixel data
-     * @param srcWidth - Source image width
-     * @param srcHeight - Source image height
-     * @param destData - Destination RGBA pixel data
-     * @param destWidth - Destination image width
-     * @param destHeight - Destination image height
-     */
     private static applyBilinearInterpolation;
-    /**
-     * Distribute quantization error to neighboring pixels using Floyd-Steinberg algorithm
-     *
-     * @param grayscale - Grayscale image data
-     * @param width - Image width
-     * @param height - Image height
-     * @param x - Current x position
-     * @param y - Current y position
-     * @param error - Quantization error to distribute
-     */
-    private static distributeErrorFloydSteinberg;
-    /**
-     * Distribute quantization error to neighboring pixels using Atkinson algorithm
-     *
-     * @param grayscale - Grayscale image data
-     * @param width - Image width
-     * @param height - Image height
-     * @param x - Current x position
-     * @param y - Current y position
-     * @param error - Quantization error to distribute
-     */
-    private static distributeErrorAtkinson;
-    /**
-     * Distribute error to a single pixel with bounds checking
-     *
-     * @param grayscale - Grayscale image data
-     * @param width - Image width
-     * @param height - Image height
-     * @param nx - New x position
-     * @param ny - New y position
-     * @param error - Error value to distribute
-     */
-    private static distributeErrorPixel;
+    private static applyGammaCorrection;
+    private static applyMedianFilter;
+    private static applyUnsharpMask;
+    private static applyPosterization;
 }

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

@@ -15,6 +15,8 @@ export declare enum PlatformType {
     BAIDU = "baidu",
     /** ByteDance Mini Program (Douyin, Toutiao) */
     BYTEDANCE = "bytedance",
+    /** QQ Mini Program */
+    QQ = "qq",
     /** Web platform */
     WEB = "web",
     /** Unknown platform */