@shopify/react-native-skia 1.11.4 → 1.11.6

package/src/specs/NativeSkiaModule.web.ts

@@ -0,0 +1,38 @@
+import type { SkRect } from "../skia/types";
+import type { ISkiaViewApi } from "../views/types";
+import type { SkiaPictureView } from "../views/SkiaPictureView.web";
+
+export type ISkiaViewApiWeb = ISkiaViewApi & {
+  views: Record<string, SkiaPictureView>;
+  registerView(nativeId: string, view: SkiaPictureView): void;
+};
+
+global.SkiaViewApi = {
+  views: {},
+  web: true,
+  registerView(nativeId: string, view: SkiaPictureView) {
+    this.views[nativeId] = view;
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setJsiProperty(nativeId: number, name: string, value: any) {
+    if (name === "picture") {
+      this.views[`${nativeId}`].setPicture(value);
+    }
+  },
+  requestRedraw(nativeId: number) {
+    this.views[`${nativeId}`].redraw();
+  },
+  makeImageSnapshot(nativeId: number, rect?: SkRect) {
+    return this.views[`${nativeId}`].makeImageSnapshot(rect);
+  },
+  makeImageSnapshotAsync(nativeId: number, rect?: SkRect) {
+    return new Promise((resolve, reject) => {
+      const result = this.views[`${nativeId}`].makeImageSnapshot(rect);
+      if (result) {
+        resolve(result);
+      } else {
+        reject(new Error("Failed to make image snapshot"));
+      }
+    });
+  },
+} as ISkiaViewApiWeb;

package/src/specs/SkiaPictureViewNativeComponent.web.ts

@@ -0,0 +1,39 @@
+import type { ViewProps } from "react-native";
+import { createElement, useEffect, useRef } from "react";
+
+import { SkiaPictureView } from "../views/SkiaPictureView.web";
+
+import type { ISkiaViewApiWeb } from "./NativeSkiaModule.web";
+
+export interface NativeProps extends ViewProps {
+  debug?: boolean;
+  opaque?: boolean;
+  nativeID: string;
+}
+
+const SkiaPictureViewNativeComponent = ({
+  nativeID,
+  debug,
+  opaque,
+  onLayout,
+  ...viewProps
+}: NativeProps) => {
+  const ref = useRef(null);
+  useEffect(() => {
+    if (ref.current) {
+      (global.SkiaViewApi as ISkiaViewApiWeb).registerView(
+        nativeID,
+        ref.current
+      );
+    }
+  }, [nativeID]);
+  return createElement(SkiaPictureView, {
+    ref,
+    debug,
+    opaque,
+    onLayout,
+    ...viewProps,
+  });
+};
+// eslint-disable-next-line import/no-default-export
+export default SkiaPictureViewNativeComponent;

package/src/views/types.ts

@@ -10,6 +10,7 @@ export type NativeSkiaViewProps = ViewProps & {
 };
 
 export interface ISkiaViewApi {
+  web?: boolean;
   setJsiProperty: <T>(nativeId: number, name: string, value: T) => void;
   requestRedraw: (nativeId: number) => void;
   makeImageSnapshot: (nativeId: number, rect?: SkRect) => SkImage;

package/cpp/jsi/JsiValue.cpp

@@ -1,345 +0,0 @@
-#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::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

package/cpp/jsi/JsiValue.h

@@ -1,222 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace RNJsi {
-
-namespace jsi = facebook::jsi;
-
-enum struct PropType {
-  Undefined = 0,
-  Null = 1, // Keep undefined / null constant so that we can do checks faster
-  Bool = 2,
-  Number = 3,
-  String = 4,
-  Object = 5,
-  HostObject = 6,
-  HostFunction = 7,
-  Array = 8
-};
-
-using PropId = const char *;
-
-class JsiPropId {
-public:
-  static const char *get(const std::string &name) { return _get(name); }
-
-  static const char *get(const std::string &&name) {
-    return _get(std::move(name));
-  }
-
-private:
-  static const char *_get(const std::string &name) {
-    if (_impls().count(name) == 0) {
-      // Alloc string
-      char *impl = new char[name.size() + 1];
-      strncpy(impl, name.c_str(), name.size() + 1);
-      _impls().emplace(name, impl);
-    }
-    return _impls().at(name);
-  }
-
-  static std::unordered_map<std::string, PropId> &_impls() {
-    static std::unordered_map<std::string, PropId> impls;
-    return impls;
-  }
-};
-
-/**
- This is a class that deep copies values from JS to C++.
- */
-class JsiValue {
-public:
-  /**
-   Default constructor for an empty JsiValue
-   */
-  JsiValue();
-
-  /**
-   Constructs an instance of the JsiValue object with a current value
-   */
-  JsiValue(jsi::Runtime &runtime, const jsi::Value &value);
-
-  /**
-   Updates the current value from the Javascript value. This function will
-   perform a deep copy of the javascript value.
-   */
-  void setCurrent(jsi::Runtime &runtime, const jsi::Value &value);
-
-  /**
-   Returns the type of value contained in this JsiValue
-   */
-  PropType getType() const { return _type; }
-
-  /**
-   Returns true if the value is undefined or null.
-   */
-  bool isUndefinedOrNull() const { return _type <= PropType::Null; }
-
-  /**
-   Returns true if the value is undefined.
-   */
-  bool isUndefined() const { return _type == PropType::Undefined; }
-
-  /**
-   Returns true if the value is null.
-   */
-  bool isNull() const { return _type == PropType::Null; }
-
-  /**
-   Returns the bool value. Requires that the underlying type is bool
-   */
-  bool getAsBool() const;
-
-  /**
-   Returns the numeric value. Requires that the underlying type is number
-   */
-  double getAsNumber() const;
-
-  /**
-   Returns the string value. Requires that the underlying type is string
-   */
-  const std::string &getAsString() const;
-
-  /**
-   Returns the array value. Requires that the underlying type is array
-   */
-  const std::vector<JsiValue> &getAsArray() const;
-
-  /**
-   Returns an inner value by name. Requires that the underlying type is Object
-   */
-  const JsiValue &getValue(PropId name) const;
-
-  /**
-   Returns true if the underlying type is Object and the property name exists.
-   */
-  bool hasValue(PropId name) const;
-
-  /**
-   Returns the names of the properties stored in this value
-   */
-  std::vector<PropId> getKeys() const;
-
-  /**
-   Returns the host object value. Requires that the underlying type is Host
-   Object
-   */
-  std::shared_ptr<jsi::HostObject> getAsHostObject() const;
-
-  /**
-   Returns a dynamic cast of the host object value. Requires that the underlying
-   type is Host Object
-   */
-  template <typename T> std::shared_ptr<T> getAs() const {
-    if (_type != PropType::HostObject) {
-      throw std::runtime_error("Expected type host object, got " +
-                               getTypeAsString(_type));
-    }
-    return std::dynamic_pointer_cast<T>(_hostObject);
-  }
-
-  /**
-   Returns the host function. Requires that the type is HostFunction
-   */
-  jsi::HostFunctionType getAsHostFunction() const;
-
-  /**
-   Returns a callable HostFunction representing the undderlying js function.
-   Requires that the type is Function
-   */
-  const jsi::HostFunctionType getAsFunction() const;
-
-  /**
-   Returns a string representation of the value
-   */
-  std::string asString() const;
-
-  /**
-   Converts the underlying value back to a JS value
-   */
-  jsi::Value getAsJsiValue(jsi::Runtime &runtime) const;
-
-  /**
-   Returns a string representing the type.
-   */
-  static std::string getTypeAsString(PropType type);
-
-  /**
-   Implements the equals operator
-   */
-  bool operator==(const JsiValue &other) const;
-
-  /**
-   Implements the inequals operator
-   */
-  bool operator!=(const JsiValue &other) const;
-
-protected:
-  const std::unordered_map<PropId, JsiValue> &getProps() const {
-    return _props;
-  }
-
-  bool boolValue() const { return _boolValue; }
-  double numberValue() const { return _numberValue; }
-  std::string stringValue() const { return _stringValue; }
-  std::shared_ptr<jsi::HostObject> hostObject() const { return _hostObject; }
-  jsi::HostFunctionType hostFunction() const { return _hostFunction; }
-  std::vector<JsiValue> array() const { return _array; }
-  std::unordered_map<PropId, JsiValue> props() const { return _props; }
-  const std::vector<PropId> &keysCache() const { return _keysCache; }
-
-private:
-  void setObject(jsi::Runtime &runtime, const jsi::Value &value);
-  jsi::Object getObject(jsi::Runtime &runtime) const;
-
-  void setFunction(jsi::Runtime &runtime, const jsi::Value &value);
-  jsi::Object getHostFunction(jsi::Runtime &runtime) const;
-
-  void setArray(jsi::Runtime &runtime, const jsi::Object &obj);
-  jsi::Array getArray(jsi::Runtime &runtime) const;
-
-  void setHostObject(jsi::Runtime &runtime, const jsi::Object &obj);
-  jsi::Object getHostObject(jsi::Runtime &runtime) const;
-
-  PropType _type = PropType::Undefined;
-  bool _boolValue;
-  double _numberValue;
-  std::string _stringValue = "";
-  std::shared_ptr<jsi::HostObject> _hostObject;
-  jsi::HostFunctionType _hostFunction;
-  std::vector<JsiValue> _array;
-  std::unordered_map<PropId, JsiValue> _props;
-  std::vector<PropId> _keysCache;
-};
-
-} // namespace RNJsi

package/lib/commonjs/renderer/Canvas.web.d.ts

@@ -1,10 +0,0 @@
-import type { ViewProps } from "react-native";
-import type { SharedValue } from "react-native-reanimated";
-import type { SkSize } from "../skia/types";
-export interface CanvasProps extends ViewProps {
-    debug?: boolean;
-    opaque?: boolean;
-    onSize?: SharedValue<SkSize>;
-    mode?: "continuous" | "default";
-}
-export declare const Canvas: import("react").ForwardRefExoticComponent<CanvasProps & import("react").RefAttributes<unknown>>;