expo-modules-core 0.4.8 → 0.5.0

package/ios/JSI/JSIInstaller.h

@@ -0,0 +1,19 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <jsi/jsi.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import <ExpoModulesCore/EXNativeModulesProxy.h>
+
+using namespace facebook;
+using namespace react;
+
+namespace expo {
+
+void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
+
+} // namespace expo
+
+#endif

package/ios/JSI/JSIInstaller.mm

@@ -0,0 +1,22 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/JSIInstaller.h>
+#import <ExpoModulesCore/ExpoModulesProxySpec.h>
+
+using namespace facebook;
+using namespace react;
+
+//using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+
+namespace expo {
+
+void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy)
+{
+  auto expoModulesProxyModule = std::make_shared<ExpoModulesProxySpec>(callInvoker, nativeModulesProxy);
+
+  runtime
+    .global()
+    .setProperty(runtime, "ExpoModulesProxy", jsi::Object::createFromHostObject(runtime, expoModulesProxyModule));
+}
+
+} // namespace expo

package/ios/ModuleRegistryAdapter/EXModuleRegistryAdapter.m

@@ -7,12 +7,7 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryHolderReactModule.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
-// For cocoapods framework, the generated swift header will be inside ExpoModulesCore module
-#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
-#else
-#import "ExpoModulesCore-Swift.h"
-#endif
+#import <ExpoModulesCore/Swift.h>
 
 @interface EXModuleRegistryAdapter ()
 

package/ios/NativeModulesProxy/EXNativeModulesProxy.h

@@ -12,6 +12,7 @@
 // Swift compatibility headers (e.g. `ExpoModulesCore-Swift.h`) are not available in headers,
 // so we use class forward declaration here. Swift header must be imported in the `.m` file.
 @class SwiftInteropBridge;
+@protocol ModulesProviderObjCProtocol;
 
 NS_SWIFT_NAME(NativeModulesProxy)
 @interface EXNativeModulesProxy : NSObject <RCTBridgeModule>
@@ -21,4 +22,9 @@ NS_SWIFT_NAME(NativeModulesProxy)
 - (nonnull instancetype)init;
 - (nonnull instancetype)initWithModuleRegistry:(nullable EXModuleRegistry *)moduleRegistry;
 
+- (void)callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNameOrKey arguments:(NSArray *)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
+- (id)callMethodSync:(NSString *)moduleName methodName:(NSString *)methodName arguments:(NSArray *)arguments;
+
++ (id<ModulesProviderObjCProtocol>)getExpoModulesProvider;
+
 @end

package/ios/NativeModulesProxy/{EXNativeModulesProxy.m → EXNativeModulesProxy.mm}

@@ -8,6 +8,8 @@
 #import <React/RCTModuleData.h>
 #import <React/RCTEventDispatcherProtocol.h>
 
+#import <jsi/jsi.h>
+
 #import <ExpoModulesCore/EXNativeModulesProxy.h>
 #import <ExpoModulesCore/EXEventEmitter.h>
 #import <ExpoModulesCore/EXViewManager.h>
@@ -15,12 +17,8 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryProvider.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
-// For cocoapods framework, the generated swift header will be inside ExpoModulesCore module
-#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
-#else
-#import "ExpoModulesCore-Swift.h"
-#endif
+#import <ExpoModulesCore/JSIInstaller.h>
+#import <ExpoModulesCore/Swift.h>
 
 static const NSString *exportedMethodsNamesKeyPath = @"exportedMethods";
 static const NSString *viewManagersNamesKeyPath = @"viewManagersNames";
@@ -37,6 +35,12 @@ static const NSString *methodInfoArgumentsCountKey = @"argumentsCount";
 
 @end
 
+@interface RCTBridge (JSIRuntime)
+
+- (void *)runtime;
+
+@end
+
 @interface RCTComponentData (EXNativeModulesProxy)
 
 - (instancetype)initWithManagerClass:(Class)managerClass bridge:(RCTBridge *)bridge eventDispatcher:(id<RCTEventDispatcherProtocol>) eventDispatcher; // available in RN 0.65+
@@ -68,7 +72,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 {
   if (self = [super init]) {
     _exModuleRegistry = moduleRegistry != nil ? moduleRegistry : [[EXModuleRegistryProvider new] moduleRegistry];
-    _swiftInteropBridge = [[SwiftInteropBridge alloc] initWithModulesProvider:[self getExpoModulesProvider] legacyModuleRegistry:_exModuleRegistry];
+    _swiftInteropBridge = [[SwiftInteropBridge alloc] initWithModulesProvider:[EXNativeModulesProxy getExpoModulesProvider] legacyModuleRegistry:_exModuleRegistry];
     _exportedMethodsKeys = [NSMutableDictionary dictionary];
     _exportedMethodsReverseKeys = [NSMutableDictionary dictionary];
     _ownsModuleRegistry = moduleRegistry == nil;
@@ -93,6 +97,9 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 
 - (NSDictionary *)constantsToExport
 {
+  // Install the TurboModule implementation of the proxy.
+  [self installExpoTurboModules];
+
   NSMutableDictionary <NSString *, id> *exportedModulesConstants = [NSMutableDictionary dictionary];
   // Grab all the constants exported by modules
   for (EXExportedModule *exportedModule in [_exModuleRegistry getAllExportedModules]) {
@@ -121,7 +128,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
   }
 
   // Add entries from Swift modules
-  [exportedMethodsNamesAccumulator addEntriesFromDictionary:[_swiftInteropBridge exportedMethodNames]];
+  [exportedMethodsNamesAccumulator addEntriesFromDictionary:[_swiftInteropBridge exportedFunctionNames]];
 
   // Also, add `viewManagersNames` for sanity check and testing purposes -- with names we know what managers to mock on UIManager
   NSArray<EXViewManager *> *viewManagers = [_exModuleRegistry getAllViewManagers];
@@ -151,7 +158,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNameOrKey arguments:(NSArray *)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
   if ([_swiftInteropBridge hasModule:moduleName]) {
-    [_swiftInteropBridge callMethod:methodNameOrKey onModule:moduleName withArgs:arguments resolve:resolve reject:reject];
+    [_swiftInteropBridge callFunction:methodNameOrKey onModule:moduleName withArgs:arguments resolve:resolve reject:reject];
     return;
   }
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
@@ -186,10 +193,20 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   });
 }
 
-#pragma mark - Privates
+- (id)callMethodSync:(NSString *)moduleName methodName:(NSString *)methodName arguments:(NSArray *)arguments
+{
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    return [_swiftInteropBridge callFunctionSync:methodName onModule:moduleName withArgs:arguments];
+  }
+  return (id)kCFNull;
+}
 
-- (id<ModulesProviderObjCProtocol>)getExpoModulesProvider
+#pragma mark - Statics
+
++ (id<ModulesProviderObjCProtocol>)getExpoModulesProvider
 {
+  // Dynamically gets the modules provider class.
+  // NOTE: This needs to be versioned in Expo Go.
   Class generatedExpoModulesProvider = NSClassFromString(@"ExpoModulesProvider");
   // Checks if `ExpoModulesProvider` was generated
   if (generatedExpoModulesProvider) {
@@ -199,6 +216,8 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   }
 }
 
+#pragma mark - Privates
+
 - (void)registerExpoModulesInBridge:(RCTBridge *)bridge
 {
   // Registering expo modules in bridge is needed only when the proxy module owns the registry
@@ -255,8 +274,10 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   // components in UIManager — we need to register them on our own.
   [self registerComponentDataForModuleClasses:additionalModuleClasses inBridge:bridge];
 
-  // Get the newly created instance of `EXReactEventEmitter` bridge module and register it in expo modules registry.
+  // Get the newly created instance of `EXReactEventEmitter` bridge module,
+  // pass event names supported by Swift modules and register it in legacy modules registry.
   EXReactNativeEventEmitter *eventEmitter = [bridge moduleForClass:[EXReactNativeEventEmitter class]];
+  [eventEmitter setSwiftInteropBridge:_swiftInteropBridge];
   [_exModuleRegistry registerInternalModule:eventEmitter];
 
   // Let the modules consume the registry :)
@@ -345,4 +366,16 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   }
 }
 
+/**
+ Installs expo modules in JSI runtime.
+ */
+- (void)installExpoTurboModules
+{
+  facebook::jsi::Runtime *runtime = [_bridge respondsToSelector:@selector(runtime)] ? reinterpret_cast<facebook::jsi::Runtime *>(_bridge.runtime) : NULL;
+
+  if (runtime) {
+    expo::installRuntimeObjects(*runtime, _bridge.jsCallInvoker, self);
+  }
+}
+
 @end

package/ios/Services/EXReactNativeEventEmitter.h

@@ -7,6 +7,12 @@
 #import <ExpoModulesCore/EXModuleRegistryConsumer.h>
 #import <ExpoModulesCore/EXBridgeModule.h>
 
+// Swift compatibility headers (e.g. `ExpoModulesCore-Swift.h`) are not available in headers,
+// so we use class forward declaration here. Swift header must be imported in the `.m` file.
+@class SwiftInteropBridge;
+
 @interface EXReactNativeEventEmitter : RCTEventEmitter <EXInternalModule, EXBridgeModule, EXModuleRegistryConsumer, EXEventEmitterService>
 
+@property (nonatomic, strong) SwiftInteropBridge *swiftInteropBridge;
+
 @end

package/ios/Services/EXReactNativeEventEmitter.m

@@ -4,6 +4,7 @@
 #import <ExpoModulesCore/EXEventEmitter.h>
 #import <ExpoModulesCore/EXExportedModule.h>
 #import <ExpoModulesCore/EXModuleRegistry.h>
+#import <ExpoModulesCore/Swift.h>
 
 @interface EXReactNativeEventEmitter ()
 
@@ -42,6 +43,10 @@
 - (NSArray<NSString *> *)supportedEvents
 {
   NSMutableSet<NSString *> *eventsAccumulator = [NSMutableSet set];
+
+  if (_swiftInteropBridge) {
+    [eventsAccumulator addObjectsFromArray:[_swiftInteropBridge getSupportedEvents]];
+  }
   for (EXExportedModule *exportedModule in [_exModuleRegistry getAllExportedModules]) {
     if ([exportedModule conformsToProtocol:@protocol(EXEventEmitter)]) {
       id<EXEventEmitter> eventEmitter = (id<EXEventEmitter>)exportedModule;
@@ -54,6 +59,11 @@
 RCT_EXPORT_METHOD(addProxiedListener:(NSString *)moduleName eventName:(NSString *)eventName)
 {
   [self addListener:eventName];
+
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    [_swiftInteropBridge modifyEventListenersCount:moduleName count:1];
+    return;
+  }
   // Validate module
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
 
@@ -90,6 +100,11 @@ RCT_EXPORT_METHOD(addProxiedListener:(NSString *)moduleName eventName:(NSString
 RCT_EXPORT_METHOD(removeProxiedListeners:(NSString *)moduleName count:(double)count)
 {
   [self removeListeners:count];
+
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    [_swiftInteropBridge modifyEventListenersCount:moduleName count:-count];
+    return;
+  }
   // Validate module
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
 

package/ios/Swift/AppContext.swift

@@ -2,7 +2,7 @@ import UIKit
 /**
  The app context is an interface to a single Expo app.
  */
-public class AppContext {
+public final class AppContext {
   /**
    The module registry for the app context.
    */
@@ -71,6 +71,13 @@ public class AppContext {
     return legacyModule(implementing: EXUtilitiesInterface.self)
   }
 
+  /**
+   Provides access to the event emitter from legacy module registry.
+   */
+  public var eventEmitter: EXEventEmitterService? {
+    return legacyModule(implementing: EXEventEmitterService.self)
+  }
+
   /**
    Starts listening to `UIApplication` notifications.
    */
@@ -108,4 +115,10 @@ public class AppContext {
     NotificationCenter.default.removeObserver(self)
     moduleRegistry.post(event: .appContextDestroys)
   }
+
+  // MARK: Errors
+
+  struct DeallocatedAppContextError: CodedError {
+    var description: String = "The app context has been deallocated."
+  }
 }

package/ios/Swift/Arguments/AnyArgument.swift

@@ -0,0 +1,14 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol for classes/structs accepted as an argument of functions.
+ */
+public protocol AnyArgument {}
+
+// Extend the primitive types — these may come from React Native bridge.
+extension Bool: AnyArgument {}
+extension Int: AnyArgument {}
+extension Double: AnyArgument {}
+extension String: AnyArgument {}
+extension Array: AnyArgument {}
+extension Dictionary: AnyArgument {}

package/ios/Swift/Arguments/AnyArgumentType.swift

@@ -0,0 +1,13 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol whose intention is to wrap function's argument type
+ to keep its real signature and not type-erase it by the compiler.
+ */
+internal protocol AnyArgumentType: CustomStringConvertible {
+  /**
+   Casts given any value to the wrapped type and returns as `Any`.
+   NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `ConvertibleArgument`).
+   */
+  func cast<ArgType>(_ value: ArgType) throws -> Any
+}

package/ios/Swift/Arguments/ArgumentType.swift

@@ -0,0 +1,24 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ Factory creating an instance of the argument type wrapper conforming to `AnyArgumentType`.
+ Depending on the given type, it may return one of `ArrayArgumentType`, `OptionalArgumentType`, `ConvertibleArgumentType`, etc.
+ */
+internal func ArgumentType<T>(_ type: T.Type) -> AnyArgumentType {
+  if let ArrayType = T.self as? AnyArrayArgument.Type {
+    return ArrayArgumentType(elementType: ArrayType.getElementArgumentType())
+  }
+  if let OptionalType = T.self as? AnyOptionalArgument.Type {
+    return OptionalArgumentType(wrappedType: OptionalType.getWrappedArgumentType())
+  }
+  if let ConvertibleType = T.self as? ConvertibleArgument.Type {
+    return ConvertibleArgumentType(innerType: ConvertibleType)
+  }
+  if let EnumType = T.self as? EnumArgument.Type {
+    return EnumArgumentType(innerType: EnumType)
+  }
+  if T.self is Promise.Type {
+    return PromiseArgumentType()
+  }
+  return RawArgumentType(innerType: T.self)
+}

package/ios/Swift/Arguments/ConvertibleArgument.swift

@@ -0,0 +1,15 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+/**
+ A protocol that allows custom classes or structs to be used as function arguments.
+ It requires static `convert(from:)` function that knows how to convert incoming
+ value of `Any` type to the type implemented by this protocol. It should throw an error
+ when the value is not recognized, is invalid or doesn't meet type requirements.
+ */
+public protocol ConvertibleArgument: AnyArgument {
+  /**
+   Converts any value to the instance of its class (or struct).
+   Throws an error when given value cannot be converted.
+   */
+  static func convert(from value: Any?) throws -> Self
+}

package/ios/Swift/Arguments/Convertibles.swift

@@ -0,0 +1,93 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import UIKit
+import CoreGraphics
+
+/// Here we extend some common iOS types to implement `ConvertibleArgument` protocol and
+/// describe how they can be converted from primitive types received from JavaScript runtime.
+/// This allows these types to be used as argument types of functions callable from JavaScript.
+/// As an example, when the `CGPoint` type is used as an argument type, its instance can be
+/// created from an array of two doubles or an object with `x` and `y` fields.
+
+// MARK: - UIKit
+
+extension UIColor: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> Self {
+    if let value = value as? String {
+      return try Conversions.toColor(hexString: value) as! Self
+    }
+    if let components = value as? [Double] {
+      let alpha = components.count > 3 ? components[3] : 1.0
+      return Self.init(red: components[0], green: components[1], blue: components[2], alpha: alpha)
+    }
+    if let value = value as? Int {
+      return try Conversions.toColor(argb: UInt64(value)) as! Self
+    }
+    throw Conversions.ConvertingError<UIColor>(value: value)
+  }
+}
+
+// MARK: - CoreGraphics
+
+extension CGPoint: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGPoint {
+    if let value = value as? [Double], value.count == 2 {
+      return CGPoint(x: value[0], y: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["x", "y"], as: Double.self)
+      return CGPoint(x: args[0], y: args[1])
+    }
+    throw Conversions.ConvertingError<CGPoint>(value: value)
+  }
+}
+
+extension CGSize: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGSize {
+    if let value = value as? [Double], value.count == 2 {
+      return CGSize(width: value[0], height: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["width", "height"], as: Double.self)
+      return CGSize(width: args[0], height: args[1])
+    }
+    throw Conversions.ConvertingError<CGSize>(value: value)
+  }
+}
+
+extension CGVector: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGVector {
+    if let value = value as? [Double], value.count == 2 {
+      return CGVector(dx: value[0], dy: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["dx", "dy"], as: Double.self)
+      return CGVector(dx: args[0], dy: args[1])
+    }
+    throw Conversions.ConvertingError<CGVector>(value: value)
+  }
+}
+
+extension CGRect: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGRect {
+    if let value = value as? [Double], value.count == 4 {
+      return CGRect(x: value[0], y: value[1], width: value[2], height: value[3])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["x", "y", "width", "height"], as: Double.self)
+      return CGRect(x: args[0], y: args[1], width: args[2], height: args[3])
+    }
+    throw Conversions.ConvertingError<CGRect>(value: value)
+  }
+}
+
+extension CGColor: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> Self {
+    do {
+      return try UIColor.convert(from: value).cgColor as! Self
+    } catch _ as Conversions.ConvertingError<UIColor> {
+      // Rethrow `ConvertingError` with proper type
+      throw Conversions.ConvertingError<CGColor>(value: value)
+    }
+  }
+}

package/ios/Swift/Arguments/Types/ArrayArgumentType.swift

@@ -0,0 +1,42 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type representing array types. Requires the argument type for
+ array's element type as it delegates casting to that type for each element in the array.
+ */
+internal struct ArrayArgumentType: AnyArgumentType {
+  let elementType: AnyArgumentType
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if let value = value as? [Any] {
+      return try value.map { try elementType.cast($0) }
+    }
+    // We should probably throw an error if we get here. On the other side, the array type
+    // requirement can be more loosen so we can try to arrayize values that are not arrays.
+    return [try elementType.cast(value)]
+  }
+
+  var description: String {
+    "[\(elementType.description)]"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize arrays with elements of argument-compatible type.
+ `Array` is a generic type, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyArrayArgument: AnyArgument {
+  /**
+   Exposes the `Element` generic type wrapped by the argument type to preserve its metadata.
+   */
+  static func getElementArgumentType() -> AnyArgumentType
+}
+
+/**
+ Extends the `Array` type to expose its generic `Element` as an argument type.
+ */
+extension Array: AnyArrayArgument where Element: AnyArgument {
+  static func getElementArgumentType() -> AnyArgumentType {
+    return ArgumentType(Element.self)
+  }
+}

package/ios/Swift/Arguments/Types/ConvertibleArgumentType.swift

@@ -0,0 +1,16 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that wraps any type conforming to `ConvertibleArgument` protocol.
+ */
+internal struct ConvertibleArgumentType: AnyArgumentType {
+  let innerType: ConvertibleArgument.Type
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    return try innerType.convert(from: value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/Arguments/Types/EnumArgumentType.swift

@@ -0,0 +1,105 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type representing an enum that conforms to `EnumArgument`.
+ */
+internal struct EnumArgumentType: AnyArgumentType {
+  let innerType: EnumArgument.Type
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    return try innerType.create(fromRawValue: value)
+  }
+
+  var description: String {
+    "Enum<\(innerType)>"
+  }
+}
+
+/**
+ A protocol that allows converting raw values to enum cases.
+ */
+public protocol EnumArgument: AnyArgument {
+  /**
+   Tries to create an enum case using given raw value.
+   May throw errors, e.g. when the raw value doesn't match any case.
+   */
+  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self
+
+  /**
+   Returns an array of all raw values available in the enum.
+   */
+  static var allRawValues: [Any] { get }
+
+  /**
+   Type-erased enum's raw value.
+   */
+  var anyRawValue: Any { get }
+}
+
+/**
+ Extension for `EnumArgument` that also conforms to `RawRepresentable`.
+ This constraint allows us to reference the associated `RawValue` type.
+ */
+public extension EnumArgument where Self: RawRepresentable, Self: Hashable {
+  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self {
+    guard let rawValue = rawValue as? RawValue else {
+      throw EnumCastingError(type: RawValue.self, value: rawValue)
+    }
+    guard let enumCase = Self.init(rawValue: rawValue) else {
+      throw EnumNoSuchValueError(type: Self.self, value: rawValue)
+    }
+    return enumCase
+  }
+
+  var anyRawValue: Any {
+    rawValue
+  }
+
+  static var allRawValues: [Any] {
+    // Be careful — it operates on unsafe pointers!
+    let sequence = AnySequence { () -> AnyIterator<RawValue> in
+      var raw = 0
+      return AnyIterator {
+        let current: Self? = withUnsafePointer(to: &raw) { ptr in
+          ptr.withMemoryRebound(to: Self.self, capacity: 1) { $0.pointee }
+        }
+        guard let value = current?.rawValue else {
+          return nil
+        }
+        raw += 1
+        return value
+      }
+    }
+    return Array(sequence)
+  }
+}
+
+/**
+ An error that is thrown when the value cannot be casted to associated `RawValue`.
+ */
+internal struct EnumCastingError: CodedError {
+  let type: Any.Type
+  let value: Any
+
+  var description: String {
+    "Cannot cast value `\(value)` to expected type `\(type)`"
+  }
+}
+
+/**
+ An error that is thrown when the value doesn't match any available case.
+ */
+internal struct EnumNoSuchValueError: CodedError {
+  let type: EnumArgument.Type
+  let value: Any
+
+  var allRawValuesFormatted: String {
+    return type.allRawValues
+      .map { "`\($0)`" }
+      .joined(separator: ", ")
+  }
+
+  var description: String {
+    "Cannot create `\(type)` enum from value `\(value)`. It must be one of: \(allRawValuesFormatted)"
+  }
+}

package/ios/Swift/Arguments/Types/OptionalArgumentType.swift

@@ -0,0 +1,49 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that represents an optional type, which allows `nil` to be passed when casting.
+ Requires the argument type for optional's unwrapped type as it delegates casting to that type for non-nil values.
+ */
+internal struct OptionalArgumentType: AnyArgumentType {
+  let wrappedType: AnyArgumentType
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if Optional.isNil(value) {
+      return Optional<Any>.none as Any
+    }
+    return try wrappedType.cast(value)
+  }
+
+  var description: String {
+    "\(wrappedType)?"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize if the generic type is an optional type.
+ `Optional` is a generic enum, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyOptionalArgument: AnyArgument {
+  /**
+   Exposes the `Wrapped` generic type wrapped by the argument type to preserve its metadata.`
+   */
+  static func getWrappedArgumentType() -> AnyArgumentType
+}
+
+/**
+ Make generic `Optional` implement non-generic `AnyOptional` and add handy check against type-erased `nil`.
+ */
+extension Optional: AnyOptionalArgument {
+  static func getWrappedArgumentType() -> AnyArgumentType {
+    return ArgumentType(Wrapped.self)
+  }
+
+  static func isNil(_ object: Wrapped) -> Bool {
+    switch object as Any {
+    case Optional<Any>.none:
+      return true
+    default:
+      return false
+    }
+  }
+}