@delicity/capacitor-thermal-printer 7.0.0

package/ios/Plugin/Image/ImageProcessor.swift

@@ -0,0 +1,168 @@
+import Foundation
+import UIKit
+import CoreGraphics
+
+/// Pipeline image -> raster thermique (miroir iOS de ImageProcessor.kt).
+///
+/// Étapes : decode -> resize largeur -> aplatir sur blanc -> niveaux de gris ->
+/// binarisation (threshold / Floyd-Steinberg / Atkinson) -> raster ESC/POS GS v 0.
+enum ImageProcessor {
+
+    private static let MAX_HEIGHT = 20_000
+
+    // MARK: - Décodage
+
+    static func decodeFile(_ path: String) throws -> UIImage {
+        let clean = path.replacingOccurrences(of: "file://", with: "")
+        guard FileManager.default.fileExists(atPath: clean),
+              let img = UIImage(contentsOfFile: clean) else {
+            throw PrinterError(.IMAGE_INVALID, "Fichier image introuvable: \(clean)")
+        }
+        return img
+    }
+
+    static func decodeBase64(_ b64: String) throws -> UIImage {
+        let payload = b64.contains("base64,") ? String(b64.split(separator: ",").last ?? "") : b64
+        guard let data = Data(base64Encoded: payload, options: .ignoreUnknownCharacters),
+              let img = UIImage(data: data) else {
+            throw PrinterError(.IMAGE_INVALID, "Base64 image invalide")
+        }
+        return img
+    }
+
+    // MARK: - Resize sur fond blanc
+
+    static func resizeToWidth(_ image: UIImage, targetWidth: Int) throws -> UIImage {
+        let w = max(8, targetWidth)
+        let ratio = CGFloat(w) / image.size.width
+        let h = Int((image.size.height * ratio).rounded())
+        guard h <= MAX_HEIGHT else {
+            throw PrinterError(.IMAGE_TOO_LARGE, "Image trop haute: \(h)px (max \(MAX_HEIGHT))")
+        }
+        let size = CGSize(width: w, height: h)
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = 1
+        format.opaque = true
+        let renderer = UIGraphicsImageRenderer(size: size, format: format)
+        return renderer.image { ctx in
+            UIColor.white.setFill()
+            ctx.fill(CGRect(origin: .zero, size: size))
+            image.draw(in: CGRect(origin: .zero, size: size))
+        }
+    }
+
+    // MARK: - Niveaux de gris
+
+    /// Extrait un buffer 8-bit gris (0=noir..255=blanc) en redessinant en contexte gris.
+    private static func grayscaleBuffer(_ image: UIImage) throws -> (px: [UInt8], w: Int, h: Int) {
+        guard let cg = image.cgImage else { throw PrinterError(.IMAGE_INVALID, "CGImage indisponible") }
+        let w = cg.width
+        let h = cg.height
+        var buffer = [UInt8](repeating: 0, count: w * h)
+        let colorSpace = CGColorSpaceCreateDeviceGray()
+        guard let ctx = CGContext(
+            data: &buffer, width: w, height: h, bitsPerComponent: 8, bytesPerRow: w,
+            space: colorSpace, bitmapInfo: CGImageAlphaInfo.none.rawValue
+        ) else { throw PrinterError(.IMAGE_INVALID, "Contexte gris impossible") }
+        ctx.draw(cg, in: CGRect(x: 0, y: 0, width: w, height: h))
+        return (buffer, w, h)
+    }
+
+    // MARK: - Binarisation
+
+    /// Produit un MonoBitmap (1 = encre/noir).
+    /// Si `options.grayscale == false`, l'image est considérée déjà préparée : seuil simple.
+    static func toMono(_ image: UIImage, options: RenderOptions) throws -> MonoBitmap {
+        var (gray, w, h) = try grayscaleBuffer(image)
+        if options.invert {
+            for i in 0..<gray.count { gray[i] = 255 - gray[i] }
+        }
+        let data: [UInt8]
+        switch (options.grayscale, options.dithering) {
+        case (false, _): data = threshold(gray, options.threshold)
+        case (_, "none"): data = threshold(gray, options.threshold)
+        case (_, "atkinson"): data = atkinson(gray, w, h)
+        default: data = floydSteinberg(gray, w, h)
+        }
+        return MonoBitmap(width: w, height: h, data: data)
+    }
+
+    private static func threshold(_ gray: [UInt8], _ t: Int) -> [UInt8] {
+        let tt = UInt8(clamping: t)
+        return gray.map { $0 < tt ? UInt8(1) : UInt8(0) }
+    }
+
+    private static func floydSteinberg(_ grayInput: [UInt8], _ w: Int, _ h: Int) -> [UInt8] {
+        var gray = grayInput.map { Float($0) }
+        var out = [UInt8](repeating: 0, count: grayInput.count)
+        func at(_ x: Int, _ y: Int) -> Int { y * w + x }
+        for y in 0..<h {
+            for x in 0..<w {
+                let idx = at(x, y)
+                let old = gray[idx]
+                let new: Float = old < 128 ? 0 : 255
+                out[idx] = new == 0 ? 1 : 0
+                let err = old - new
+                if x + 1 < w { gray[at(x + 1, y)] += err * 7 / 16 }
+                if x - 1 >= 0 && y + 1 < h { gray[at(x - 1, y + 1)] += err * 3 / 16 }
+                if y + 1 < h { gray[at(x, y + 1)] += err * 5 / 16 }
+                if x + 1 < w && y + 1 < h { gray[at(x + 1, y + 1)] += err / 16 }
+            }
+        }
+        return out
+    }
+
+    private static func atkinson(_ grayInput: [UInt8], _ w: Int, _ h: Int) -> [UInt8] {
+        var gray = grayInput.map { Float($0) }
+        var out = [UInt8](repeating: 0, count: grayInput.count)
+        func at(_ x: Int, _ y: Int) -> Int { y * w + x }
+        func spread(_ x: Int, _ y: Int, _ e: Float) {
+            if x >= 0 && x < w && y >= 0 && y < h { gray[at(x, y)] += e }
+        }
+        for y in 0..<h {
+            for x in 0..<w {
+                let idx = at(x, y)
+                let old = gray[idx]
+                let new: Float = old < 128 ? 0 : 255
+                out[idx] = new == 0 ? 1 : 0
+                let err = (old - new) / 8
+                spread(x + 1, y, err); spread(x + 2, y, err)
+                spread(x - 1, y + 1, err); spread(x, y + 1, err); spread(x + 1, y + 1, err)
+                spread(x, y + 2, err)
+            }
+        }
+        return out
+    }
+
+    // MARK: - Raster ESC/POS GS v 0
+
+    static func encodeEscPosRaster(_ mono: MonoBitmap) -> [UInt8] {
+        let w = mono.width
+        let h = mono.height
+        let bytesPerRow = (w + 7) / 8
+        let xL = UInt8(bytesPerRow & 0xff)
+        let xH = UInt8((bytesPerRow >> 8) & 0xff)
+        let yL = UInt8(h & 0xff)
+        let yH = UInt8((h >> 8) & 0xff)
+        var out: [UInt8] = [0x1D, 0x76, 0x30, 0x00, xL, xH, yL, yH]
+        var body = [UInt8](repeating: 0, count: bytesPerRow * h)
+        for y in 0..<h {
+            let rowOff = y * bytesPerRow
+            let srcOff = y * w
+            for x in 0..<w where mono.data[srcOff + x] == 1 {
+                let byteIndex = rowOff + (x >> 3)
+                let bit = 7 - (x & 7)
+                body[byteIndex] |= UInt8(1 << bit)
+            }
+        }
+        out.append(contentsOf: body)
+        return out
+    }
+}
+
+/// Image 1-bit : data[i]=1 => point noir/encre.
+struct MonoBitmap {
+    let width: Int
+    let height: Int
+    let data: [UInt8]
+}

package/ios/Plugin/Image/TextRasterizer.swift

@@ -0,0 +1,81 @@
+import Foundation
+import UIKit
+
+/// Rend une liste d'items texte (`printText`) en **UIImage**, pour les adapters dont
+/// le SDK n'a pas de builder texte natif (Brother, Zebra). Le moteur appelle ensuite
+/// `printImage` → le SDK imprime l'image.
+///
+/// Police monospace (alignement colonne fiable). Supporte texte (align, gras,
+/// souligné, multiplicateur de taille), séparateur, saut de ligne. Les items
+/// QR/code-barres sont rendus en texte de repli ; image/raw/cut/tiroir ignorés.
+enum TextRasterizer {
+
+    private struct Line {
+        let text: String
+        let sizeMul: Int
+        let bold: Bool
+        let underline: Bool
+        let align: String
+    }
+
+    static func render(_ items: [PrintItem], widthDots: Int) -> UIImage {
+        let width = CGFloat(max(128, widthDots))
+        let columns = widthDots <= 420 ? 32 : 48
+
+        // Taille de base : caler N caractères monospace sur la largeur cible.
+        var fontSize: CGFloat = 24
+        let probe = UIFont.monospacedSystemFont(ofSize: fontSize, weight: .regular)
+        let charW = ("M" as NSString).size(withAttributes: [.font: probe]).width
+        fontSize = fontSize * (width / CGFloat(columns)) / max(1, charW)
+        let baseFont = UIFont.monospacedSystemFont(ofSize: fontSize, weight: .regular)
+        let baseLineH = baseFont.lineHeight
+
+        var lines: [Line?] = []
+        for item in items {
+            switch item {
+            case let .text(value, style):
+                for raw in value.components(separatedBy: "\n") {
+                    lines.append(Line(text: raw, sizeMul: min(max(style.heightMultiplier, 1), 6),
+                                      bold: style.bold, underline: style.underline != "none", align: style.align ?? "left"))
+                }
+            case let .divider(char, cols, align, bold):
+                let n = cols ?? columns
+                let c = char.isEmpty ? "-" : String(char.prefix(1))
+                lines.append(Line(text: String(repeating: c, count: min(max(n, 1), 96)), sizeMul: 1, bold: bold, underline: false, align: align ?? "left"))
+            case let .feed(n):
+                for _ in 0..<min(max(n, 1), 20) { lines.append(nil) }
+            case let .qrcode(value, _, _, align):
+                lines.append(Line(text: "[QR] \(value)", sizeMul: 1, bold: false, underline: false, align: align))
+            case let .barcode(value, symbology, _, _, _, align):
+                lines.append(Line(text: "[\(symbology)] \(value)", sizeMul: 1, bold: false, underline: false, align: align))
+            case .cut, .cashDrawer, .image, .raw:
+                break
+            }
+        }
+        if lines.isEmpty { lines.append(nil) }
+
+        let totalH = lines.reduce(CGFloat(0)) { $0 + CGFloat($1?.sizeMul ?? 1) * baseLineH } + 8
+        let height = max(baseLineH, totalH)
+
+        let format = UIGraphicsImageRendererFormat.default()
+        format.scale = 1
+        format.opaque = true
+        let renderer = UIGraphicsImageRenderer(size: CGSize(width: width, height: height), format: format)
+        return renderer.image { ctx in
+            UIColor.white.setFill()
+            ctx.fill(CGRect(x: 0, y: 0, width: width, height: height))
+            var y: CGFloat = 0
+            for line in lines {
+                guard let l = line else { y += baseLineH; continue }
+                let font = UIFont.monospacedSystemFont(ofSize: fontSize * CGFloat(l.sizeMul), weight: l.bold ? .bold : .regular)
+                var attrs: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: UIColor.black]
+                if l.underline { attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue }
+                let ns = l.text as NSString
+                let tw = ns.size(withAttributes: attrs).width
+                let x: CGFloat = l.align == "center" ? max(0, (width - tw) / 2) : (l.align == "right" ? max(0, width - tw) : 0)
+                ns.draw(at: CGPoint(x: x, y: y), withAttributes: attrs)
+                y += font.lineHeight
+            }
+        }
+    }
+}

package/ios/Plugin/Logger.swift

@@ -0,0 +1,33 @@
+import Foundation
+import os.log
+
+/// Logger circulaire en mémoire + os_log, pour le diagnostic support (miroir Logger.kt).
+final class Logger {
+    static let shared = Logger()
+    private let maxLines = 500
+    private var ring: [[String: Any]] = []
+    private let queue = DispatchQueue(label: "thermalprinter.logger")
+    var verbose = false
+    private let osLog = OSLog(subsystem: "com.delicity.thermalprinter", category: "plugin")
+
+    func log(_ category: String, _ message: String, _ data: [String: Any]? = nil) {
+        queue.sync {
+            var entry: [String: Any] = [
+                "ts": Date().timeIntervalSince1970 * 1000,
+                "category": category, "message": message,
+            ]
+            data?.forEach { entry[$0.key] = $0.value }
+            if ring.count >= maxLines { ring.removeFirst() }
+            ring.append(entry)
+            if verbose { os_log("[%{public}@] %{public}@", log: osLog, type: .debug, category, message) }
+        }
+    }
+
+    func error(_ category: String, _ message: String) {
+        log(category, message, ["level": "error"])
+        os_log("[%{public}@] %{public}@", log: osLog, type: .error, category, message)
+    }
+
+    func snapshot() -> [[String: Any]] { queue.sync { ring } }
+    func clear() { queue.sync { ring.removeAll() } }
+}

package/ios/Plugin/Model/Models.swift

@@ -0,0 +1,174 @@
+import Foundation
+
+/// Transports physiques. Aligné avec PrinterTransport (TypeScript).
+enum Transport: String, Codable {
+    case wifi, ethernet, bluetooth, ble, usb
+    static func from(_ v: String?) -> Transport { Transport(rawValue: v ?? "") ?? .wifi }
+}
+
+/// Identifiants d'adapter. Aligné avec PrinterAdapterId (TypeScript).
+enum AdapterId: String, Codable {
+    case escpos, epson, star, brother, zebra
+    case rawTcp = "rawTcp"
+    static func from(_ v: String?) -> AdapterId { AdapterId(rawValue: v ?? "") ?? .escpos }
+}
+
+/// Codes d'erreur normalisés. Aligné avec PrintErrorCode (TypeScript).
+enum ErrorCode: String {
+    case PRINTER_NOT_FOUND, PRINTER_OFFLINE, CONNECTION_FAILED, PERMISSION_DENIED
+    case BLUETOOTH_DISABLED, WIFI_NOT_CONNECTED, PAIRING_REQUIRED, UNSUPPORTED_TRANSPORT
+    case UNSUPPORTED_PRINTER, IMAGE_INVALID, IMAGE_TOO_LARGE, PRINT_FAILED, PAPER_EMPTY
+    case COVER_OPEN, SDK_NOT_AVAILABLE, TIMEOUT, UNKNOWN
+}
+
+/// Erreur interne portant un code normalisé.
+struct PrinterError: Error {
+    let code: ErrorCode
+    let message: String
+    let detail: String?
+    let retryable: Bool
+    init(_ code: ErrorCode, _ message: String, detail: String? = nil, retryable: Bool = false) {
+        self.code = code; self.message = message; self.detail = detail; self.retryable = retryable
+    }
+}
+
+struct Capabilities: Codable {
+    var paperWidthMm: Int = 80
+    var printableDots: Int = 576
+    var dpi: Int = 203
+    var supportsCut: Bool = true
+    var supportsCashDrawer: Bool = false
+    var supportsStatus: Bool = false
+    var supportsRasterImage: Bool = true
+    var supportsQrCode: Bool = false
+    var supportsBarcode: Bool = false
+
+    func toDict() -> [String: Any] {
+        [
+            "paperWidthMm": paperWidthMm, "printableDots": printableDots, "dpi": dpi,
+            "supportsCut": supportsCut, "supportsCashDrawer": supportsCashDrawer,
+            "supportsStatus": supportsStatus, "supportsRasterImage": supportsRasterImage,
+            "supportsQrCode": supportsQrCode, "supportsBarcode": supportsBarcode,
+        ]
+    }
+
+    static func fromDict(_ d: [String: Any]?) -> Capabilities {
+        guard let d = d else { return Capabilities() }
+        var c = Capabilities()
+        c.paperWidthMm = d["paperWidthMm"] as? Int ?? 80
+        c.printableDots = d["printableDots"] as? Int ?? 576
+        c.dpi = d["dpi"] as? Int ?? 203
+        c.supportsCut = d["supportsCut"] as? Bool ?? true
+        c.supportsCashDrawer = d["supportsCashDrawer"] as? Bool ?? false
+        c.supportsStatus = d["supportsStatus"] as? Bool ?? false
+        c.supportsRasterImage = d["supportsRasterImage"] as? Bool ?? true
+        c.supportsQrCode = d["supportsQrCode"] as? Bool ?? false
+        c.supportsBarcode = d["supportsBarcode"] as? Bool ?? false
+        return c
+    }
+}
+
+struct DiscoveredPrinter {
+    let id: String
+    let name: String
+    var brand: String?
+    var model: String?
+    let transport: Transport
+    var adapter: AdapterId
+    let address: String
+    var capabilities: Capabilities?
+    var discoveredBy: Set<String> = []
+    var lastSeenAt: Double = Date().timeIntervalSince1970 * 1000
+    var isDefault: Bool = false
+    var isConnected: Bool = false
+
+    func toDict() -> [String: Any] {
+        var d: [String: Any] = [
+            "id": id, "name": name, "transport": transport.rawValue, "adapter": adapter.rawValue,
+            "address": address, "lastSeenAt": lastSeenAt, "isDefault": isDefault, "isConnected": isConnected,
+            "discoveredBy": Array(discoveredBy),
+        ]
+        if let brand = brand { d["brand"] = brand }
+        if let model = model { d["model"] = model }
+        if let caps = capabilities { d["capabilities"] = caps.toDict() }
+        return d
+    }
+}
+
+struct PrinterProfile {
+    let id: String
+    var adapter: AdapterId
+    let transport: Transport
+    let address: String
+    var brand: String?
+    var model: String?
+    let name: String
+    var capabilities: Capabilities
+    var adapterMeta: [String: Any] = [:]
+    var isDefault: Bool = false
+    var createdAt: Double = Date().timeIntervalSince1970 * 1000
+    var updatedAt: Double = Date().timeIntervalSince1970 * 1000
+
+    func toDict() -> [String: Any] {
+        var d: [String: Any] = [
+            "id": id, "adapter": adapter.rawValue, "transport": transport.rawValue, "address": address,
+            "name": name, "capabilities": capabilities.toDict(), "adapterMeta": adapterMeta,
+            "isDefault": isDefault, "createdAt": createdAt, "updatedAt": updatedAt,
+        ]
+        if let brand = brand { d["brand"] = brand }
+        if let model = model { d["model"] = model }
+        return d
+    }
+
+    static func fromDict(_ d: [String: Any]) -> PrinterProfile {
+        PrinterProfile(
+            id: d["id"] as? String ?? "",
+            adapter: AdapterId.from(d["adapter"] as? String),
+            transport: Transport.from(d["transport"] as? String),
+            address: d["address"] as? String ?? "",
+            brand: d["brand"] as? String,
+            model: d["model"] as? String,
+            name: d["name"] as? String ?? "",
+            capabilities: Capabilities.fromDict(d["capabilities"] as? [String: Any]),
+            adapterMeta: d["adapterMeta"] as? [String: Any] ?? [:],
+            isDefault: d["isDefault"] as? Bool ?? false,
+            createdAt: d["createdAt"] as? Double ?? Date().timeIntervalSince1970 * 1000,
+            updatedAt: d["updatedAt"] as? Double ?? Date().timeIntervalSince1970 * 1000
+        )
+    }
+}
+
+struct PrinterStatus {
+    let id: String
+    var connection: String
+    var online: Bool
+    var paper: String
+    var coverOpen: Bool?
+    var errorCode: ErrorCode?
+    var rawStatus: String?
+    var checkedAt: Double = Date().timeIntervalSince1970 * 1000
+
+    func toDict() -> [String: Any] {
+        var d: [String: Any] = [
+            "id": id, "connection": connection, "online": online, "paper": paper, "checkedAt": checkedAt,
+        ]
+        if let coverOpen = coverOpen { d["coverOpen"] = coverOpen }
+        if let errorCode = errorCode { d["errorCode"] = errorCode.rawValue }
+        if let rawStatus = rawStatus { d["rawStatus"] = rawStatus }
+        return d
+    }
+}
+
+struct RenderOptions {
+    var widthDots: Int
+    var resize: Bool = true
+    var grayscale: Bool = true
+    var threshold: Int = 128
+    var dithering: String = "floyd_steinberg"
+    var align: String = "center"
+    var invert: Bool = false
+    var cut: Bool = true
+    var feedLines: Int = 3
+    var openCashDrawer: Bool = false
+    var copies: Int = 1
+}

package/ios/Plugin/Model/PrintItem.swift

@@ -0,0 +1,111 @@
+import Foundation
+
+/// Modèle d'items texte iOS (miroir de src/core/text.ts et de PrintItem.kt).
+
+struct TextStyle {
+    var align: String?
+    var bold = false
+    var underline = "none"
+    var font = "A"
+    var widthMultiplier = 1
+    var heightMultiplier = 1
+    var doubleStrike = false
+    var invert = false
+    var upsideDown = false
+    var rotate90 = false
+    var letterSpacing: Int?
+    var lineSpacing: Int?
+    var codePage: String?
+    var codePageId: Int?
+    var newline = true
+
+    static func fromDict(_ d: [String: Any]?) -> TextStyle {
+        guard let d = d else { return TextStyle() }
+        var s = TextStyle()
+        s.align = d["align"] as? String
+        s.bold = d["bold"] as? Bool ?? false
+        s.underline = d["underline"] as? String ?? "none"
+        s.font = d["font"] as? String ?? "A"
+        s.widthMultiplier = d["widthMultiplier"] as? Int ?? 1
+        s.heightMultiplier = d["heightMultiplier"] as? Int ?? 1
+        s.doubleStrike = d["doubleStrike"] as? Bool ?? false
+        s.invert = d["invert"] as? Bool ?? false
+        s.upsideDown = d["upsideDown"] as? Bool ?? false
+        s.rotate90 = d["rotate90"] as? Bool ?? false
+        s.letterSpacing = d["letterSpacing"] as? Int
+        s.lineSpacing = d["lineSpacing"] as? Int
+        s.codePage = d["codePage"] as? String
+        s.codePageId = d["codePageId"] as? Int
+        s.newline = d["newline"] as? Bool ?? true
+        return s
+    }
+}
+
+enum PrintItem {
+    case text(value: String, style: TextStyle)
+    case feed(lines: Int)
+    case cut(mode: String, feedBefore: Int)
+    case divider(char: String, columns: Int?, align: String?, bold: Bool)
+    case qrcode(value: String, size: Int, ec: String, align: String)
+    case barcode(value: String, symbology: String, height: Int, width: Int, hri: String, align: String)
+    case cashDrawer(pin: Int)
+    case image(filePath: String?, url: String?, base64: String?, render: [String: Any]?)
+    case raw(bytesBase64: String)
+
+    static func parseList(_ arr: [[String: Any]]) -> [PrintItem] {
+        arr.compactMap { parse($0) }
+    }
+
+    static func parse(_ d: [String: Any]) -> PrintItem? {
+        switch d["type"] as? String {
+        case "text":
+            return .text(value: d["value"] as? String ?? "", style: TextStyle.fromDict(d["style"] as? [String: Any]))
+        case "feed":
+            return .feed(lines: d["lines"] as? Int ?? 1)
+        case "cut":
+            return .cut(mode: d["mode"] as? String ?? "partial", feedBefore: d["feedBefore"] as? Int ?? 0)
+        case "divider":
+            let style = d["style"] as? [String: Any]
+            return .divider(char: d["char"] as? String ?? "-", columns: d["columns"] as? Int,
+                            align: style?["align"] as? String, bold: style?["bold"] as? Bool ?? false)
+        case "qrcode":
+            return .qrcode(value: d["value"] as? String ?? "", size: d["size"] as? Int ?? 6,
+                           ec: d["errorCorrection"] as? String ?? "M", align: d["align"] as? String ?? "center")
+        case "barcode":
+            return .barcode(value: d["value"] as? String ?? "", symbology: d["symbology"] as? String ?? "CODE128",
+                            height: d["height"] as? Int ?? 80, width: d["width"] as? Int ?? 3,
+                            hri: d["hri"] as? String ?? "below", align: d["align"] as? String ?? "center")
+        case "cashDrawer":
+            return .cashDrawer(pin: d["pin"] as? Int ?? 2)
+        case "image":
+            let img = d["image"] as? [String: Any]
+            return .image(filePath: img?["filePath"] as? String, url: img?["url"] as? String,
+                          base64: img?["base64"] as? String, render: d["render"] as? [String: Any])
+        case "raw":
+            return .raw(bytesBase64: d["bytesBase64"] as? String ?? "")
+        default:
+            return nil
+        }
+    }
+}
+
+/// Mise à jour d'état d'un job d'impression (émis via printJobStatus).
+struct JobUpdate {
+    let jobId: String
+    let printerId: String
+    let state: String
+    var holdReason: String?
+    var progress: Double?
+    var errorCode: ErrorCode?
+    var message: String?
+
+    func toDict() -> [String: Any] {
+        var d: [String: Any] = ["jobId": jobId, "printerId": printerId, "state": state,
+                                "updatedAt": Date().timeIntervalSince1970 * 1000]
+        if let holdReason = holdReason { d["holdReason"] = holdReason }
+        if let progress = progress { d["progress"] = progress }
+        if let errorCode = errorCode { d["errorCode"] = errorCode.rawValue }
+        if let message = message { d["message"] = message }
+        return d
+    }
+}

package/ios/Plugin/Store/PrinterStore.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/// Persistance des profils via UserDefaults (JSON). Miroir de PrinterStore.kt.
+final class PrinterStore {
+
+    private let key = "delicity.thermalprinter.profiles_v1"
+    private let defaults = UserDefaults.standard
+    private let queue = DispatchQueue(label: "thermalprinter.store")
+
+    func all() -> [PrinterProfile] {
+        queue.sync {
+            guard let data = defaults.data(forKey: key),
+                  let arr = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else { return [] }
+            return arr.map { PrinterProfile.fromDict($0) }
+        }
+    }
+
+    func get(_ id: String) -> PrinterProfile? { all().first { $0.id == id } }
+    func getDefault() -> PrinterProfile? { all().first { $0.isDefault } }
+
+    func upsert(_ profile: PrinterProfile) {
+        var list = all()
+        var p = profile
+        p.updatedAt = Date().timeIntervalSince1970 * 1000
+        if let idx = list.firstIndex(where: { $0.id == p.id }) { list[idx] = p } else { list.append(p) }
+        persist(list)
+    }
+
+    @discardableResult
+    func setDefault(_ id: String) -> PrinterProfile? {
+        var list = all()
+        var target: PrinterProfile?
+        for i in list.indices {
+            list[i].isDefault = list[i].id == id
+            if list[i].isDefault { target = list[i] }
+        }
+        persist(list)
+        return target
+    }
+
+    func remove(_ id: String) { persist(all().filter { $0.id != id }) }
+
+    private func persist(_ list: [PrinterProfile]) {
+        queue.sync {
+            let arr = list.map { $0.toDict() }
+            if let data = try? JSONSerialization.data(withJSONObject: arr) {
+                defaults.set(data, forKey: key)
+            }
+        }
+    }
+}