expo-modules-core 0.7.0 → 0.8.0

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/{JavaScriptRuntime.h → EXJavaScriptRuntime.h}

@@ -1,6 +1,7 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
-#import <ExpoModulesCore/JavaScriptObject.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
 
 #ifdef __cplusplus
 #import <ReactCommon/CallInvoker.h>
@@ -9,12 +10,23 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 #endif // __cplusplus
 
-@interface JavaScriptRuntime : NSObject
+@class EXJavaScriptValue;
+@class EXJavaScriptObject;
 
 #ifdef __cplusplus
-typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> callInvoker, NSArray * _Nonnull arguments);
+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;
 
-- (nonnull instancetype)initWithRuntime:(jsi::Runtime &)runtime
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull jsi::Runtime *)runtime
                             callInvoker:(std::shared_ptr<react::CallInvoker>)callInvoker;
 
 /**
@@ -28,9 +40,9 @@ typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr
 - (std::shared_ptr<react::CallInvoker>)callInvoker;
 
 /**
- Wraps given host object to `JavaScriptObject`.
+ Wraps given host object to `EXJavaScriptObject`.
  */
-- (nonnull JavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
+- (nonnull EXJavaScriptObject *)createHostObject:(std::shared_ptr<jsi::HostObject>)jsiHostObjectPtr;
 
 - (jsi::Function)createSyncFunction:(nonnull NSString *)name
                           argsCount:(NSInteger)argsCount
@@ -44,11 +56,18 @@ typedef jsi::Value (^JSHostFunctionBlock)(jsi::Runtime &runtime, std::shared_ptr
 /**
  Returns the runtime global object for use in Swift.
  */
-- (nonnull JavaScriptObject *)global;
+- (nonnull EXJavaScriptObject *)global;
 
 /**
  Creates a new object for use in Swift.
  */
-- (nonnull JavaScriptObject *)createObject;
+- (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

package/ios/JSI/EXJavaScriptValue.mm

@@ -0,0 +1,166 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+@implementation EXJavaScriptValue {
+  __weak EXJavaScriptRuntime *_runtime;
+  std::shared_ptr<jsi::Value> _value;
+}
+
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+    _value = value;
+  }
+  return self;
+}
+
+- (nonnull jsi::Value *)get
+{
+  return _value.get();
+}
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined
+{
+  return _value->isUndefined();
+}
+
+- (BOOL)isNull
+{
+  return _value->isNull();
+}
+
+- (BOOL)isBool
+{
+  return _value->isBool();
+}
+
+- (BOOL)isNumber
+{
+  return _value->isNumber();
+}
+
+- (BOOL)isString
+{
+  return _value->isString();
+}
+
+- (BOOL)isSymbol
+{
+  return _value->isSymbol();
+}
+
+- (BOOL)isObject
+{
+  return _value->isObject();
+}
+
+- (BOOL)isFunction
+{
+  if (_value->isObject()) {
+    jsi::Runtime *runtime = [_runtime get];
+    return _value->getObject(*runtime).isFunction(*runtime);
+  }
+  return false;
+}
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value
+{
+  if ([value isUndefined]) {
+    return @"undefined";
+  }
+  if ([value isNull]) {
+    return @"null";
+  }
+  if ([value isBool]) {
+    return @"boolean";
+  }
+  if ([value isNumber]) {
+    return @"number";
+  }
+  if ([value isString]) {
+    return @"string";
+  }
+  if ([value isFunction]) {
+    return @"function";
+  }
+  assert([value isObject] && "Expecting object.");
+  return @"object";
+}
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw
+{
+  return expo::convertJSIValueToObjCObject(*[_runtime get], *_value, [_runtime callInvoker]);
+}
+
+- (BOOL)getBool
+{
+  return _value->getBool();
+}
+
+- (NSInteger)getInt
+{
+  return _value->getNumber();
+}
+
+- (double)getDouble
+{
+  return _value->getNumber();
+}
+
+- (nonnull NSString *)getString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->getString(*runtime));
+}
+
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Array jsiArray = _value->getObject(*runtime).getArray(*runtime);
+  size_t arraySize = jsiArray.size(*runtime);
+  NSMutableArray *result = [NSMutableArray arrayWithCapacity:arraySize];
+
+  for (size_t i = 0; i < arraySize; i++) {
+    jsi::Value item = jsiArray.getValueAtIndex(*runtime, i);
+
+    if (item.isUndefined() || item.isNull()) {
+      [result addObject:(id)kCFNull];
+    } else {
+      std::shared_ptr<jsi::Value> valuePtr = std::make_shared<jsi::Value>(*runtime, item);
+      [result addObject:[[EXJavaScriptValue alloc] initWithRuntime:_runtime value:valuePtr]];
+    }
+  }
+  return result;
+}
+
+- (nonnull NSDictionary<NSString *, id> *)getDictionary
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIObjectToNSDictionary(*runtime, _value->getObject(*runtime), [_runtime callInvoker]);
+}
+
+- (nonnull EXJavaScriptObject *)getObject
+{
+  jsi::Runtime *runtime = [_runtime get];
+  std::shared_ptr<jsi::Object> objectPtr = std::make_shared<jsi::Object>(_value->asObject(*runtime));
+  return [[EXJavaScriptObject alloc] initWith:objectPtr runtime:_runtime];
+}
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->toString(*runtime));
+}
+
+@end

package/ios/JSI/ExpoModulesHostObject.mm

@@ -1,6 +1,7 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
 #import <ExpoModulesCore/Swift.h>
 
 namespace expo {
@@ -13,7 +14,7 @@ ExpoModulesHostObject::~ExpoModulesHostObject() {
 
 jsi::Value ExpoModulesHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
   NSString *moduleName = [NSString stringWithUTF8String:name.utf8(runtime).c_str()];
-  JavaScriptObject *nativeObject = [swiftInterop getNativeModuleObject:moduleName];
+  EXJavaScriptObject *nativeObject = [swiftInterop getNativeModuleObject:moduleName];
 
   return nativeObject ? jsi::Value(runtime, *[nativeObject get]) : jsi::Value::undefined();
 }

package/ios/JSI/JavaScriptRuntime.swift

@@ -0,0 +1,32 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public extension JavaScriptRuntime {
+  /**
+   Evaluates JavaScript code represented as a string.
+
+   - Parameter source: A string representing a JavaScript expression, statement, or sequence of statements.
+                       The expression can include variables and properties of existing objects.
+   - Returns: The completion value of evaluating the given code represented as `JavaScriptValue`.
+              If the completion value is empty, `undefined` is returned.
+   - Throws: `JavaScriptEvalException` when evaluated code has invalid syntax or throws an error.
+   - Note: It wraps the original `evaluateScript` to better handle and rethrow exceptions.
+   */
+  func eval(_ source: String) throws -> JavaScriptValue {
+    do {
+      var result: JavaScriptValue?
+      try EXUtilities.catchException {
+        result = self.evaluateScript(source)
+      }
+      // There is no risk to force unwrapping as long as the `evaluateScript` returns nonnull value.
+      return result!
+    } catch {
+      throw JavaScriptEvalException(error as NSError)
+    }
+  }
+}
+
+internal final class JavaScriptEvalException: GenericException<NSError> {
+  override var reason: String {
+    return param.userInfo["message"] as? String ?? "unknown reason"
+  }
+}