@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/jsi/JsiHostObject.cpp

@@ -34,8 +34,7 @@ JsiHostObject::~JsiHostObject() {
 void JsiHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
                         const jsi::Value &value) {
 
-  auto nameVal = name.utf8(rt);
-  auto nameStr = nameVal.c_str();
+  auto nameStr = name.utf8(rt);
 
   /** Check the static setters map */
   const JsiPropertySettersMap &setters = getExportedPropertySettersMap();
@@ -54,8 +53,15 @@ void JsiHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
 
 jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
                               const jsi::PropNameID &name) {
-  auto nameVal = name.utf8(runtime);
-  auto nameStr = nameVal.c_str();
+  auto nameStr = name.utf8(runtime);
+
+  // Do the happy-paths first
+
+  // Check function cache
+  auto cachedFunc = _hostFunctionCache.find(nameStr);
+  if (cachedFunc != _hostFunctionCache.end()) {
+    return cachedFunc->second.asFunction(runtime);
+  }
 
   // Check the static getters map
   const JsiPropertyGettersMap &getters = getExportedPropertyGettersMap();
@@ -65,23 +71,6 @@ jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
     return dispatcher(runtime);
   }
 
-  // Check the cache for functions
-  auto runtimeCache = _cache.find(&runtime);
-  JsiHostFunctionCache *currentCache;
-  if (runtimeCache != _cache.end()) {
-    currentCache = &runtimeCache->second;
-    // Check if the runtime cache as a cache of the host function
-    auto cachedFunc = runtimeCache->second.find(nameStr);
-    if (cachedFunc != runtimeCache->second.end()) {
-      return cachedFunc->second->asFunction(runtime);
-    }
-  } else {
-    // Create cache for this runtime
-    JsiHostFunctionCache runtimeCache;
-    _cache.emplace(&runtime, JsiHostFunctionCache{});
-    currentCache = &_cache.at(&runtime);
-  }
-
   // Check the static function map
   const JsiFunctionMap &funcs = getExportedFunctionMap();
   auto func = funcs.find(nameStr);
@@ -91,13 +80,12 @@ jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
                   std::placeholders::_1, std::placeholders::_2,
                   std::placeholders::_3, std::placeholders::_4);
 
-    // Add to cache
-    currentCache->emplace(nameStr, std::make_unique<jsi::Function>(
-                                       jsi::Function::createFromHostFunction(
-                                           runtime, name, 0, dispatcher)));
-
-    // return retVal;
-    return currentCache->at(nameStr)->asFunction(runtime);
+    // Add to cache - it is important to cache the results from the
+    // createFromHostFunction function which takes some time.
+    return _hostFunctionCache
+        .emplace(nameStr, jsi::Function::createFromHostFunction(runtime, name,
+                                                                0, dispatcher))
+        .first->second.asFunction(runtime);
   }
 
   if (_funcMap.count(nameStr) > 0) {

package/cpp/jsi/JsiHostObject.h

@@ -3,6 +3,7 @@
 #include <jsi/jsi.h>
 
 #include <functional>
+#include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -123,12 +124,6 @@ using JsiPropertySettersMap =
     std::unordered_map<std::string, void (JsiHostObject::*)(
                                         jsi::Runtime &, const jsi::Value &)>;
 
-using JsiHostFunctionCache =
-    std::unordered_map<std::string, std::unique_ptr<jsi::Function>>;
-
-using JsiRuntimeCache =
-    std::unordered_map<jsi::Runtime *, JsiHostFunctionCache>;
-
 /**
  * Base class for jsi host objects
  */
@@ -240,9 +235,134 @@ protected:
                            });
   }
 
+  /**
+   @Returns a reference to the argument at the given position in the arguments
+   array. Raises an error if the index is above the number of arguments.
+   @param runtime jsi::Runtime
+   @param arguments Arguments list
+   @param count Number of arguments in arguments list
+   @param index Index of parameter to return
+   */
+  static const jsi::Value &getArgument(jsi::Runtime &runtime,
+                                       const jsi::Value *arguments,
+                                       size_t count, size_t index) {
+    if (index >= count) {
+      throw jsi::JSError(runtime, "Argument index out of bounds.");
+    }
+
+    return arguments[index];
+  }
+
+  /**
+   Returns argument as number or throws
+   */
+  static double getArgumentAsNumber(jsi::Runtime &runtime,
+                                    const jsi::Value *arguments, size_t count,
+                                    size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isNumber()) {
+      throw jsi::JSError(runtime,
+                         "Expected type number for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asNumber();
+  }
+
+  /**
+   Returns argument as bool or throws
+   */
+  static bool getArgumentAsBool(jsi::Runtime &runtime,
+                                const jsi::Value *arguments, size_t count,
+                                size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isBool()) {
+      throw jsi::JSError(runtime,
+                         "Expected type boolean for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.getBool();
+  }
+
+  /**
+   Returns argument as string or throws
+   */
+  static jsi::String getArgumentAsString(jsi::Runtime &runtime,
+                                         const jsi::Value *arguments,
+                                         size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isString()) {
+      throw jsi::JSError(runtime,
+                         "Expected type string for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asString(runtime);
+  }
+
+  /**
+   Returns argument as object or throws
+   */
+  static jsi::Object getArgumentAsObject(jsi::Runtime &runtime,
+                                         const jsi::Value *arguments,
+                                         size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime,
+                         "Expected type object for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asObject(runtime);
+  }
+
+  /**
+   Returns argument as host object or throws
+   */
+  template <typename T = HostObject>
+  static std::shared_ptr<T>
+  getArgumentAsHostObject(jsi::Runtime &runtime, const jsi::Value *arguments,
+                          size_t count, size_t index) {
+    auto value = getArgumentAsObject(runtime, arguments, count, index);
+    if (!value.isHostObject(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected type host object for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asHostObject<T>(runtime);
+  }
+
+  /**
+   Returns argument as array or throws
+   */
+  static jsi::Array getArgumentAsArray(jsi::Runtime &runtime,
+                                       const jsi::Value *arguments,
+                                       size_t count, size_t index) {
+    auto value = getArgumentAsObject(runtime, arguments, count, index);
+    if (!value.isArray(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected type array for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asArray(runtime);
+  }
+
+  /**
+   Returns argument as function or throws
+   */
+  static jsi::Object getArgumentAsFunction(jsi::Runtime &runtime,
+                                           const jsi::Value *arguments,
+                                           size_t count, size_t index) {
+    auto value = getArgumentAsObject(runtime, arguments, count, index);
+    if (!value.isFunction(runtime)) {
+      throw jsi::JSError(runtime,
+                         "Expected type function for parameter at index " +
+                             std::to_string(index));
+    }
+    return value.asFunction(runtime);
+  }
+
 private:
   std::unordered_map<std::string, jsi::HostFunctionType> _funcMap;
   std::unordered_map<std::string, JsPropertyType> _propMap;
-  JsiRuntimeCache _cache;
+
+  std::map<std::string, jsi::Function> _hostFunctionCache;
 };
 } // namespace RNJsi

package/cpp/jsi/JsiValue.cpp

@@ -0,0 +1,346 @@
+#include "JsiValue.h"
+
+namespace RNJsi {
+
+JsiValue::JsiValue() : _type(PropType::Undefined) {}
+
+JsiValue::JsiValue(jsi::Runtime &runtime, const jsi::Value &value)
+    : JsiValue() {
+  setCurrent(runtime, value);
+}
+
+void JsiValue::setCurrent(jsi::Runtime &runtime, const jsi::Value &value) {
+  _stringValue = "";
+  _hostObject = nullptr;
+  _hostFunction = nullptr;
+  _props.clear();
+  _array.clear();
+  _keysCache.clear();
+
+  if (value.isNumber()) {
+    _type = PropType::Number;
+    _numberValue = value.asNumber();
+  } else if (value.isBool()) {
+    _type = PropType::Bool;
+    _boolValue = value.getBool();
+  } else if (value.isString()) {
+    _type = PropType::String;
+    _stringValue = value.asString(runtime).utf8(runtime);
+  } else if (value.isUndefined()) {
+    _type = PropType::Undefined;
+  } else if (value.isNull()) {
+    _type = PropType::Null;
+  } else if (value.isObject()) {
+    setObject(runtime, value);
+  } else {
+    throw std::runtime_error("Could not store jsi::Value of provided type");
+  }
+}
+
+bool JsiValue::getAsBool() const {
+  if (_type != PropType::Bool) {
+    throw std::runtime_error("Expected type bool, got " +
+                             getTypeAsString(_type));
+  }
+  return _boolValue;
+}
+
+double JsiValue::getAsNumber() const {
+  if (_type != PropType::Number) {
+    throw std::runtime_error("Expected type number, got " +
+                             getTypeAsString(_type));
+  }
+  return _numberValue;
+}
+
+const std::string &JsiValue::getAsString() const {
+  if (_type == PropType::Number) {
+    return std::move(std::to_string(_numberValue));
+  }
+
+  if (_type != PropType::String) {
+    throw std::runtime_error("Expected type string, got " +
+                             getTypeAsString(_type));
+  }
+  return _stringValue;
+}
+
+const std::vector<JsiValue> &JsiValue::getAsArray() const {
+  if (_type != PropType::Array) {
+    throw std::runtime_error("Expected type array, got " +
+                             getTypeAsString(_type));
+  }
+  return _array;
+}
+
+const JsiValue &JsiValue::getValue(PropId name) const {
+  if (_type != PropType::Object) {
+    throw std::runtime_error("Expected type object, got " +
+                             getTypeAsString(_type));
+  }
+  return _props.at(name);
+}
+
+bool JsiValue::hasValue(PropId name) const {
+  if (_type != PropType::Object) {
+    throw std::runtime_error("Expected type object, got " +
+                             getTypeAsString(_type));
+  }
+  return _props.count(name) > 0;
+}
+
+std::vector<PropId> JsiValue::getKeys() const {
+  if (_type != PropType::Object) {
+    throw std::runtime_error("Expected type object, got " +
+                             getTypeAsString(_type));
+  }
+  return _keysCache;
+}
+
+std::shared_ptr<jsi::HostObject> JsiValue::getAsHostObject() const {
+  if (_type != PropType::HostObject) {
+    throw std::runtime_error("Expected type host object, got " +
+                             getTypeAsString(_type));
+  }
+  return _hostObject;
+}
+
+jsi::HostFunctionType JsiValue::getAsHostFunction() const {
+  if (_type != PropType::HostFunction) {
+    throw std::runtime_error("Expected type host function, got " +
+                             getTypeAsString(_type));
+  }
+  return _hostFunction;
+}
+
+const jsi::HostFunctionType JsiValue::getAsFunction() const {
+  return getAsHostFunction();
+}
+
+std::string JsiValue::asString() const {
+  switch (_type) {
+  case PropType::Null:
+    return "(null)";
+  case PropType::Undefined:
+    return "(undefined)";
+  case PropType::Number:
+    return std::to_string(_numberValue);
+  case PropType::Bool:
+    return std::to_string(_boolValue);
+  case PropType::String:
+    return _stringValue;
+  case PropType::Object:
+    return "[Object]";
+  case PropType::Array:
+    return "[Array]";
+  case PropType::HostObject:
+    return "[HostObject]";
+  case PropType::HostFunction:
+    return "[HostFunction]";
+  }
+}
+
+jsi::Value JsiValue::getAsJsiValue(jsi::Runtime &runtime) const {
+  switch (_type) {
+  case PropType::Undefined:
+    return jsi::Value::undefined();
+  case PropType::Null:
+    return jsi::Value::null();
+  case PropType::Number:
+    return _numberValue;
+  case PropType::Bool:
+    return _boolValue;
+  case PropType::String:
+    return jsi::String::createFromUtf8(runtime, _stringValue);
+  case PropType::Object:
+    return getObject(runtime);
+  case PropType::Array:
+    return getArray(runtime);
+  case PropType::HostObject:
+    return getHostObject(runtime);
+  case PropType::HostFunction:
+    return getHostFunction(runtime);
+  }
+}
+
+std::string JsiValue::getTypeAsString(PropType type) {
+  switch (type) {
+  case PropType::Undefined:
+    return "undefined";
+  case PropType::Null:
+    return "null";
+  case PropType::Number:
+    return "number";
+  case PropType::Bool:
+    return "boolean";
+  case PropType::String:
+    return "string";
+  case PropType::Object:
+    return "object";
+  case PropType::Array:
+    return "array";
+  case PropType::HostObject:
+    return "hostobject";
+  case PropType::HostFunction:
+    return "hostfunction";
+  }
+}
+
+void JsiValue::setObject(jsi::Runtime &runtime, const jsi::Value &value) {
+  auto obj = value.asObject(runtime);
+  if (obj.isFunction(runtime)) {
+    setFunction(runtime, value);
+  } else if (obj.isArray(runtime)) {
+    setArray(runtime, obj);
+  } else if (obj.isHostObject(runtime)) {
+    setHostObject(runtime, obj);
+  } else {
+    _type = PropType::Object;
+    // Read object keys
+    auto keys = obj.getPropertyNames(runtime);
+    size_t size = keys.size(runtime);
+    _keysCache.clear();
+    _keysCache.reserve(size);
+    _props.clear();
+    _props.reserve(size);
+
+    for (size_t i = 0; i < size; ++i) {
+      auto key = JsiPropId::get(
+          keys.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime));
+      try {
+        _props.try_emplace(key, runtime, obj.getProperty(runtime, key));
+        _keysCache.push_back(key);
+      } catch (jsi::JSError e) {
+        throw jsi::JSError(runtime,
+                           "Could not set property for key " +
+                               std::string(key) + ":\n" + e.getMessage(),
+                           e.getStack());
+      }
+    }
+  }
+}
+
+jsi::Object JsiValue::getObject(jsi::Runtime &runtime) const {
+  assert(_type == PropType::Object);
+  auto obj = jsi::Object(runtime);
+  for (auto &p : _props) {
+    obj.setProperty(runtime, p.first, p.second.getAsJsiValue(runtime));
+  }
+  return obj;
+}
+
+bool JsiValue::operator!=(const JsiValue &other) const {
+  return !(this->operator==(other));
+}
+
+bool JsiValue::operator==(const JsiValue &other) const {
+
+  if (other.getType() != getType()) {
+    return false;
+  }
+
+  switch (_type) {
+  case PropType::Null:
+  case PropType::Undefined:
+    return true;
+  case PropType::Number:
+    return _numberValue == other.getAsNumber();
+  case PropType::Bool:
+    return _boolValue == other.getAsBool();
+  case PropType::String:
+    return _stringValue == other.getAsString();
+  case PropType::Object: {
+    if (_props.size() != other.getProps().size()) {
+      return false;
+    }
+    for (auto &p : _props) {
+      auto t = p.second.operator==(other.getValue(p.first));
+      if (!t) {
+        return false;
+      }
+    }
+    return true;
+  }
+  case PropType::Array: {
+    auto otherArr = other.getAsArray();
+    if (_array.size() != otherArr.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < _array.size(); ++i) {
+      if (!_array[i].operator==(otherArr[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  case PropType::HostObject:
+    return getAsHostObject() == other.getAsHostObject();
+  case PropType::HostFunction:
+    // Unable to compare host functions
+    return false;
+  }
+
+  throw std::runtime_error(
+      "Wrong type in equals call. Should not happen. File a bug.");
+
+  return false;
+}
+
+void JsiValue::setFunction(jsi::Runtime &runtime, const jsi::Value &value) {
+  auto func = value.asObject(runtime).asFunction(runtime);
+  if (func.isHostFunction(runtime)) {
+    _type = PropType::HostFunction;
+    _hostFunction = func.getHostFunction(runtime);
+  } else {
+    _type = PropType::HostFunction;
+    auto obj = std::make_shared<jsi::Object>(value.asObject(runtime));
+    _hostFunction = [obj](jsi::Runtime &runtime, const jsi::Value &thisValue,
+                          const jsi::Value *arguments,
+                          size_t count) -> jsi::Value {
+      auto func = obj->asFunction(runtime);
+      if (thisValue.isNull() || thisValue.isUndefined()) {
+        return func.call(runtime, arguments, count);
+      } else {
+        return func.callWithThis(runtime, thisValue.asObject(runtime),
+                                 arguments, count);
+      }
+    };
+  }
+}
+
+jsi::Object JsiValue::getHostFunction(jsi::Runtime &runtime) const {
+  assert(_type == PropType::HostFunction);
+  return jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forUtf8(runtime, "fn"), 0, _hostFunction);
+}
+
+void JsiValue::setArray(jsi::Runtime &runtime, const jsi::Object &obj) {
+  _type = PropType::Array;
+  auto arr = obj.asArray(runtime);
+  size_t size = arr.size(runtime);
+  _array.reserve(size);
+  for (size_t i = 0; i < size; ++i) {
+    _array.emplace_back(runtime, arr.getValueAtIndex(runtime, i));
+  }
+}
+
+jsi::Array JsiValue::getArray(jsi::Runtime &runtime) const {
+  assert(_type == PropType::Array);
+  jsi::Array arr = jsi::Array(runtime, _array.size());
+  for (size_t i = 0; i < _array.size(); ++i) {
+    arr.setValueAtIndex(runtime, i, _array[i].getAsJsiValue(runtime));
+  }
+  return arr;
+}
+
+void JsiValue::setHostObject(jsi::Runtime &runtime, const jsi::Object &obj) {
+  _type = PropType::HostObject;
+  _hostObject = obj.asHostObject(runtime);
+}
+
+jsi::Object JsiValue::getHostObject(jsi::Runtime &runtime) const {
+  assert(_type == PropType::HostObject);
+  return jsi::Object::createFromHostObject(runtime, _hostObject);
+}
+
+} // namespace RNJsi