react-native-list 1.0.0 → 2.0.0-alpha.1

package/ios/DataSource/HybridNativeListDataSource.swift

@@ -0,0 +1,213 @@
+import DifferenceKit
+import Foundation
+import NitroModules
+
+final class DiffableListItem: Differentiable {
+    typealias DifferenceIdentifier = String
+
+    let nativeItem: NativeListItem
+    private let contentEqual: (NativeListItem, NativeListItem) -> Bool
+
+    init(
+        nativeItem: NativeListItem,
+        contentEqual: @escaping (NativeListItem, NativeListItem) -> Bool
+    ) {
+        self.nativeItem = nativeItem
+        self.contentEqual = contentEqual
+    }
+
+    var differenceIdentifier: String {
+        return nativeItem.type + ":" + nativeItem.key
+    }
+
+    func isContentEqual(to source: DiffableListItem) -> Bool {
+        if nativeItem.type != source.nativeItem.type {
+            return false
+        }
+        if nativeItem.width != source.nativeItem.width {
+            return false
+        }
+        if nativeItem.height != source.nativeItem.height {
+            return false
+        }
+        return contentEqual(source.nativeItem, nativeItem)
+    }
+}
+
+protocol NativeListDataSourceObserver: AnyObject {
+    func dataSourceDidReload(
+        _ dataSource: HybridNativeListDataSource,
+        animated: Bool,
+        changeset: StagedChangeset<[DiffableListItem]>?
+    )
+    func dataSourceDidInsert(_ dataSource: HybridNativeListDataSource, index: Int)
+    func dataSourceDidUpdate(
+        _ dataSource: HybridNativeListDataSource,
+        index: Int,
+        previousItem: NativeListItem
+    )
+    func dataSourceDidRemove(
+        _ dataSource: HybridNativeListDataSource,
+        index: Int,
+        removedItem: NativeListItem
+    )
+    func dataSourceDidMove(_ dataSource: HybridNativeListDataSource, fromIndex: Int, toIndex: Int)
+}
+
+class HybridNativeListDataSource: HybridNativeListDataSourceSpec {
+    weak var observer: NativeListDataSourceObserver?
+    private var items: [DiffableListItem] = []
+    private var pendingTargetItems: [DiffableListItem]?
+    private var animatedReloadSourceItems: [DiffableListItem]?
+    private var contentEqual: (NativeListItem, NativeListItem) -> Bool = { _, _ in false }
+
+    func dispose() {
+        observer = nil
+        items.removeAll()
+        pendingTargetItems = nil
+        animatedReloadSourceItems = nil
+        contentEqual = { _, _ in false }
+    }
+
+    func setContentEqualCallback(
+        isContentEqual: @escaping (NativeListItem, NativeListItem) -> Bool
+    ) throws {
+        contentEqual = isContentEqual
+    }
+
+    func replaceData(items newItems: [NativeListItem], animated: Bool) throws {
+        let targetItems = wrap(newItems)
+        guard animated, observer != nil else {
+            pendingTargetItems = nil
+            animatedReloadSourceItems = nil
+            items = targetItems
+            observer?.dataSourceDidReload(self, animated: false, changeset: nil)
+            return
+        }
+
+        animatedReloadSourceItems = items
+        let changeset = StagedChangeset(source: items, target: targetItems)
+        guard !changeset.isEmpty else {
+            pendingTargetItems = nil
+            animatedReloadSourceItems = nil
+            items = targetItems
+            observer?.dataSourceDidReload(self, animated: false, changeset: nil)
+            return
+        }
+
+        pendingTargetItems = targetItems
+        observer?.dataSourceDidReload(self, animated: true, changeset: changeset)
+    }
+
+    func insertItem(index: Double, item: NativeListItem) throws {
+        let itemIndex = validInsertionIndex(index)
+        let wrappedItem = wrap(item)
+        items.insert(wrappedItem, at: itemIndex)
+        observer?.dataSourceDidInsert(self, index: itemIndex)
+    }
+
+    func updateItem(index: Double, item: NativeListItem) throws {
+        let itemIndex = validExistingIndex(index)
+        let previousItem = items[itemIndex].nativeItem
+        let wrappedItem = wrap(item)
+        items[itemIndex] = wrappedItem
+        observer?.dataSourceDidUpdate(self, index: itemIndex, previousItem: previousItem)
+    }
+
+    func removeItem(index: Double) throws {
+        let itemIndex = validExistingIndex(index)
+        let removedItem = items.remove(at: itemIndex).nativeItem
+        observer?.dataSourceDidRemove(self, index: itemIndex, removedItem: removedItem)
+    }
+
+    func moveItem(fromIndex: Double, toIndex: Double) throws {
+        let sourceIndex = validExistingIndex(fromIndex)
+        let targetIndex = validExistingIndex(toIndex)
+        let item = items.remove(at: sourceIndex)
+        items.insert(item, at: targetIndex)
+        observer?.dataSourceDidMove(self, fromIndex: sourceIndex, toIndex: targetIndex)
+    }
+
+    func getCount() throws -> Double {
+        return Double(items.count)
+    }
+
+    func getItem(index: Double) throws -> NativeListItem {
+        let itemIndex = validExistingIndex(index)
+        return item(at: itemIndex)
+    }
+
+    func item(at index: Int) -> NativeListItem {
+        return items[index].nativeItem
+    }
+
+    func itemForCollectionViewQuery(at index: Int) -> NativeListItem {
+        if items.indices.contains(index) {
+            return items[index].nativeItem
+        }
+
+        // During DifferenceKit staged reloads, UICollectionViewFlowLayout can still ask for
+        // sizing information from the pre-animation snapshot after the stage data was applied.
+        if let animatedReloadSourceItems, animatedReloadSourceItems.indices.contains(index) {
+            return animatedReloadSourceItems[index].nativeItem
+        }
+
+        preconditionFailure("List item index \(index) is out of bounds for collection view query.")
+    }
+
+    func replaceWrappedItemsFromCollectionView(_ nextItems: [DiffableListItem]) {
+        items = nextItems
+
+        guard let pendingTargetItems else {
+            animatedReloadSourceItems = nil
+            return
+        }
+
+        if hasSameIdentity(nextItems, pendingTargetItems) {
+            self.pendingTargetItems = nil
+            animatedReloadSourceItems = nil
+        }
+    }
+
+    func itemsForPremeasurement() -> [NativeListItem] {
+        let sourceItems = pendingTargetItems ?? items
+        return sourceItems.map { item in
+            item.nativeItem
+        }
+    }
+
+    private func wrap(_ item: NativeListItem) -> DiffableListItem {
+        return DiffableListItem(nativeItem: item, contentEqual: contentEqual)
+    }
+
+    private func wrap(_ nativeItems: [NativeListItem]) -> [DiffableListItem] {
+        return nativeItems.map { item in
+            wrap(item)
+        }
+    }
+
+    private func hasSameIdentity(
+        _ firstItems: [DiffableListItem],
+        _ secondItems: [DiffableListItem]
+    ) -> Bool {
+        if firstItems.count != secondItems.count {
+            return false
+        }
+
+        return zip(firstItems, secondItems).allSatisfy { firstItem, secondItem in
+            return firstItem.differenceIdentifier == secondItem.differenceIdentifier
+        }
+    }
+
+    private func validExistingIndex(_ value: Double) -> Int {
+        let index = Int(value)
+        precondition(index >= 0 && index < items.count, "List index \(index) is out of bounds.")
+        return index
+    }
+
+    private func validInsertionIndex(_ value: Double) -> Int {
+        let index = Int(value)
+        precondition(index >= 0 && index <= items.count, "List index \(index) is out of bounds.")
+        return index
+    }
+}

package/ios/HybridObjects/HybridUiListModule.swift

@@ -0,0 +1,49 @@
+//
+//  HybridUiListModule.swift
+//  ReactNativeList
+//
+//  Created by Hanno Gödecke on 14.02.26.
+//
+
+import Foundation
+import NitroModules
+
+class HybridUiListModule : HybridUiListModuleSpec {
+    func iosGetWorkletsModule() throws -> any HybridIOSWorkletsModuleProxyHolderSpec {
+        do {
+            let holderBox = try TurboModuleInstaller.createWorkletsModuleProxyHolder()
+            return HybridIOSWorkletsModuleProxyHolder(holderBox: holderBox)
+        } catch {
+            throw RuntimeError.error(withMessage: String(describing: error))
+        }
+    }
+
+    func setupRuntime(workletsModuleHolder: Variant_NullType__any_HybridIOSWorkletsModuleProxyHolderSpec_?) throws {
+        if (!Thread.isMainThread) {
+            throw RuntimeError.error(withMessage: "setupRuntime() must be called from UI thread!")
+        }
+
+        guard let workletsModuleHolder else {
+            throw RuntimeError.error(withMessage: "setupRuntime() requires IOSWorkletsModuleProxyHolder on iOS.")
+        }
+
+        let holder: HybridIOSWorkletsModuleProxyHolder
+        switch workletsModuleHolder {
+        case .first:
+            throw RuntimeError.error(withMessage: "setupRuntime() received null holder on iOS.")
+        case .second(let anyHolder):
+            guard let concreteHolder = anyHolder as? HybridIOSWorkletsModuleProxyHolder else {
+                throw RuntimeError.error(withMessage: "setupRuntime() received unexpected holder type.")
+            }
+            holder = concreteHolder
+        }
+
+        do {
+            _ = try TurboModuleInstaller.installNativeModuleProxyInUIRuntime(withHolder: holder.holderBox)
+            _ = try TurboModuleInstaller.setupEventInterceptor()
+        } catch {
+            let message = String(describing: error)
+            throw RuntimeError.error(withMessage: message)
+        }
+    }
+}

package/ios/HybridObjects/HybridViewHolder.swift

@@ -0,0 +1,16 @@
+//
+//  HybridVIewHolder.swift
+//  ReactNativeList
+//
+//  Created by Hanno Gödecke on 14.02.26.
+//
+
+import Foundation
+
+class HybridViewHolder : HybridViewHolderSpec {
+    var view: UIView = UIView()
+    
+    typealias ViewType = UIView
+    
+    
+}

package/ios/Layout/HybridNativeListLayout.swift

@@ -0,0 +1,128 @@
+import NitroModules
+import UIKit
+
+class HybridNativeListLayout: HybridNativeListLayoutSpec {}
+
+protocol NativeListLayoutProviding: AnyObject {
+    func makeCollectionViewLayout(owner: HybridUiListView) -> UICollectionViewLayout
+    func layoutSize(contentSize: CGSize) -> CGSize
+    func itemContentInset() -> UIEdgeInsets
+    func estimatedContentWidth(collectionViewWidth: CGFloat, viewWidth: CGFloat) -> CGFloat
+    func estimatedContentHeight(collectionViewHeight: CGFloat, viewHeight: CGFloat) -> CGFloat
+}
+
+class HybridNativeLinearListLayout: HybridNativeLinearListLayoutSpec, NativeListLayoutProviding {
+    private var topInset: CGFloat = 16
+    private var bottomInset: CGFloat = 16
+    private var itemSpacing: CGFloat = 12
+    private var itemHorizontalInset: CGFloat = 0
+    private var itemVerticalInset: CGFloat = 0
+    private var estimatedItemWidth: CGFloat?
+    private var estimatedItemHeight: CGFloat?
+
+    func dispose() {
+        topInset = 16
+        bottomInset = 16
+        itemSpacing = 12
+        itemHorizontalInset = 0
+        itemVerticalInset = 0
+        estimatedItemWidth = nil
+        estimatedItemHeight = nil
+    }
+
+    func setConfig(config: NativeLinearListLayoutConfig) throws {
+        topInset = CGFloat(config.topInset)
+        bottomInset = CGFloat(config.bottomInset)
+        itemSpacing = CGFloat(config.itemSpacing)
+        itemHorizontalInset = CGFloat(config.itemHorizontalInset)
+        itemVerticalInset = CGFloat(config.itemVerticalInset)
+
+        let estimatedItemSize = config.iosConfig?.estimatedItemSize
+        if let width = estimatedItemSize?.width {
+            estimatedItemWidth = CGFloat(width)
+        } else {
+            estimatedItemWidth = nil
+        }
+
+        if let height = estimatedItemSize?.height {
+            estimatedItemHeight = CGFloat(height)
+        } else {
+            estimatedItemHeight = nil
+        }
+    }
+
+    func makeCollectionViewLayout(owner: HybridUiListView) -> UICollectionViewLayout {
+        let layout = UICollectionViewFlowLayout()
+        layout.scrollDirection = .vertical
+        layout.minimumLineSpacing = itemSpacing
+        layout.minimumInteritemSpacing = 0
+        layout.sectionInset = UIEdgeInsets(
+            top: topInset,
+            left: 0,
+            bottom: bottomInset,
+            right: 0
+        )
+        // FlowLayout owns the vertical offset bookkeeping; we only provide measured sizes.
+        layout.estimatedItemSize = .zero
+        return layout
+    }
+
+    func layoutSize(contentSize: CGSize) -> CGSize {
+        let width = ceil(contentSize.width + itemHorizontalInset * 2)
+        let height = ceil(contentSize.height + itemVerticalInset * 2)
+        return CGSize(width: width, height: height)
+    }
+
+    func itemContentInset() -> UIEdgeInsets {
+        return UIEdgeInsets(
+            top: itemVerticalInset,
+            left: itemHorizontalInset,
+            bottom: itemVerticalInset,
+            right: itemHorizontalInset
+        )
+    }
+
+    func estimatedContentWidth(collectionViewWidth: CGFloat, viewWidth: CGFloat) -> CGFloat {
+        // FlowLayout may ask for sizes before a cell has rendered. A user-provided
+        // estimate is only used for that first pass; measured and explicit item sizes
+        // are resolved by HybridUiListView before this fallback is reached.
+        if let estimatedItemWidth, estimatedItemWidth.isFinite, estimatedItemWidth > 0 {
+            return estimatedItemWidth
+        }
+
+        let availableWidth = collectionViewWidth - itemHorizontalInset * 2
+        if availableWidth.isFinite && availableWidth > 0 {
+            return availableWidth
+        }
+
+        let fallbackWidth = viewWidth - itemHorizontalInset * 2
+        if fallbackWidth.isFinite && fallbackWidth > 0 {
+            return fallbackWidth
+        }
+
+        return 1
+    }
+
+    func estimatedContentHeight(collectionViewHeight: CGFloat, viewHeight: CGFloat) -> CGFloat {
+        // Keep the built-in fallback finite so FlowLayout can place initial cells,
+        // then let real measurements replace it after cells bind their content.
+        if let estimatedItemHeight, estimatedItemHeight.isFinite, estimatedItemHeight > 0 {
+            return estimatedItemHeight
+        }
+
+        if collectionViewHeight.isFinite && collectionViewHeight > 0 {
+            return collectionViewHeight / 2
+        }
+
+        if viewHeight.isFinite && viewHeight > 0 {
+            return viewHeight / 2
+        }
+
+        let screenHeight = UIScreen.main.bounds.height
+        if screenHeight.isFinite && screenHeight > 0 {
+            return screenHeight / 2
+        }
+
+        return 120
+    }
+}

package/ios/Utils/ErrorUtils.h

@@ -0,0 +1,26 @@
+//
+//  ErrorUtils.h
+//  ReactNativeList
+//
+//  Created by Hanno Gödecke on 15.02.26.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString *const kInstallerErrorDomain = @"ReactNativeList.HybridUiListTurboModuleInstaller";
+
+inline void assignError(NSError *__autoreleasing _Nullable *error, NSString *message)
+{
+  if (error == nil) {
+    return;
+  }
+
+  *error = [NSError errorWithDomain:kInstallerErrorDomain
+                               code:1
+                           userInfo:@{
+                             NSLocalizedDescriptionKey : message,
+                           }];
+}
+NS_ASSUME_NONNULL_END

package/ios/Utils/HybridIOSWorkletsModuleProxyHolder.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+class HybridIOSWorkletsModuleProxyHolder: HybridIOSWorkletsModuleProxyHolderSpec {
+    let holderBox: HybridWorkletsModuleProxyHolderBox
+
+    init(holderBox: HybridWorkletsModuleProxyHolderBox) {
+        self.holderBox = holderBox
+        super.init()
+    }
+}

package/ios/Utils/SurfaceHelper.h

@@ -0,0 +1,20 @@
+//
+//  SurfaceHelper.h
+//  ReactNativeList
+//
+//  Created by Hanno Gödecke on 15.02.26.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTPrimitives.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SurfaceHelper : NSObject
++ (nullable NSNumber *)createExternalSurface:(NSError * _Nullable * _Nullable)error;
++ (BOOL)releaseExternalSurface:(ReactTag)surfaceId error:(NSError * _Nullable * _Nullable)error;
++ (nullable UIView *)getViewByTag:(ReactTag)tag error:(NSError * _Nullable * _Nullable)error;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/SurfaceHelper.mm

@@ -0,0 +1,144 @@
+//
+//  SurfaceHelper.m
+//  ReactNativeList
+//
+//  Created by Hanno Gödecke on 15.02.26.
+//
+
+#import "SurfaceHelper.h"
+#import "SurfacePresenterRegistry.h"
+#import "ErrorUtils.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTFabricSurface.h>
+#import <React/RCTSurfacePresenterStub.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfaceProtocol.h>
+
+#import <React/RCTComponentViewProtocol.h>
+#import <React/RCTComponentViewRegistry.h>
+#import <React/RCTMountingManager.h>
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace {
+    static NSMutableDictionary<NSNumber *, id<RCTSurfaceProtocol>> *externalSurfaces()
+    {
+      static NSMutableDictionary<NSNumber *, id<RCTSurfaceProtocol>> *surfaces = nil;
+      static dispatch_once_t onceToken;
+      dispatch_once(&onceToken, ^{
+        surfaces = [NSMutableDictionary new];
+      });
+      return surfaces;
+    }
+
+    inline RCTSurfacePresenter* _Nullable resolveSurfacePresenter(RCTBridge *bridge)
+    {
+      id<RCTSurfacePresenterStub> surfacePresenter =
+          (id<RCTSurfacePresenterStub>)[SurfacePresenterRegistry currentSurfacePresenter];
+      if (surfacePresenter != nil) {
+        return surfacePresenter;
+      }
+
+      return [bridge surfacePresenter];
+    }
+} // namespace
+
+@implementation SurfaceHelper
+
++ (nullable NSNumber *)createExternalSurface:(NSError *__autoreleasing _Nullable * _Nullable)error
+{
+  @try {
+    if (![NSThread isMainThread]) {
+      assignError(error, @"createExternalSurface() must run on the main thread.");
+      return nil;
+    }
+
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge == nil) {
+      assignError(error, @"Could not access RCTBridge.currentBridge.");
+      return nil;
+    }
+
+    RCTSurfacePresenter *surfacePresenter = resolveSurfacePresenter(bridge);
+    if (surfacePresenter == nil) {
+      assignError(error, @"Could not access an active RCTSurfacePresenter.");
+      return nil;
+    }
+
+    id<RCTSurfaceProtocol> surface = [surfacePresenter createFabricSurfaceForModuleName:@"" initialProperties:@{}];
+    if (surface == nil) {
+      assignError(error, @"Failed to create Fabric surface.");
+      return nil;
+    }
+
+    if (![surface isKindOfClass:[RCTFabricSurface class]]) {
+      assignError(error, @"Expected a RCTFabricSurface instance.");
+      return nil;
+    }
+
+    [surface start];
+    NSNumber *surfaceId = @(surface.rootTag);
+    externalSurfaces()[surfaceId] = surface;
+    NSLog(@"Created external surface %@", surfaceId);
+    return surfaceId;
+  } @catch (NSException *exception) {
+    assignError(error, [NSString stringWithFormat:@"Surface creation failed with NSException: %@", exception.reason]);
+    return nil;
+  }
+}
+
++ (BOOL)releaseExternalSurface:(ReactTag)surfaceId error:(NSError * _Nullable __autoreleasing * _Nullable)error {
+    @try {
+        if (![NSThread isMainThread]) {
+          assignError(error, @"releaseExternalSurface() must run on the main thread.");
+          return NO;
+        }
+
+        NSNumber *surfaceKey = @(surfaceId);
+        id<RCTSurfaceProtocol> surface = externalSurfaces()[surfaceKey];
+        if (surface == nil) {
+            return YES;
+        }
+
+        [surface stop];
+        [externalSurfaces() removeObjectForKey:surfaceKey];
+        return YES;
+    } @catch (NSException *exception) {
+        assignError(error, [NSString stringWithFormat:@"Surface release failed with NSException: %@", exception.reason]);
+        return NO;
+    }
+}
+
++ (nullable UIView *)getViewByTag:(ReactTag)tag error:(NSError * _Nullable __autoreleasing * _Nullable)error {
+    if (![NSThread isMainThread]) {
+      assignError(error, @"getViewByTag() must run on the main thread.");
+      return nil;
+    }
+
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge == nil) {
+      assignError(error, @"Could not access RCTBridge.currentBridge.");
+      return nil;
+    }
+
+    RCTSurfacePresenter *surfacePresenter = resolveSurfacePresenter(bridge);
+    if (surfacePresenter == nil) {
+      assignError(error, @"Could not access an active RCTSurfacePresenter.");
+      return nil;
+    }
+
+    RCTComponentViewRegistry *componentViewRegistry = surfacePresenter.mountingManager.componentViewRegistry;
+    Tag intTag = static_cast<Tag>(tag);
+    UIView<RCTComponentViewProtocol> *componentView = [componentViewRegistry findComponentViewWithTag:intTag];
+    if (componentView == nil) {
+        assignError(error, [NSString stringWithFormat:@"Could not resolve view with tag %d on surface %@", intTag, @-1]);
+        return nil;
+    }
+    
+    return componentView;
+}
+
+@end

package/ios/Utils/SurfacePresenterRegistry.h

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * A module whos purpose it is to receive the surface presenter.
+ * (RN injects this during module instantiation).
+ */
+@interface SurfacePresenterRegistry : NSObject <RCTBridgeModule>
+
++ (nullable id)currentSurfacePresenter;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/SurfacePresenterRegistry.m

@@ -0,0 +1,31 @@
+#import "SurfacePresenterRegistry.h"
+
+#import <React/RCTSurfacePresenterStub.h>
+
+@protocol RCTTurboModule;
+
+static __weak id<RCTSurfacePresenterStub> sCurrentSurfacePresenter = nil;
+
+@interface SurfacePresenterRegistry () <RCTTurboModule>
+@end
+
+@implementation SurfacePresenterRegistry
+
+RCT_EXPORT_MODULE(HybridUiListSurfacePresenterRegistry);
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
++ (nullable id)currentSurfacePresenter
+{
+  return sCurrentSurfacePresenter;
+}
+
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  sCurrentSurfacePresenter = surfacePresenter;
+}
+
+@end

package/ios/Utils/TurboModuleInstaller.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+@interface HybridWorkletsModuleProxyHolderBox : NSObject
+@end
+
+@interface TurboModuleInstaller : NSObject
+
++ (nullable HybridWorkletsModuleProxyHolderBox *)createWorkletsModuleProxyHolder:(NSError * _Nullable * _Nullable)error;
++ (BOOL)installNativeModuleProxyInUIRuntimeWithHolder:(HybridWorkletsModuleProxyHolderBox *)holder
+                                                 error:(NSError * _Nullable * _Nullable)error;
++ (BOOL)setupEventInterceptor:(NSError * _Nullable * _Nullable)error;
+
+@end
+
+NS_ASSUME_NONNULL_END