@delicity/capacitor-thermal-printer 7.0.0

package/ios/Plugin/Adapters/EpsonAdapter.swift

@@ -0,0 +1,131 @@
+import Foundation
+import UIKit
+
+// Le module ePOS2 iOS est livré en xcframework manuel (licence Epson, non
+// redistribuable). Le nom de module peut varier selon la version du SDK
+// (`libepos2`). Si l'import échoue -> stub inerte (aucune casse de build).
+// Voir docs/SDK_INTEGRATION.md (§ Epson iOS).
+#if canImport(libepos2)
+import libepos2
+#endif
+
+/// Adapter Epson iOS basé sur le SDK ePOS2.
+///
+/// ⚠️ API ObjC pilotée en Swift : à VÉRIFIER sur device avec le xcframework réel
+/// (la version du SDK peut ajuster les signatures / le nom de module).
+/// Chemin principal : impression IMAGE (réception rendue en bitmap).
+final class EpsonAdapter: PrinterAdapter {
+
+    let id: AdapterId = .epson
+    private var printers: [String: AnyObject] = [:]
+    private let lock = NSLock()
+
+    func isAvailable() -> Bool {
+        #if canImport(libepos2)
+        return true
+        #else
+        // Détection runtime de secours si le framework est lié sans module Swift.
+        return NSClassFromString("Epos2Printer") != nil
+        #endif
+    }
+
+    func canHandle(_ profile: PrinterProfile) -> Bool { isAvailable() && profile.adapter == .epson }
+
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {
+        // La découverte Epson (Epos2Discovery) nécessite un delegate ObjC ; les
+        // imprimantes Epson réseau restent trouvées par le scan TCP générique.
+        // Découverte SDK dédiée à activer si besoin (voir docs).
+    }
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        #if canImport(libepos2)
+        if isConnected(profile.id) { return }
+        guard let printer = Epos2Printer(printerSeries: Self.series(for: profile.model), lang: EPOS2_MODEL_ANK.rawValue) else {
+            throw PrinterError(.SDK_NOT_AVAILABLE, "Init Epos2Printer échouée")
+        }
+        let result = printer.connect(Self.target(for: profile), timeout: Int(timeoutMs))
+        guard result == EPOS2_SUCCESS.rawValue else {
+            throw PrinterError(.CONNECTION_FAILED, "Connexion Epson échouée: \(profile.address)", detail: "\(result)", retryable: true)
+        }
+        lock.lock(); printers[profile.id] = printer; lock.unlock()
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Epson ePOS2 absent")
+        #endif
+    }
+
+    func isConnected(_ printerId: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        return printers[printerId] != nil
+    }
+
+    func disconnect(_ printerId: String) async {
+        #if canImport(libepos2)
+        lock.lock(); let p = printers.removeValue(forKey: printerId) as? Epos2Printer; lock.unlock()
+        p?.disconnect()
+        p?.clearCommandBuffer()
+        #endif
+    }
+
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int {
+        #if canImport(libepos2)
+        lock.lock(); let p = printers[profile.id] as? Epos2Printer; lock.unlock()
+        guard let printer = p else { throw PrinterError(.CONNECTION_FAILED, "Epson non connecté: \(profile.id)") }
+        for _ in 0..<max(1, options.copies) {
+            printer.beginTransaction()
+            printer.add(image, x: 0, y: 0,
+                        width: Int(image.size.width), height: Int(image.size.height),
+                        color: Int(EPOS2_COLOR_1.rawValue), mode: Int(EPOS2_MODE_MONO.rawValue),
+                        halftone: Self.halftone(options.dithering), brightness: 1.0,
+                        compress: Int(EPOS2_COMPRESS_AUTO.rawValue))
+            if options.cut && profile.capabilities.supportsCut { printer.addCut(Int(EPOS2_CUT_FEED.rawValue)) }
+            if options.openCashDrawer && profile.capabilities.supportsCashDrawer {
+                printer.addPulse(Int(EPOS2_DRAWER_2PIN.rawValue), time: Int(EPOS2_PULSE_100.rawValue))
+            }
+            let result = printer.sendData(Int(EPOS2_PARAM_DEFAULT))
+            printer.endTransaction()
+            printer.clearCommandBuffer()
+            if result != EPOS2_SUCCESS.rawValue {
+                throw PrinterError(.PRINT_FAILED, "Impression Epson échouée", detail: "\(result)", retryable: true)
+            }
+        }
+        return Int(image.size.width * image.size.height) / 8
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Epson ePOS2 absent")
+        #endif
+    }
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus {
+        let connected = isConnected(profile.id)
+        return PrinterStatus(id: profile.id, connection: connected ? "connected" : "disconnected",
+                             online: connected, paper: "unknown",
+                             rawStatus: "Epson: statut détaillé via getStatus() à activer si besoin")
+    }
+
+    // MARK: Helpers typés
+
+    #if canImport(libepos2)
+    private static func target(for profile: PrinterProfile) -> String {
+        if profile.address.hasPrefix("TCP:") || profile.address.hasPrefix("BT:") || profile.address.hasPrefix("USB:") {
+            return profile.address
+        }
+        switch profile.transport {
+        case .wifi, .ethernet: return "TCP:\(profile.address.split(separator: ":").first.map(String.init) ?? profile.address)"
+        case .bluetooth, .ble: return "BT:\(profile.address)"
+        case .usb: return "USB:\(profile.address)"
+        }
+    }
+
+    private static func series(for model: String?) -> Int32 {
+        // Best effort : série générique. Affiner via EPOS2_TM_* si le modèle est connu.
+        return EPOS2_TM_M30.rawValue
+    }
+
+    private static func halftone(_ dithering: String) -> Int {
+        switch dithering {
+        case "none": return Int(EPOS2_HALFTONE_THRESHOLD.rawValue)
+        case "atkinson", "floyd_steinberg": return Int(EPOS2_HALFTONE_ERROR_DIFFUSION.rawValue)
+        default: return Int(EPOS2_HALFTONE_DITHER.rawValue)
+        }
+    }
+    #endif
+}

package/ios/Plugin/Adapters/EscPosAdapter.swift

@@ -0,0 +1,106 @@
+import Foundation
+import UIKit
+
+/// Adapter ESC/POS générique iOS.
+///
+/// ⚠️ LIMITE iOS : pas de Bluetooth Classic / SPP générique (voir README).
+/// Cet adapter ne gère donc QUE le TCP (Wi-Fi / Ethernet). Pour le Bluetooth
+/// d'une imprimante ESC/POS sur iOS, deux seules options réelles :
+///   - le fabricant fournit un SDK MFi (Epson/Star/...) -> utiliser leur adapter,
+///   - l'imprimante expose un service BLE exploitable -> BleAdapter (allowlist).
+final class EscPosAdapter: PrinterAdapter {
+
+    let id: AdapterId = .escpos
+    private var connections: [String: TcpTransport] = [:]
+    private let lock = NSLock()
+
+    func isAvailable() -> Bool { true }
+
+    func supportsTextItems() -> Bool { true }
+
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {
+        // Délégué au TcpScanner / Bonjour (DiscoveryManager).
+    }
+
+    func canHandle(_ profile: PrinterProfile) -> Bool {
+        profile.adapter == .escpos && (profile.transport == .wifi || profile.transport == .ethernet)
+    }
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        if isConnected(profile.id) { return }
+        // iOS : pas de Bluetooth Classic/SPP ni de GATT BLE générique exposé par le
+        // plugin. Le BLE/Bluetooth passe par les SDK MFi (Star/Epson/Brother).
+        guard profile.transport == .wifi || profile.transport == .ethernet else {
+            throw PrinterError(
+                .UNSUPPORTED_TRANSPORT,
+                "iOS : le transport \(profile.transport.rawValue) générique n'est pas exposé. " +
+                "Utilisez une imprimante via son SDK MFi (Star/Epson/Brother). Voir docs/SDK_INTEGRATION.md."
+            )
+        }
+        let (host, port) = splitHostPort(profile.address, defaultPort: 9100)
+        let t = TcpTransport(host: host, port: port)
+        try await t.open(timeoutMs: timeoutMs)
+        lock.lock(); connections[profile.id] = t; lock.unlock()
+    }
+
+    func isConnected(_ printerId: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        return connections[printerId]?.isOpen == true
+    }
+
+    func disconnect(_ printerId: String) async {
+        lock.lock(); let t = connections.removeValue(forKey: printerId); lock.unlock()
+        t?.close()
+    }
+
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int {
+        lock.lock(); let t = connections[profile.id]; lock.unlock()
+        guard let transport = t else {
+            throw PrinterError(.CONNECTION_FAILED, "ESC/POS non connecté: \(profile.id)")
+        }
+        let mono = try ImageProcessor.toMono(image, options: options)
+        let raster = ImageProcessor.encodeEscPosRaster(mono)
+        let job = EscPosCommands.buildJob(
+            raster: raster, align: options.align, feedLines: options.feedLines,
+            cut: options.cut && profile.capabilities.supportsCut,
+            openDrawer: options.openCashDrawer && profile.capabilities.supportsCashDrawer
+        )
+        var sent = 0
+        for _ in 0..<max(1, options.copies) {
+            try await transport.write(job)
+            sent += job.count
+        }
+        return sent
+    }
+
+    func printItems(_ profile: PrinterProfile, items: [PrintItem], defaultCodePage: String, cut: Bool, feedLines: Int) async throws -> Int {
+        lock.lock(); let t = connections[profile.id]; lock.unlock()
+        guard let transport = t else { throw PrinterError(.CONNECTION_FAILED, "ESC/POS non connecté: \(profile.id)") }
+        let columns = profile.capabilities.printableDots <= 420 ? 32 : 48
+        let encoded = EscPosTextEncoder.encode(items, defaultCodePage: defaultCodePage, columns: columns)
+        var job = encoded.bytes
+        if feedLines > 0 { job += EscPosCommands.feed(feedLines) }
+        if cut && profile.capabilities.supportsCut { job += EscPosCommands.CUT_PARTIAL }
+        try await transport.write(job)
+        return job.count
+    }
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus {
+        let connected = isConnected(profile.id)
+        return PrinterStatus(
+            id: profile.id,
+            connection: connected ? "connected" : "disconnected",
+            online: connected, paper: "unknown",
+            rawStatus: "ESC/POS TCP: statut temps réel non lu (unidirectionnel)"
+        )
+    }
+
+    private func splitHostPort(_ addr: String, defaultPort: UInt16) -> (String, UInt16) {
+        if let idx = addr.lastIndex(of: ":"), addr.firstIndex(of: ":") == idx {
+            let host = String(addr[..<idx])
+            let portStr = String(addr[addr.index(after: idx)...])
+            return (host, UInt16(portStr) ?? defaultPort)
+        }
+        return (addr, defaultPort)
+    }
+}

package/ios/Plugin/Adapters/EscPosCommands.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+/// Constantes et helpers de commandes ESC/POS (miroir iOS de EscPosCommands.kt).
+enum EscPosCommands {
+    static let INIT: [UInt8] = [0x1B, 0x40]
+    static let ALIGN_LEFT: [UInt8] = [0x1B, 0x61, 0x00]
+    static let ALIGN_CENTER: [UInt8] = [0x1B, 0x61, 0x01]
+    static let ALIGN_RIGHT: [UInt8] = [0x1B, 0x61, 0x02]
+    static let CUT_PARTIAL: [UInt8] = [0x1D, 0x56, 0x01]
+    static let DRAWER_PIN2: [UInt8] = [0x1B, 0x70, 0x00, 0x19, 0xFA]
+
+    static func feed(_ lines: Int) -> [UInt8] { [0x1B, 0x64, UInt8(clamping: lines)] }
+
+    static func alignOf(_ align: String) -> [UInt8] {
+        switch align {
+        case "center": return ALIGN_CENTER
+        case "right": return ALIGN_RIGHT
+        default: return ALIGN_LEFT
+        }
+    }
+
+    static func buildJob(raster: [UInt8], align: String, feedLines: Int, cut: Bool, openDrawer: Bool) -> [UInt8] {
+        var out: [UInt8] = []
+        out.append(contentsOf: INIT)
+        out.append(contentsOf: alignOf(align))
+        out.append(contentsOf: raster)
+        out.append(contentsOf: feed(feedLines))
+        if cut { out.append(contentsOf: CUT_PARTIAL) }
+        if openDrawer { out.append(contentsOf: DRAWER_PIN2) }
+        return out
+    }
+}

package/ios/Plugin/Adapters/EscPosTextEncoder.swift

@@ -0,0 +1,115 @@
+import Foundation
+
+/// Encodeur ESC/POS texte iOS (miroir de escpos-text.ts / EscPosTextEncoder.kt).
+enum EscPosTextEncoder {
+
+    private static let ESC: UInt8 = 0x1B
+    private static let GS: UInt8 = 0x1D
+    private static let LF: UInt8 = 0x0A
+
+    private static let codePageToEscT: [String: UInt8] = [
+        "CP437": 0, "CP850": 2, "CP858": 19, "WPC1252": 16, "CP852": 18, "CP866": 17,
+    ]
+    private static let barcodeM: [String: UInt8] = [
+        "UPC_A": 65, "UPC_E": 66, "EAN13": 67, "EAN8": 68,
+        "CODE39": 69, "ITF": 70, "CODABAR": 71, "CODE93": 72, "CODE128": 73,
+    ]
+
+    struct Encoded { let bytes: [UInt8]; let imageIndexes: [Int] }
+
+    static func encodeString(_ value: String) -> [UInt8] {
+        value.unicodeScalars.map { $0.value <= 0xFF ? UInt8($0.value) : 0x3F }
+    }
+
+    static func sizeByte(_ w: Int, _ h: Int) -> UInt8 {
+        let ww = UInt8(min(8, max(1, w)) - 1)
+        let hh = UInt8(min(8, max(1, h)) - 1)
+        return (ww << 4) | hh
+    }
+
+    private static func openStyle(_ out: inout [UInt8], _ s: TextStyle, _ defaultCodePage: String) {
+        let cp = s.codePageId.map { UInt8(truncatingIfNeeded: $0) } ?? (codePageToEscT[s.codePage ?? defaultCodePage] ?? 16)
+        out += [ESC, 0x74, cp]
+        let align: UInt8 = s.align == "center" ? 1 : (s.align == "right" ? 2 : 0)
+        out += [ESC, 0x61, align]
+        out += [ESC, 0x4D, s.font == "B" ? 1 : 0]
+        out += [ESC, 0x45, s.bold ? 1 : 0]
+        out += [ESC, 0x47, s.doubleStrike ? 1 : 0]
+        let ul: UInt8 = s.underline == "single" ? 1 : (s.underline == "double" ? 2 : 0)
+        out += [ESC, 0x2D, ul]
+        out += [GS, 0x42, s.invert ? 1 : 0]
+        out += [ESC, 0x7B, s.upsideDown ? 1 : 0]
+        out += [ESC, 0x56, s.rotate90 ? 1 : 0]
+        out += [GS, 0x21, sizeByte(s.widthMultiplier, s.heightMultiplier)]
+        if let ls = s.letterSpacing { out += [ESC, 0x20, UInt8(truncatingIfNeeded: ls)] }
+        if let lsp = s.lineSpacing { out += [ESC, 0x33, UInt8(truncatingIfNeeded: lsp)] } else { out += [ESC, 0x32] }
+    }
+
+    private static func qrCode(_ out: inout [UInt8], value: String, size: Int, ec: String, align: String) {
+        let a: UInt8 = align == "left" ? 0 : (align == "right" ? 2 : 1)
+        out += [ESC, 0x61, a]
+        out += [GS, 0x28, 0x6B, 0x04, 0x00, 0x31, 0x41, 0x32, 0x00]
+        out += [GS, 0x28, 0x6B, 0x03, 0x00, 0x31, 0x43, UInt8(min(16, max(1, size)))]
+        let ecv: UInt8 = ec == "L" ? 48 : (ec == "Q" ? 50 : (ec == "H" ? 51 : 49))
+        out += [GS, 0x28, 0x6B, 0x03, 0x00, 0x31, 0x45, ecv]
+        let data = encodeString(value)
+        let len = data.count + 3
+        out += [GS, 0x28, 0x6B, UInt8(len & 0xFF), UInt8((len >> 8) & 0xFF), 0x31, 0x50, 0x30]
+        out += data
+        out += [GS, 0x28, 0x6B, 0x03, 0x00, 0x31, 0x51, 0x30]
+    }
+
+    private static func barcode(_ out: inout [UInt8], value: String, symbology: String, height: Int, width: Int, hri: String, align: String) {
+        let a: UInt8 = align == "left" ? 0 : (align == "right" ? 2 : 1)
+        out += [ESC, 0x61, a]
+        let h: UInt8 = hri == "above" ? 1 : (hri == "both" ? 3 : (hri == "none" ? 0 : 2))
+        out += [GS, 0x48, h]
+        out += [GS, 0x68, UInt8(min(255, max(1, height)))]
+        out += [GS, 0x77, UInt8(min(6, max(2, width)))]
+        let m = barcodeM[symbology] ?? 73
+        var data = encodeString(value)
+        if symbology == "CODE128" && !(data.first == 0x7B) { data = [0x7B, 0x42] + data }
+        out += [GS, 0x6B, m, UInt8(data.count)]
+        out += data
+    }
+
+    static func encode(_ items: [PrintItem], defaultCodePage: String = "WPC1252", columns: Int = 48) -> Encoded {
+        var out: [UInt8] = [ESC, 0x40] // reset
+        var imageIndexes: [Int] = []
+        for (index, item) in items.enumerated() {
+            switch item {
+            case let .text(value, style):
+                openStyle(&out, style, defaultCodePage)
+                out += encodeString(value)
+                if style.newline { out.append(LF) }
+                out += [ESC, 0x40]
+            case let .feed(lines):
+                out += [ESC, 0x64, UInt8(min(255, max(0, lines)))]
+            case let .divider(char, cols, align, bold):
+                let ch = char.unicodeScalars.first.map { UInt8(truncatingIfNeeded: $0.value) } ?? 0x2D
+                let n = cols ?? columns
+                let a: UInt8 = align == "center" ? 1 : (align == "right" ? 2 : 0)
+                out += [ESC, 0x61, a]
+                if bold { out += [ESC, 0x45, 1] }
+                out += [UInt8](repeating: ch, count: n)
+                out.append(LF)
+                out += [ESC, 0x40]
+            case let .qrcode(value, size, ec, align):
+                qrCode(&out, value: value, size: size, ec: ec, align: align)
+            case let .barcode(value, symbology, height, width, hri, align):
+                barcode(&out, value: value, symbology: symbology, height: height, width: width, hri: hri, align: align)
+            case let .cashDrawer(pin):
+                out += pin == 5 ? [ESC, 0x70, 0x01, 0x19, 0xFA] : [ESC, 0x70, 0x00, 0x19, 0xFA]
+            case let .cut(mode, feedBefore):
+                if feedBefore > 0 { out += [ESC, 0x64, UInt8(truncatingIfNeeded: feedBefore)] }
+                out += mode == "full" ? [GS, 0x56, 0x00] : [GS, 0x56, 0x01]
+            case let .raw(bytesBase64):
+                let clean = bytesBase64.contains("base64,") ? String(bytesBase64.split(separator: ",").last ?? "") : bytesBase64
+                if let data = Data(base64Encoded: clean, options: .ignoreUnknownCharacters) { out += [UInt8](data) }
+            case .image:
+                imageIndexes.append(index)
+            }
+        }
+        return Encoded(bytes: out, imageIndexes: imageIndexes)
+    }
+}

package/ios/Plugin/Adapters/PrinterAdapter.swift

@@ -0,0 +1,44 @@
+import Foundation
+import UIKit
+
+/// Contrat commun à tous les adapters iOS (miroir de l'interface Android).
+///
+/// Toutes les méthodes longues sont `async` et lèvent `PrinterError` en cas d'échec.
+protocol PrinterAdapter {
+    var id: AdapterId { get }
+
+    /// True si le SDK requis est lié à l'app (sinon adapter ignoré).
+    func isAvailable() -> Bool
+
+    /// Découverte propre à l'adapter, résultats poussés via `onFound`.
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async
+
+    func canHandle(_ profile: PrinterProfile) -> Bool
+
+    /// True si l'adapter imprime des items texte NATIVEMENT. Sinon le moteur rend
+    /// les items en image (TextRasterizer) puis appelle `printImage`.
+    func supportsTextItems() -> Bool
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws
+    func isConnected(_ printerId: String) -> Bool
+    func disconnect(_ printerId: String) async
+
+    /// Imprime un UIImage DÉJÀ redimensionné à la largeur cible.
+    /// Retourne le nombre d'octets envoyés (best effort).
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int
+
+    /// Imprime une liste d'items texte stylés (+ QR/code-barres/feed/cut...).
+    /// Pour ESC/POS : encodage via EscPosTextEncoder. SDK : builder du SDK.
+    func printItems(_ profile: PrinterProfile, items: [PrintItem], defaultCodePage: String, cut: Bool, feedLines: Int) async throws -> Int
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus
+}
+
+/// Implémentation par défaut : printText non supporté (les SDK la surchargent).
+extension PrinterAdapter {
+    func supportsTextItems() -> Bool { false }
+
+    func printItems(_ profile: PrinterProfile, items: [PrintItem], defaultCodePage: String, cut: Bool, feedLines: Int) async throws -> Int {
+        throw PrinterError(.SDK_NOT_AVAILABLE, "printText non implémenté pour cet adapter (\(id.rawValue)) — voir docs/SDK_INTEGRATION.md")
+    }
+}

package/ios/Plugin/Adapters/RawTcpAdapter.swift

@@ -0,0 +1,70 @@
+import Foundation
+import UIKit
+
+/// Adapter filet de sécurité réseau iOS : raster ESC/POS sur TCP brut, sans statut.
+final class RawTcpAdapter: PrinterAdapter {
+
+    let id: AdapterId = .rawTcp
+    private var connections: [String: TcpTransport] = [:]
+    private let lock = NSLock()
+
+    func isAvailable() -> Bool { true }
+
+    func supportsTextItems() -> Bool { true }
+
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {}
+
+    func canHandle(_ profile: PrinterProfile) -> Bool {
+        profile.adapter == .rawTcp && (profile.transport == .wifi || profile.transport == .ethernet)
+    }
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        if isConnected(profile.id) { return }
+        var host = profile.address
+        var port: UInt16 = 9100
+        if let idx = profile.address.lastIndex(of: ":") {
+            host = String(profile.address[..<idx])
+            port = UInt16(profile.address[profile.address.index(after: idx)...]) ?? 9100
+        }
+        let t = TcpTransport(host: host, port: port)
+        try await t.open(timeoutMs: timeoutMs)
+        lock.lock(); connections[profile.id] = t; lock.unlock()
+    }
+
+    func isConnected(_ printerId: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        return connections[printerId]?.isOpen == true
+    }
+
+    func disconnect(_ printerId: String) async {
+        lock.lock(); let t = connections.removeValue(forKey: printerId); lock.unlock()
+        t?.close()
+    }
+
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int {
+        lock.lock(); let t = connections[profile.id]; lock.unlock()
+        guard let transport = t else { throw PrinterError(.CONNECTION_FAILED, "rawTcp non connecté") }
+        let mono = try ImageProcessor.toMono(image, options: options)
+        let raster = ImageProcessor.encodeEscPosRaster(mono)
+        let job = EscPosCommands.buildJob(raster: raster, align: options.align, feedLines: options.feedLines, cut: options.cut, openDrawer: options.openCashDrawer)
+        try await transport.write(job)
+        return job.count
+    }
+
+    func printItems(_ profile: PrinterProfile, items: [PrintItem], defaultCodePage: String, cut: Bool, feedLines: Int) async throws -> Int {
+        lock.lock(); let t = connections[profile.id]; lock.unlock()
+        guard let transport = t else { throw PrinterError(.CONNECTION_FAILED, "rawTcp non connecté") }
+        let columns = profile.capabilities.printableDots <= 420 ? 32 : 48
+        let encoded = EscPosTextEncoder.encode(items, defaultCodePage: defaultCodePage, columns: columns)
+        var job = encoded.bytes
+        if feedLines > 0 { job += EscPosCommands.feed(feedLines) }
+        if cut { job += EscPosCommands.CUT_PARTIAL }
+        try await transport.write(job)
+        return job.count
+    }
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus {
+        let c = isConnected(profile.id)
+        return PrinterStatus(id: profile.id, connection: c ? "connected" : "disconnected", online: c, paper: "unknown", rawStatus: "rawTcp: statut non supporté")
+    }
+}