expo-modules-core 0.6.4 → 0.8.0

package/ios/JSI/EXJSIUtils.mm

@@ -0,0 +1,89 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <React/RCTUtils.h>
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJSIUtils.h>
+
+using namespace facebook;
+
+namespace expo {
+
+void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock)
+{
+  auto weakResolveWrapper = CallbackWrapper::createWeak(promise->resolve_.getFunction(runtime), runtime, jsInvoker);
+  auto weakRejectWrapper = CallbackWrapper::createWeak(promise->reject_.getFunction(runtime), runtime, jsInvoker);
+
+  __block BOOL resolveWasCalled = NO;
+  __block BOOL rejectWasCalled = NO;
+
+  RCTPromiseResolveBlock resolveBlock = ^(id result) {
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise after it's already been rejected.");
+    }
+
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongResolveWrapper2->runtime();
+      jsi::Value arg = convertObjCObjectToJSIValue(rt, result);
+      strongResolveWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    resolveWasCalled = YES;
+  };
+
+  RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to reject a promise after it's already been resolved.");
+    }
+
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to reject a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
+    strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongRejectWrapper2->runtime();
+      jsi::Value arg = convertNSDictionaryToJSIObject(rt, jsError);
+      strongRejectWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    rejectWasCalled = YES;
+  };
+
+  setupBlock(resolveBlock, rejectBlock);
+}
+
+} // namespace expo

package/ios/JSI/EXJavaScriptObject.h

@@ -0,0 +1,97 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+#import <ReactCommon/CallInvoker.h>
+
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+typedef void (^JSAsyncFunctionBlock)(NSArray * _Nonnull, RCTPromiseResolveBlock _Nonnull, RCTPromiseRejectBlock _Nonnull);
+typedef id _Nullable (^JSSyncFunctionBlock)(NSArray * _Nonnull);
+
+@class EXJavaScriptRuntime;
+@class EXJavaScriptValue;
+
+/**
+ The property descriptor options for the property being defined or modified.
+ */
+typedef NS_OPTIONS(NSInteger, EXJavaScriptObjectPropertyDescriptor) {
+  /**
+   If set, the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.
+   */
+  EXJavaScriptObjectPropertyDescriptorConfigurable = 1 << 0,
+  /**
+   If set, the property shows up during enumeration of the properties on the corresponding object.
+   */
+  EXJavaScriptObjectPropertyDescriptorEnumerable = 1 << 1,
+  /**
+   If set, the value associated with the property may be changed with an assignment operator.
+   */
+  EXJavaScriptObjectPropertyDescriptorWritable = 1 << 2,
+} NS_SWIFT_NAME(JavaScriptObjectPropertyDescriptor);
+
+NS_SWIFT_NAME(JavaScriptObject)
+@interface EXJavaScriptObject : NSObject
+
+// Some parts of the interface must be hidden for Swift – it can't import any C++ code.
+#ifdef __cplusplus
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObjectPtr
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime;
+
+/**
+ Returns the pointer to the underlying object.
+ */
+- (nonnull jsi::Object *)get;
+#endif // __cplusplus
+
+#pragma mark - Accessing object properties
+
+/**
+ \return a bool whether the object has a property with the given name.
+ */
+- (BOOL)hasProperty:(nonnull NSString *)name;
+
+/**
+ \return the property of the object with the given name.
+ If the name isn't a property on the object, returns the `undefined` value.
+ */
+- (nonnull EXJavaScriptValue *)getProperty:(nonnull NSString *)name;
+
+/**
+ \return an array consisting of all enumerable property names in the object and its prototype chain.
+ */
+- (nonnull NSArray<NSString *> *)getPropertyNames;
+
+#pragma mark - Modifying object properties
+
+/**
+ Sets the value for the property with the given name.
+ */
+- (void)setProperty:(nonnull NSString *)name value:(nullable id)value;
+
+/**
+ Defines a new property or modifies an existing property on the object. Calls `Object.defineProperty` under the hood.
+ */
+- (void)defineProperty:(nonnull NSString *)name value:(nullable id)value options:(EXJavaScriptObjectPropertyDescriptor)options;
+
+#pragma mark - Functions
+
+/**
+ Sets given function block on the object as a host function returning a promise.
+ */
+- (void)setAsyncFunction:(nonnull NSString *)key
+               argsCount:(NSInteger)argsCount
+                   block:(nonnull JSAsyncFunctionBlock)block;
+
+/**
+ Sets given synchronous function block as a host function on the object.
+ */
+- (void)setSyncFunction:(nonnull NSString *)name
+              argsCount:(NSInteger)argsCount
+                  block:(nonnull JSSyncFunctionBlock)block;
+
+@end

package/ios/JSI/EXJavaScriptObject.mm

@@ -0,0 +1,121 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+@implementation EXJavaScriptObject {
+  /**
+   Pointer to the `EXJavaScriptRuntime` wrapper.
+
+   \note It must be weak because only then the original runtime can be safely deallocated
+   when the JS engine wants to without unsetting it on each created object.
+   */
+  __weak EXJavaScriptRuntime *_runtime;
+
+  /**
+   Shared pointer to the original JSI object that is being wrapped by `EXJavaScriptObject` class.
+   */
+  std::shared_ptr<jsi::Object> _jsObjectPtr;
+}
+
+- (nonnull instancetype)initWith:(std::shared_ptr<jsi::Object>)jsObjectPtr
+                         runtime:(nonnull EXJavaScriptRuntime *)runtime
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+    _jsObjectPtr = jsObjectPtr;
+  }
+  return self;
+}
+
+- (nonnull jsi::Object *)get
+{
+  return _jsObjectPtr.get();
+}
+
+#pragma mark - Accessing object properties
+
+- (BOOL)hasProperty:(nonnull NSString *)name
+{
+  return _jsObjectPtr->hasProperty(*[_runtime get], [name UTF8String]);
+}
+
+- (nonnull EXJavaScriptValue *)getProperty:(nonnull NSString *)name
+{
+  std::shared_ptr<jsi::Value> value = std::make_shared<jsi::Value>(_jsObjectPtr->getProperty(*[_runtime get], [name UTF8String]));
+  return [[EXJavaScriptValue alloc] initWithRuntime:_runtime value:value];
+}
+
+- (nonnull NSArray<NSString *> *)getPropertyNames
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Array propertyNamesArray = _jsObjectPtr->getPropertyNames(*[_runtime get]);
+  return expo::convertJSIArrayToNSArray(*runtime, propertyNamesArray, nullptr);
+}
+
+#pragma mark - Modifying object properties
+
+- (void)setProperty:(nonnull NSString *)name value:(nullable id)value
+{
+  jsi::Value jsiValue = expo::convertObjCObjectToJSIValue(*[_runtime get], value);
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], jsiValue);
+}
+
+- (void)defineProperty:(nonnull NSString *)name value:(nullable id)value options:(EXJavaScriptObjectPropertyDescriptor)options
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Object global = runtime->global();
+  jsi::Object objectClass = global.getPropertyAsObject(*runtime, "Object");
+  jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(*runtime, "defineProperty");
+  jsi::Object descriptor = [self preparePropertyDescriptorWithOptions:options];
+
+  descriptor.setProperty(*runtime, "value", expo::convertObjCObjectToJSIValue(*runtime, value));
+
+  // This call is basically the same as `Object.defineProperty(object, name, descriptor)` in JS
+  definePropertyFunction.callWithThis(*runtime, objectClass, {
+    jsi::Value(*runtime, *_jsObjectPtr.get()),
+    jsi::String::createFromUtf8(*runtime, [name UTF8String]),
+    std::move(descriptor),
+  });
+}
+
+#pragma mark - Functions
+
+- (void)setAsyncFunction:(nonnull NSString *)name
+               argsCount:(NSInteger)argsCount
+                   block:(nonnull JSAsyncFunctionBlock)block
+{
+  if (!_runtime) {
+    NSLog(@"Cannot set '%@' async function when the EXJavaScript runtime is no longer available.", name);
+    return;
+  }
+  jsi::Function function = [_runtime createAsyncFunction:name argsCount:argsCount block:block];
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], function);
+}
+
+- (void)setSyncFunction:(nonnull NSString *)name
+              argsCount:(NSInteger)argsCount
+                  block:(nonnull JSSyncFunctionBlock)block
+{
+  if (!_runtime) {
+    NSLog(@"Cannot set '%@' sync function when the EXJavaScript runtime is no longer available.", name);
+    return;
+  }
+  jsi::Function function = [_runtime createSyncFunction:name argsCount:argsCount block:block];
+  _jsObjectPtr->setProperty(*[_runtime get], [name UTF8String], function);
+}
+
+#pragma mark - Private helpers
+
+- (jsi::Object)preparePropertyDescriptorWithOptions:(EXJavaScriptObjectPropertyDescriptor)options
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Object descriptor(*runtime);
+  descriptor.setProperty(*runtime, "configurable", (bool)(options & EXJavaScriptObjectPropertyDescriptorConfigurable));
+  descriptor.setProperty(*runtime, "enumerable", (bool)(options & EXJavaScriptObjectPropertyDescriptorEnumerable));
+  descriptor.setProperty(*runtime, "writable", (bool)(options & EXJavaScriptObjectPropertyDescriptorWritable));
+  return descriptor;
+}
+
+@end

package/ios/JSI/EXJavaScriptRuntime.h

@@ -0,0 +1,73 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+
+#ifdef __cplusplus
+#import <ReactCommon/CallInvoker.h>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+#endif // __cplusplus
+
+@class EXJavaScriptValue;
+@class EXJavaScriptObject;
+
+#ifdef __cplusplus
+typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray<EXJavaScriptValue *> * _Nonnull arguments);
+#endif // __cplusplus
+
+NS_SWIFT_NAME(JavaScriptRuntime)
+@interface EXJavaScriptRuntime : NSObject
+
+/**
+ Creates a new JavaScript runtime.
+ */
+- (nonnull instancetype)init;
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
+                            callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker;
+
+/**
+ Returns the underlying runtime object.
+ */
+- (nonnull jsi::Runtime *)get;
+
+/**
+ Returns the call invoker the runtime was initialized with.
+ */
+- (std::shared_ptr<react::CallInvoker>)callInvoker;
+
+/**
+ Wraps given host object to `EXJavaScriptObject`.
+ */
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
+
+- (jsi::Function)createSyncFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSSyncFunctionBlock)block;
+
+- (jsi::Function)createAsyncFunction:(nonnull NSString *)name
+                           argsCount:(NSInteger)argsCount
+                               block:(nonnull JSAsyncFunctionBlock)block;
+#endif // __cplusplus
+
+/**
+ Returns the runtime global object for use in Swift.
+ */
+- (nonnull EXJavaScriptObject *)global;
+
+/**
+ Creates a new object for use in Swift.
+ */
+- (nonnull EXJavaScriptObject *)createObject;
+
+#pragma mark - Script evaluation
+
+/**
+ Evaluates given JavaScript source code.
+ */
+- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource;
+
+@end

package/ios/JSI/EXJavaScriptRuntime.mm

@@ -0,0 +1,153 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <jsi/jsi.h>
+
+#if __has_include(<reacthermes/HermesExecutorFactory.h>)
+#import <reacthermes/HermesExecutorFactory.h>
+#elif __has_include(<hermes/hermes.h>)
+#import <hermes/hermes.h>
+#else
+#import <jsi/JSCRuntime.h>
+#endif
+
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+#import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/EXJSIUtils.h>
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/Swift.h>
+
+using namespace facebook;
+
+@implementation EXJavaScriptRuntime {
+  std::shared_ptr<jsi::Runtime> _runtime;
+  std::shared_ptr<react::CallInvoker> _jsCallInvoker;
+}
+
+/**
+ Initializes a runtime that is independent from React Native and its runtime initialization.
+ This flow is mostly intended for tests. The JS call invoker is unavailable thus calling async functions is not supported.
+ TODO: Implement the call invoker when it becomes necessary.
+ */
+- (nonnull instancetype)init
+{
+  if (self = [super init]) {
+#if __has_include(<reacthermes/HermesExecutorFactory.h>) || __has_include(<hermes/hermes.h>)
+    _runtime = hermes::makeHermesRuntime();
+#else
+    _runtime = jsc::makeJSCRuntime();
+#endif
+    _jsCallInvoker = nil;
+  }
+  return self;
+}
+
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
+                            callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker
+{
+  if (self = [super init]) {
+    // Creating a shared pointer that points to the runtime but doesn't own it, thus doesn't release it.
+    // In this code flow, the runtime should be owned by something else like the RCTBridge.
+    // See explanation for constructor (8): https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
+    _runtime = std::shared_ptr<jsi::Runtime>(std::shared_ptr<jsi::Runtime>(), runtime);
+    _jsCallInvoker = callInvoker;
+  }
+  return self;
+}
+
+- (nonnull jsi::Runtime *)get
+{
+  return _runtime.get();
+}
+
+- (std::shared_ptr<react::CallInvoker>)callInvoker
+{
+  return _jsCallInvoker;
+}
+
+- (nonnull EXJavaScriptObject *)createObject
+{
+  auto jsObjectPtr = std::make_shared<jsi::Object>(*_runtime);
+  return [[EXJavaScriptObject alloc] initWith:jsObjectPtr runtime:self];
+}
+
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr
+{
+  auto jsObjectPtr = std::make_shared<jsi::Object>(jsi::Object::createFromHostObject(*_runtime, jsiHostObjectPtr));
+  return [[EXJavaScriptObject alloc] initWith:jsObjectPtr runtime:self];
+}
+
+- (nonnull EXJavaScriptObject *)global
+{
+  auto jsGlobalPtr = std::make_shared<jsi::Object>(_runtime->global());
+  return [[EXJavaScriptObject alloc] initWith:jsGlobalPtr runtime:self];
+}
+
+- (jsi::Function)createSyncFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSSyncFunctionBlock)block
+{
+  return [self createHostFunction:name argsCount:argsCount block:^jsi::Value(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray * _Nonnull arguments) {
+    return expo::convertObjCObjectToJSIValue(runtime, block(arguments));
+  }];
+}
+
+- (jsi::Function)createAsyncFunction:(nonnull NSString *)name
+                           argsCount:(NSInteger)argsCount
+                               block:(nonnull JSAsyncFunctionBlock)block
+{
+  return [self createHostFunction:name argsCount:argsCount block:^jsi::Value(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray *arguments) {
+    if (!callInvoker) {
+      // In mocked environment the call invoker may be null so it's not supported to call async functions.
+      // Testing async functions is a bit more complicated anyway. See `init` description for more.
+      throw jsi::JSError(runtime, "Calling async functions is not supported when the call invoker is unavailable");
+    }
+    // The function that is invoked as a setup of the EXJavaScript `Promise`.
+    auto promiseSetup = [callInvoker, block, arguments](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
+      expo::callPromiseSetupWithBlock(runtime, callInvoker, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
+        block(arguments, resolver, rejecter);
+      });
+    };
+    return createPromiseAsJSIValue(runtime, promiseSetup);
+  }];
+}
+
+#pragma mark - Script evaluation
+
+- (nonnull EXJavaScriptValue *)evaluateScript:(nonnull NSString *)scriptSource
+{
+  std::shared_ptr<jsi::StringBuffer> scriptBuffer = std::make_shared<jsi::StringBuffer>([scriptSource UTF8String]);
+  std::shared_ptr<jsi::Value> result;
+
+  try {
+    result = std::make_shared<jsi::Value>(_runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>"));
+  } catch (jsi::JSError &error) {
+    NSString *reason = [NSString stringWithUTF8String:error.getMessage().c_str()];
+    NSString *stack = [NSString stringWithUTF8String:error.getStack().c_str()];
+
+    @throw [NSException exceptionWithName:@"ScriptEvaluationException" reason:reason userInfo:@{
+      @"message": reason,
+      @"stack": stack,
+    }];
+  }
+  return [[EXJavaScriptValue alloc] initWithRuntime:self value:result];
+}
+
+#pragma mark - Private
+
+- (jsi::Function)createHostFunction:(nonnull NSString *)name
+                          argsCount:(NSInteger)argsCount
+                              block:(nonnull JSHostFunctionBlock)block
+{
+  jsi::PropNameID propNameId = jsi::PropNameID::forAscii(*_runtime, [name UTF8String], [name length]);
+  std::weak_ptr<react::CallInvoker> weakCallInvoker = _jsCallInvoker;
+  jsi::HostFunctionType function = [weakCallInvoker, block, self](jsi::Runtime &runtime, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+    // Theoretically should check here whether the call invoker isn't null, but in mocked environment
+    // there is no need to care about that for synchronous calls, so it's ensured in `createAsyncFunction` instead.
+    auto callInvoker = weakCallInvoker.lock();
+    NSArray<EXJavaScriptValue *> *arguments = expo::convertJSIValuesToNSArray(self, args, count);
+    return block(runtime, callInvoker, arguments);
+  };
+  return jsi::Function::createFromHostFunction(*_runtime, propNameId, (unsigned int)argsCount, function);
+}
+
+@end

package/ios/JSI/EXJavaScriptValue.h

@@ -0,0 +1,57 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+@class EXJavaScriptRuntime;
+
+/**
+ Represents any JavaScript value. Its purpose is to exposes `facebook::jsi::Value` API back to Swift.
+ */
+NS_SWIFT_NAME(JavaScriptValue)
+@interface EXJavaScriptValue : NSObject
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value;
+
+/**
+ \return the underlying `jsi::Value`.
+ */
+- (nonnull jsi::Value *)get;
+#endif // __cplusplus
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined;
+- (BOOL)isNull;
+- (BOOL)isBool;
+- (BOOL)isNumber;
+- (BOOL)isString;
+- (BOOL)isSymbol;
+- (BOOL)isObject;
+- (BOOL)isFunction;
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value;
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw;
+- (BOOL)getBool;
+- (NSInteger)getInt;
+- (double)getDouble;
+- (nonnull NSString *)getString;
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray;
+- (nonnull NSDictionary<NSString *, id> *)getDictionary;
+- (nonnull EXJavaScriptObject *)getObject;
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString;
+
+@end