IanKeen

public protocol DynamicProperties: AnyObject {
    subscript<T>(dynamic key: String) -> T? { get set }
}

private extension String {
    var unsafePointer: UnsafeRawPointer {
        return UnsafeRawPointer(bitPattern: hashValue)!
    }
}
extension DynamicProperties {

IanKeen

import Observation

public protocol _Observable: Observable {
    nonisolated
    func _access<Member>(keyPath: KeyPath<Self, Member>)

    nonisolated
    func _withMutation<Member, MutationResult>(
        keyPath: KeyPath<Self, Member>,
        _ mutation: () throws -> MutationResult

IanKeen

@propertyWrapper
public struct AllowDecodingFailure<T: Codable>: Codable {
    public var wrappedValue: T?
    public var error: Error?
    public var projectedValue: AllowDecodingFailure<T> { self }

    public init(wrappedValue: T?) {
        self.wrappedValue = wrappedValue
        self.error = nil
    }

IanKeen

@propertyWrapper
public struct AllowDecodingFailures<T: Codable>: Codable {
    public var wrappedValue: [T]
    public var errors: [Error]
    public var projectedValue: AllowDecodingFailures<T> { self }

    private struct Empty: Decodable { }

    public init(wrappedValue: [T]) {
        self.init(wrappedValue: wrappedValue, errors: [])

IanKeen

@propertyWrapper @MainActor public struct AsyncPublished<Value> {
    public typealias AsyncAction = (Value) async throws -> Void

    private class State {
        var wrappedValue: Value
        var isWorking: Bool = false
        var current: Task<Void, Never>?
        var action: AsyncAction = { _ in fatalError("Please configure action in parent object") }

        init(wrappedValue: Value) {

IanKeen

public protocol AnalyticsReducer {
    associatedtype State
    associatedtype Action

    func analytics(before: State, after: State, action: Action) -> Effect<Action>
}

public struct _AnalyticsReducer<Base: Reducer, Analytics: AnalyticsReducer>: Reducer where Analytics.State == Base.State, Analytics.Action == Base.Action {
    @usableFromInline
    let base: Base

IanKeen

struct ReadSpacing<Content: View>: View {
    @State private var spacing: CGFloat = 0
    @Binding private var outsideSpacing: CGFloat?
    private let content: (CGFloat) -> Content

    init(@ViewBuilder content: @escaping (CGFloat) -> Content) {
        self._outsideSpacing = .constant(nil)
        self.content = content
    }
    init(into spacing: Binding<CGFloat>, @ViewBuilder content: @escaping () -> Content) {

IanKeen

// MARK: - TCAView
public protocol TCAView: View where Body == WithViewStore<ScopedState, ScopedAction, Content> {
    associatedtype ViewState
    associatedtype ViewAction

    associatedtype ScopedState
    associatedtype ScopedAction

    associatedtype Content

IanKeen

struct Invalidation {
    static let display = Invalidation { $0.setNeedsDisplay() }
    static let layout = Invalidation { $0.setNeedsLayout() }

    let action: (UIView) -> Void
}

@propertyWrapper
struct Invalidating<Value> {
    private let invalidations: [Invalidation]

IanKeen

struct Parent: View {
	@State private var foo = "foo" {
		didSet { print("Parent", foo) }
	}

	var body: some View {
		VStack {
			Inner(value: foo)
      
			Button("Parent Double") {