398 lines
14 KiB
Swift
398 lines
14 KiB
Swift
//
|
|
// Property.swift
|
|
// Meta
|
|
//
|
|
// Created by david-swift on 12.09.24.
|
|
//
|
|
|
|
/// Assign an updating closure to a widget's property.
|
|
///
|
|
/// This will be used if you do not provide a custom ``Widget/update(_:data:updateProperties:type:)`` method
|
|
/// or call the ``Widget/updateProperties(_:updateProperties:)`` method in your custom update method.
|
|
@propertyWrapper
|
|
public struct Property<Value, Pointer>: PropertyProtocol where Value: Sendable {
|
|
|
|
/// The function applying the property to the UI.
|
|
public var setProperty: @Sendable (Pointer, Value, ViewStorage) async -> Void
|
|
/// The wrapped value.
|
|
public var wrappedValue: Value
|
|
/// The update strategy.
|
|
public var updateStrategy: UpdateStrategy
|
|
|
|
/// Initialize a property.
|
|
/// - Parameters:
|
|
/// - wrappedValue: The wrapped value.
|
|
/// - setProperty: The function applying the property to the UI.
|
|
/// - pointer: The type of the pointer.
|
|
/// - updateStrategy: The update strategy, this should be ``UpdateStrategy/automatic`` in most cases.
|
|
public init(
|
|
wrappedValue: Value,
|
|
set setProperty: @Sendable @escaping (Pointer, Value, ViewStorage) async -> Void,
|
|
pointer: Pointer.Type,
|
|
updateStrategy: UpdateStrategy = .automatic
|
|
) {
|
|
self.setProperty = setProperty
|
|
self.wrappedValue = wrappedValue
|
|
self.updateStrategy = updateStrategy
|
|
}
|
|
|
|
/// Initialize a property.
|
|
/// - Parameters:
|
|
/// - wrappedValue: The wrapped value.
|
|
/// - setProperty: The function applying the property to the UI.
|
|
/// - pointer: The type of the pointer.
|
|
/// - updateStrategy: The update strategy, this should be ``UpdateStrategy/automatic`` in most cases.
|
|
public init(
|
|
wrappedValue: Value,
|
|
set setProperty: @Sendable @escaping (Pointer, Value) async -> Void,
|
|
pointer: Pointer.Type,
|
|
updateStrategy: UpdateStrategy = .automatic
|
|
) {
|
|
self.init(
|
|
wrappedValue: wrappedValue,
|
|
set: { pointer, value, _ in await setProperty(pointer, value) },
|
|
pointer: pointer,
|
|
updateStrategy: updateStrategy
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
extension Property where Value: OptionalProtocol {
|
|
|
|
/// Initialize a property.
|
|
/// - Parameters:
|
|
/// - setProperty: The function applying the property to the UI.
|
|
/// - pointer: The type of the pointer.
|
|
/// - updateStrategy: The update strategy, this should be ``UpdateStrategy/automatic`` in most cases.
|
|
public init(
|
|
set setProperty: @Sendable @escaping (Pointer, Value.Wrapped, ViewStorage) async -> Void,
|
|
pointer: Pointer.Type,
|
|
updateStrategy: UpdateStrategy = .automatic
|
|
) {
|
|
self.setProperty = { pointer, value, storage in
|
|
if let value = value.optionalValue {
|
|
await setProperty(pointer, value, storage)
|
|
}
|
|
}
|
|
wrappedValue = nil
|
|
self.updateStrategy = updateStrategy
|
|
}
|
|
|
|
/// Initialize a property.
|
|
/// - Parameters:
|
|
/// - wrappedValue: The wrapped value.
|
|
/// - setProperty: The function applying the property to the UI.
|
|
/// - pointer: The type of the pointer.
|
|
/// - updateStrategy: The update strategy, this should be ``UpdateStrategy/automatic`` in most cases.
|
|
public init(
|
|
set setProperty: @Sendable @escaping (Pointer, Value.Wrapped) async -> Void,
|
|
pointer: Pointer.Type,
|
|
updateStrategy: UpdateStrategy = .automatic
|
|
) {
|
|
self.init(
|
|
set: { pointer, value, _ in await setProperty(pointer, value) },
|
|
pointer: pointer,
|
|
updateStrategy: updateStrategy
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
/// The property protocol.
|
|
protocol PropertyProtocol: Sendable {
|
|
|
|
/// The type of the wrapped value.
|
|
associatedtype Value
|
|
/// The type of the view's pointer.
|
|
associatedtype Pointer
|
|
|
|
/// The wrapped value.
|
|
var wrappedValue: Value { get }
|
|
/// Set the property.
|
|
var setProperty: @Sendable (Pointer, Value, ViewStorage) async -> Void { get }
|
|
/// The update strategy.
|
|
var updateStrategy: UpdateStrategy { get }
|
|
|
|
}
|
|
|
|
/// The update strategy for properties.
|
|
public enum UpdateStrategy: Sendable {
|
|
|
|
/// If equatable, update only when the value changed.
|
|
/// If not equatable, this is equivalent to ``UpdateStrategy/always``.
|
|
case automatic
|
|
/// Update always when an update is triggered.
|
|
case always
|
|
/// Update always when a state value in a parent view changed,
|
|
/// regardless of the property's value.
|
|
case alwaysWhenStateUpdate
|
|
|
|
}
|
|
|
|
extension Widget {
|
|
|
|
/// The view storage.
|
|
/// - Parameters:
|
|
/// - data: Modify views before being updated.
|
|
/// - type: The view render data type.
|
|
/// - Returns: The view storage.
|
|
public func container<Data>(
|
|
data: WidgetData,
|
|
type: Data.Type
|
|
) async -> ViewStorage where Data: ViewRenderData {
|
|
let storage = ViewStorage(initializeWidget())
|
|
await initProperties(storage, data: data, type: type)
|
|
await update(storage, data: data, updateProperties: true, type: type)
|
|
return storage
|
|
}
|
|
|
|
/// Update the stored content.
|
|
/// - Parameters:
|
|
/// - storage: The storage to update.
|
|
/// - data: Modify views before being updated
|
|
/// - updateProperties: Whether to update the view's properties.
|
|
/// - type: The view render data type.
|
|
///
|
|
/// This is the default implementation which requires the usage of ``Property``.
|
|
public func update<Data>(
|
|
_ storage: ViewStorage,
|
|
data: WidgetData,
|
|
updateProperties: Bool,
|
|
type: Data.Type
|
|
) async where Data: ViewRenderData {
|
|
await self.updateProperties(storage, data: data, updateProperties: updateProperties, type: type)
|
|
if updateProperties {
|
|
await storage.setPreviousState(self)
|
|
}
|
|
}
|
|
|
|
/// Initialize the properties wrapped with ``Property``.
|
|
/// - Parameters:
|
|
/// - storage: The view storage.
|
|
/// - data: Modify views before being updated.
|
|
/// - type: The view render data type.
|
|
public func initProperties<Data>(
|
|
_ storage: ViewStorage,
|
|
data: WidgetData,
|
|
type: Data.Type
|
|
) async where Data: ViewRenderData {
|
|
let mirror = Mirror(reflecting: self)
|
|
for property in mirror.children {
|
|
if let value = property.value as? any ViewPropertyProtocol {
|
|
let subview = await value.wrappedValue.storage(data: data, type: type)
|
|
await initViewProperty(value, view: subview, parent: storage)
|
|
await storage.setContent(key: property.label ?? .mainContent, value: [subview])
|
|
}
|
|
if let value = property.value as? any BindingPropertyProtocol {
|
|
await initBindingProperty(value, parent: storage)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Initialize the properties wrapped with ``ViewProperty``.
|
|
/// - Parameters:
|
|
/// - value: The property.
|
|
/// - view: The subview's view storage.
|
|
/// - parent: The parent's view storage.
|
|
func initViewProperty<Property>(
|
|
_ value: Property,
|
|
view: ViewStorage,
|
|
parent: ViewStorage
|
|
) async where Property: ViewPropertyProtocol {
|
|
if let view = await view.pointer as? Property.ViewPointer,
|
|
let pointer = await parent.pointer as? Property.Pointer {
|
|
await value.setView(pointer, view)
|
|
}
|
|
}
|
|
|
|
/// Initialize a binding property.
|
|
/// - Parameters:
|
|
/// - value: The property.
|
|
/// - parent: The view storage.
|
|
func initBindingProperty<Property>(
|
|
_ value: Property,
|
|
parent: ViewStorage
|
|
) async where Property: BindingPropertyProtocol {
|
|
if let view = await parent.pointer as? Property.Pointer {
|
|
await value.observe(
|
|
view,
|
|
.init {
|
|
value.wrappedValue.wrappedValue
|
|
} set: { newValue in
|
|
if let compareValue = newValue as? any Equatable,
|
|
!equal(value.wrappedValue.wrappedValue, compareValue) {
|
|
value.wrappedValue.wrappedValue = newValue
|
|
}
|
|
},
|
|
parent
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Update the properties wrapped with ``Property``.
|
|
/// - Parameters:
|
|
/// - storage: The storage to update.
|
|
/// - data: The widget data.
|
|
/// - updateProperties: Whether to update the view's properties.
|
|
/// - type: The view render data type.
|
|
public func updateProperties<Data>(
|
|
_ storage: ViewStorage,
|
|
data: WidgetData,
|
|
updateProperties: Bool,
|
|
type: Data.Type
|
|
) async where Data: ViewRenderData {
|
|
let mirror = Mirror(reflecting: self)
|
|
await updateNotEquatable(
|
|
mirror: mirror,
|
|
storage: storage,
|
|
data: data,
|
|
updateProperties: updateProperties,
|
|
type: type
|
|
)
|
|
guard updateProperties else {
|
|
return
|
|
}
|
|
await updateAlwaysWhenStateUpdate(mirror: mirror, storage: storage)
|
|
await updateEquatable(mirror: mirror, storage: storage)
|
|
}
|
|
|
|
/// Update the properties which are not equatable and should always be updated (e.g. closures).
|
|
/// - Parameters:
|
|
/// - mirror: A mirror of the widget.
|
|
/// - storage: The view storage.
|
|
/// - data: The widget data.
|
|
/// - updateProperties: Whether to update the properties.
|
|
/// - type: The view render data type.
|
|
func updateNotEquatable<Data>(
|
|
mirror: Mirror,
|
|
storage: ViewStorage,
|
|
data: WidgetData,
|
|
updateProperties: Bool,
|
|
type: Data.Type
|
|
) async where Data: ViewRenderData {
|
|
for property in mirror.children {
|
|
if let value = property.value as? any PropertyProtocol {
|
|
if value.updateStrategy == .always ||
|
|
value.wrappedValue as? any Equatable == nil && value.updateStrategy != .alwaysWhenStateUpdate {
|
|
await setProperty(property: value, storage: storage)
|
|
}
|
|
}
|
|
if let value = property.value as? any ViewPropertyProtocol,
|
|
let storage = await storage.getContent(key: property.label ?? .mainContent).first {
|
|
await value.wrappedValue
|
|
.updateStorage(storage, data: data, updateProperties: updateProperties, type: type)
|
|
}
|
|
if let value = property.value as? any BindingPropertyProtocol {
|
|
await setBindingProperty(property: value, storage: storage)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Update the properties which should always be updated when a state property changed
|
|
/// (e.g. "regular" properties which are not equatable).
|
|
/// - Parameters:
|
|
/// - mirror: A mirror of the widget.
|
|
/// - storage: The view storage.
|
|
///
|
|
/// Initialize the ``Property`` property wrapper with the ``UpdateStrategy/alwaysWhenStateUpdate``.
|
|
func updateAlwaysWhenStateUpdate(mirror: Mirror, storage: ViewStorage) async {
|
|
for property in mirror.children {
|
|
if let value = property.value as? any PropertyProtocol {
|
|
if value.updateStrategy == .alwaysWhenStateUpdate {
|
|
await setProperty(property: value, storage: storage)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Update equatable properties (most properties).
|
|
/// - Parameters:
|
|
/// - mirror: A mirror of the widget.
|
|
/// - storage: The view storage.
|
|
func updateEquatable(mirror: Mirror, storage: ViewStorage) async {
|
|
let previousState: Mirror.Children? = if let previousState = await storage.previousState {
|
|
Mirror(reflecting: previousState).children
|
|
} else {
|
|
nil
|
|
}
|
|
for property in mirror.children {
|
|
if let value = property.value as? any PropertyProtocol,
|
|
value.updateStrategy == .automatic,
|
|
let wrappedValue = value.wrappedValue as? any Equatable {
|
|
var update = true
|
|
if let previous = previousState?.first(where: { previousProperty in
|
|
previousProperty.label == property.label
|
|
})?.value as? any PropertyProtocol,
|
|
equal(previous, wrappedValue) {
|
|
update = false
|
|
}
|
|
if update {
|
|
await setProperty(property: value, storage: storage)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Check whether a property is equal to a value.
|
|
/// - Parameters:
|
|
/// - property: The property.
|
|
/// - value: The value.
|
|
/// - Returns: Whether the property and value are equal.
|
|
func equal<Property, Value>(
|
|
_ property: Property,
|
|
_ value: Value
|
|
) -> Bool where Property: PropertyProtocol, Value: Equatable {
|
|
equal(property.wrappedValue, value)
|
|
}
|
|
|
|
/// Check whether a value is equal to another value.
|
|
/// - Parameters:
|
|
/// - value1: The first value.
|
|
/// - value2: The second value.
|
|
/// - Returns: Whether the values are equal.
|
|
func equal<Value1, Value2>(
|
|
_ value1: Value1,
|
|
_ value2: Value2
|
|
) -> Bool where Value2: Equatable {
|
|
if let value1 = value1 as? Value2 {
|
|
return value1 == value2
|
|
}
|
|
return false
|
|
}
|
|
|
|
/// Apply a property to the framework.
|
|
/// - Parameters:
|
|
/// - property: The property.
|
|
/// - storage: The view storage.
|
|
func setProperty<Property>(property: Property, storage: ViewStorage) async where Property: PropertyProtocol {
|
|
if let optional = property.wrappedValue as? any OptionalProtocol, optional.optionalValue == nil {
|
|
return
|
|
}
|
|
if let pointer = await storage.pointer as? Property.Pointer {
|
|
await property.setProperty(pointer, property.wrappedValue, storage)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/// A protocol for values which can be optional.
|
|
public protocol OptionalProtocol: ExpressibleByNilLiteral {
|
|
|
|
/// The type of the wrapped value.
|
|
associatedtype Wrapped
|
|
|
|
/// The value.
|
|
var optionalValue: Wrapped? { get }
|
|
|
|
}
|
|
|
|
extension Optional: OptionalProtocol {
|
|
|
|
/// The optional value.
|
|
public var optionalValue: Wrapped? {
|
|
self
|
|
}
|
|
|
|
}
|