pythonnative 0.40.0__cp314-cp314-win_amd64.whl

pythonnative/native/ios/Tests/PythonNativeKitTests/PNCommitTests.swift

@@ -0,0 +1,86 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNCommitTests: XCTestCase {
+    private let app = UUID().uuidString
+
+    private func commit(_ operations: [[Any]], revision: Int = 1) -> [String: Any] {
+        PNJSON.decodeObject(PNCommit.apply(PNJSON.encode([
+            "version": 2, "application": app, "surface": 1,
+            "revision": revision, "ops": operations,
+        ])))
+    }
+
+    override func tearDown() {
+        _ = PNCommit.apply(PNJSON.encode([
+            "version": 2, "application": UUID().uuidString, "surface": 1,
+            "revision": 1, "ops": [],
+        ]))
+        super.tearDown()
+    }
+
+    func testInvalidInsertionDoesNotPartiallyCreateWidgets() {
+        let result = commit([["c", 9101, "View", [:]], ["c", 9102, "Text", ["text": "pending"]], ["i", 9101, 9102, 3]])
+        XCTAssertEqual(result["ok"] as? Bool, false)
+        XCTAssertNil(PNViewRegistry.shared.view(for: 9101))
+        XCTAssertNil(PNViewRegistry.shared.view(for: 9102))
+        XCTAssertEqual(commit([["c", 9101, "View", [:]]])["ok"] as? Bool, true)
+    }
+
+    func testTypedUpdatesValidateTagsCreatedInTheSameCommit() {
+        let result = commit([["c", 9201, "TextInput", ["value": "valid"]], ["u", 9201, ["value": 12]]])
+        XCTAssertEqual(result["ok"] as? Bool, false)
+        XCTAssertNil(PNViewRegistry.shared.view(for: 9201))
+    }
+
+    func testHorizontalListMeasuresRowsAlongTheirWidth() {
+        let result = commit([
+            ["c", 9601, "VirtualList", ["keys": ["one"], "revision": 1, "horizontal": true, "width": 300, "height": 100]],
+            ["c", 9602, "View", ["_pn_list_key": "one", "width": 80, "height": 100]],
+            ["i", 9601, 9602, 0],
+        ])
+        XCTAssertEqual(result["ok"] as? Bool, true)
+        PNViewRegistry.shared.view(for: 9601)?.frame = CGRect(x: 0, y: 0, width: 300, height: 100)
+        let frames = PNLayout.compute(["roots": [Int64(9601)], "width": 300, "height": 100])
+        let row = frames.first { $0.first == 9602 }
+        XCTAssertEqual(row?[3], 80)
+        XCTAssertEqual(row?[4], 100)
+    }
+
+    func testPortalLaysOutAgainstItsViewportWithoutAScreenParent() {
+        XCTAssertEqual(commit([
+            ["c", 9700, "View", [:]],
+            ["c", 9701, "Portal", [:]],
+            ["c", 9702, "View", ["position": "absolute", "left": 24, "right": 24, "bottom": 40, "height": 80]],
+            ["c", 9703, "View", ["height": 30]],
+            ["c", 9704, "View", ["height": 20]],
+            ["i", 9701, 9702, 0],
+            ["i", 9701, 9703, 1],
+            ["i", 9701, 9704, 2],
+        ])["ok"] as? Bool, true)
+        let request: [String: Any] = ["roots": [Int64(9700)], "width": 320, "height": 640]
+        // The native overlay can be smaller than the screen, for example below a navigation bar.
+        PNViewRegistry.shared.view(for: 9701)?.frame = CGRect(x: 0, y: 0, width: 300, height: 600)
+        let frames = PNLayout.compute(request)
+        XCTAssertTrue(frames.flatMap { $0 }.allSatisfy { $0.isFinite })
+        XCTAssertEqual(frames.first { $0.first == 9701 }, [9701, 0, 0, 300, 600])
+        XCTAssertEqual(frames.first { $0.first == 9702 }, [9702, 24, 480, 252, 80])
+        XCTAssertEqual(frames.first { $0.first == 9704 }, [9704, 0, 30, 300, 20])
+        XCTAssertTrue(PNLayout.compute(request).isEmpty)
+
+        PNViewRegistry.shared.view(for: 9701)?.frame = CGRect(x: 0, y: 0, width: 400, height: 700)
+        let resized = PNLayout.compute(request)
+        XCTAssertEqual(resized.first { $0.first == 9702 }, [9702, 24, 580, 352, 80])
+        XCTAssertEqual(commit([["d", 9702], ["d", 9703], ["d", 9704], ["d", 9701]], revision: 2)["ok"] as? Bool, true)
+        XCTAssertNil(PNLayout.nodes[9701])
+        XCTAssertTrue(PNLayout.compute(request).isEmpty)
+    }
+
+    func testReplayCannotDestroyAnAcceptedWidget() {
+        XCTAssertEqual(commit([["c", 9301, "View", [:]]])["ok"] as? Bool, true)
+        XCTAssertEqual(commit([["d", 9301]])["ok"] as? Bool, false)
+        XCTAssertNotNil(PNViewRegistry.shared.view(for: 9301))
+        XCTAssertEqual(commit([["d", 9301]], revision: 2)["ok"] as? Bool, true)
+        XCTAssertNil(PNViewRegistry.shared.view(for: 9301))
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNGestureTests.swift

@@ -0,0 +1,101 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNGestureTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testSpecsBecomeRecognizersWithRelationships() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 1, props: [
+            "gestures": [
+                ["kind": "tap", "n_taps": 2, "simultaneous": [1], "wait_for": []],
+                ["kind": "pan", "min_distance": 10, "simultaneous": [0], "wait_for": []],
+                ["kind": "long_press", "min_duration_ms": 800, "simultaneous": [], "wait_for": [0]],
+                ["kind": "swipe", "direction": "left", "simultaneous": [], "wait_for": []],
+                ["kind": "pinch", "simultaneous": [], "wait_for": []],
+                ["kind": "rotation", "simultaneous": [], "wait_for": []],
+                ["kind": "fling", "direction": "down", "n_pointers": 2, "simultaneous": [], "wait_for": []],
+            ],
+        ])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 7)
+        XCTAssertEqual((recognizers[0] as? UITapGestureRecognizer)?.numberOfTapsRequired, 2)
+        XCTAssertTrue(recognizers[1] is UIPanGestureRecognizer)
+        XCTAssertEqual((recognizers[2] as? UILongPressGestureRecognizer)?.minimumPressDuration ?? 0, 0.8, accuracy: 0.001)
+        XCTAssertEqual((recognizers[3] as? UISwipeGestureRecognizer)?.direction, .left)
+        XCTAssertTrue(recognizers[4] is UIPinchGestureRecognizer)
+        XCTAssertTrue(recognizers[5] is UIRotationGestureRecognizer)
+        XCTAssertEqual((recognizers[6] as? UISwipeGestureRecognizer)?.numberOfTouchesRequired, 2)
+        XCTAssertEqual((recognizers[6] as? UISwipeGestureRecognizer)?.direction, .down)
+
+        let coordinator = PNGestureCoordinator.shared
+        XCTAssertEqual(coordinator.index(of: recognizers[2]), 2)
+        XCTAssertTrue(coordinator.allowsSimultaneous(recognizers[0], recognizers[1]))
+        XCTAssertFalse(coordinator.allowsSimultaneous(recognizers[0], recognizers[2]))
+        XCTAssertFalse(coordinator.allowsSimultaneous(recognizers[3], recognizers[4]))
+        XCTAssertTrue(view.isUserInteractionEnabled)
+        XCTAssertTrue(recognizers.allSatisfy { $0.view === view && !$0.cancelsTouchesInView })
+    }
+
+    func testRewiringReplacesRecognizersAndUnknownKindsAreSkipped() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 2, props: ["gestures": [["kind": "tap"]]])
+        XCTAssertEqual(view.gestureRecognizers?.count, 1)
+        manager.update(view: view, changed: ["gestures": [["kind": "nonsense"], ["kind": "pan"]]])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 1)
+        XCTAssertTrue(recognizers[0] is UIPanGestureRecognizer)
+        XCTAssertEqual(PNGestureCoordinator.shared.index(of: recognizers[0]), 1, "index follows the spec position")
+        manager.update(view: view, changed: ["gestures": NSNull()])
+        XCTAssertEqual(view.gestureRecognizers?.count ?? 0, 0)
+    }
+
+    func testStateAndDirectionNames() {
+        XCTAssertEqual(PNGestureCoordinator.stateName(.began), "began")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.changed), "changed")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.ended), "ended")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.cancelled), "cancelled")
+        XCTAssertEqual(PNGestureCoordinator.swipeDirection("up"), .up)
+        XCTAssertEqual(PNGestureCoordinator.swipeDirection("any"), [.left, .right, .up, .down])
+    }
+
+    func testAnyDirectionSwipeInstallsOneRecognizerPerDirection() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 3, props: [
+            "gestures": [
+                ["kind": "tap", "simultaneous": [], "wait_for": [1]],
+                ["kind": "swipe", "direction": "any", "simultaneous": [], "wait_for": []],
+            ],
+        ])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 5, "one tap plus four single-direction swipes")
+        let coordinator = PNGestureCoordinator.shared
+        let swipes = recognizers.compactMap { $0 as? UISwipeGestureRecognizer }
+        XCTAssertEqual(swipes.map { coordinator.direction(of: $0) }, ["left", "right", "up", "down"])
+        XCTAssertEqual(swipes.map { $0.direction }, [.left, .right, .up, .down])
+        XCTAssertTrue(swipes.allSatisfy { coordinator.index(of: $0) == 1 }, "every recognizer reports the spec index")
+        XCTAssertNil(coordinator.direction(of: recognizers[0]))
+    }
+
+    func testAnimatorTimingParameters() {
+        let timing = PNAnimator.timingParameters(kind: "timing", spec: ["duration_ms": 250, "easing": "linear"])
+        XCTAssertEqual(timing.duration, 0.25, accuracy: 0.0001)
+        let spring = PNAnimator.timingParameters(kind: "spring", spec: ["stiffness": 100, "damping": 10, "mass": 1, "from": 0, "to": 1])
+        XCTAssertGreaterThan(spring.duration, 0.15)
+        XCTAssertTrue(spring.parameters is UISpringTimingParameters)
+        XCTAssertTrue(PNAnimator.curve(for: [0.1, 0.2, 0.3, 0.4]) is UICubicTimingParameters)
+    }
+
+    func testAnimatorSetAppliesImmediately() {
+        PNTransaction.apply("[[\"c\", 50, \"View\", {}]]")
+        _ = PNAnimator.shared.handle(tag: 50, request: ["op": "set", "prop": "opacity", "value": 0.25])
+        XCTAssertEqual(PNViewRegistry.shared.view(for: 50)?.alpha ?? 0, 0.25, accuracy: 0.001)
+        _ = PNAnimator.shared.handle(tag: 50, request: ["op": "set", "prop": "translate_x", "value": 12])
+        XCTAssertEqual(PNViewRegistry.shared.view(for: 50)?.transform.tx ?? 0, 12, accuracy: 0.001)
+        let rejected = PNAnimator.shared.handle(tag: 50, request: ["op": "start", "id": 1, "prop": "opacity", "spec": ["kind": "mystery"]])
+        XCTAssertEqual((rejected as? [String: Any])?["ok"] as? Bool, false)
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNManagerTests.swift

@@ -0,0 +1,126 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNManagerTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testViewManagerAppliesCommonProps() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 1, props: [
+            "background_color": "#ff0000",
+            "opacity": 0.5,
+            "border_width": 2,
+            "border_color": "#00ff00",
+            "border_radius": 8,
+            "test_id": "hero",
+            "accessibility_label": "Hero card",
+        ])
+        XCTAssertEqual(view.alpha, 0.5, accuracy: 0.001)
+        XCTAssertEqual(view.layer.borderWidth, 2)
+        XCTAssertEqual(view.layer.cornerRadius, 8)
+        XCTAssertEqual(view.accessibilityIdentifier, "hero")
+        XCTAssertEqual(view.accessibilityLabel, "Hero card")
+        XCTAssertEqual(PNColor.hexString(view.backgroundColor ?? .clear).lowercased(), "#ffff0000")
+
+        manager.update(view: view, changed: ["opacity": 1, "background_color": NSNull(), "display": "none"])
+        XCTAssertEqual(view.alpha, 1, accuracy: 0.001)
+        XCTAssertTrue(view.isHidden)
+        XCTAssertNil(PNViewState.existing(for: view)?.props["background_color"])
+        XCTAssertEqual(PNProps.double(PNViewState.existing(for: view)?.props["opacity"]), 1)
+    }
+
+    func testTransformPropBuildsAffineTransform() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 2, props: [
+            "transform": [["translate_x": 10], ["translate_y": 5], ["scale": 2]],
+        ])
+        XCTAssertEqual(view.transform.tx, 10, accuracy: 0.001)
+        XCTAssertEqual(view.transform.ty, 5, accuracy: 0.001)
+        XCTAssertEqual(view.transform.a, 2, accuracy: 0.001)
+        XCTAssertEqual(view.transform.d, 2, accuracy: 0.001)
+
+        manager.update(view: view, changed: ["transform": [["rotate": "90deg"]]])
+        XCTAssertEqual(view.transform.b, 1, accuracy: 0.001)
+        XCTAssertEqual(view.transform.a, 0, accuracy: 0.001)
+
+        manager.update(view: view, changed: ["transform": NSNull()])
+        XCTAssertTrue(view.transform.isIdentity)
+    }
+
+    func testFrameSurvivesTransform() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 3, props: ["transform": [["scale": 2]]])
+        manager.setFrame(view: view, x: 10, y: 20, w: 100, h: 50)
+        XCTAssertEqual(view.bounds.size, CGSize(width: 100, height: 50))
+        XCTAssertEqual(view.center, CGPoint(x: 60, y: 45))
+    }
+
+    func testTextMeasureAndTransform() {
+        let manager = PNTextManager()
+        let view = manager.createView(tag: 4, props: ["text": "hello world", "font_size": 20, "text_transform": "uppercase"])
+        XCTAssertEqual((view as? UILabel)?.text, "HELLO WORLD")
+        let unconstrained = manager.measure(view: view, maxW: .infinity, maxH: .infinity)
+        XCTAssertGreaterThan(unconstrained.width, 50)
+        XCTAssertGreaterThan(unconstrained.height, 15)
+        let narrow = manager.measure(view: view, maxW: 60, maxH: 1e6)
+        XCTAssertLessThanOrEqual(narrow.width, 60)
+        XCTAssertGreaterThan(narrow.height, unconstrained.height, "wrapped text grows in height")
+        XCTAssertEqual(PNTextManager.transform("hello big world", mode: "capitalize"), "Hello Big World")
+    }
+
+    func testTextSpansProduceAttributedString() {
+        let manager = PNTextManager()
+        let view = manager.createView(tag: 5, props: [
+            "spans": [["text": "Hi "], ["text": "there", "bold": true, "color": "#ff0000"]],
+        ])
+        let label = view as? UILabel
+        XCTAssertEqual(label?.attributedText?.string, "Hi there")
+        var range = NSRange()
+        let color = label?.attributedText?.attribute(.foregroundColor, at: 3, effectiveRange: &range) as? UIColor
+        XCTAssertNotNil(color)
+        XCTAssertEqual(range.location, 3)
+        XCTAssertEqual(range.length, 5)
+    }
+
+    func testVirtualListBindsRowsThroughRegistry() {
+        PNTransaction.apply("[[\"c\", 40, \"View\", {\"background_color\": \"#123456\"}]]")
+        let manager = PNVirtualListManager()
+        guard let table = manager.createView(tag: 41, props: ["keys": ["a", "b", "c"], "revision": 1, "row_heights": [50.0, 50.0, 50.0]]) as? UICollectionView else {
+            return XCTFail("expected a collection view")
+        }
+        XCTAssertEqual(table.numberOfItems(inSection: 0), 3)
+        let delegate = table.delegate as? UICollectionViewDelegateFlowLayout
+        XCTAssertEqual(delegate?.collectionView?(table, layout: table.collectionViewLayout, sizeForItemAt: IndexPath(item: 1, section: 0)).height, 50)
+        manager.update(view: table, changed: ["row_heights": [10.0, 20.0, 30.0], "keys": ["a", "b", "c"], "revision": 2])
+        XCTAssertEqual(delegate?.collectionView?(table, layout: table.collectionViewLayout, sizeForItemAt: IndexPath(item: 2, section: 0)).height, 30)
+        manager.destroy(view: table)
+    }
+
+    func testScrollPayloadShape() {
+        let scroll = UIScrollView(frame: CGRect(x: 0, y: 0, width: 100, height: 200))
+        scroll.contentSize = CGSize(width: 100, height: 800)
+        scroll.contentOffset = CGPoint(x: 0, y: 40)
+        let payload = PNScrollPayload.make(scroll)
+        XCTAssertEqual(payload["y"] as? Double, 40)
+        XCTAssertEqual(payload["extent"] as? Double, 200)
+        XCTAssertEqual(payload["range"] as? Double, 800)
+    }
+
+    func testRegistryKnowsEveryBuiltinType() {
+        let names = PNRegistry.shared.componentNames
+        for type in ["View", "Column", "Row", "Text", "Button", "TextInput", "Image", "Switch", "ProgressBar",
+                     "ActivityIndicator", "WebView", "Spacer", "ScrollView", "SafeAreaView", "Modal", "Portal",
+                     "Slider", "TabBar", "Pressable", "StatusBar", "KeyboardAvoidingView", "Picker", "Checkbox",
+                     "SegmentedControl", "DatePicker", "VirtualList"] {
+            XCTAssertTrue(names.contains(type), "missing manager for \(type)")
+        }
+        for module in ["Host", "Device", "Alert", "Storage", "SecureStore", "Clipboard", "Share", "Linking",
+                       "Haptics", "Battery", "NetInfo", "AppState", "Permissions", "Notifications", "Camera",
+                       "Location", "Biometrics"] {
+            XCTAssertTrue(PNRegistry.shared.moduleNames.contains(module), "missing module \(module)")
+        }
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNModuleTests.swift

@@ -0,0 +1,111 @@
+import XCTest
+@testable import PythonNativeKit
+
+/// A module that settles inline or later depending on the method.
+final class PNTestEchoModule: PNNativeModule {
+    static let name = "TestEcho"
+    static var pending: PNPromise?
+
+    init() {}
+
+    func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "echo": promise.resolve(args["value"])
+        case "fail": promise.reject("nope", code: "test_code")
+        case "later": PNTestEchoModule.pending = promise
+        default: promise.reject("unknown method \(method)")
+        }
+    }
+}
+
+final class PNModuleTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        PNRegistry.shared.registerModule(PNTestEchoModule.self)
+    }
+
+    func testSynchronousResolveProducesOkEnvelope() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "echo", envelope: ["call_id": 7, "args": ["value": 42]])
+        XCTAssertEqual(result["ok"] as? Bool, true)
+        XCTAssertEqual(result["value"] as? Int, 42)
+        XCTAssertNil(result["pending"])
+    }
+
+    func testRejectProducesErrorEnvelope() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "fail", envelope: ["call_id": 8, "args": [:]])
+        XCTAssertEqual(result["ok"] as? Bool, false)
+        XCTAssertEqual(result["error"] as? String, "nope")
+        XCTAssertEqual(result["code"] as? String, "test_code")
+    }
+
+    func testUnknownModuleAndMethod() {
+        let missing = PNModuleDispatcher.shared.call(module: "Nope", method: "x", envelope: [:])
+        XCTAssertEqual(missing["ok"] as? Bool, false)
+        XCTAssertEqual(missing["code"] as? String, "unknown_module")
+        let method = PNModuleDispatcher.shared.call(module: "TestEcho", method: "zzz", envelope: [:])
+        XCTAssertEqual(method["ok"] as? Bool, false)
+    }
+
+    func testAsynchronousSettlementReturnsPending() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "later", envelope: ["call_id": 9, "args": [:]])
+        XCTAssertEqual(result["pending"] as? Bool, true)
+        guard let promise = PNTestEchoModule.pending else { return XCTFail("promise not captured") }
+        XCTAssertFalse(promise.isSettled)
+        XCTAssertEqual(promise.callId, 9)
+        promise.resolve("done")
+        XCTAssertTrue(promise.isSettled)
+        promise.resolve("again")
+        XCTAssertEqual(promise.result?["value"] as? String, "done", "second settlement is ignored")
+    }
+
+    func testEnvelopeJSONRoundTrip() {
+        let ok = PNJSON.encode(["ok": true, "value": ["a": 1]])
+        let decoded = PNJSON.decodeObject(ok)
+        XCTAssertEqual(decoded["ok"] as? Bool, true)
+        XCTAssertEqual((decoded["value"] as? [String: Any])?["a"] as? Int, 1)
+        XCTAssertEqual(PNJSON.decodeObject(PNJSON.encode(["pending": true]))["pending"] as? Bool, true)
+        XCTAssertEqual(PNJSON.encode(Double.infinity), "null", "non-finite numbers never leave Swift as JSON numbers")
+        XCTAssertEqual(PNJSON.resolveInfinity("inf") as? Double, Double.infinity)
+        XCTAssertEqual(PNJSON.encode(nil), "null")
+    }
+
+    func testCancellationReleasesNativeWorkAndIgnoresLateCompletion() {
+        _ = PNModuleDispatcher.shared.call(module: "TestEcho", method: "later", envelope: ["call_id": 99, "args": [:]])
+        guard let promise = PNTestEchoModule.pending else { return XCTFail("missing promise") }
+        var cancelled = 0
+        promise.onCancel { cancelled += 1 }
+        _ = PNModuleDispatcher.shared.call(module: "TestEcho", method: "_pn_cancel", envelope: ["args": ["call_id": 99]])
+        promise.cancel()
+        promise.resolve("late")
+        XCTAssertTrue(promise.isCancelled)
+        XCTAssertEqual(cancelled, 1)
+        XCTAssertNil(promise.result)
+    }
+
+    func testDeviceInfoShape() {
+        let info = DeviceModule.info()
+        XCTAssertEqual(info["os"] as? String, "ios")
+        XCTAssertNotNil(info["os_version"])
+        XCTAssertNotNil(info["app_dir"])
+        XCTAssertNotNil(info["cache_dir"])
+        XCTAssertNotNil(info["scale"])
+    }
+
+    func testStorageModuleRoundTrip() {
+        let storage = StorageModule()
+        _ = PNModuleDispatcher.shared.call(module: "Storage", method: "clear", envelope: [:])
+        let set = PNPromise(callId: 1, module: "Storage", method: "set")
+        storage.call("set", args: ["key": "k", "value": "v"], promise: set)
+        let get = PNPromise(callId: 2, module: "Storage", method: "get")
+        storage.call("get", args: ["key": "k"], promise: get)
+        XCTAssertEqual(get.result?["value"] as? String, "v")
+        let keys = PNPromise(callId: 3, module: "Storage", method: "all_keys")
+        storage.call("all_keys", args: [:], promise: keys)
+        XCTAssertEqual(keys.result?["value"] as? [String], ["k"])
+        let del = PNPromise(callId: 4, module: "Storage", method: "delete")
+        storage.call("delete", args: ["key": "k"], promise: del)
+        let missing = PNPromise(callId: 5, module: "Storage", method: "get")
+        storage.call("get", args: ["key": "k"], promise: missing)
+        XCTAssertTrue(missing.result?["value"] is NSNull)
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNTransactionTests.swift

@@ -0,0 +1,91 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNTransactionTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testDecodesEveryOpcode() throws {
+        let json = """
+        [["c", 1, "View", {"background_color": "#ff0000"}],
+         ["u", 1, {"opacity": 0.5}],
+         ["c", 2, "Text", {"text": "hi"}],
+         ["i", 1, 2, 0],
+         ["f", 2, 1.5, 2.5, 100, 20],
+         ["d", 2]]
+        """
+        let ops = try PNTransaction.decode(json)
+        XCTAssertEqual(ops.count, 6)
+        XCTAssertEqual(ops[0], .create(tag: 1, type: "View", props: ["background_color": "#ff0000"]))
+        XCTAssertEqual(ops[1], .update(tag: 1, changed: ["opacity": 0.5]))
+        XCTAssertEqual(ops[3], .insert(parent: 1, child: 2, index: 0))
+        XCTAssertEqual(ops[4], .frame(tag: 2, x: 1.5, y: 2.5, w: 100, h: 20))
+        XCTAssertEqual(ops[5], .destroy(tag: 2))
+    }
+
+    func testInfinityStringsBecomeInfinity() throws {
+        let ops = try PNTransaction.decode("[[\"c\", 5, \"View\", {\"max_width\": \"inf\", \"nested\": {\"h\": \"inf\"}}]]")
+        guard case let .create(_, _, props) = ops[0] else { return XCTFail("expected create") }
+        XCTAssertEqual(props["max_width"] as? Double, Double.infinity)
+        XCTAssertEqual((props["nested"] as? [String: Any])?["h"] as? Double, Double.infinity)
+    }
+
+    func testMalformedOpsAreSkippedNotFatal() throws {
+        let ops = try PNTransaction.decode("[[\"c\", 1, \"View\", {}], [\"zz\", 9], [\"u\"], 42, [\"d\", 1]]")
+        XCTAssertEqual(ops.count, 2)
+        XCTAssertEqual(ops[0], .create(tag: 1, type: "View", props: [:]))
+        XCTAssertEqual(ops[1], .destroy(tag: 1))
+    }
+
+    func testNonArrayDocumentThrows() {
+        XCTAssertThrowsError(try PNTransaction.decode("{\"not\": \"an array\"}"))
+    }
+
+    func testApplyBuildsHierarchyAndIsolatesFailures() {
+        PNTransaction.apply("""
+        [["c", 10, "View", {"background_color": "#00ff00"}],
+         ["c", 11, "Text", {"text": "hello"}],
+         ["u", 999, {"opacity": 0.1}],
+         ["i", 10, 11, 0],
+         ["i", 10, 12345, 0],
+         ["f", 11, 4, 8, 120, 30],
+         ["c", 13, "NoSuchType", {}]]
+        """)
+        let parent = PNViewRegistry.shared.view(for: 10)
+        let child = PNViewRegistry.shared.view(for: 11)
+        XCTAssertNotNil(parent)
+        XCTAssertNotNil(child)
+        XCTAssertTrue(child?.superview === parent)
+        XCTAssertEqual(child?.frame, CGRect(x: 4, y: 8, width: 120, height: 30))
+        XCTAssertNotNil(PNViewRegistry.shared.view(for: 13), "unknown types get a placeholder view")
+        XCTAssertEqual(PNViewRegistry.shared.resolve(13)?.typeName, "NoSuchType")
+
+        PNTransaction.apply("[[\"d\", 11]]")
+        XCTAssertNil(PNViewRegistry.shared.view(for: 11))
+        XCTAssertEqual(parent?.subviews.count, 0)
+    }
+
+    func testInsertIsMoveAwareAndClamps() {
+        PNTransaction.apply("""
+        [["c", 20, "View", {}], ["c", 21, "View", {}], ["c", 22, "View", {}], ["c", 23, "View", {}],
+         ["i", 20, 21, 0], ["i", 20, 22, 1], ["i", 20, 23, 99]]
+        """)
+        let parent = PNViewRegistry.shared.view(for: 20)
+        XCTAssertEqual(parent?.subviews.map { PNViewState.existing(for: $0)?.tag }, [21, 22, 23])
+        PNTransaction.apply("[[\"i\", 20, 23, 0]]")
+        XCTAssertEqual(parent?.subviews.map { PNViewState.existing(for: $0)?.tag }, [23, 21, 22])
+        XCTAssertEqual(parent?.subviews.count, 3)
+    }
+
+    func testFrameClampsNonFiniteValues() {
+        PNTransaction.apply("[[\"c\", 30, \"View\", {}]]")
+        guard let record = PNViewRegistry.shared.resolve(30) else { return XCTFail("missing view") }
+        record.manager.setFrame(view: record.view, x: .nan, y: 5, w: .infinity, h: -3)
+        XCTAssertEqual(record.view.frame.origin.x, 0)
+        XCTAssertEqual(record.view.frame.origin.y, 5)
+        XCTAssertEqual(record.view.frame.size.height, 0)
+        XCTAssertTrue(record.view.frame.size.width.isFinite)
+    }
+}

pythonnative/native/yoga/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pythonnative/native/yoga/Package.swift

@@ -0,0 +1,9 @@
+// swift-tools-version: 5.9
+import PackageDescription
+let package = Package(
+    name: "YogaCore",
+    products: [.library(name: "YogaCore", targets: ["YogaCore"])],
+    targets: [.target(name: "YogaCore", path: ".", exclude: ["yoga/CMakeLists.txt", "yoga/module.modulemap"], sources: ["yoga", "style.cpp"],
+                      publicHeadersPath: "include", cxxSettings: [.headerSearchPath(".")])],
+    cxxLanguageStandard: .cxx20
+)

pythonnative/native/yoga/VENDORED.md

@@ -0,0 +1,2 @@
+3.2.1
+https://github.com/react/yoga/releases/tag/v3.2.1

pythonnative/native/yoga/include/PNStyle.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <yoga/Yoga.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+// Returns false for an unsupported or invalid layout property.
+bool PNYogaSetStyle(YGNodeRef node, const char* key, const char* value);
+#ifdef __cplusplus
+}
+#endif

pythonnative/native/yoga/include/module.modulemap

@@ -0,0 +1,5 @@
+module YogaCore {
+    header "yoga/Yoga.h"
+    header "PNStyle.h"
+    export *
+}