remove stray foundation dependency (#35)

* remove stray foundation dependency

* add a test for good measure

Author: sliemeobn

README.md

@@ -34,7 +34,7 @@ For embedded builds, Swift 6.2 or later with matching *Swift SDKs for WebAssembl
 - ~~better control over animations~~
 - ~~somehow migrate over to "var body" instead of "var content" (what was I thinking....)~~
 - ~~automatic FLIP animations for certain layout changes (child-layout after changes, maybe size of containers)~~
-- fix those Foundation imports, review thread-local + mutex usage
+- ~~fix those Foundation imports, review thread-local + mutex usage~~
 - more built-in animatable CSS modifiers (colors, borders, borders?, blur)
 - basic phaseAnimator implementations
 - implement auto-flip animation for custom CSS values (on value triggers)

Sources/Reactivity/Internals.swift renamed to Sources/Reactivity/_MutexBox.swift

@@ -1,26 +1,19 @@
+#if _runtime(_multithreaded)
 import Synchronization
+final class MutexBox<State: ~Copyable>: Sendable {
+    private let state: Mutex<State>
 
-#if canImport(Foundation)
-import Foundation
-#endif
-
-// TODO: figure this out
-enum _ThreadLocal {
-    #if !canImport(Foundation) || os(WASI)
-    nonisolated(unsafe) static var value: UnsafeMutableRawPointer?
-    #else
-    private struct Key: Hashable {}
+    init(_ state: consuming sending State) {
+        self.state = Mutex(state)
+    }
 
-    static var value: UnsafeMutableRawPointer? {
-        get { Thread.current.threadDictionary[Key()] as! UnsafeMutableRawPointer? }
-        set { Thread.current.threadDictionary[Key()] = newValue }
+    func withLock<Result>(_ body: sending (inout sending State) -> sending Result) -> sending Result {
+        state.withLock(body)
     }
-    #endif
-}
 
-// TODO: Mutex causes swift compiler crash on github CI - figure out why
-#if hasFeature(Embedded) || os(Linux)
-// TODO: figure this out
+    var id: ObjectIdentifier { ObjectIdentifier(self) }
+}
+#else
 final class MutexBox<State>: @unchecked Sendable {
     private var state: State
 
@@ -34,18 +27,4 @@ final class MutexBox<State>: @unchecked Sendable {
 
     var id: ObjectIdentifier { ObjectIdentifier(self) }
 }
-#else
-final class MutexBox<State: ~Copyable>: Sendable {
-    private let state: Mutex<State>
-
-    init(_ state: consuming sending State) {
-        self.state = Mutex(state)
-    }
-
-    func withLock<Result>(_ body: sending (inout sending State) -> sending Result) -> sending Result {
-        state.withLock(body)
-    }
-
-    var id: ObjectIdentifier { ObjectIdentifier(self) }
-}
 #endif

Sources/Reactivity/_ThreadLocal.swift

@@ -0,0 +1,29 @@
+#if _runtime(_multithreaded)
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+@preconcurrency import Glibc
+#else
+#error("Unsupported platform")
+#endif
+
+enum _ThreadLocal {
+    static let key: pthread_key_t = __makeKey()
+
+    static var value: UnsafeMutableRawPointer? {
+        get { pthread_getspecific(key) }
+        set { pthread_setspecific(key, newValue) }
+    }
+
+    static func __makeKey() -> pthread_key_t {
+        var key: pthread_key_t = 0
+        pthread_key_create(&key, nil)
+        return key
+    }
+}
+#else
+// single-threaded runtime
+enum _ThreadLocal {
+    nonisolated(unsafe) static var value: UnsafeMutableRawPointer?
+}
+#endif

Tests/ElementaryDOMTests/Reconciler/TestDOM.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 @testable import ElementaryDOM
 
 private extension DOM.Event {

Tests/ReactivityTests/ReactiveClassesTests.swift

@@ -20,6 +20,32 @@ struct ReactiveClassesTests {
         foo.one = "test"
         #expect(tracker.hasChanged)
     }
+
+    @Test
+    func tracksChangesInParellel() async {
+        await withTaskGroup { group in
+            for _ in 0..<1000 {
+                group.addTask {
+                    let foo = Foo()
+                    let tracker = ChangeTracker()
+                    await Task.yield()
+                    withReactiveTracking {
+                        _ = foo.one
+                    } onChange: {
+                        tracker.hasChanged = true
+                    }
+                    await Task.yield()
+                    foo.two = "test"
+                    await Task.yield()
+                    #expect(!tracker.hasChanged)
+                    await Task.yield()
+                    foo.one = "test"
+                    #expect(tracker.hasChanged)
+                }
+            }
+        }
+
+    }
 }
 
 final class ChangeTracker: Sendable {