@centimoo/capacitor-tcp-printer 1.0.0

package/ios/Sources/TcpPrinterPlugin/TcpPrinterPlugin.swift

@@ -0,0 +1,254 @@
+import Foundation
+import Capacitor
+import Network
+
+@objc(TcpPrinter)
+public class TcpPrinter: CAPPlugin, CAPBridgedPlugin {
+
+    // MARK: - Capacitor Bridge
+
+    public let identifier = "TcpPrinter"
+    public let jsName = "TcpPrinter"
+
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "connect",    returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "send",       returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "read",       returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "disconnect", returnType: CAPPluginReturnPromise)
+    ]
+
+    // MARK: - Types
+
+    /// Wraps an NWConnection together with any pending Capacitor call that is
+    /// waiting for data (one-shot read model).
+    private struct ManagedConnection {
+        let connection: NWConnection
+        var pendingReadCall: CAPPluginCall?
+    }
+
+    // MARK: - Internal State
+
+    /// All mutable state is accessed exclusively through this serial queue,
+    /// eliminating data races on `connections` and `nextClientId`.
+    private let queue = DispatchQueue(label: "com.tcpprinter.plugin", qos: .utility)
+
+    private var connections: [Int: ManagedConnection] = [:]
+    private var nextClientId: Int = 0
+
+    private let debugEnabled = true
+
+    // MARK: - Logging
+
+    private func log(_ message: String) {
+        if debugEnabled {
+            print("🖨 TcpPrinter: \(message)")
+        }
+    }
+
+    // MARK: - Plugin Load
+
+    override public func load() {
+        log("Plugin loaded")
+    }
+
+    // MARK: - Connect
+
+    @objc public func connect(_ call: CAPPluginCall) {
+        guard let host = call.getString("ipAddress"), !host.isEmpty else {
+            call.reject("IP address is required")
+            return
+        }
+
+        let portValue = call.getInt("port") ?? 9100
+        guard portValue > 0, portValue <= 65535,
+              let port = NWEndpoint.Port(rawValue: UInt16(portValue)) else {
+            call.reject("Invalid port: must be 1–65535")
+            return
+        }
+
+        // Optional connect timeout in milliseconds (default 10 s)
+        let timeoutMs = call.getInt("timeoutMs") ?? 10_000
+
+        log("Connecting to \(host):\(portValue) (timeout \(timeoutMs) ms)")
+
+        let connection = NWConnection(
+            host: NWEndpoint.Host(host),
+            port: port,
+            using: .tcp
+        )
+
+        // Capture clientId safely inside the serial queue
+        queue.async { [weak self] in
+            guard let self else {
+                call.reject("Plugin deallocated")
+                return
+            }
+
+            let clientId = self.nextClientId
+            self.nextClientId += 1
+
+            // Connect-timeout work item — cancelled if we reach .ready first
+            let timeoutItem = DispatchWorkItem { [weak self] in
+                self?.log("Connection timed out (client \(clientId))")
+                connection.cancel()
+                // Only reject if we haven't already resolved
+                call.reject("Connection timed out after \(timeoutMs) ms")
+            }
+            self.queue.asyncAfter(
+                deadline: .now() + .milliseconds(timeoutMs),
+                execute: timeoutItem
+            )
+
+            connection.stateUpdateHandler = { [weak self] state in
+                guard let self else { return }
+
+                switch state {
+                case .ready:
+                    timeoutItem.cancel()
+                    self.queue.async {
+                        // Guard against resolving twice if timeout fired first
+                        guard !timeoutItem.isCancelled == false else { return }
+                        self.connections[clientId] = ManagedConnection(connection: connection)
+                        self.log("Connection ready (client \(clientId))")
+                        call.resolve(["client": clientId])
+                    }
+
+                case .failed(let error):
+                    timeoutItem.cancel()
+                    self.log("Connection failed (client \(clientId)): \(error.localizedDescription)")
+                    self.queue.async {
+                        self.connections.removeValue(forKey: clientId)
+                    }
+                    connection.cancel()
+                    call.reject("Connection failed: \(error.localizedDescription)")
+
+                case .cancelled:
+                    self.log("Connection cancelled (client \(clientId))")
+                    self.queue.async {
+                        self.connections.removeValue(forKey: clientId)
+                    }
+
+                case .waiting(let error):
+                    // Network temporarily unavailable — log but don't reject yet;
+                    // NWConnection will retry or eventually move to .failed.
+                    self.log("Connection waiting (client \(clientId)): \(error.localizedDescription)")
+
+                default:
+                    break
+                }
+            }
+
+            // Start the connection on our serial queue so NWConnection callbacks
+            // can safely read/write the connections dictionary via queue.async.
+            connection.start(queue: self.queue)
+        }
+    }
+
+    // MARK: - Send
+
+    @objc public func send(_ call: CAPPluginCall) {
+        queue.async { [weak self] in
+            guard let self else { call.reject("Plugin deallocated"); return }
+
+            guard let clientId = call.getInt("client"),
+                  let managed = self.connections[clientId] else {
+                call.reject("Invalid or disconnected client")
+                return
+            }
+
+            guard let dataArray = call.getArray("data") as? [Any] else {
+                call.reject("No data provided")
+                return
+            }
+
+            // Validate every element is in the 0–255 range before sending
+            var bytes = [UInt8]()
+            bytes.reserveCapacity(dataArray.count)
+            for (index, element) in dataArray.enumerated() {
+                guard let intVal = element as? Int, intVal >= 0, intVal <= 255 else {
+                    call.reject("data[\(index)] is out of byte range (0–255)")
+                    return
+                }
+                bytes.append(UInt8(intVal))
+            }
+
+            let data = Data(bytes)
+            self.log("Sending \(data.count) bytes to client \(clientId)")
+
+            managed.connection.send(content: data, completion: .contentProcessed { [weak self] error in
+                if let error = error {
+                    self?.log("Send failed (client \(clientId)): \(error.localizedDescription)")
+                    call.reject("Send failed: \(error.localizedDescription)")
+                } else {
+                    self?.log("Send success (client \(clientId))")
+                    call.resolve()
+                }
+            })
+        }
+    }
+
+    // MARK: - Read
+
+    /// One-shot receive.  The caller must invoke `read` again to receive the
+    /// next chunk.  Unsolicited data pushed by the printer between explicit
+    /// `read` calls is buffered by NWConnection internally.
+    @objc public func read(_ call: CAPPluginCall) {
+        queue.async { [weak self] in
+            guard let self else { call.reject("Plugin deallocated"); return }
+
+            guard let clientId = call.getInt("client"),
+                  let managed = self.connections[clientId] else {
+                call.reject("Invalid or disconnected client")
+                return
+            }
+
+            let maxLen = max(1, call.getInt("expectLen") ?? 1024)
+            self.log("Reading up to \(maxLen) bytes from client \(clientId)")
+
+            managed.connection.receive(
+                minimumIncompleteLength: 1,
+                maximumLength: maxLen
+            ) { [weak self] data, _, isComplete, error in
+                guard let self else { return }
+
+                if let error = error {
+                    self.log("Read failed (client \(clientId)): \(error.localizedDescription)")
+                    call.reject("Read failed: \(error.localizedDescription)")
+                    return
+                }
+
+                let bytes = data.map { Array($0) } ?? []
+                self.log("Received \(bytes.count) bytes (client \(clientId))")
+                call.resolve(["result": bytes])
+
+                if isComplete {
+                    self.log("Peer closed connection (client \(clientId))")
+                    self.queue.async {
+                        self.connections.removeValue(forKey: clientId)
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Disconnect
+
+    @objc public func disconnect(_ call: CAPPluginCall) {
+        queue.async { [weak self] in
+            guard let self else { call.reject("Plugin deallocated"); return }
+
+            guard let clientId = call.getInt("client"),
+                  let managed = self.connections[clientId] else {
+                call.reject("Invalid or disconnected client")
+                return
+            }
+
+            self.log("Disconnecting client \(clientId)")
+            managed.connection.cancel()
+            // Removal also happens in the .cancelled state handler, but we do it
+            // here immediately so subsequent calls see the client as gone right away.
+            self.connections.removeValue(forKey: clientId)
+            call.resolve(["client": clientId])
+        }
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@centimoo/capacitor-tcp-printer",
+  "version": "1.0.0",
+  "description": "Native TCP printer plugin for Capacitor using Apple Network.framework. Enables raw socket printing (ESC/POS) to LAN printers on iOS.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CentimooCapacitorTcpPrinter.podspec"
+  ],
+  "author": "Wail Djenane",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DzCorps/capacitor-tcp-printer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DzCorps/capacitor-tcp-printer.git/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "tcp",
+    "printer",
+    "escpos",
+    "ios",
+    "ionic"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CentimooCapacitorTcpPrinter -destination generic/platform=iOS",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api TcpPrinterPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.1",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    }
+  }
+}