taro-bluetooth-print 2.4.0 → 2.5.0

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

@@ -0,0 +1,22 @@
+import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
+/**
+ * QQ Mini Program Bluetooth Low Energy adapter
+ *
+ * Uses the QQ mini-program's BLE APIs (qq.xxx).
+ * All connection, write, and service discovery logic is inherited from MiniProgramAdapter.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new QQAdapter();
+ * await adapter.connect('device-id-123');
+ * await adapter.write('device-id-123', buffer);
+ * await adapter.disconnect('device-id-123');
+ * ```
+ */
+export declare class QQAdapter extends MiniProgramAdapter {
+    /**
+     * Returns the QQ mini-program BLE API object
+     * @returns The qq global object providing BLE capabilities
+     */
+    protected getApi(): MiniProgramBLEApi;
+}

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

@@ -0,0 +1,111 @@
+import { BaseAdapter } from './BaseAdapter';
+import { IPrinterAdapter, IAdapterOptions } from '../types';
+/**
+ * React Native BLE Manager interface
+ * Compatible with react-native-ble-plx API
+ */
+interface BLEManager {
+    startDeviceScan(serviceUUIDs: string[] | null, options: Record<string, unknown> | null, onDeviceScanned: (error: unknown, device: unknown) => void): void;
+    stopDeviceScan(): void;
+    connectToDevice(deviceIdentifier: string, options: Record<string, unknown>): Promise<unknown>;
+    disconnectFromDevice(deviceIdentifier: string, force?: boolean): Promise<unknown>;
+    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: string): Promise<unknown>;
+    writeCharacteristicWithResponseForDevice(deviceIdentifier: string, serviceUUID: string, characteristicUUID: string, value: string, transactionId?: string): Promise<unknown>;
+    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: string, serviceUUID: string, characteristicUUID: string, value: string, transactionId?: string): Promise<unknown>;
+    readCharacteristicForDevice(deviceIdentifier: string, serviceUUID: string, characteristicUUID: string, transactionId?: string): Promise<unknown>;
+    monitorCharacteristicForDevice(deviceIdentifier: string, serviceUUID: string, characteristicUUID: string, onUpdate: (error: unknown, characteristic: unknown) => void, transactionId?: string): {
+        remove: () => void;
+    };
+}
+/**
+ * React Native Bluetooth Low Energy adapter
+ *
+ * Uses react-native-ble-plx for BLE operations on iOS and Android.
+ * This adapter does NOT extend MiniProgramAdapter because React Native
+ * has a fundamentally different BLE API compared to mini-program platforms.
+ *
+ * @example
+ * ```typescript
+ * import BleManager from 'react-native-ble-plx';
+ * import { ReactNativeAdapter } from 'taro-bluetooth-print';
+ *
+ * BleManager.start({ showAlert: false });
+ *
+ * const adapter = new ReactNativeAdapter({ bleManager: BleManager });
+ * await adapter.connect('device-uuid-123');
+ * await adapter.write('device-uuid-123', buffer);
+ * await adapter.disconnect('device-uuid-123');
+ * ```
+ */
+export declare class ReactNativeAdapter extends BaseAdapter implements IPrinterAdapter {
+    private bleManager;
+    private deviceCache;
+    /**
+     * Creates a new ReactNativeAdapter instance
+     *
+     * @param options - Configuration options
+     * @param options.bleManager - BLE Manager instance (e.g., from react-native-ble-plx)
+     * @throws {Error} If bleManager is not provided or not supported
+     */
+    constructor(options: {
+        bleManager: BLEManager;
+    });
+    /**
+     * Connect to a Bluetooth device and discover services
+     *
+     * @param deviceId - Unique identifier (UUID) of the device to connect to
+     * @throws {BluetoothPrintError} When connection fails or device not found
+     */
+    connect(deviceId: string): Promise<void>;
+    /**
+     * Perform the actual BLE connection
+     */
+    private performConnect;
+    /**
+     * Disconnect from a Bluetooth device
+     *
+     * @param deviceId - Unique identifier of the device to disconnect from
+     */
+    disconnect(deviceId: string): Promise<void>;
+    /**
+     * Write data to the Bluetooth device in chunks
+     *
+     * Features:
+     * - Automatic chunk size adjustment
+     * - Dynamic delay for congestion control
+     * - Retry with exponential backoff
+     * - Write timeout per chunk
+     *
+     * @param deviceId - Unique identifier of the connected device
+     * @param buffer - Data to write as ArrayBuffer
+     * @param options - Optional write settings (chunkSize, delay, retries)
+     * @throws {BluetoothPrintError} When write fails after all retries
+     */
+    write(deviceId: string, buffer: ArrayBuffer, options?: IAdapterOptions): Promise<void>;
+    /**
+     * Start discovering nearby Bluetooth devices
+     *
+     * Note: This is optional in IPrinterAdapter. In React Native BLE,
+     * device discovery is typically done via scan events.
+     */
+    startDiscovery?(): Promise<void>;
+    /**
+     * Stop discovering nearby Bluetooth devices
+     */
+    stopDiscovery?(): Promise<void>;
+    /**
+     * Discover services and characteristics for a connected device
+     *
+     * @param deviceId - Device identifier
+     * @param device - Connected device object
+     */
+    private discoverServices;
+    /**
+     * Convert ArrayBuffer to base64 string for react-native-ble-plx
+     *
+     * @param buffer - ArrayBuffer to convert
+     * @returns Base64 encoded string
+     */
+    private arrayBufferToBase64;
+}
+export {};

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

@@ -0,0 +1,13 @@
+/**
+ * Adapters barrel export
+ */
+export { BaseAdapter, MiniProgramAdapter } from './BaseAdapter';
+export type { MiniProgramBLEApi, ServiceInfo, BLECharacteristic, BLECharacteristicProperties } from './BaseAdapter';
+export { TaroAdapter } from './TaroAdapter';
+export { AlipayAdapter } from './AlipayAdapter';
+export { BaiduAdapter } from './BaiduAdapter';
+export { ByteDanceAdapter } from './ByteDanceAdapter';
+export { QQAdapter } from './QQAdapter';
+export { ReactNativeAdapter } from './ReactNativeAdapter';
+export { WebBluetoothAdapter } from './WebBluetoothAdapter';
+export { AdapterFactory } from './AdapterFactory';

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

@@ -132,7 +132,7 @@ export declare class MultiPrinterManager {
     /**
      * Print to a specific printer
      */
-    print(printerId: string, data: Uint8Array): Promise<void>;
+    print(printerId: string, data: Uint8Array): void;
     /**
      * Broadcast data to all connected printers
      */

package/dist/types/drivers/StarPrinter.d.ts

@@ -0,0 +1,243 @@
+import { IPrinterDriver, IQrOptions } from '../types';
+/**
+ * Alignment options for text positioning
+ */
+export type Alignment = 'left' | 'center' | 'right';
+/**
+ * Barcode types supported by STAR printers
+ */
+export type BarcodeType = 'CODE39' | 'CODE128' | 'EAN13';
+/**
+ * STAR printer driver options
+ */
+export interface StarPrinterOptions {
+    /** Use the EncodingService for GBK/UTF-8 encoding (default: true) */
+    useEncodingService?: boolean;
+    /** Show warnings for unsupported characters (default: true) */
+    showEncodingWarnings?: boolean;
+    /** Fallback character for unsupported characters (default: '?') */
+    fallbackChar?: string;
+    /** Enable international character mode (default: true) */
+    internationalCharset?: boolean;
+}
+/**
+ * Barcode options for STAR printers
+ */
+export interface StarBarcodeOptions {
+    /** Barcode height in dots (default: 40) */
+    height?: number;
+    /** Barcode width (default: 2) */
+    width?: number;
+    /** HRI text position: 'none' | 'above' | 'below' | 'both' (default: 'below') */
+    hri?: 'none' | 'above' | 'below' | 'both';
+    /** Barcode type: CODE39, CODE128, EAN13 */
+    type?: BarcodeType;
+}
+/**
+ * QR code options for STAR printers
+ */
+export interface StarQrOptions {
+    /** QR code model (default: 2) */
+    model?: 1 | 2;
+    /** QR code cell size in dots (default: 4) */
+    cellSize?: number;
+    /** Error correction level: 'L' | 'M' | 'Q' | 'H' (default: 'M') */
+    errorCorrection?: 'L' | 'M' | 'Q' | 'H';
+}
+/**
+ * Image print options
+ */
+export interface StarImageOptions {
+    /** Enable dithering (default: true) */
+    dithering?: boolean;
+    /** Threshold for binarization 0-255 (default: 128) */
+    threshold?: number;
+    /** Print in greyscale mode (default: false) */
+    greyscale?: boolean;
+}
+/**
+ * STAR TSP/TSP700 series thermal printer driver
+ *
+ * Implements the STAR command set for thermal receipt printers.
+ * Supports text, images, QR codes, barcodes, and paper control.
+ *
+ * @example
+ * ```typescript
+ * const driver = new StarPrinter();
+ * const commands = [
+ *   ...driver.init(),
+ *   ...driver.text('Hello World!'),
+ *   ...driver.feed(3),
+ *   ...driver.cut()
+ * ];
+ * ```
+ */
+export declare class StarPrinter implements IPrinterDriver {
+    private readonly logger;
+    private readonly encodingService;
+    private readonly useEncodingService;
+    private readonly internationalCharset;
+    private _boldEnabled;
+    private _alignment;
+    /**
+     * Creates a new StarPrinter driver instance
+     * @param options - Driver options
+     */
+    constructor(options?: StarPrinterOptions);
+    /**
+     * Initialize the printer to default state
+     * Sends ESC @ to reset printer to power-on defaults
+     *
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * const commands = driver.init();
+     * ```
+     */
+    init(): Uint8Array[];
+    /**
+     * Print text content with specified encoding
+     *
+     * Supports GBK, UTF-8, EUC-KR, Shift-JIS, ISO-2022-JP through EncodingService.
+     * When using ESC/POS compatible mode, text is output as-is with line feed.
+     *
+     * @param content - Text content to print
+     * @param encoding - Text encoding (default: 'GBK')
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.text('Hello World', 'UTF-8');
+     * driver.text('你好世界', 'GBK');
+     * ```
+     */
+    text(content: string, encoding?: string): Uint8Array[];
+    /**
+     * Feed paper by specified number of lines
+     *
+     * @param lines - Number of lines to feed (default: 1, max: 255)
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.feed(3); // Feed 3 lines
+     * ```
+     */
+    feed(lines?: number): Uint8Array[];
+    /**
+     * Cut the paper using the built-in cutter
+     *
+     * Note: Not all STAR printers have a cutter. For printers without cutter,
+     * this will attempt a full paper cut which may result in no action.
+     *
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.cut();
+     * ```
+     */
+    cut(): Uint8Array[];
+    /**
+     * Print a QR code
+     *
+     * Uses STAR's built-in QR code command when available (GS W 01 pattern),
+     * otherwise falls back to printing QR code as a raster image.
+     *
+     * @param content - Content to encode in the QR code
+     * @param options - QR code options (model, cellSize, errorCorrection)
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.qr('https://example.com', { model: 2, cellSize: 6, errorCorrection: 'M' });
+     * ```
+     */
+    qr(content: string, options?: IQrOptions | StarQrOptions): Uint8Array[];
+    /**
+     * Print a barcode
+     *
+     * Supports CODE39, CODE128, and EAN13 barcode types.
+     * HRI (Human Readable Interpretation) text can be positioned above,
+     * below, or both sides of the barcode.
+     *
+     * @param data - Barcode data content
+     * @param options - Barcode options (type, height, width, hri)
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.barcode('123456789012', { type: 'EAN13', height: 60 });
+     * driver.barcode('ABC-1234', { type: 'CODE39', width: 3 });
+     * ```
+     */
+    barcode(data: string, options?: StarBarcodeOptions): Uint8Array[];
+    /**
+     * Print a raster image
+     *
+     * Converts RGBA image data to 1-bit bitmap using dithering and sends
+     * to the printer using STAR's raster image command.
+     *
+     * @param data - RGBA pixel data (Uint8Array, 4 bytes per pixel)
+     * @param width - Image width in pixels
+     * @param height - Image height in pixels
+     * @param options - Image print options (dithering, threshold, greyscale)
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * const imageData = new Uint8Array(width * height * 4); // RGBA
+     * driver.image(imageData, 200, 100, { dithering: true });
+     * ```
+     */
+    image(data: Uint8Array, width: number, height: number, options?: StarImageOptions): Uint8Array[];
+    /**
+     * Sound a beep/buzzer on supported printers
+     *
+     * Sends a command to activate the printer's built-in buzzer.
+     * Useful for alerting operators to print completion or errors.
+     *
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.beep();
+     * ```
+     */
+    beep(): Uint8Array[];
+    /**
+     * Enable or disable bold text
+     *
+     * When bold is enabled, subsequent text will be printed in bold.
+     * This state persists until explicitly disabled.
+     *
+     * @param on - true to enable bold, false to disable
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.bold(true);
+     * driver.text('Bold Text');
+     * driver.bold(false);
+     * ```
+     */
+    bold(on: boolean): Uint8Array[];
+    /**
+     * Set text alignment
+     *
+     * Controls horizontal text alignment for subsequent text.
+     * Alignment persists until explicitly changed.
+     *
+     * @param align - Alignment: 'left' | 'center' | 'right'
+     * @returns Array of command buffers
+     *
+     * @example
+     * ```typescript
+     * driver.align('center');
+     * driver.text('Centered Title');
+     * driver.align('left');
+     * ```
+     */
+    align(align: Alignment): Uint8Array[];
+}

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

@@ -7,3 +7,4 @@ export { GPrinterDriver, type GPrinterOptions } from './GPrinterDriver';
 export { TsplDriver, type LabelSize, type TextOptions, type BarcodeOptions, type QRCodeOptions, type BoxOptions, type LineOptions, } from './TsplDriver';
 export { ZplDriver, type ZplLabelSize, type ZplTextOptions, type ZplBarcodeOptions, type ZplQRCodeOptions, type ZplBoxOptions, } from './ZplDriver';
 export { CpclDriver, type CPCLPageSize, type CpclTextOptions, type CpclBarcodeOptions, type CpclQRCodeOptions, type CpclLineOptions, type CpclBoxOptions, } from './CpclDriver';
+export { StarPrinter, type StarPrinterOptions, type Alignment, type BarcodeType, type StarBarcodeOptions, type StarQrOptions, type StarImageOptions, } from './StarPrinter';

package/dist/types/encoding/EncodingService.d.ts

@@ -1,20 +1,27 @@
 /**
  * Encoding Service
  *
- * Provides comprehensive encoding support for GBK, GB2312, Big5, and UTF-8.
+ * Provides comprehensive encoding support for:
+ * - GBK, GB2312, Big5 (Chinese)
+ * - EUC-KR (Korean)
+ * - Shift-JIS, ISO-2022-JP (Japanese)
+ * - UTF-8
+ *
  * Handles character conversion for thermal printer output.
  *
  * @example
  * ```typescript
  * const service = new EncodingService();
  * const bytes = service.encode('你好世界', 'GBK');
+ * const korean = service.encode('안녕하세요', 'EUC-KR');
+ * const japanese = service.encode('こんにちは', 'Shift-JIS');
  * const detected = service.detectEncoding('Hello 世界');
  * ```
  */
 /**
  * Supported encoding types
  */
-export type SupportedEncoding = 'GBK' | 'GB2312' | 'BIG5' | 'UTF-8' | 'UTF8';
+export type SupportedEncoding = 'GBK' | 'GB2312' | 'BIG5' | 'UTF-8' | 'UTF8' | 'EUC-KR' | 'EUCKR' | 'SHIFT-JIS' | 'SHIFTJIS' | 'SJIS' | 'ISO-2022-JP' | 'ISO2022JP' | 'JIS';
 /**
  * Encoding configuration options
  */
@@ -130,6 +137,38 @@ export declare class EncodingService {
      * @returns Big5 encoded bytes
      */
     private encodeBig5;
+    /**
+     * Encode text to EUC-KR (Korean) bytes
+     *
+     * EUC-KR (KS X 1001) is the standard Korean character encoding.
+     * Supports Hangul syllables, Hanja, and special Korean characters.
+     * Uses TextEncoder when available for full coverage.
+     *
+     * @param text - Text to encode
+     * @returns EUC-KR encoded bytes
+     */
+    private encodeKorean;
+    /**
+     * Encode text to Shift-JIS (Japanese) bytes
+     *
+     * Shift-JIS (JIS X 0201/0208) is the standard Japanese encoding.
+     * Supports Hiragana, Katakana, Kanji, and punctuation.
+     * Uses TextEncoder when available for full coverage.
+     *
+     * @param text - Text to encode
+     * @returns Shift-JIS encoded bytes
+     */
+    private encodeShiftJis;
+    /**
+     * Encode text to ISO-2022-JP (Japanese) bytes
+     *
+     * ISO-2022-JP (JIS X 4081) uses escape sequences to switch character sets.
+     * Format: ESC ( B for ASCII, ESC $ B for JIS X 0208 (Kanji/Katakana).
+     *
+     * @param text - Text to encode
+     * @returns ISO-2022-JP encoded bytes with escape sequences
+     */
+    private encodeIso2022Jp;
     /**
      * Normalize encoding name to standard format
      * @param encoding - Encoding name

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

@@ -1,6 +1,7 @@
 /**
  * Encoding Service Module
- * 编码服务模块 - 负责字符集转换 (GBK, GB2312, Big5, UTF-8)
+ * 编码服务模块 - 负责字符集转换 (GBK, GB2312, Big5, EUC-KR, Shift-JIS, ISO-2022-JP, UTF-8)
  */
 export { EncodingService, encodingService, type EncodingConfig, type EncodingResult, type SupportedEncoding, } from './EncodingService';
 export { unicodeToGbk, gbkToUnicode, unicodeToBig5, big5ToUnicode, getGbkBytes, getUnicodeFromGbk, getBig5Bytes, isAscii, isCjk, isChinesePunctuation, } from './gbk-table';
+export { encodeHangulSyllable, isKoreanHangul, isKoreanHanja, isKoreanJamo, unicodeToShiftJisHiragana, unicodeToShiftJisKatakana, isJapaneseHiragana, isJapaneseKatakana, isJapaneseKanji, ISO2022JP_ESC_ASCII, ISO2022JP_ESC_JIS0208, requiresJisX0208Escape, isJisX0201Katakana, } from './korean-japanese';

package/dist/types/encoding/korean-japanese.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Korean & Japanese Encoding Tables
+ *
+ * Provides character mapping support for:
+ * - EUC-KR (Korean) - KS X 1001/1003 encoding
+ * - Shift-JIS (Japanese) - JIS X 0201/0208 encoding
+ * - ISO-2022-JP (Japanese) - JIS encoding with escape sequences
+ *
+ * Note: For full coverage, these use TextEncoder/TextDecoder as the primary
+ * implementation since they provide native support in modern environments.
+ * The mapping tables here serve as reference and fallback.
+ */
+/**
+ * KS X 1001 (Hangul) code range in EUC-KR:
+ * First byte: 0xB0-0xC8 (128-200)
+ * Second byte: 0xA1-0xFE (161-254)
+ *
+ * KS X 1003 (Hanja) code range in EUC-KR:
+ * First byte: 0xCA-0xFD
+ * Second byte: 0xA1-0xFE
+ */
+export declare const HANGUL_SYLLABLE_OFFSET = 44032;
+export declare const HANGUL_INITIAL_COUNT = 21;
+export declare const HANGUL_MEDIAL_COUNT = 21;
+export declare const HANGUL_FINAL_COUNT = 28;
+/**
+ * JIS X 0201 (Half-width Katakana):
+ * First byte: 0xA1-0xDF (single-byte)
+ *
+ * JIS X 0208 (Kanji):
+ * First byte: 0x81-0x9F (low) or 0xE0-0xEF (high)
+ * Second byte: 0x40-0x7E (low) or 0x80-0xFC (high)
+ *
+ * JIS X 0212 (Supplementary Kanji):
+ * First byte: 0xE0-0xEA
+ * Second byte: 0x40-0x7E or 0x80-0xFC
+ */
+export declare const SHIFT_JIS_KATAKANA_START = 161;
+export declare const SHIFT_JIS_KATAKANA_END = 223;
+export declare const SHIFT_JIS_KANJI_LOW_START = 129;
+export declare const SHIFT_JIS_KANJI_LOW_END = 159;
+export declare const SHIFT_JIS_KANJI_HIGH_START = 224;
+export declare const SHIFT_JIS_KANJI_HIGH_END = 239;
+export declare const SHIFT_JIS_KANJI_SECOND_MIN = 64;
+export declare const SHIFT_JIS_KANJI_SECOND_MAX = 252;
+/**
+ * Check if a Unicode code point is a Korean Hangul syllable
+ */
+export declare function isKoreanHangul(code: number): boolean;
+/**
+ * Check if a Unicode code point is a Korean Hanja (Hanja)
+ */
+export declare function isKoreanHanja(code: number): boolean;
+/**
+ * Check if a Unicode code point is basic Korean (Hangul Jamo)
+ */
+export declare function isKoreanJamo(code: number): boolean;
+/**
+ * Check if a code point is Japanese Hiragana
+ */
+export declare function isJapaneseHiragana(code: number): boolean;
+/**
+ * Check if a code point is Japanese Katakana (full-width)
+ */
+export declare function isJapaneseKatakana(code: number): boolean;
+/**
+ * Check if a code point is Japanese Kanji (CJK Unified Ideographs in Japanese range)
+ */
+export declare function isJapaneseKanji(code: number): boolean;
+/**
+ * Encode a Hangul syllable to EUC-KR bytes
+ *
+ * Hangul syllables in Unicode are algorithmically decomposable:
+ * 1. Syllable = 0xAC00 + (initial × 21 + medial) × 28 + final
+ * 2. We decompose to lead, vowel, trail
+ * 3. Then convert to EUC-KR lead/trail bytes
+ */
+export declare function encodeHangulSyllable(code: number): [number, number] | null;
+/**
+ * Convert Unicode Hiragana to Shift-JIS
+ * U+3040-309F → 0x829F-0x82F1 (simplified mapping)
+ */
+export declare function unicodeToShiftJisHiragana(code: number): [number, number] | null;
+/**
+ * Convert Unicode Katakana to Shift-JIS
+ * U+30A0-30FF → 0x8340-0x8396 (full-width Katakana)
+ */
+export declare function unicodeToShiftJisKatakana(code: number): [number, number] | null;
+/**
+ * Convert half-width Katakana to Shift-JIS
+ * U+FF61-U+FF9F → 0xA1-0xDF
+ */
+export declare function unicodeToHalfWidthKatakana(code: number): number | null;
+/**
+ * Check if a code point is in JIS X 0208 range and estimate its Shift-JIS position
+ * This is a simplified heuristic - full conversion requires large tables
+ */
+export declare function isInJisX0208Range(code: number): boolean;
+/**
+ * ISO-2022-JP (JIS X 4081) escape sequences:
+ * - ESC ( B - ASCII
+ * - ESC ( J - JIS X 0201 Roman
+ * - ESC $ B - JIS X 0208
+ * - ESC $ @ - JIS X 0208:1983 (old)
+ * - ESC $ D - JIS X 0208:1990 (new)
+ * - ESC $ ( C - JIS X 0212 supplementary
+ */
+/**
+ * ISO-2022-JP escape sequences
+ */
+export declare const ISO2022JP_ESC_ASCII: Uint8Array<ArrayBuffer>;
+export declare const ISO2022JP_ESC_JIS0201: Uint8Array<ArrayBuffer>;
+export declare const ISO2022JP_ESC_JIS0208: Uint8Array<ArrayBuffer>;
+export declare const ISO2022JP_ESC_JIS0208_83: Uint8Array<ArrayBuffer>;
+export declare const ISO2022JP_ESC_JIS0208_90: Uint8Array<ArrayBuffer>;
+/**
+ * ISO-2022-JP text encoder state
+ */
+export type ISO2022JPState = 'ASCII' | 'JIS0208' | 'JIS0201';
+/**
+ * Check if a code point requires JIS X 0208 escape sequence
+ */
+export declare function requiresJisX0208Escape(code: number): boolean;
+/**
+ * Check if a code point is JIS X 0201 Katakana (half-width)
+ */
+export declare function isJisX0201Katakana(code: number): boolean;

package/dist/types/index.d.ts

@@ -43,7 +43,7 @@ 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 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';