Swift Package IndexBuild Information
Successful build of Sica, reference master (547976), with Swift 6.0 for macOS (SPM) on 31 Oct 2024 20:43:33 UTC.
Swift 6 data race errors: 110
Build Command
env DEVELOPER_DIR=/Applications/Xcode-16.1.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=completeBuild Log
22 | let rawValue: String
23 |
:
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
| |- warning: static property 'sublayerTransformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformTranslationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
121 | public static let sublayerTransformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.z")
122 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:121:23: warning: static property 'sublayerTransformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
121 | public static let sublayerTransformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.z")
| |- warning: static property 'sublayerTransformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformTranslationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
122 | }
123 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:125:23: warning: static property 'transformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
123 |
124 | extension AnimationKeyPaths {
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
| |- warning: static property 'transformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:126:23: warning: static property 'transformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
124 | extension AnimationKeyPaths {
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
| |- warning: static property 'transformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:127:23: warning: static property 'transformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
| |- warning: static property 'transformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:128:23: warning: static property 'transformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
| |- warning: static property 'transformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:129:23: warning: static property 'transformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
| |- warning: static property 'transformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:130:23: warning: static property 'transformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
| |- warning: static property 'transformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:131:23: warning: static property 'transformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
| |- warning: static property 'transformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:132:23: warning: static property 'transformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
| |- warning: static property 'transformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
134 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:133:23: warning: static property 'transformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
| |- warning: static property 'transformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
134 | }
135 |
[10/11] Emitting module Sica
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:42:23: warning: static property 'anchorPoint' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
40 |
41 | extension AnimationKeyPaths {
42 | public static let anchorPoint = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.anchorPoint))
| |- warning: static property 'anchorPoint' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'anchorPoint' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
43 | public static let backgroundColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.backgroundColor))
44 | public static let borderColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.borderColor))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:43:23: warning: static property 'backgroundColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
41 | extension AnimationKeyPaths {
42 | public static let anchorPoint = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.anchorPoint))
43 | public static let backgroundColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.backgroundColor))
| |- warning: static property 'backgroundColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'backgroundColor' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
44 | public static let borderColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.borderColor))
45 | public static let borderWidth = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.borderWidth))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:44:23: warning: static property 'borderColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
42 | public static let anchorPoint = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.anchorPoint))
43 | public static let backgroundColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.backgroundColor))
44 | public static let borderColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.borderColor))
| |- warning: static property 'borderColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'borderColor' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
45 | public static let borderWidth = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.borderWidth))
46 | public static let bounds = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.bounds))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:45:23: warning: static property 'borderWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
43 | public static let backgroundColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.backgroundColor))
44 | public static let borderColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.borderColor))
45 | public static let borderWidth = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.borderWidth))
| |- warning: static property 'borderWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'borderWidth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
46 | public static let bounds = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.bounds))
47 | public static let contents = AnimationKeyPath<[Any]>(keyPath: #keyPath(CALayer.contents))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:46:23: warning: static property 'bounds' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
44 | public static let borderColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.borderColor))
45 | public static let borderWidth = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.borderWidth))
46 | public static let bounds = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.bounds))
| |- warning: static property 'bounds' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'bounds' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
47 | public static let contents = AnimationKeyPath<[Any]>(keyPath: #keyPath(CALayer.contents))
48 | public static let contentsRect = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.contentsRect))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:47:23: warning: static property 'contents' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[Any]>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
45 | public static let borderWidth = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.borderWidth))
46 | public static let bounds = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.bounds))
47 | public static let contents = AnimationKeyPath<[Any]>(keyPath: #keyPath(CALayer.contents))
| |- warning: static property 'contents' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[Any]>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contents' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | public static let contentsRect = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.contentsRect))
49 | public static let cornerRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.cornerRadius))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:48:23: warning: static property 'contentsRect' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
46 | public static let bounds = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.bounds))
47 | public static let contents = AnimationKeyPath<[Any]>(keyPath: #keyPath(CALayer.contents))
48 | public static let contentsRect = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.contentsRect))
| |- warning: static property 'contentsRect' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRect' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
49 | public static let cornerRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.cornerRadius))
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:49:23: warning: static property 'cornerRadius' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
47 | public static let contents = AnimationKeyPath<[Any]>(keyPath: #keyPath(CALayer.contents))
48 | public static let contentsRect = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.contentsRect))
49 | public static let cornerRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.cornerRadius))
| |- warning: static property 'cornerRadius' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'cornerRadius' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:50:23: warning: static property 'filters' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[CIFilter]>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
48 | public static let contentsRect = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.contentsRect))
49 | public static let cornerRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.cornerRadius))
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
| |- warning: static property 'filters' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[CIFilter]>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'filters' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:51:23: warning: static property 'frame' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
49 | public static let cornerRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.cornerRadius))
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
| |- warning: static property 'frame' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGRect>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frame' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:52:92: warning: 'hidden' has been renamed to 'isHidden'
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
| `- warning: 'hidden' has been renamed to 'isHidden'
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
QuartzCore.CALayer:35:14: note: 'hidden' was obsoleted in Swift 3
33 | open var isHidden: Bool { get set }
34 | @available(swift, obsoleted: 3, renamed: "isHidden")
35 | open var hidden: Bool { get set }
| `- note: 'hidden' was obsoleted in Swift 3
36 | open var isDoubleSided: Bool { get set }
37 | @available(swift, obsoleted: 3, renamed: "isDoubleSided")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:52:23: warning: static property 'hidden' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<Bool>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
50 | public static let filters = AnimationKeyPath<[CIFilter]>(keyPath: #keyPath(CALayer.filters))
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
| |- warning: static property 'hidden' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<Bool>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hidden' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:53:23: warning: static property 'mask' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CALayer>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
51 | public static let frame = AnimationKeyPath<CGRect>(keyPath: #keyPath(CALayer.frame))
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
| |- warning: static property 'mask' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CALayer>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mask' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
55 | public static let opacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.opacity))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:54:23: warning: static property 'masksToBounds' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<Bool>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
52 | public static let hidden = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.hidden))
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
| |- warning: static property 'masksToBounds' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<Bool>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'masksToBounds' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
55 | public static let opacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.opacity))
56 | public static let path = AnimationKeyPath<CGPath>(keyPath: #keyPath(CAShapeLayer.path))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:55:23: warning: static property 'opacity' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
53 | public static let mask = AnimationKeyPath<CALayer>(keyPath: #keyPath(CALayer.mask))
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
55 | public static let opacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.opacity))
| |- warning: static property 'opacity' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'opacity' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
56 | public static let path = AnimationKeyPath<CGPath>(keyPath: #keyPath(CAShapeLayer.path))
57 | public static let position = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.position))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:56:23: warning: static property 'path' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPath>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
54 | public static let masksToBounds = AnimationKeyPath<Bool>(keyPath: #keyPath(CALayer.masksToBounds))
55 | public static let opacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.opacity))
56 | public static let path = AnimationKeyPath<CGPath>(keyPath: #keyPath(CAShapeLayer.path))
| |- warning: static property 'path' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPath>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'path' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
57 | public static let position = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.position))
58 | public static let shadowColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.shadowColor))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:57:23: warning: static property 'position' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
55 | public static let opacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.opacity))
56 | public static let path = AnimationKeyPath<CGPath>(keyPath: #keyPath(CAShapeLayer.path))
57 | public static let position = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.position))
| |- warning: static property 'position' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'position' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
58 | public static let shadowColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.shadowColor))
59 | public static let shadowOffset = AnimationKeyPath<CGSize>(keyPath: #keyPath(CALayer.shadowOffset))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:58:23: warning: static property 'shadowColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
56 | public static let path = AnimationKeyPath<CGPath>(keyPath: #keyPath(CAShapeLayer.path))
57 | public static let position = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.position))
58 | public static let shadowColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.shadowColor))
| |- warning: static property 'shadowColor' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGColor>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowColor' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
59 | public static let shadowOffset = AnimationKeyPath<CGSize>(keyPath: #keyPath(CALayer.shadowOffset))
60 | public static let shadowOpacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowOpacity))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:59:23: warning: static property 'shadowOffset' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
57 | public static let position = AnimationKeyPath<CGPoint>(keyPath: #keyPath(CALayer.position))
58 | public static let shadowColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.shadowColor))
59 | public static let shadowOffset = AnimationKeyPath<CGSize>(keyPath: #keyPath(CALayer.shadowOffset))
| |- warning: static property 'shadowOffset' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowOffset' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
60 | public static let shadowOpacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowOpacity))
61 | public static let shadowPath = AnimationKeyPath<CGPath>(keyPath: #keyPath(CALayer.shadowPath))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:60:23: warning: static property 'shadowOpacity' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
58 | public static let shadowColor = AnimationKeyPath<CGColor>(keyPath: #keyPath(CALayer.shadowColor))
59 | public static let shadowOffset = AnimationKeyPath<CGSize>(keyPath: #keyPath(CALayer.shadowOffset))
60 | public static let shadowOpacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowOpacity))
| |- warning: static property 'shadowOpacity' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowOpacity' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 | public static let shadowPath = AnimationKeyPath<CGPath>(keyPath: #keyPath(CALayer.shadowPath))
62 | public static let shadowRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowRadius))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:61:23: warning: static property 'shadowPath' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPath>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
59 | public static let shadowOffset = AnimationKeyPath<CGSize>(keyPath: #keyPath(CALayer.shadowOffset))
60 | public static let shadowOpacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowOpacity))
61 | public static let shadowPath = AnimationKeyPath<CGPath>(keyPath: #keyPath(CALayer.shadowPath))
| |- warning: static property 'shadowPath' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPath>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowPath' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
62 | public static let shadowRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowRadius))
63 | public static let sublayers = AnimationKeyPath<[CALayer]>(keyPath: #keyPath(CALayer.sublayers))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:62:23: warning: static property 'shadowRadius' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
60 | public static let shadowOpacity = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowOpacity))
61 | public static let shadowPath = AnimationKeyPath<CGPath>(keyPath: #keyPath(CALayer.shadowPath))
62 | public static let shadowRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowRadius))
| |- warning: static property 'shadowRadius' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowRadius' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
63 | public static let sublayers = AnimationKeyPath<[CALayer]>(keyPath: #keyPath(CALayer.sublayers))
64 | public static let sublayerTransform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.sublayerTransform))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:63:23: warning: static property 'sublayers' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[CALayer]>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
61 | public static let shadowPath = AnimationKeyPath<CGPath>(keyPath: #keyPath(CALayer.shadowPath))
62 | public static let shadowRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowRadius))
63 | public static let sublayers = AnimationKeyPath<[CALayer]>(keyPath: #keyPath(CALayer.sublayers))
| |- warning: static property 'sublayers' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<[CALayer]>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayers' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 | public static let sublayerTransform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.sublayerTransform))
65 | public static let transform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.transform))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:64:23: warning: static property 'sublayerTransform' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CATransform3D>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
62 | public static let shadowRadius = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.shadowRadius))
63 | public static let sublayers = AnimationKeyPath<[CALayer]>(keyPath: #keyPath(CALayer.sublayers))
64 | public static let sublayerTransform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.sublayerTransform))
| |- warning: static property 'sublayerTransform' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CATransform3D>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
65 | public static let transform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.transform))
66 | public static let zPosition = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.zPosition))
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:65:23: warning: static property 'transform' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CATransform3D>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
63 | public static let sublayers = AnimationKeyPath<[CALayer]>(keyPath: #keyPath(CALayer.sublayers))
64 | public static let sublayerTransform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.sublayerTransform))
65 | public static let transform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.transform))
| |- warning: static property 'transform' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CATransform3D>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
66 | public static let zPosition = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.zPosition))
67 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:66:23: warning: static property 'zPosition' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
64 | public static let sublayerTransform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.sublayerTransform))
65 | public static let transform = AnimationKeyPath<CATransform3D>(keyPath: #keyPath(CALayer.transform))
66 | public static let zPosition = AnimationKeyPath<CGFloat>(keyPath: #keyPath(CALayer.zPosition))
| |- warning: static property 'zPosition' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'zPosition' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 | }
68 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:70:23: warning: static property 'anchorPointX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
68 |
69 | extension AnimationKeyPaths {
70 | public static let anchorPointX = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.anchorPoint)).x")
| |- warning: static property 'anchorPointX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'anchorPointX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
71 | public static let anchorPointy = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.anchorPoint)).y")
72 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:71:23: warning: static property 'anchorPointy' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
69 | extension AnimationKeyPaths {
70 | public static let anchorPointX = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.anchorPoint)).x")
71 | public static let anchorPointy = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.anchorPoint)).y")
| |- warning: static property 'anchorPointy' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'anchorPointy' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
72 | }
73 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:75:23: warning: static property 'boundsOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
73 |
74 | extension AnimationKeyPaths {
75 | public static let boundsOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.bounds)).origin")
| |- warning: static property 'boundsOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsOrigin' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
76 | public static let boundsOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.x")
77 | public static let boundsOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:76:23: warning: static property 'boundsOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
74 | extension AnimationKeyPaths {
75 | public static let boundsOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.bounds)).origin")
76 | public static let boundsOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.x")
| |- warning: static property 'boundsOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsOriginX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | public static let boundsOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.y")
78 | public static let boundsSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.bounds)).size")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:77:23: warning: static property 'boundsOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
75 | public static let boundsOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.bounds)).origin")
76 | public static let boundsOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.x")
77 | public static let boundsOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.y")
| |- warning: static property 'boundsOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsOriginY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
78 | public static let boundsSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.bounds)).size")
79 | public static let boundsSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.width")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:78:23: warning: static property 'boundsSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
76 | public static let boundsOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.x")
77 | public static let boundsOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.y")
78 | public static let boundsSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.bounds)).size")
| |- warning: static property 'boundsSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsSize' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
79 | public static let boundsSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.width")
80 | public static let boundsSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.height")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:79:23: warning: static property 'boundsSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
77 | public static let boundsOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).origin.y")
78 | public static let boundsSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.bounds)).size")
79 | public static let boundsSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.width")
| |- warning: static property 'boundsSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsSizeWidth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
80 | public static let boundsSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.height")
81 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:80:23: warning: static property 'boundsSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
78 | public static let boundsSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.bounds)).size")
79 | public static let boundsSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.width")
80 | public static let boundsSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.bounds)).size.height")
| |- warning: static property 'boundsSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'boundsSizeHeight' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
81 |
82 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:85:23: warning: static property 'contentsRectOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
83 |
84 | extension AnimationKeyPaths {
85 | public static let contentsRectOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin")
| |- warning: static property 'contentsRectOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectOrigin' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
86 | public static let contentsRectOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.x")
87 | public static let contentsRectOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:86:23: warning: static property 'contentsRectOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
84 | extension AnimationKeyPaths {
85 | public static let contentsRectOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin")
86 | public static let contentsRectOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.x")
| |- warning: static property 'contentsRectOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectOriginX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
87 | public static let contentsRectOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.y")
88 | public static let contentsRectSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.contentsRect)).size")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:87:23: warning: static property 'contentsRectOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
85 | public static let contentsRectOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin")
86 | public static let contentsRectOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.x")
87 | public static let contentsRectOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.y")
| |- warning: static property 'contentsRectOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectOriginY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
88 | public static let contentsRectSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.contentsRect)).size")
89 | public static let contentsRectSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.width")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:88:23: warning: static property 'contentsRectSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
86 | public static let contentsRectOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.x")
87 | public static let contentsRectOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.y")
88 | public static let contentsRectSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.contentsRect)).size")
| |- warning: static property 'contentsRectSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectSize' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
89 | public static let contentsRectSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.width")
90 | public static let contentsRectSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.height")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:89:23: warning: static property 'contentsRectSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
87 | public static let contentsRectOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).origin.y")
88 | public static let contentsRectSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.contentsRect)).size")
89 | public static let contentsRectSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.width")
| |- warning: static property 'contentsRectSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectSizeWidth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 | public static let contentsRectSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.height")
91 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:90:23: warning: static property 'contentsRectSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
88 | public static let contentsRectSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.contentsRect)).size")
89 | public static let contentsRectSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.width")
90 | public static let contentsRectSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.contentsRect)).size.height")
| |- warning: static property 'contentsRectSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentsRectSizeHeight' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
91 | }
92 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:94:23: warning: static property 'frameOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
92 |
93 | extension AnimationKeyPaths {
94 | public static let frameOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.frame)).origin")
| |- warning: static property 'frameOrigin' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGPoint>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameOrigin' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
95 | public static let frameOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.x")
96 | public static let frameOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:95:23: warning: static property 'frameOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
93 | extension AnimationKeyPaths {
94 | public static let frameOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.frame)).origin")
95 | public static let frameOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.x")
| |- warning: static property 'frameOriginX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameOriginX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
96 | public static let frameOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.y")
97 | public static let frameSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.frame)).size")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:96:23: warning: static property 'frameOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
94 | public static let frameOrigin = AnimationKeyPath<CGPoint>(keyPath: "\(#keyPath(CALayer.frame)).origin")
95 | public static let frameOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.x")
96 | public static let frameOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.y")
| |- warning: static property 'frameOriginY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameOriginY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
97 | public static let frameSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.frame)).size")
98 | public static let frameSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.width")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:97:23: warning: static property 'frameSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
95 | public static let frameOriginX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.x")
96 | public static let frameOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.y")
97 | public static let frameSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.frame)).size")
| |- warning: static property 'frameSize' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGSize>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameSize' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
98 | public static let frameSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.width")
99 | public static let frameSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.height")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:98:23: warning: static property 'frameSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
96 | public static let frameOriginY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).origin.y")
97 | public static let frameSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.frame)).size")
98 | public static let frameSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.width")
| |- warning: static property 'frameSizeWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameSizeWidth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
99 | public static let frameSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.height")
100 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:99:23: warning: static property 'frameSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
97 | public static let frameSize = AnimationKeyPath<CGSize>(keyPath: "\(#keyPath(CALayer.frame)).size")
98 | public static let frameSizeWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.width")
99 | public static let frameSizeHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.frame)).size.height")
| |- warning: static property 'frameSizeHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'frameSizeHeight' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
100 | }
101 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:103:23: warning: static property 'positionX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
101 |
102 | extension AnimationKeyPaths {
103 | public static let positionX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.position)).x")
| |- warning: static property 'positionX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'positionX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
104 | public static let positionY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.position)).y")
105 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:104:23: warning: static property 'positionY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
102 | extension AnimationKeyPaths {
103 | public static let positionX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.position)).x")
104 | public static let positionY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.position)).y")
| |- warning: static property 'positionY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'positionY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
105 | }
106 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:108:23: warning: static property 'shadowOffsetWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
106 |
107 | extension AnimationKeyPaths {
108 | public static let shadowOffsetWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.shadowOffset)).width")
| |- warning: static property 'shadowOffsetWidth' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowOffsetWidth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 | public static let shadowOffsetHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.shadowOffset)).height")
110 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:109:23: warning: static property 'shadowOffsetHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
107 | extension AnimationKeyPaths {
108 | public static let shadowOffsetWidth = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.shadowOffset)).width")
109 | public static let shadowOffsetHeight = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.shadowOffset)).height")
| |- warning: static property 'shadowOffsetHeight' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shadowOffsetHeight' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
110 | }
111 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:113:23: warning: static property 'sublayerTransformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
111 |
112 | extension AnimationKeyPaths {
113 | public static let sublayerTransformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.x")
| |- warning: static property 'sublayerTransformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformRotationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
114 | public static let sublayerTransformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.y")
115 | public static let sublayerTransformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:114:23: warning: static property 'sublayerTransformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
112 | extension AnimationKeyPaths {
113 | public static let sublayerTransformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.x")
114 | public static let sublayerTransformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.y")
| |- warning: static property 'sublayerTransformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformRotationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
115 | public static let sublayerTransformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.z")
116 | public static let sublayerTransformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:115:23: warning: static property 'sublayerTransformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
113 | public static let sublayerTransformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.x")
114 | public static let sublayerTransformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.y")
115 | public static let sublayerTransformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.z")
| |- warning: static property 'sublayerTransformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformRotationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
116 | public static let sublayerTransformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.x")
117 | public static let sublayerTransformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:116:23: warning: static property 'sublayerTransformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
114 | public static let sublayerTransformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.y")
115 | public static let sublayerTransformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.z")
116 | public static let sublayerTransformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.x")
| |- warning: static property 'sublayerTransformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformScaleX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
117 | public static let sublayerTransformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.y")
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:117:23: warning: static property 'sublayerTransformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
115 | public static let sublayerTransformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).rotation.z")
116 | public static let sublayerTransformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.x")
117 | public static let sublayerTransformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.y")
| |- warning: static property 'sublayerTransformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformScaleY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:118:23: warning: static property 'sublayerTransformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
116 | public static let sublayerTransformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.x")
117 | public static let sublayerTransformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.y")
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
| |- warning: static property 'sublayerTransformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformScaleZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:119:23: warning: static property 'sublayerTransformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
117 | public static let sublayerTransformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.y")
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
| |- warning: static property 'sublayerTransformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformTranslationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
121 | public static let sublayerTransformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:120:23: warning: static property 'sublayerTransformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
118 | public static let sublayerTransformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).scale.z")
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
| |- warning: static property 'sublayerTransformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformTranslationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
121 | public static let sublayerTransformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.z")
122 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:121:23: warning: static property 'sublayerTransformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
119 | public static let sublayerTransformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.x")
120 | public static let sublayerTransformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.y")
121 | public static let sublayerTransformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.sublayerTransform)).translation.z")
| |- warning: static property 'sublayerTransformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sublayerTransformTranslationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
122 | }
123 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:125:23: warning: static property 'transformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
123 |
124 | extension AnimationKeyPaths {
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
| |- warning: static property 'transformRotationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:126:23: warning: static property 'transformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
124 | extension AnimationKeyPaths {
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
| |- warning: static property 'transformRotationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:127:23: warning: static property 'transformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
125 | public static let transformRotationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.x")
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
| |- warning: static property 'transformRotationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformRotationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:128:23: warning: static property 'transformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
126 | public static let transformRotationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.y")
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
| |- warning: static property 'transformScaleX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:129:23: warning: static property 'transformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
127 | public static let transformRotationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).rotation.z")
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
| |- warning: static property 'transformScaleY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:130:23: warning: static property 'transformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
128 | public static let transformScaleX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.x")
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
| |- warning: static property 'transformScaleZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformScaleZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:131:23: warning: static property 'transformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
129 | public static let transformScaleY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.y")
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
| |- warning: static property 'transformTranslationX' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationX' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:132:23: warning: static property 'transformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
130 | public static let transformScaleZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).scale.z")
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
| |- warning: static property 'transformTranslationY' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationY' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
134 | }
/Users/admin/builder/spi-builder-workspace/Sica/Source/AnimationKeyPaths.swift:133:23: warning: static property 'transformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
19 | public protocol AnimationValueType {}
20 |
21 | public final class AnimationKeyPath<ValueType: AnimationValueType>: AnimationKeyPaths {
| `- note: generic class 'AnimationKeyPath' does not conform to the 'Sendable' protocol
22 | let rawValue: String
23 |
:
131 | public static let transformTranslationX = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.x")
132 | public static let transformTranslationY = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.y")
133 | public static let transformTranslationZ = AnimationKeyPath<CGFloat>(keyPath: "\(#keyPath(CALayer.transform)).translation.z")
| |- warning: static property 'transformTranslationZ' is not concurrency-safe because non-'Sendable' type 'AnimationKeyPath<CGFloat>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transformTranslationZ' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
134 | }
135 |
/Users/admin/builder/spi-builder-workspace/Sica/Source/FillMode.swift:15:23: warning: static property 'forwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | public struct FillMode {
| `- note: consider making struct 'FillMode' conform to the 'Sendable' protocol
13 | #if swift(>=4.2)
14 | typealias RawValue = CAMediaTimingFillMode
15 | public static let forwards = FillMode(rawValue: .forwards)
| |- warning: static property 'forwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'forwards' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | public static let backwards = FillMode(rawValue: .backwards)
17 | public static let both = FillMode(rawValue: .both)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:14:23: warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
14 | public static let `default` = TimingFunction(name: CAMediaTimingFunctionName.default)
| |- warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'default' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
15 | public static let linear = TimingFunction(name: CAMediaTimingFunctionName.linear)
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
/Users/admin/builder/spi-builder-workspace/Sica/Source/CALayer+Sica.swift:12:13: warning: let '_animatorAssociatedKey' is not concurrency-safe because non-'Sendable' type 'UnsafeMutablePointer<UInt>' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | private let _animatorAssociatedKey = UnsafeMutablePointer<UInt>.allocate(capacity: 1)
| |- warning: let '_animatorAssociatedKey' is not concurrency-safe because non-'Sendable' type 'UnsafeMutablePointer<UInt>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate '_animatorAssociatedKey' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
13 |
14 | extension CALayer {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sica/Source/FillMode.swift:16:23: warning: static property 'backwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | public struct FillMode {
| `- note: consider making struct 'FillMode' conform to the 'Sendable' protocol
13 | #if swift(>=4.2)
14 | typealias RawValue = CAMediaTimingFillMode
15 | public static let forwards = FillMode(rawValue: .forwards)
16 | public static let backwards = FillMode(rawValue: .backwards)
| |- warning: static property 'backwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'backwards' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | public static let both = FillMode(rawValue: .both)
18 | public static let removed = FillMode(rawValue: .removed)
/Users/admin/builder/spi-builder-workspace/Sica/Source/FillMode.swift:17:23: warning: static property 'both' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | public struct FillMode {
| `- note: consider making struct 'FillMode' conform to the 'Sendable' protocol
13 | #if swift(>=4.2)
14 | typealias RawValue = CAMediaTimingFillMode
15 | public static let forwards = FillMode(rawValue: .forwards)
16 | public static let backwards = FillMode(rawValue: .backwards)
17 | public static let both = FillMode(rawValue: .both)
| |- warning: static property 'both' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'both' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | public static let removed = FillMode(rawValue: .removed)
19 | #else
/Users/admin/builder/spi-builder-workspace/Sica/Source/FillMode.swift:18:23: warning: static property 'removed' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | public struct FillMode {
| `- note: consider making struct 'FillMode' conform to the 'Sendable' protocol
13 | #if swift(>=4.2)
14 | typealias RawValue = CAMediaTimingFillMode
:
16 | public static let backwards = FillMode(rawValue: .backwards)
17 | public static let both = FillMode(rawValue: .both)
18 | public static let removed = FillMode(rawValue: .removed)
| |- warning: static property 'removed' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'removed' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | #else
20 | typealias RawValue = String
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:15:23: warning: static property 'linear' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
14 | public static let `default` = TimingFunction(name: CAMediaTimingFunctionName.default)
15 | public static let linear = TimingFunction(name: CAMediaTimingFunctionName.linear)
| |- warning: static property 'linear' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'linear' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
17 | public static let easeOut = TimingFunction(name: CAMediaTimingFunctionName.easeOut)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:16:23: warning: static property 'easeIn' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
14 | public static let `default` = TimingFunction(name: CAMediaTimingFunctionName.default)
15 | public static let linear = TimingFunction(name: CAMediaTimingFunctionName.linear)
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
| |- warning: static property 'easeIn' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeIn' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | public static let easeOut = TimingFunction(name: CAMediaTimingFunctionName.easeOut)
18 | public static let easeInEaseOut = TimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:17:23: warning: static property 'easeOut' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
15 | public static let linear = TimingFunction(name: CAMediaTimingFunctionName.linear)
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
17 | public static let easeOut = TimingFunction(name: CAMediaTimingFunctionName.easeOut)
| |- warning: static property 'easeOut' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOut' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | public static let easeInEaseOut = TimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut)
19 | #else
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:18:23: warning: static property 'easeInEaseOut' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
17 | public static let easeOut = TimingFunction(name: CAMediaTimingFunctionName.easeOut)
18 | public static let easeInEaseOut = TimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut)
| |- warning: static property 'easeInEaseOut' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInEaseOut' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | #else
20 | public typealias NameValue = String
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:51:23: warning: static property 'easeInSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
49 | extension TimingFunction {
50 | #if swift(>=4.2)
51 | public static let easeInSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInSine"), controlPoints: 0.47, 0, 0.745, 0.715)
| |- warning: static property 'easeInSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInSine' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | public static let easeOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutSine"), controlPoints: 0.39, 0.575, 0.565, 1)
53 | public static let easeInOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutSine"), controlPoints: 0.445, 0.05, 0.55, 0.95)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:52:23: warning: static property 'easeOutSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
50 | #if swift(>=4.2)
51 | public static let easeInSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInSine"), controlPoints: 0.47, 0, 0.745, 0.715)
52 | public static let easeOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutSine"), controlPoints: 0.39, 0.575, 0.565, 1)
| |- warning: static property 'easeOutSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutSine' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
53 | public static let easeInOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutSine"), controlPoints: 0.445, 0.05, 0.55, 0.95)
54 | public static let easeInQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuad"), controlPoints: 0.55, 0.085, 0.68, 0.53)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:53:23: warning: static property 'easeInOutSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
51 | public static let easeInSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInSine"), controlPoints: 0.47, 0, 0.745, 0.715)
52 | public static let easeOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutSine"), controlPoints: 0.39, 0.575, 0.565, 1)
53 | public static let easeInOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutSine"), controlPoints: 0.445, 0.05, 0.55, 0.95)
| |- warning: static property 'easeInOutSine' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutSine' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
54 | public static let easeInQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuad"), controlPoints: 0.55, 0.085, 0.68, 0.53)
55 | public static let easeOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuad"), controlPoints: 0.25, 0.46, 0.45, 0.94)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:54:23: warning: static property 'easeInQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
52 | public static let easeOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutSine"), controlPoints: 0.39, 0.575, 0.565, 1)
53 | public static let easeInOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutSine"), controlPoints: 0.445, 0.05, 0.55, 0.95)
54 | public static let easeInQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuad"), controlPoints: 0.55, 0.085, 0.68, 0.53)
| |- warning: static property 'easeInQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInQuad' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
55 | public static let easeOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuad"), controlPoints: 0.25, 0.46, 0.45, 0.94)
56 | public static let easeInOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuad"), controlPoints: 0.455, 0.03, 0.515, 0.955)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:55:23: warning: static property 'easeOutQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
53 | public static let easeInOutSine = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutSine"), controlPoints: 0.445, 0.05, 0.55, 0.95)
54 | public static let easeInQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuad"), controlPoints: 0.55, 0.085, 0.68, 0.53)
55 | public static let easeOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuad"), controlPoints: 0.25, 0.46, 0.45, 0.94)
| |- warning: static property 'easeOutQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutQuad' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
56 | public static let easeInOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuad"), controlPoints: 0.455, 0.03, 0.515, 0.955)
57 | public static let easeInCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCubic"), controlPoints: 0.55, 0.055, 0.675, 0.19)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:56:23: warning: static property 'easeInOutQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
54 | public static let easeInQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuad"), controlPoints: 0.55, 0.085, 0.68, 0.53)
55 | public static let easeOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuad"), controlPoints: 0.25, 0.46, 0.45, 0.94)
56 | public static let easeInOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuad"), controlPoints: 0.455, 0.03, 0.515, 0.955)
| |- warning: static property 'easeInOutQuad' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutQuad' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
57 | public static let easeInCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCubic"), controlPoints: 0.55, 0.055, 0.675, 0.19)
58 | public static let easeOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCubic"), controlPoints: 0.215, 0.61, 0.355, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:57:23: warning: static property 'easeInCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
55 | public static let easeOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuad"), controlPoints: 0.25, 0.46, 0.45, 0.94)
56 | public static let easeInOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuad"), controlPoints: 0.455, 0.03, 0.515, 0.955)
57 | public static let easeInCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCubic"), controlPoints: 0.55, 0.055, 0.675, 0.19)
| |- warning: static property 'easeInCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInCubic' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
58 | public static let easeOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCubic"), controlPoints: 0.215, 0.61, 0.355, 1)
59 | public static let easeInOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCubic"), controlPoints: 0.645, 0.045, 0.355, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:58:23: warning: static property 'easeOutCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
56 | public static let easeInOutQuad = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuad"), controlPoints: 0.455, 0.03, 0.515, 0.955)
57 | public static let easeInCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCubic"), controlPoints: 0.55, 0.055, 0.675, 0.19)
58 | public static let easeOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCubic"), controlPoints: 0.215, 0.61, 0.355, 1)
| |- warning: static property 'easeOutCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutCubic' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
59 | public static let easeInOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCubic"), controlPoints: 0.645, 0.045, 0.355, 1)
60 | public static let easeInQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuart"), controlPoints: 0.895, 0.03, 0.685, 0.22)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:59:23: warning: static property 'easeInOutCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
57 | public static let easeInCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCubic"), controlPoints: 0.55, 0.055, 0.675, 0.19)
58 | public static let easeOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCubic"), controlPoints: 0.215, 0.61, 0.355, 1)
59 | public static let easeInOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCubic"), controlPoints: 0.645, 0.045, 0.355, 1)
| |- warning: static property 'easeInOutCubic' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutCubic' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
60 | public static let easeInQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuart"), controlPoints: 0.895, 0.03, 0.685, 0.22)
61 | public static let easeOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuart"), controlPoints: 0.165, 0.84, 0.44, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:60:23: warning: static property 'easeInQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
58 | public static let easeOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCubic"), controlPoints: 0.215, 0.61, 0.355, 1)
59 | public static let easeInOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCubic"), controlPoints: 0.645, 0.045, 0.355, 1)
60 | public static let easeInQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuart"), controlPoints: 0.895, 0.03, 0.685, 0.22)
| |- warning: static property 'easeInQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInQuart' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 | public static let easeOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuart"), controlPoints: 0.165, 0.84, 0.44, 1)
62 | public static let easeInOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuart"), controlPoints: 0.77, 0, 0.175, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:61:23: warning: static property 'easeOutQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
59 | public static let easeInOutCubic = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCubic"), controlPoints: 0.645, 0.045, 0.355, 1)
60 | public static let easeInQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuart"), controlPoints: 0.895, 0.03, 0.685, 0.22)
61 | public static let easeOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuart"), controlPoints: 0.165, 0.84, 0.44, 1)
| |- warning: static property 'easeOutQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutQuart' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
62 | public static let easeInOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuart"), controlPoints: 0.77, 0, 0.175, 1)
63 | public static let easeInQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuint"), controlPoints: 0.755, 0.05, 0.855, 0.06)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:62:23: warning: static property 'easeInOutQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
60 | public static let easeInQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuart"), controlPoints: 0.895, 0.03, 0.685, 0.22)
61 | public static let easeOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuart"), controlPoints: 0.165, 0.84, 0.44, 1)
62 | public static let easeInOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuart"), controlPoints: 0.77, 0, 0.175, 1)
| |- warning: static property 'easeInOutQuart' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutQuart' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
63 | public static let easeInQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuint"), controlPoints: 0.755, 0.05, 0.855, 0.06)
64 | public static let easeOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuint"), controlPoints: 0.23, 1, 0.32, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:63:23: warning: static property 'easeInQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
61 | public static let easeOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuart"), controlPoints: 0.165, 0.84, 0.44, 1)
62 | public static let easeInOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuart"), controlPoints: 0.77, 0, 0.175, 1)
63 | public static let easeInQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuint"), controlPoints: 0.755, 0.05, 0.855, 0.06)
| |- warning: static property 'easeInQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInQuint' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 | public static let easeOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuint"), controlPoints: 0.23, 1, 0.32, 1)
65 | public static let easeInOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuint"), controlPoints: 0.86, 0, 0.07, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:64:23: warning: static property 'easeOutQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
62 | public static let easeInOutQuart = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuart"), controlPoints: 0.77, 0, 0.175, 1)
63 | public static let easeInQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuint"), controlPoints: 0.755, 0.05, 0.855, 0.06)
64 | public static let easeOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuint"), controlPoints: 0.23, 1, 0.32, 1)
| |- warning: static property 'easeOutQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutQuint' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
65 | public static let easeInOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuint"), controlPoints: 0.86, 0, 0.07, 1)
66 | public static let easeInExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInExpo"), controlPoints: 0.95, 0.05, 0.795, 0.035)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:65:23: warning: static property 'easeInOutQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
63 | public static let easeInQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInQuint"), controlPoints: 0.755, 0.05, 0.855, 0.06)
64 | public static let easeOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuint"), controlPoints: 0.23, 1, 0.32, 1)
65 | public static let easeInOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuint"), controlPoints: 0.86, 0, 0.07, 1)
| |- warning: static property 'easeInOutQuint' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutQuint' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
66 | public static let easeInExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInExpo"), controlPoints: 0.95, 0.05, 0.795, 0.035)
67 | public static let easeOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutExpo"), controlPoints: 0.19, 1, 0.22, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:66:23: warning: static property 'easeInExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
64 | public static let easeOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutQuint"), controlPoints: 0.23, 1, 0.32, 1)
65 | public static let easeInOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuint"), controlPoints: 0.86, 0, 0.07, 1)
66 | public static let easeInExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInExpo"), controlPoints: 0.95, 0.05, 0.795, 0.035)
| |- warning: static property 'easeInExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInExpo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 | public static let easeOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutExpo"), controlPoints: 0.19, 1, 0.22, 1)
68 | public static let easeInOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutExpo"), controlPoints: 1, 0, 0, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:67:23: warning: static property 'easeOutExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
65 | public static let easeInOutQuint = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutQuint"), controlPoints: 0.86, 0, 0.07, 1)
66 | public static let easeInExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInExpo"), controlPoints: 0.95, 0.05, 0.795, 0.035)
67 | public static let easeOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutExpo"), controlPoints: 0.19, 1, 0.22, 1)
| |- warning: static property 'easeOutExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutExpo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
68 | public static let easeInOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutExpo"), controlPoints: 1, 0, 0, 1)
69 | public static let easeInCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCirc"), controlPoints: 0.6, 0.04, 0.98, 0.335)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:68:23: warning: static property 'easeInOutExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
66 | public static let easeInExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInExpo"), controlPoints: 0.95, 0.05, 0.795, 0.035)
67 | public static let easeOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutExpo"), controlPoints: 0.19, 1, 0.22, 1)
68 | public static let easeInOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutExpo"), controlPoints: 1, 0, 0, 1)
| |- warning: static property 'easeInOutExpo' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutExpo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
69 | public static let easeInCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCirc"), controlPoints: 0.6, 0.04, 0.98, 0.335)
70 | public static let easeOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCirc"), controlPoints: 0.075, 0.82, 0.165, 1)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:69:23: warning: static property 'easeInCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
67 | public static let easeOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutExpo"), controlPoints: 0.19, 1, 0.22, 1)
68 | public static let easeInOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutExpo"), controlPoints: 1, 0, 0, 1)
69 | public static let easeInCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCirc"), controlPoints: 0.6, 0.04, 0.98, 0.335)
| |- warning: static property 'easeInCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInCirc' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 | public static let easeOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCirc"), controlPoints: 0.075, 0.82, 0.165, 1)
71 | public static let easeInOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCirc"), controlPoints: 0.785, 0.135, 0.15, 0.86)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:70:23: warning: static property 'easeOutCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
68 | public static let easeInOutExpo = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutExpo"), controlPoints: 1, 0, 0, 1)
69 | public static let easeInCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCirc"), controlPoints: 0.6, 0.04, 0.98, 0.335)
70 | public static let easeOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCirc"), controlPoints: 0.075, 0.82, 0.165, 1)
| |- warning: static property 'easeOutCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutCirc' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
71 | public static let easeInOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCirc"), controlPoints: 0.785, 0.135, 0.15, 0.86)
72 | public static let easeInBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInBack"), controlPoints: 0.6, -0.28, 0.735, 0.045)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:71:23: warning: static property 'easeInOutCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
69 | public static let easeInCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInCirc"), controlPoints: 0.6, 0.04, 0.98, 0.335)
70 | public static let easeOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCirc"), controlPoints: 0.075, 0.82, 0.165, 1)
71 | public static let easeInOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCirc"), controlPoints: 0.785, 0.135, 0.15, 0.86)
| |- warning: static property 'easeInOutCirc' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutCirc' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
72 | public static let easeInBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInBack"), controlPoints: 0.6, -0.28, 0.735, 0.045)
73 | public static let easeOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutBack"), controlPoints: 0.175, 0.885, 0.32, 1.275)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:72:23: warning: static property 'easeInBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
70 | public static let easeOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutCirc"), controlPoints: 0.075, 0.82, 0.165, 1)
71 | public static let easeInOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCirc"), controlPoints: 0.785, 0.135, 0.15, 0.86)
72 | public static let easeInBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInBack"), controlPoints: 0.6, -0.28, 0.735, 0.045)
| |- warning: static property 'easeInBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInBack' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
73 | public static let easeOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutBack"), controlPoints: 0.175, 0.885, 0.32, 1.275)
74 | public static let easeInOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutBack"), controlPoints: 0.68, -0.55, 0.265, 1.55)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:73:23: warning: static property 'easeOutBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
71 | public static let easeInOutCirc = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutCirc"), controlPoints: 0.785, 0.135, 0.15, 0.86)
72 | public static let easeInBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInBack"), controlPoints: 0.6, -0.28, 0.735, 0.045)
73 | public static let easeOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutBack"), controlPoints: 0.175, 0.885, 0.32, 1.275)
| |- warning: static property 'easeOutBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeOutBack' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
74 | public static let easeInOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutBack"), controlPoints: 0.68, -0.55, 0.265, 1.55)
75 | #else
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:74:23: warning: static property 'easeInOutBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
:
72 | public static let easeInBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInBack"), controlPoints: 0.6, -0.28, 0.735, 0.045)
73 | public static let easeOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeOutBack"), controlPoints: 0.175, 0.885, 0.32, 1.275)
74 | public static let easeInOutBack = TimingFunction(name: TimingFunction.NameValue(rawValue: "easeInOutBack"), controlPoints: 0.68, -0.55, 0.265, 1.55)
| |- warning: static property 'easeInOutBack' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'easeInOutBack' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
75 | #else
76 | public static let easeInSine = TimingFunction(name: "easeInSine", controlPoints: 0.47, 0, 0.745, 0.715)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:14:23: warning: static property 'fade' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct Transition {
| `- note: consider making struct 'Transition' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | typealias RawValue = CATransitionType
14 | public static let fade = Transition(rawValue: .fade)
| |- warning: static property 'fade' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'fade' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
15 | public static let moveIn = Transition(rawValue: .moveIn)
16 | public static let push = Transition(rawValue: .push)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:15:23: warning: static property 'moveIn' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct Transition {
| `- note: consider making struct 'Transition' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | typealias RawValue = CATransitionType
14 | public static let fade = Transition(rawValue: .fade)
15 | public static let moveIn = Transition(rawValue: .moveIn)
| |- warning: static property 'moveIn' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'moveIn' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | public static let push = Transition(rawValue: .push)
17 | public static let reveal = Transition(rawValue: .reveal)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:16:23: warning: static property 'push' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct Transition {
| `- note: consider making struct 'Transition' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | typealias RawValue = CATransitionType
14 | public static let fade = Transition(rawValue: .fade)
15 | public static let moveIn = Transition(rawValue: .moveIn)
16 | public static let push = Transition(rawValue: .push)
| |- warning: static property 'push' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'push' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | public static let reveal = Transition(rawValue: .reveal)
18 | #else
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:17:23: warning: static property 'reveal' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct Transition {
| `- note: consider making struct 'Transition' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | typealias RawValue = CATransitionType
:
15 | public static let moveIn = Transition(rawValue: .moveIn)
16 | public static let push = Transition(rawValue: .push)
17 | public static let reveal = Transition(rawValue: .reveal)
| |- warning: static property 'reveal' is not concurrency-safe because non-'Sendable' type 'Transition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'reveal' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | #else
19 | typealias RawValue = String
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:32:23: warning: static property 'right' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
27 | }
28 |
29 | public struct TransitionSub {
| `- note: consider making struct 'TransitionSub' conform to the 'Sendable' protocol
30 | #if swift(>=4.2)
31 | typealias RawValue = CATransitionSubtype
32 | public static let right = TransitionSub(rawValue: .fromRight)
| |- warning: static property 'right' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'right' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
33 | public static let left = TransitionSub(rawValue: .fromLeft)
34 | public static let top = TransitionSub(rawValue: .fromTop)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:33:23: warning: static property 'left' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
27 | }
28 |
29 | public struct TransitionSub {
| `- note: consider making struct 'TransitionSub' conform to the 'Sendable' protocol
30 | #if swift(>=4.2)
31 | typealias RawValue = CATransitionSubtype
32 | public static let right = TransitionSub(rawValue: .fromRight)
33 | public static let left = TransitionSub(rawValue: .fromLeft)
| |- warning: static property 'left' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'left' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
34 | public static let top = TransitionSub(rawValue: .fromTop)
35 | public static let bottom = TransitionSub(rawValue: .fromBottom)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:34:23: warning: static property 'top' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
27 | }
28 |
29 | public struct TransitionSub {
| `- note: consider making struct 'TransitionSub' conform to the 'Sendable' protocol
30 | #if swift(>=4.2)
31 | typealias RawValue = CATransitionSubtype
32 | public static let right = TransitionSub(rawValue: .fromRight)
33 | public static let left = TransitionSub(rawValue: .fromLeft)
34 | public static let top = TransitionSub(rawValue: .fromTop)
| |- warning: static property 'top' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'top' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
35 | public static let bottom = TransitionSub(rawValue: .fromBottom)
36 | #else
/Users/admin/builder/spi-builder-workspace/Sica/Source/Transition.swift:35:23: warning: static property 'bottom' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
27 | }
28 |
29 | public struct TransitionSub {
| `- note: consider making struct 'TransitionSub' conform to the 'Sendable' protocol
30 | #if swift(>=4.2)
31 | typealias RawValue = CATransitionSubtype
:
33 | public static let left = TransitionSub(rawValue: .fromLeft)
34 | public static let top = TransitionSub(rawValue: .fromTop)
35 | public static let bottom = TransitionSub(rawValue: .fromBottom)
| |- warning: static property 'bottom' is not concurrency-safe because non-'Sendable' type 'TransitionSub' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'bottom' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
36 | #else
37 | typealias RawValue = String
/Users/admin/builder/spi-builder-workspace/Sica/Source/View+Sica.swift:11:13: warning: let '_animatorAssociatedKey' is not concurrency-safe because non-'Sendable' type 'UnsafeMutablePointer<UInt>' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import Foundation
10 |
11 | private let _animatorAssociatedKey = UnsafeMutablePointer<UInt>.allocate(capacity: 1)
| |- warning: let '_animatorAssociatedKey' is not concurrency-safe because non-'Sendable' type 'UnsafeMutablePointer<UInt>' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate '_animatorAssociatedKey' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
12 |
13 | extension View {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
[11/11] Compiling Sica Animator.swift
/Users/admin/builder/spi-builder-workspace/Sica/Source/FillMode.swift:15:23: warning: static property 'forwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
10 | import QuartzCore
11 |
12 | public struct FillMode {
| `- note: consider making struct 'FillMode' conform to the 'Sendable' protocol
13 | #if swift(>=4.2)
14 | typealias RawValue = CAMediaTimingFillMode
15 | public static let forwards = FillMode(rawValue: .forwards)
| |- warning: static property 'forwards' is not concurrency-safe because non-'Sendable' type 'FillMode' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'forwards' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | public static let backwards = FillMode(rawValue: .backwards)
17 | public static let both = FillMode(rawValue: .both)
/Users/admin/builder/spi-builder-workspace/Sica/Source/TimingFunction.swift:14:23: warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
9 | import QuartzCore
10 |
11 | public struct TimingFunction {
| `- note: consider making struct 'TimingFunction' conform to the 'Sendable' protocol
12 | #if swift(>=4.2)
13 | public typealias NameValue = CAMediaTimingFunctionName
14 | public static let `default` = TimingFunction(name: CAMediaTimingFunctionName.default)
| |- warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'TimingFunction' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'default' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
15 | public static let linear = TimingFunction(name: CAMediaTimingFunctionName.linear)
16 | public static let easeIn = TimingFunction(name: CAMediaTimingFunctionName.easeIn)
/Users/admin/builder/spi-builder-workspace/Sica/Source/Animator.swift:45:14: warning: main actor-isolated property 'wantsLayer' can not be mutated from a nonisolated context; this is an error in the Swift 6 language mode
43 | self.layer = view.layer
44 | #elseif os(macOS)
45 | view.wantsLayer = true
| `- warning: main actor-isolated property 'wantsLayer' can not be mutated from a nonisolated context; this is an error in the Swift 6 language mode
46 | if let layer = view.layer {
47 | self.layer = layer
AppKit.NSView:270:25: note: mutation of this property is only permitted within the actor
268 | open var layerContentsPlacement: NSView.LayerContentsPlacement { get set }
269 | @available(macOS 10.5, *)
270 | @MainActor open var wantsLayer: Bool { get set }
| `- note: mutation of this property is only permitted within the actor
271 | @available(macOS 10.5, *)
272 | open var layer: CALayer? { get set }
/Users/admin/builder/spi-builder-workspace/Sica/Source/Animator.swift:46:29: warning: main actor-isolated property 'layer' can not be referenced from a nonisolated context; this is an error in the Swift 6 language mode
44 | #elseif os(macOS)
45 | view.wantsLayer = true
46 | if let layer = view.layer {
| `- warning: main actor-isolated property 'layer' can not be referenced from a nonisolated context; this is an error in the Swift 6 language mode
47 | self.layer = layer
48 | } else {
AppKit.NSView:272:14: note: property declared here
270 | @MainActor open var wantsLayer: Bool { get set }
271 | @available(macOS 10.5, *)
272 | open var layer: CALayer? { get set }
| `- note: property declared here
273 | @available(macOS 10.8, *)
274 | open var wantsUpdateLayer: Bool { get }
Build complete! (13.23s)
Build complete.
{
"dependencies" : [
],
"manifest_display_name" : "Sica",
"name" : "Sica",
"path" : "/Users/admin/builder/spi-builder-workspace",
"platforms" : [
{
"name" : "ios",
"version" : "9.0"
},
{
"name" : "macos",
"version" : "10.10"
},
{
"name" : "tvos",
"version" : "10.0"
}
],
"products" : [
{
"name" : "Sica",
"targets" : [
"Sica"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"swift_languages_versions" : [
"4.2",
"5"
],
"targets" : [
{
"c99name" : "Sica",
"module_type" : "SwiftTarget",
"name" : "Sica",
"path" : "Sica/Source",
"product_memberships" : [
"Sica"
],
"sources" : [
"AnimationKeyPaths.swift",
"Animator.swift",
"CAAnimation+Extension.swift",
"CALayer+Sica.swift",
"FillMode.swift",
"TimingFunction.swift",
"Transition.swift",
"View+Sica.swift"
],
"type" : "library"
}
],
"tools_version" : "5.1"
}
Done.