taro-bluetooth-print 2.5.0 → 2.6.0

package/src/encoding/korean-japanese.ts

@@ -27,12 +27,11 @@
 
 // Korean Hangul Syllables (U+AC00 - U+D7AF)
 // These are composed syllables that map to EUC-KR precomposed forms
-export const HANGUL_SYLLABLE_OFFSET = 0xAC00;
-export const HANGUL_INITIAL_COUNT = 21;  // 19 initials × 21 vowels
+export const HANGUL_SYLLABLE_OFFSET = 0xac00;
+export const HANGUL_INITIAL_COUNT = 21; // 19 initials × 21 vowels
 export const HANGUL_MEDIAL_COUNT = 21;
 export const HANGUL_FINAL_COUNT = 28;
 
-
 // ============================================================================
 // Shift-JIS (Japanese) Constants
 // ============================================================================
@@ -51,18 +50,18 @@ export const HANGUL_FINAL_COUNT = 28;
  */
 
 // JIS X 0201 Katakana range
-export const SHIFT_JIS_KATAKANA_START = 0xA1;
-export const SHIFT_JIS_KATAKANA_END = 0xDF;
+export const SHIFT_JIS_KATAKANA_START = 0xa1;
+export const SHIFT_JIS_KATAKANA_END = 0xdf;
 
 // JIS X 0208 Kanji regions
 export const SHIFT_JIS_KANJI_LOW_START = 0x81;
-export const SHIFT_JIS_KANJI_LOW_END = 0x9F;
-export const SHIFT_JIS_KANJI_HIGH_START = 0xE0;
-export const SHIFT_JIS_KANJI_HIGH_END = 0xEF;
+export const SHIFT_JIS_KANJI_LOW_END = 0x9f;
+export const SHIFT_JIS_KANJI_HIGH_START = 0xe0;
+export const SHIFT_JIS_KANJI_HIGH_END = 0xef;
 
 // JIS non-pictorial (Kanji) area
 export const SHIFT_JIS_KANJI_SECOND_MIN = 0x40;
-export const SHIFT_JIS_KANJI_SECOND_MAX = 0xFC;
+export const SHIFT_JIS_KANJI_SECOND_MAX = 0xfc;
 
 // ============================================================================
 // Character Classification Helpers
@@ -72,39 +71,43 @@ export const SHIFT_JIS_KANJI_SECOND_MAX = 0xFC;
  * Check if a Unicode code point is a Korean Hangul syllable
  */
 export function isKoreanHangul(code: number): boolean {
-  return code >= 0xAC00 && code <= 0xD7AF;
+  return code >= 0xac00 && code <= 0xd7af;
 }
 
 /**
  * Check if a Unicode code point is a Korean Hanja (Hanja)
  */
 export function isKoreanHanja(code: number): boolean {
-  return (code >= 0x4E00 && code <= 0x9FFF) ||
-         (code >= 0xF900 && code <= 0xFAFF) ||
-         (code >= 0x3400 && code <= 0x4DBF);
+  return (
+    (code >= 0x4e00 && code <= 0x9fff) ||
+    (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0x3400 && code <= 0x4dbf)
+  );
 }
 
 /**
  * Check if a Unicode code point is basic Korean (Hangul Jamo)
  */
 export function isKoreanJamo(code: number): boolean {
-  return (code >= 0x1100 && code <= 0x11FF) ||
-         (code >= 0x3130 && code <= 0x318F) ||
-         (code >= 0xFFA0 && code <= 0xFFDF);
+  return (
+    (code >= 0x1100 && code <= 0x11ff) ||
+    (code >= 0x3130 && code <= 0x318f) ||
+    (code >= 0xffa0 && code <= 0xffdf)
+  );
 }
 
 /**
  * Check if a code point is Japanese Hiragana
  */
 export function isJapaneseHiragana(code: number): boolean {
-  return code >= 0x3040 && code <= 0x309F;
+  return code >= 0x3040 && code <= 0x309f;
 }
 
 /**
  * Check if a code point is Japanese Katakana (full-width)
  */
 export function isJapaneseKatakana(code: number): boolean {
-  return code >= 0x30A0 && code <= 0x30FF;
+  return code >= 0x30a0 && code <= 0x30ff;
 }
 
 /**
@@ -115,9 +118,11 @@ export function isJapaneseKanji(code: number): boolean {
   // Common: U+4E00-U+9FFF (with many gaps)
   // Extended A: U+3400-U+4DBF
   // Extended B: U+20000-U+2A6DF (not supported)
-  return (code >= 0x4E00 && code <= 0x9FFF) ||
-         (code >= 0x3400 && code <= 0x4DBF) ||
-         (code >= 0xF900 && code <= 0xFAFF);
+  return (
+    (code >= 0x4e00 && code <= 0x9fff) ||
+    (code >= 0x3400 && code <= 0x4dbf) ||
+    (code >= 0xf900 && code <= 0xfaff)
+  );
 }
 
 // ============================================================================
@@ -142,18 +147,50 @@ export function encodeHangulSyllable(code: number): [number, number] | null {
 
   // Calculate leading consonant (initial), vowel (medial), trailing consonant (final)
   const leadingConsonant = Math.floor(syllableIndex / (HANGUL_MEDIAL_COUNT * HANGUL_FINAL_COUNT));
-  const vowelIndex = Math.floor((syllableIndex % (HANGUL_MEDIAL_COUNT * HANGUL_FINAL_COUNT)) / HANGUL_FINAL_COUNT);
+  const vowelIndex = Math.floor(
+    (syllableIndex % (HANGUL_MEDIAL_COUNT * HANGUL_FINAL_COUNT)) / HANGUL_FINAL_COUNT
+  );
   const trailingConsonant = syllableIndex % HANGUL_FINAL_COUNT;
 
   // Lead consonants: ㄱㄴㄷㄹㅁㅂㅅㅇㅈㅊㅋㅌㅍㅎ (14 consonants)
-  const LEAD_CONSONANTS = [0x81, 0x82, 0x84, 0x85, 0x88, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92];
+  const LEAD_CONSONANTS = [
+    0x81, 0x82, 0x84, 0x85, 0x88, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92,
+  ];
   // Vowels: ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ (21 vowels)
-  const VOWELS = [0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5];
+  const VOWELS = [
+    0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0,
+    0xb1, 0xb2, 0xb3, 0xb4, 0xb5,
+  ];
   // Trail consonants (finals): ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ (27 finals, 0=none)
   const TRAIL_CONSONANTS: number[] = [
     0x00, // No final
-    0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B
+    0x81,
+    0x82,
+    0x83,
+    0x84,
+    0x85,
+    0x86,
+    0x87,
+    0x88,
+    0x89,
+    0x8a,
+    0x8b,
+    0x8c,
+    0x8d,
+    0x8e,
+    0x8f,
+    0x90,
+    0x91,
+    0x92,
+    0x93,
+    0x94,
+    0x95,
+    0x96,
+    0x97,
+    0x98,
+    0x99,
+    0x9a,
+    0x9b,
   ];
 
   if (leadingConsonant >= LEAD_CONSONANTS.length) return null;
@@ -179,9 +216,9 @@ export function encodeHangulSyllable(code: number): [number, number] | null {
   if (trail === 0x00) {
     // Map to EUC-KR compatible range
     const row = Math.floor((lead - 0x81) * 21 + vowelIndex);
-    const eucLead = 0xB0 + Math.floor(row / 0x5E);
-    const eucTrail = 0xA1 + (row % 0x5E);
-    return [eucLead & 0xFF, eucTrail & 0xFF];
+    const eucLead = 0xb0 + Math.floor(row / 0x5e);
+    const eucTrail = 0xa1 + (row % 0x5e);
+    return [eucLead & 0xff, eucTrail & 0xff];
   }
 
   return [leadByte, trailByte];
@@ -196,12 +233,12 @@ export function encodeHangulSyllable(code: number): [number, number] | null {
  * U+3040-309F → 0x829F-0x82F1 (simplified mapping)
  */
 export function unicodeToShiftJisHiragana(code: number): [number, number] | null {
-  if (code >= 0x3040 && code <= 0x309F) {
+  if (code >= 0x3040 && code <= 0x309f) {
     const offset = code - 0x3040;
     // JIS X 0201 Hiragana range
     const jisLead = 0x82;
-    const jisTrail = 0x9F + offset;
-    return [jisLead, jisTrail & 0xFF];
+    const jisTrail = 0x9f + offset;
+    return [jisLead, jisTrail & 0xff];
   }
   return null;
 }
@@ -211,11 +248,11 @@ export function unicodeToShiftJisHiragana(code: number): [number, number] | null
  * U+30A0-30FF → 0x8340-0x8396 (full-width Katakana)
  */
 export function unicodeToShiftJisKatakana(code: number): [number, number] | null {
-  if (code >= 0x30A0 && code <= 0x30FF) {
-    const offset = code - 0x30A0;
+  if (code >= 0x30a0 && code <= 0x30ff) {
+    const offset = code - 0x30a0;
     const jisLead = 0x83;
     const jisTrail = 0x40 + offset;
-    return [jisLead, jisTrail & 0xFF];
+    return [jisLead, jisTrail & 0xff];
   }
   return null;
 }
@@ -225,8 +262,8 @@ export function unicodeToShiftJisKatakana(code: number): [number, number] | null
  * U+FF61-U+FF9F → 0xA1-0xDF
  */
 export function unicodeToHalfWidthKatakana(code: number): number | null {
-  if (code >= 0xFF61 && code <= 0xFF9F) {
-    return code - 0xFF61 + 0xA1;
+  if (code >= 0xff61 && code <= 0xff9f) {
+    return code - 0xff61 + 0xa1;
   }
   return null;
 }
@@ -237,8 +274,7 @@ export function unicodeToHalfWidthKatakana(code: number): number | null {
  */
 export function isInJisX0208Range(code: number): boolean {
   // Level 1 and Level 2 Kanji
-  return (code >= 0x4E00 && code <= 0x9FFF) ||
-         (code >= 0x3400 && code <= 0x4DBF);
+  return (code >= 0x4e00 && code <= 0x9fff) || (code >= 0x3400 && code <= 0x4dbf);
 }
 
 // ============================================================================
@@ -258,9 +294,9 @@ export function isInJisX0208Range(code: number): boolean {
 /**
  * ISO-2022-JP escape sequences
  */
-export const ISO2022JP_ESC_ASCII = new Uint8Array([0x1b, 0x28, 0x42]);     // ESC ( B
-export const ISO2022JP_ESC_JIS0201 = new Uint8Array([0x1b, 0x28, 0x4a]);  // ESC ( J
-export const ISO2022JP_ESC_JIS0208 = new Uint8Array([0x1b, 0x24, 0x42]);  // ESC $ B
+export const ISO2022JP_ESC_ASCII = new Uint8Array([0x1b, 0x28, 0x42]); // ESC ( B
+export const ISO2022JP_ESC_JIS0201 = new Uint8Array([0x1b, 0x28, 0x4a]); // ESC ( J
+export const ISO2022JP_ESC_JIS0208 = new Uint8Array([0x1b, 0x24, 0x42]); // ESC $ B
 export const ISO2022JP_ESC_JIS0208_83 = new Uint8Array([0x1b, 0x24, 0x40]); // ESC $ @
 export const ISO2022JP_ESC_JIS0208_90 = new Uint8Array([0x1b, 0x24, 0x44]); // ESC $ D
 
@@ -273,9 +309,7 @@ export type ISO2022JPState = 'ASCII' | 'JIS0208' | 'JIS0201';
  * Check if a code point requires JIS X 0208 escape sequence
  */
 export function requiresJisX0208Escape(code: number): boolean {
-  return isJapaneseHiragana(code) ||
-         isJapaneseKatakana(code) ||
-         isJapaneseKanji(code);
+  return isJapaneseHiragana(code) || isJapaneseKatakana(code) || isJapaneseKanji(code);
 }
 
 /**
@@ -283,7 +317,9 @@ export function requiresJisX0208Escape(code: number): boolean {
  */
 export function isJisX0201Katakana(code: number): boolean {
   // Half-width Katakana range
-  return (code >= 0xFF61 && code <= 0xFF9F) ||
-         // Full-width Katakana (JIS X 0201 range mapped to U+30A0)
-         (code >= 0x30A0 && code <= 0x30FF);
+  return (
+    (code >= 0xff61 && code <= 0xff9f) ||
+    // Full-width Katakana (JIS X 0201 range mapped to U+30A0)
+    (code >= 0x30a0 && code <= 0x30ff)
+  );
 }

package/src/services/BatchPrintManager.ts

@@ -238,7 +238,9 @@ export class BatchPrintManager {
     this.jobs.sort((a, b) => b.priority - a.priority);
 
     this.emit('job-added', job);
-    this.logger.debug(`Job added: ${id} (priority: ${priority}, queue size: ${this.jobs.length}, bytes: ${data.length})`);
+    this.logger.debug(
+      `Job added: ${id} (priority: ${priority}, queue size: ${this.jobs.length}, bytes: ${data.length})`
+    );
 
     // Start/restart wait timer
     this.startWaitTimer();
@@ -361,7 +363,8 @@ export class BatchPrintManager {
 
       // Report merge stats if jobs were merged
       if (fromCount !== toCount) {
-        const savedBytes = batchJobs.slice(0, fromCount).reduce((sum, j) => sum + j.data.length, 0) -
+        const savedBytes =
+          batchJobs.slice(0, fromCount).reduce((sum, j) => sum + j.data.length, 0) -
           mergedData.length;
         this.emit('jobs-merged', { fromCount, toCount, savedBytes: Math.abs(savedBytes) });
         this.stats.mergedJobs += fromCount - toCount;
@@ -427,15 +430,17 @@ export class BatchPrintManager {
    * @param jobs - Jobs to merge
    * @returns Merged data with metadata about the merge operation
    */
-  private mergeJobs(
-    jobs: BatchJob[]
-  ): { mergedData: Uint8Array; fromCount: number; toCount: number } {
+  private mergeJobs(jobs: BatchJob[]): {
+    mergedData: Uint8Array;
+    fromCount: number;
+    toCount: number;
+  } {
     if (!this.config.enableMerging || jobs.length === 1) {
       let mergedData: Uint8Array;
 
       if (jobs.length === 1 && this.config.unifiedCutCommand) {
         // Single job with unified cut
-        mergedData = this.concatBuffers([jobs[0]!.data, this.config.unifiedCutCommand!]);
+        mergedData = this.concatBuffers([jobs[0]!.data, this.config.unifiedCutCommand]);
         this.stats.unifiedCutsApplied++;
       } else {
         mergedData = jobs[0]?.data ?? new Uint8Array(0);
@@ -486,7 +491,7 @@ export class BatchPrintManager {
 
     this.logger.debug(
       `Merged ${fromCount} jobs into ${toCountAfterSmallMerge} after small-job merge, ` +
-      `final size: ${totalSize} bytes`
+        `final size: ${totalSize} bytes`
     );
 
     return { mergedData: result, fromCount, toCount: toCountAfterSmallMerge };
@@ -520,9 +525,7 @@ export class BatchPrintManager {
           bufferPriority = job.priority;
           bufferAddedAt = job.addedAt;
         }
-        this.logger.debug(
-          `Small job ${job.id} (${job.data.length} bytes) queued for merge buffer`
-        );
+        this.logger.debug(`Small job ${job.id} (${job.data.length} bytes) queued for merge buffer`);
       } else {
         // Non-small job - flush buffer first if not empty
         if (buffer.length > 0) {
@@ -550,11 +553,7 @@ export class BatchPrintManager {
    * @param addedAt - Timestamp of the first job in the merge
    * @returns Merged BatchJob
    */
-  private createMergedJob(
-    buffers: Uint8Array[],
-    priority: number,
-    addedAt: number
-  ): BatchJob {
+  private createMergedJob(buffers: Uint8Array[], priority: number, addedAt: number): BatchJob {
     // Calculate total size
     let totalSize = 0;
     for (const buf of buffers) {
@@ -674,7 +673,7 @@ export class BatchPrintManager {
       if (elapsed >= this.config.flushIntervalTimeout && this.jobs.length > 0) {
         this.logger.debug(
           `Flush interval timeout triggered: ${this.jobs.length} jobs pending, ` +
-          `elapsed: ${elapsed}ms`
+            `elapsed: ${elapsed}ms`
         );
         this.stats.autoFlushCount++;
         this.emit('auto-flush', {

package/src/services/PrintStatistics.ts

@@ -266,8 +266,7 @@ export class PrintStatistics {
     const completedOrFailed = this.completedJobs + this.failedJobs;
     const successRate = completedOrFailed > 0 ? this.completedJobs / completedOrFailed : 0;
 
-    const averagePrintTime =
-      this.completedJobs > 0 ? this.totalPrintTime / this.completedJobs : 0;
+    const averagePrintTime = this.completedJobs > 0 ? this.totalPrintTime / this.completedJobs : 0;
 
     return {
       totalJobs: this.totalJobs,
@@ -352,10 +351,7 @@ export class PrintStatistics {
    * @param endDate - End date (timestamp or Date)
    * @returns Filtered statistics
    */
-  getStatisticsByDateRange(
-    startDate: Date | number,
-    endDate: Date | number
-  ): PrintStatisticsData {
+  getStatisticsByDateRange(startDate: Date | number, endDate: Date | number): PrintStatisticsData {
     const start = typeof startDate === 'number' ? startDate : startDate.getTime();
     const end = typeof endDate === 'number' ? endDate : endDate.getTime();
 
@@ -467,7 +463,9 @@ export class PrintStatistics {
     return String(error);
   }
 
-  private aggregateByDate(jobs: JobRecord[]): Record<string, { completed: number; failed: number }> {
+  private aggregateByDate(
+    jobs: JobRecord[]
+  ): Record<string, { completed: number; failed: number }> {
     const result: Record<string, { completed: number; failed: number }> = {};
     for (const job of jobs) {
       const dateKey = this.formatDateKey(job.startedAt);
@@ -483,7 +481,9 @@ export class PrintStatistics {
     return result;
   }
 
-  private aggregateByDriver(jobs: JobRecord[]): Record<string, { completed: number; failed: number }> {
+  private aggregateByDriver(
+    jobs: JobRecord[]
+  ): Record<string, { completed: number; failed: number }> {
     const result: Record<string, { completed: number; failed: number }> = {};
     for (const job of jobs) {
       if (!job.driver) continue;

package/src/services/ScheduledRetryManager.ts

@@ -141,10 +141,7 @@ export class ScheduledRetryManager {
    * @param config - Optional configuration overrides
    * @param offlineCache - Optional OfflineCache instance (uses singleton if not provided)
    */
-  constructor(
-    config?: Partial<ScheduledRetryManagerConfig>,
-    offlineCache?: OfflineCache
-  ) {
+  constructor(config?: Partial<ScheduledRetryManagerConfig>, offlineCache?: OfflineCache) {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.offlineCache = offlineCache ?? new OfflineCache();
 
@@ -197,15 +194,13 @@ export class ScheduledRetryManager {
 
     // Schedule the timeout
     entry.timeout = setTimeout(() => {
-      this.executeRetry(entry);
+      void this.executeRetry(entry);
     }, delay);
 
     this.scheduledRetries.set(jobId, entry);
-    this.persistRetry(entry);
+    void this.persistRetry(entry);
 
-    this.logger.info(
-      `Retry scheduled: ${jobId}, runAt: ${runAt.toISOString()}, delay: ${delay}ms`
-    );
+    this.logger.info(`Retry scheduled: ${jobId}, runAt: ${runAt.toISOString()}, delay: ${delay}ms`);
   }
 
   /**
@@ -289,7 +284,8 @@ export class ScheduledRetryManager {
     const entry = this.scheduledRetries.get(jobId);
     if (!entry) return undefined;
 
-    // Return a copy without the timeout
+    // Return a copy without the timeout (timeout cannot be serialized)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { timeout, ...rest } = entry;
     return rest as ScheduledRetry;
   }
@@ -425,11 +421,11 @@ export class ScheduledRetryManager {
         entry.runAt = nextRunAt;
 
         entry.timeout = setTimeout(() => {
-          this.executeRetry(entry);
+          void this.executeRetry(entry);
         }, nextDelay);
 
         this.scheduledRetries.set(jobId, entry);
-        this.persistRetry(entry);
+        void this.persistRetry(entry);
 
         this.logger.info(
           `Scheduled next retry for ${jobId}: ${nextRunAt.toISOString()}, attempt: ${entry.attemptCount}`
@@ -499,11 +495,8 @@ export class ScheduledRetryManager {
 
       for (const cached of cachedJobs) {
         // Only restore scheduled_retry entries
-        if (
-          cached.metadata &&
-          (cached.metadata as Record<string, unknown>).type === 'scheduled_retry'
-        ) {
-          const meta = cached.metadata as Record<string, unknown>;
+        if (cached.metadata && cached.metadata.type === 'scheduled_retry') {
+          const meta = cached.metadata;
           const runAtStr = meta.runAt as string;
           const runAt = new Date(runAtStr);
 
@@ -526,7 +519,7 @@ export class ScheduledRetryManager {
 
           // Schedule with correct delay
           entry.timeout = setTimeout(() => {
-            this.executeRetry(entry);
+            void this.executeRetry(entry);
           }, runAt.getTime() - now);
 
           this.scheduledRetries.set(entry.jobId, entry);
@@ -546,7 +539,10 @@ export class ScheduledRetryManager {
   /**
    * Emit an event
    */
-  private emit<K extends keyof ScheduledRetryEvents>(event: K, data: ScheduledRetryEvents[K]): void {
+  private emit<K extends keyof ScheduledRetryEvents>(
+    event: K,
+    data: ScheduledRetryEvents[K]
+  ): void {
     const handlers = this.listeners.get(event);
     if (handlers) {
       handlers.forEach(handler => {