@bricks-soft/capacitor-thermal-printer 0.0.0-stage → 8.0.0

package/dist/plugin.js

@@ -0,0 +1,68 @@
+var capacitorThermalPrinter = (function (exports, core) {
+    'use strict';
+
+    const native = core.registerPlugin('ThermalPrinter', {
+        web: () => Promise.resolve().then(function () { return web; }).then(m => new m.ThermalPrinterWeb()),
+    });
+    const unwrap = (request) => request.then(result => result.value).catch(error => {
+        if (error && typeof error === 'object' && error.data && typeof error.data === 'object') {
+            Object.assign(error, error.data);
+        }
+        throw error;
+    });
+    const ThermalPrinter = {
+        listPrinters: data => unwrap(native.listPrinters(data)),
+        printFormattedText: data => unwrap(native.printFormattedText(data)),
+        printFormattedTextAndCut: data => unwrap(native.printFormattedTextAndCut(data)),
+        getEncoding: data => unwrap(native.getEncoding(data)),
+        disconnectPrinter: data => unwrap(native.disconnectPrinter(data)),
+        requestPermissions: data => unwrap(native.requestPermissions(data)),
+        requestBTPermissions: data => unwrap(native.requestBTPermissions(data)),
+        requestUSBPermissions: data => unwrap(native.requestUSBPermissions(data)),
+        bitmapToHexadecimalString: data => unwrap(native.bitmapToHexadecimalString(data)),
+        bytesToHexadecimalString: data => unwrap(native.bytesToHexadecimalString(data)),
+    };
+
+    class ThermalPrinterWeb extends core.WebPlugin {
+        async listPrinters() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async printFormattedText() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async printFormattedTextAndCut() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async getEncoding() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async disconnectPrinter() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async requestPermissions() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async requestBTPermissions() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async requestUSBPermissions() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async bitmapToHexadecimalString() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+        async bytesToHexadecimalString() {
+            throw this.unavailable('Thermal printing is unavailable on the web.');
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        ThermalPrinterWeb: ThermalPrinterWeb
+    });
+
+    exports.ThermalPrinter = ThermalPrinter;
+
+    return exports;
+
+})({}, capacitorExports);

package/ios/Sources/ThermalPrinter/EscPosBarcode.swift

@@ -0,0 +1,121 @@
+import Foundation
+
+class EscPosBarcode {
+    let barcodeType: Int
+    var code: JavaString
+    let height: Int
+    let textPosition: Int
+    private(set) var colWidth = 0
+
+    var codeLength: Int { code.length }
+    var colsCount: Int { (codeLength + 5) * 11 }
+
+    init(printerSize: EscPosPrinterSize, barcodeType: Int, code: JavaString, widthMM: Float, heightMM: Float, textPosition: Int) throws {
+        self.barcodeType = barcodeType
+        self.code = code
+        self.height = printerSize.mmToPx(heightMM)
+        self.textPosition = textPosition
+    }
+
+    func computeColWidth(printerSize: EscPosPrinterSize, widthMM requestedWidthMM: Float) throws {
+        var widthMM = requestedWidthMM
+        if widthMM == 0 {
+            widthMM = printerSize.printerWidthMM * 0.7
+        }
+        let wantedPxWidth = widthMM > printerSize.printerWidthMM ? printerSize.printerWidthPx : printerSize.mmToPx(widthMM)
+        var width = JavaMath.round(Double(wantedPxWidth) / Double(colsCount))
+        if width * colsCount > printerSize.printerWidthPx {
+            width -= 1
+        }
+        if width == 0 {
+            throw EscPosError.barcode("Barcode is too long for the paper size.")
+        }
+        colWidth = width
+    }
+
+    static func make(type: String, printerSize: EscPosPrinterSize, code: JavaString, widthMM: Float, heightMM: Float, textPosition: Int) throws -> EscPosBarcode {
+        let barcode: EscPosBarcode
+        switch type {
+        case "ean8":
+            barcode = try EscPosBarcodeNumber(printerSize: printerSize, barcodeType: EscPosPrinterCommands.barcodeTypeEAN8, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition, fixedLength: 8)
+        case "ean13":
+            barcode = try EscPosBarcodeNumber(printerSize: printerSize, barcodeType: EscPosPrinterCommands.barcodeTypeEAN13, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition, fixedLength: 13)
+        case "upca":
+            barcode = try EscPosBarcodeNumber(printerSize: printerSize, barcodeType: EscPosPrinterCommands.barcodeTypeUPCA, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition, fixedLength: 12)
+        case "upce":
+            barcode = try EscPosBarcodeUPCE(printerSize: printerSize, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition)
+        case "128":
+            barcode = try EscPosBarcode(printerSize: printerSize, barcodeType: EscPosPrinterCommands.barcodeType128, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition)
+            try barcode.computeColWidth(printerSize: printerSize, widthMM: widthMM)
+        default:
+            throw EscPosError.parser("Invalid barcode attribute : type")
+        }
+        return barcode
+    }
+}
+
+final class EscPosBarcodeNumber: EscPosBarcode {
+    private let fixedLength: Int
+
+    override var codeLength: Int { fixedLength }
+    override var colsCount: Int { codeLength * 7 + 11 }
+
+    init(printerSize: EscPosPrinterSize, barcodeType: Int, code: JavaString, widthMM: Float, heightMM: Float, textPosition: Int, fixedLength: Int) throws {
+        self.fixedLength = fixedLength
+        try super.init(printerSize: printerSize, barcodeType: barcodeType, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition)
+        try computeColWidth(printerSize: printerSize, widthMM: widthMM)
+        try checkCode()
+    }
+
+    private func checkCode() throws {
+        let checkedLength = codeLength - 1
+        if code.length < checkedLength {
+            throw EscPosError.barcode("Code is too short for the barcode type.")
+        }
+        let digits = try code.substring(0, checkedLength)
+        var total = 0
+        for index in 0..<checkedLength {
+            let position = checkedLength - 1 - index
+            guard let digit = EscPosBarcodeNumber.digit(digits.units[position]) else {
+                throw EscPosError.barcode("Invalid barcode number")
+            }
+            total += index % 2 == 0 ? 3 * digit : digit
+        }
+        var key = String(10 - (total % 10))
+        if key.count == 2 {
+            key = "0"
+        }
+        code = JavaString(digits.string + key)
+    }
+
+    static func digit(_ unit: UInt16) -> Int? {
+        guard let scalar = Unicode.Scalar(unit),
+              scalar.properties.generalCategory == .decimalNumber,
+              let value = scalar.properties.numericValue
+        else {
+            return nil
+        }
+        return Int(value)
+    }
+}
+
+final class EscPosBarcodeUPCE: EscPosBarcode {
+    override var codeLength: Int { 6 }
+    override var colsCount: Int { codeLength * 7 + 16 }
+
+    init(printerSize: EscPosPrinterSize, code: JavaString, widthMM: Float, heightMM: Float, textPosition: Int) throws {
+        try super.init(printerSize: printerSize, barcodeType: EscPosPrinterCommands.barcodeTypeUPCE, code: code, widthMM: widthMM, heightMM: heightMM, textPosition: textPosition)
+        try computeColWidth(printerSize: printerSize, widthMM: widthMM)
+        try checkCode()
+    }
+
+    private func checkCode() throws {
+        if code.length < codeLength {
+            throw EscPosError.barcode("Code is too short for the barcode type.")
+        }
+        code = try code.substring(0, codeLength)
+        for unit in code.units where EscPosBarcodeNumber.digit(unit) == nil {
+            throw EscPosError.barcode("Invalid barcode number")
+        }
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosBitmap.swift

@@ -0,0 +1,178 @@
+import CoreGraphics
+import Foundation
+import ImageIO
+
+struct EscPosBitmap {
+    let width: Int
+    let height: Int
+    let pixels: [UInt32]
+
+    init(width: Int, height: Int, pixels: [UInt32]) {
+        self.width = width
+        self.height = height
+        self.pixels = pixels
+    }
+
+    func pixel(_ x: Int, _ y: Int) -> UInt32 {
+        pixels[y * width + x]
+    }
+
+    static func decode(_ data: Data) -> EscPosBitmap? {
+        guard let source = CGImageSourceCreateWithData(data as CFData, nil),
+              CGImageSourceGetCount(source) > 0,
+              let image = CGImageSourceCreateImageAtIndex(source, 0, [kCGImageSourceShouldCache: false] as CFDictionary)
+        else {
+            return nil
+        }
+        return EscPosBitmap(image: image)
+    }
+
+    init?(image: CGImage) {
+        let width = image.width
+        let height = image.height
+        guard width > 0, height > 0 else { return nil }
+        let isGray = image.colorSpace?.model == .monochrome
+        let hasAlpha: Bool
+        switch image.alphaInfo {
+        case .none, .noneSkipFirst, .noneSkipLast:
+            hasAlpha = false
+        default:
+            hasAlpha = true
+        }
+        if isGray && !hasAlpha, let gray = EscPosBitmap.renderGray(image) {
+            self.init(width: width, height: height, pixels: gray.map { value in
+                let level = UInt32(value)
+                return 0xFF00_0000 | level << 16 | level << 8 | level
+            })
+            return
+        }
+        guard let rgba = EscPosBitmap.renderRGBA(image, width: width, height: height) else { return nil }
+        var pixels = [UInt32](repeating: 0, count: width * height)
+        for index in 0..<(width * height) {
+            let alpha = UInt32(rgba[index * 4 + 3])
+            var red = UInt32(rgba[index * 4])
+            var green = UInt32(rgba[index * 4 + 1])
+            var blue = UInt32(rgba[index * 4 + 2])
+            if alpha == 0 {
+                red = 0
+                green = 0
+                blue = 0
+            } else if alpha < 255 {
+                red = min(255, (red * 255 + alpha / 2) / alpha)
+                green = min(255, (green * 255 + alpha / 2) / alpha)
+                blue = min(255, (blue * 255 + alpha / 2) / alpha)
+            }
+            pixels[index] = alpha << 24 | red << 16 | green << 8 | blue
+        }
+        self.init(width: width, height: height, pixels: pixels)
+    }
+
+    func scaled(width newWidth: Int, height newHeight: Int) -> EscPosBitmap {
+        guard newWidth > 0, newHeight > 0, let image = cgImage() else {
+            return EscPosBitmap(width: max(newWidth, 0), height: max(newHeight, 0), pixels: [UInt32](repeating: 0, count: max(newWidth, 0) * max(newHeight, 0)))
+        }
+        let bytesPerRow = newWidth * 4
+        var buffer = [UInt8](repeating: 0, count: bytesPerRow * newHeight)
+        let drawn: Bool = buffer.withUnsafeMutableBytes { raw in
+            guard let context = CGContext(
+                data: raw.baseAddress,
+                width: newWidth,
+                height: newHeight,
+                bitsPerComponent: 8,
+                bytesPerRow: bytesPerRow,
+                space: CGColorSpaceCreateDeviceRGB(),
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue
+            ) else { return false }
+            context.interpolationQuality = .medium
+            context.setBlendMode(.copy)
+            context.draw(image, in: CGRect(x: 0, y: 0, width: newWidth, height: newHeight))
+            return true
+        }
+        guard drawn, let scaledImage = EscPosBitmap.makeImage(rgba: buffer, width: newWidth, height: newHeight),
+              let result = EscPosBitmap(image: scaledImage)
+        else {
+            return EscPosBitmap(width: newWidth, height: newHeight, pixels: [UInt32](repeating: 0, count: newWidth * newHeight))
+        }
+        return result
+    }
+
+    private func cgImage() -> CGImage? {
+        var rgba = [UInt8](repeating: 0, count: width * height * 4)
+        for index in 0..<(width * height) {
+            let pixel = pixels[index]
+            let alpha = (pixel >> 24) & 0xFF
+            rgba[index * 4] = UInt8((((pixel >> 16) & 0xFF) * alpha + 127) / 255)
+            rgba[index * 4 + 1] = UInt8((((pixel >> 8) & 0xFF) * alpha + 127) / 255)
+            rgba[index * 4 + 2] = UInt8(((pixel & 0xFF) * alpha + 127) / 255)
+            rgba[index * 4 + 3] = UInt8(alpha)
+        }
+        return EscPosBitmap.makeImage(rgba: rgba, width: width, height: height)
+    }
+
+    private static func makeImage(rgba: [UInt8], width: Int, height: Int) -> CGImage? {
+        guard let provider = CGDataProvider(data: Data(rgba) as CFData) else { return nil }
+        return CGImage(
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bitsPerPixel: 32,
+            bytesPerRow: width * 4,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue),
+            provider: provider,
+            decode: nil,
+            shouldInterpolate: false,
+            intent: .defaultIntent
+        )
+    }
+
+    private static func renderRGBA(_ image: CGImage, width: Int, height: Int) -> [UInt8]? {
+        let space: CGColorSpace
+        if let imageSpace = image.colorSpace, imageSpace.model == .rgb {
+            space = imageSpace
+        } else {
+            space = CGColorSpace(name: CGColorSpace.sRGB) ?? CGColorSpaceCreateDeviceRGB()
+        }
+        let bytesPerRow = width * 4
+        var buffer = [UInt8](repeating: 0, count: bytesPerRow * height)
+        let drawn: Bool = buffer.withUnsafeMutableBytes { raw in
+            guard let context = CGContext(
+                data: raw.baseAddress,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: bytesPerRow,
+                space: space,
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue
+            ) else { return false }
+            context.interpolationQuality = .none
+            context.setBlendMode(.copy)
+            context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
+            return true
+        }
+        return drawn ? buffer : nil
+    }
+
+    private static func renderGray(_ image: CGImage) -> [UInt8]? {
+        guard let space = image.colorSpace else { return nil }
+        let width = image.width
+        let height = image.height
+        var buffer = [UInt8](repeating: 0, count: width * height)
+        let drawn: Bool = buffer.withUnsafeMutableBytes { raw in
+            guard let context = CGContext(
+                data: raw.baseAddress,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: width,
+                space: space,
+                bitmapInfo: CGImageAlphaInfo.none.rawValue
+            ) else { return false }
+            context.interpolationQuality = .none
+            context.setBlendMode(.copy)
+            context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
+            return true
+        }
+        return drawn ? buffer : nil
+    }
+}