@shopify/react-native-skia 1.5.10 → 1.7.0

package/src/renderer/__tests__/e2e/Matrix4.spec.tsx

@@ -12,6 +12,9 @@ import {
   toMatrix3,
   Matrix4,
   mapPoint3d,
+  invert4,
+  scale,
+  rotateZ,
 } from "../../../skia/types";
 
 const ckPerspective = (d: number) => [
@@ -272,4 +275,94 @@ describe("Matrix4", () => {
     const result = mapPoint3d(translationMatrix, point);
     expect(result).toEqual(expectedResult);
   });
+
+  const almostEqual = (
+    a: number[] | Matrix4 | readonly [number, number, number],
+    b: number[] | Matrix4 | readonly [number, number, number],
+    epsilon = 1e-10
+  ) => {
+    expect(a.length).toBe(b.length);
+    a.forEach((val, idx) => {
+      expect(Math.abs(val - b[idx])).toBeLessThan(epsilon);
+    });
+  };
+
+  const matrixEqual = (a: number[] | Matrix4, b: number[] | Matrix4) => {
+    expect(a.length).toBe(b.length);
+    a.forEach((val, idx) => {
+      // Object.is will distinguish -0 from 0, so we use === instead
+      const equal = val === b[idx] || (val === 0 && b[idx] === 0);
+      expect(equal).toBe(true);
+    });
+  };
+
+  it("should return the identity matrix when inverting the identity matrix", () => {
+    const identityMatrix = Matrix4();
+    const result = invert4(identityMatrix);
+    matrixEqual(result, identityMatrix);
+  });
+
+  it("should correctly invert a translation matrix", () => {
+    const translationMatrix = translate(100, -50, 25);
+    const inverse = invert4(translationMatrix);
+    // Inverse of translation(x,y,z) should be translation(-x,-y,-z)
+    const expectedInverse = translate(-100, 50, -25);
+    matrixEqual(inverse, expectedInverse);
+  });
+
+  it("should correctly invert a scale matrix", () => {
+    const scaleMatrix = scale(2, 4, 8);
+    const inverse = invert4(scaleMatrix);
+    // Inverse of scale(x,y,z) should be scale(1/x,1/y,1/z)
+    const expectedInverse = scale(1 / 2, 1 / 4, 1 / 8);
+    matrixEqual(inverse, expectedInverse);
+  });
+
+  it("should return identity matrix for non-invertible matrix", () => {
+    // A matrix of all zeros is not invertible
+    const nonInvertibleMatrix = [
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ] as Matrix4;
+    const result = invert4(nonInvertibleMatrix);
+    matrixEqual(result, Matrix4());
+  });
+
+  it("multiplying a matrix by its inverse should give the identity matrix", () => {
+    // Create a complex transformation matrix
+    const complexMatrix = processTransform3d([
+      { scale: 2 },
+      { rotateZ: Math.PI / 4 },
+      { translate: [100, 100, 50] as const },
+    ]);
+
+    const inverse = invert4(complexMatrix);
+    const result = multiply4(complexMatrix, inverse);
+
+    // Due to floating point arithmetic, we use almostEqual instead of exact equality
+    almostEqual(result, Matrix4());
+  });
+
+  it("should correctly transform points when using inverse matrix", () => {
+    const transformMatrix = translate(100, 100, 100);
+    const inverse = invert4(transformMatrix);
+
+    const point = [200, 0, 300] as const;
+    const transformedPoint = mapPoint3d(inverse, point);
+    const expectedPoint = [100, -100, 200] as const;
+
+    // Using almostEqual for floating point comparison
+    almostEqual(transformedPoint, expectedPoint);
+  });
+
+  it("should maintain inverse relationship for rotations", () => {
+    const rotationMatrix = rotateZ(Math.PI / 3); // 60 degrees rotation
+    const inverse = invert4(rotationMatrix);
+    const point = [100, 100, 0] as const;
+
+    // Transform point forward then backward should give original point
+    const transformed = mapPoint3d(rotationMatrix, point);
+    const backTransformed = mapPoint3d(inverse, transformed);
+
+    almostEqual(backTransformed, point);
+  });
 });

package/src/skia/__tests__/Enums.spec.ts

@@ -4,7 +4,6 @@ import {
   AlphaType,
   BlurStyle,
   ClipOp,
-  ColorType,
   FillType,
   FilterMode,
   FontEdging,
@@ -27,6 +26,7 @@ import {
 import { Path1DEffectStyle } from "../types/PathEffect";
 import { BlendMode } from "../types/Paint/BlendMode";
 import { mapKeys } from "../../renderer/typeddash";
+import { ColorTypeCanvasKit } from "../types/Image/ColorType.web";
 
 import { setupSkia } from "./setup";
 
@@ -71,7 +71,7 @@ describe("Enums", () => {
   });
   it("Should match Image enums values with CanvasKit", () => {
     const { CanvasKit } = setupSkia();
-    checkEnum(ColorType, CanvasKit.ColorType);
+    checkEnum(ColorTypeCanvasKit, CanvasKit.ColorType);
     checkEnum(AlphaType, CanvasKit.AlphaType);
     checkEnum(ImageFormat, CanvasKit.ImageFormat);
     checkEnum(MipmapMode, CanvasKit.MipmapMode);

package/src/skia/types/Image/ColorType.ts

@@ -0,0 +1,21 @@
+export enum ColorType {
+  Unknown, // uninitialized
+  Alpha_8, // pixel with alpha in 8-bit byte
+  RGB_565, // pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
+  ARGB_4444, // pixel with 4 bits for alpha, red, green, blue; in 16-bit word
+  RGBA_8888, // pixel with 8 bits for red, green, blue, alpha; in 32-bit word
+  RGB_888x, // pixel with 8 bits each for red, green, blue; in 32-bit word
+  BGRA_8888, // pixel with 8 bits for blue, green, red, alpha; in 32-bit word
+  RGBA_1010102, // 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
+  BGRA_1010102, // 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
+  RGB_101010x, // pixel with 10 bits each for red, green, blue; in 32-bit word
+  BGR_101010x, // pixel with 10 bits each for blue, green, red; in 32-bit word
+  BGR_101010x_XR, // pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
+  BGRA_10101010_XR, // pixel with 10 bits each for blue, green, red, alpha; in 64-bit word, extended range
+  RGBA_10x6, // pixel with 10 used bits (most significant) followed by 6 unused
+  Gray_8, // pixel with grayscale level in 8-bit byte
+  RGBA_F16Norm, // pixel with half floats in [0,1] for red, green, blue, alpha; in 64-bit word
+  RGBA_F16, // pixel with half floats for red, green, blue, alpha; in 64-bit word
+  RGB_F16F16F16x, // pixel with half floats for red, green, blue; in 64-bit word
+  RGBA_F32, // pixel using C float for red, green, blue, alpha; in 128-bit word
+}

package/src/skia/types/Image/ColorType.web.ts

@@ -0,0 +1,19 @@
+export enum ColorTypeCanvasKit {
+  Unknown, // uninitialized
+  Alpha_8, // pixel with alpha in 8-bit byte
+  RGB_565, // pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
+  ARGB_4444, // pixel with 4 bits for alpha, red, green, blue; in 16-bit word
+  RGBA_8888, // pixel with 8 bits for red, green, blue, alpha; in 32-bit word
+  RGB_888x, // pixel with 8 bits each for red, green, blue; in 32-bit word
+  BGRA_8888, // pixel with 8 bits for blue, green, red, alpha; in 32-bit word
+  RGBA_1010102, // 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
+  BGRA_1010102, // 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
+  RGB_101010x, // pixel with 10 bits each for red, green, blue; in 32-bit word
+  BGR_101010x, // pixel with 10 bits each for blue, green, red; in 32-bit word
+  BGR_101010x_XR, // pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
+  RGBA_10x6, // pixel with 10 used bits (most significant) followed by 6 unused
+  Gray_8, // pixel with grayscale level in 8-bit byte
+  RGBA_F16Norm, // pixel with half floats in [0,1] for red, green, blue, alpha; in 64-bit word
+  RGBA_F16, // pixel with half floats for red, green, blue, alpha; in 64-bit word
+  RGBA_F32, // pixel using C float for red, green, blue, alpha; in 128-bit word
+}

package/src/skia/types/Image/Image.ts

@@ -48,6 +48,17 @@ export interface SkImage extends SkJSIInstance<"Image"> {
    */
   getImageInfo(): ImageInfo;
 
+  /**
+   * Returns the backend texture of the image.
+   * The returned object can be used to create a Skia Image object.
+   * The returned object is backend specific and should be used with caution.
+   * It is the caller's responsibility to ensure that the texture is not used after the image is deleted.
+   * The returned object may be null if the image does not have a backend texture.
+   *
+   * @return backend texture of the image or null
+   */
+  getNativeTextureUnstable(): unknown;
+
   /**
    * Returns this image as a shader with the specified tiling. It will use cubic sampling.
    * @param tx - tile mode in the x direction.

package/src/skia/types/Image/ImageFactory.ts

@@ -1,6 +1,7 @@
 import type { SkData } from "../Data";
 import type { NativeBuffer } from "../NativeBuffer";
 
+import type { ColorType } from "./ColorType";
 import type { SkImage } from "./Image";
 
 export enum AlphaType {
@@ -10,26 +11,6 @@ export enum AlphaType {
   Unpremul,
 }
 
-export enum ColorType {
-  Unknown, // uninitialized
-  Alpha_8, // pixel with alpha in 8-bit byte
-  RGB_565, // pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
-  ARGB_4444, // pixel with 4 bits for alpha, red, green, blue; in 16-bit word
-  RGBA_8888, // pixel with 8 bits for red, green, blue, alpha; in 32-bit word
-  RGB_888x, // pixel with 8 bits each for red, green, blue; in 32-bit word
-  BGRA_8888, // pixel with 8 bits for blue, green, red, alpha; in 32-bit word
-  RGBA_1010102, // 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
-  BGRA_1010102, // 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
-  RGB_101010x, // pixel with 10 bits each for red, green, blue; in 32-bit word
-  BGR_101010x, // pixel with 10 bits each for blue, green, red; in 32-bit word
-  BGR_101010x_XR, // pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
-  RGBA_10x6, // pixel with 10 used bits (most significant) followed by 6 unused
-  Gray_8, // pixel with grayscale level in 8-bit byte
-  RGBA_F16Norm, // pixel with half floats in [0,1] for red, green, blue, alpha; in 64-bit word
-  RGBA_F16, // pixel with half floats for red, green, blue, alpha; in 64-bit word
-  RGBA_F32, // pixel using C float for red, green, blue, alpha; in 128-bit word
-}
-
 export interface ImageInfo {
   alphaType: AlphaType;
   // TODO: add support for color space
@@ -68,6 +49,30 @@ export interface ImageFactory {
    */
   MakeImageFromNativeBuffer: (nativeBuffer: NativeBuffer) => SkImage;
 
+  /**
+   *
+   * Return an Image backed by a given native texture.
+   *
+   * The native texture must be a valid owning reference.
+   *
+   * This API might be used to integrate with other libraries using gpu textures,
+   * or to transfer images between different threads.
+   *
+   * @param texture A native texture handle
+   * @param width The width of the texture
+   * @param height The height of the texture
+   * @param mipmapped Whether the texture is mipmapped
+   * @throws Throws an error if the Image could not be created, for example when the given native texture is invalid.
+   *
+   * @returns Returns a valid SkImage, if the texture is invalid, an error is thrown.
+   */
+  MakeImageFromNativeTextureUnstable: (
+    texture: unknown,
+    width: number,
+    height: number,
+    mipmapped?: boolean
+  ) => SkImage;
+
   /**
    * Returns an image that will be a screenshot of the view represented by
    * the view tag

package/src/skia/types/Image/index.ts

@@ -1,2 +1,3 @@
 export * from "./Image";
 export * from "./ImageFactory";
+export * from "./ColorType";

package/src/skia/types/Matrix4.ts

@@ -370,3 +370,104 @@ export const convertToAffineMatrix = (m4: Matrix4) => {
   // Returning the 6-element affine transformation matrix
   return [a, b, c, d, tx, ty];
 };
+
+/**
+ * Calculates the determinant of a 3x3 matrix
+ * @worklet
+ */
+const det3x3 = (
+  a00: number,
+  a01: number,
+  a02: number,
+  a10: number,
+  a11: number,
+  a12: number,
+  a20: number,
+  a21: number,
+  a22: number
+): number => {
+  "worklet";
+  return (
+    a00 * (a11 * a22 - a12 * a21) +
+    a01 * (a12 * a20 - a10 * a22) +
+    a02 * (a10 * a21 - a11 * a20)
+  );
+};
+
+/**
+ * Inverts a 4x4 matrix
+ * @worklet
+ * @returns The inverted matrix, or the identity matrix if the input is not invertible
+ */
+export const invert4 = (m: Matrix4): Matrix4 => {
+  "worklet";
+
+  const a00 = m[0],
+    a01 = m[1],
+    a02 = m[2],
+    a03 = m[3];
+  const a10 = m[4],
+    a11 = m[5],
+    a12 = m[6],
+    a13 = m[7];
+  const a20 = m[8],
+    a21 = m[9],
+    a22 = m[10],
+    a23 = m[11];
+  const a30 = m[12],
+    a31 = m[13],
+    a32 = m[14],
+    a33 = m[15];
+
+  // Calculate cofactors
+  const b00 = det3x3(a11, a12, a13, a21, a22, a23, a31, a32, a33);
+  const b01 = -det3x3(a10, a12, a13, a20, a22, a23, a30, a32, a33);
+  const b02 = det3x3(a10, a11, a13, a20, a21, a23, a30, a31, a33);
+  const b03 = -det3x3(a10, a11, a12, a20, a21, a22, a30, a31, a32);
+
+  const b10 = -det3x3(a01, a02, a03, a21, a22, a23, a31, a32, a33);
+  const b11 = det3x3(a00, a02, a03, a20, a22, a23, a30, a32, a33);
+  const b12 = -det3x3(a00, a01, a03, a20, a21, a23, a30, a31, a33);
+  const b13 = det3x3(a00, a01, a02, a20, a21, a22, a30, a31, a32);
+
+  const b20 = det3x3(a01, a02, a03, a11, a12, a13, a31, a32, a33);
+  const b21 = -det3x3(a00, a02, a03, a10, a12, a13, a30, a32, a33);
+  const b22 = det3x3(a00, a01, a03, a10, a11, a13, a30, a31, a33);
+  const b23 = -det3x3(a00, a01, a02, a10, a11, a12, a30, a31, a32);
+
+  const b30 = -det3x3(a01, a02, a03, a11, a12, a13, a21, a22, a23);
+  const b31 = det3x3(a00, a02, a03, a10, a12, a13, a20, a22, a23);
+  const b32 = -det3x3(a00, a01, a03, a10, a11, a13, a20, a21, a23);
+  const b33 = det3x3(a00, a01, a02, a10, a11, a12, a20, a21, a22);
+
+  // Calculate determinant
+  const det = a00 * b00 + a01 * b01 + a02 * b02 + a03 * b03;
+
+  // Check if matrix is invertible
+  if (Math.abs(det) < 1e-8) {
+    // Return identity matrix if not invertible
+    return Matrix4();
+  }
+
+  const invDet = 1.0 / det;
+
+  // Calculate inverse matrix
+  return [
+    b00 * invDet,
+    b10 * invDet,
+    b20 * invDet,
+    b30 * invDet,
+    b01 * invDet,
+    b11 * invDet,
+    b21 * invDet,
+    b31 * invDet,
+    b02 * invDet,
+    b12 * invDet,
+    b22 * invDet,
+    b32 * invDet,
+    b03 * invDet,
+    b13 * invDet,
+    b23 * invDet,
+    b33 * invDet,
+  ] as Matrix4;
+};

package/src/skia/types/Surface/Surface.ts

@@ -14,6 +14,18 @@ export interface SkSurface extends SkJSIInstance<"Surface"> {
   */
   getCanvas(): SkCanvas;
 
+  /**
+   * Returns the backend texture of the surface.
+   * The returned object can be used to create a Skia Image object.
+   * The returned object is backend specific and should be used with caution.
+   * It is the caller's responsibility to ensure that the texture is not used after the surface is deleted
+   * or draw operations are performed on the surface.
+   * The returned object may be null if the surface does not have a backend texture.
+   *
+   * @return backend texture of the surface or null
+   */
+  getNativeTextureUnstable(): unknown;
+
   /** Returns Image capturing Surface contents. Subsequent drawing to
      Surface contents are not captured.
 

package/src/skia/web/JsiSkImage.ts

@@ -170,4 +170,9 @@ export class JsiSkImage extends HostObject<Image, "Image"> implements SkImage {
     }
     return new JsiSkImage(this.CanvasKit, img);
   }
+
+  getNativeTextureUnstable(): unknown {
+    console.warn("getBackendTexture is not implemented on Web");
+    return null;
+  }
 }

package/src/skia/web/JsiSkImageFactory.ts

@@ -75,6 +75,10 @@ export class JsiSkImageFactory extends Host implements ImageFactory {
     return new JsiSkImage(this.CanvasKit, image);
   }
 
+  MakeImageFromNativeTextureUnstable(): SkImage {
+    throw new Error("MakeImageFromNativeTexture is not implemented on web");
+  }
+
   MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number) {
     // see toSkImageInfo() from canvaskit
     const image = this.CanvasKit.MakeImage(

package/src/skia/web/JsiSkSurface.ts

@@ -43,4 +43,9 @@ export class JsiSkSurface
     );
     return new JsiSkImage(this.CanvasKit, image);
   }
+
+  getNativeTextureUnstable(): unknown {
+    console.warn("getBackendTexture is not implemented on Web");
+    return null;
+  }
 }

package/src/specs/SkiaPictureViewNativeComponent.ts

@@ -3,6 +3,7 @@ import type { ViewProps } from "react-native";
 
 export interface NativeProps extends ViewProps {
   debug?: boolean;
+  opaque?: boolean;
 }
 
 // eslint-disable-next-line import/no-default-export

package/src/views/SkiaDomView.tsx

@@ -97,12 +97,13 @@ export class SkiaDomView extends React.Component<SkiaDomViewProps> {
   }
 
   render() {
-    const { debug = false, ...viewProps } = this.props;
+    const { debug = false, opaque = false, ...viewProps } = this.props;
     return (
       <NativeSkiaDomView
         collapsable={false}
         nativeID={`${this._nativeId}`}
         debug={debug}
+        opaque={opaque}
         {...viewProps}
       />
     );

package/src/views/SkiaPictureView.tsx

@@ -38,6 +38,7 @@ export class SkiaPictureView extends React.Component<SkiaPictureViewProps> {
   }
 
   componentDidUpdate(prevProps: SkiaPictureViewProps) {
+    console.log("componentDidUpdate");
     const { picture, onSize } = this.props;
     if (picture !== prevProps.picture) {
       assertSkiaViewApi();
@@ -78,16 +79,18 @@ export class SkiaPictureView extends React.Component<SkiaPictureViewProps> {
    */
   public redraw() {
     assertSkiaViewApi();
+    console.log("Request redraw: ", this._nativeId);
     SkiaViewApi.requestRedraw(this._nativeId);
   }
 
   render() {
-    const { mode, debug = false, ...viewProps } = this.props;
+    const { mode, debug = false, opaque = false, ...viewProps } = this.props;
     return (
       <NativeSkiaPictureView
         collapsable={false}
         nativeID={`${this._nativeId}`}
         debug={debug}
+        opaque={opaque}
         {...viewProps}
       />
     );

package/src/views/types.ts

@@ -6,6 +6,7 @@ import type { SharedValueType } from "../renderer/processors/Animations/Animatio
 
 export type NativeSkiaViewProps = ViewProps & {
   debug?: boolean;
+  opaque?: boolean;
 };
 
 export interface DrawingInfo {
@@ -32,6 +33,8 @@ export interface SkiaBaseViewProps extends ViewProps {
    * the Skia view is resized.
    */
   onSize?: SharedValueType<SkSize>;
+
+  opaque?: boolean;
 }
 
 export interface SkiaPictureViewNativeProps extends SkiaBaseViewProps {

package/cpp/jsi/JsiValueWrapper.h

@@ -1,164 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-
-namespace RNJsi {
-namespace jsi = facebook::jsi;
-
-enum JsiWrapperValueType {
-  NonInitialized,
-  Undefined,
-  Null,
-  Bool,
-  Number,
-  String,
-  Object,
-  Function,
-  Array,
-  HostObject,
-  Unknown
-};
-
-/**
- Implements a simple wrapper class for JSI values where the value can be read
- without asking the runtime for any assistance Meaning that we can access
- members without being on the JS thread.
- */
-class JsiValueWrapper {
-public:
-  explicit JsiValueWrapper(jsi::Runtime &runtime)
-      : _type(JsiWrapperValueType::Undefined) {}
-
-  JsiValueWrapper(jsi::Runtime &runtime, const jsi::Value &value)
-      : JsiValueWrapper(runtime) {
-    setCurrent(runtime, value);
-  }
-
-  void setCurrent(jsi::Runtime &runtime, const jsi::Value &value) {
-    if (value.isNumber()) {
-      _type = JsiWrapperValueType::Number;
-      _numberValue = value.asNumber();
-    } else if (value.isBool()) {
-      _type = JsiWrapperValueType::Bool;
-      _boolValue = value.getBool();
-    } else if (value.isString()) {
-      _type = JsiWrapperValueType::String;
-      _stringValue = value.asString(runtime).utf8(runtime);
-    } else if (value.isUndefined()) {
-      _type = JsiWrapperValueType::Undefined;
-    } else if (value.isNull()) {
-      _type = JsiWrapperValueType::Null;
-    } else if (value.isObject()) {
-      _type = JsiWrapperValueType::Object;
-      _objectValue = std::make_shared<jsi::Object>(value.asObject(runtime));
-      if (_objectValue->isFunction(runtime)) {
-        _type = JsiWrapperValueType::Function;
-        _functionValue =
-            std::make_shared<jsi::Function>(_objectValue->asFunction(runtime));
-        _objectValue = nullptr;
-      } else if (_objectValue->isArray(runtime)) {
-        _type = JsiWrapperValueType::Array;
-        _arrayValue =
-            std::make_shared<jsi::Array>(_objectValue->asArray(runtime));
-        _objectValue = nullptr;
-      } else if (_objectValue->isHostObject(runtime)) {
-        _type = JsiWrapperValueType::HostObject;
-        _hostObjectValue = _objectValue->asHostObject(runtime);
-        _objectValue = nullptr;
-      }
-    } else {
-      throw std::runtime_error("Could not store jsi::Value of provided type");
-    }
-    // Save in value holder as well so that we can return current
-    if (_valueHolder == nullptr) {
-      _valueHolder = std::make_shared<jsi::Object>(runtime);
-    }
-    _valueHolder->setProperty(runtime, "current", value);
-  }
-
-  jsi::Value getCurrent(jsi::Runtime &runtime) {
-    if (_valueHolder == nullptr) {
-      return jsi::Value::undefined();
-    }
-    return _valueHolder->getProperty(runtime, "current");
-  }
-
-  bool isUndefinedOrNull() { return isUndefined() || isNull(); }
-
-  bool isUndefined() { return _type == JsiWrapperValueType::Undefined; }
-
-  bool isNull() { return _type == JsiWrapperValueType::Null; }
-
-  bool getAsBool() {
-    assert(_type == JsiWrapperValueType::Bool);
-    return _boolValue;
-  }
-
-  double getAsNumber() {
-    assert(_type == JsiWrapperValueType::Number);
-    return _numberValue;
-  }
-
-  const std::string &getAsString() {
-    assert(_type == JsiWrapperValueType::String);
-    return _stringValue;
-  }
-
-  std::shared_ptr<jsi::Function> getAsFunction() {
-    assert(_type == JsiWrapperValueType::Function);
-    return _functionValue;
-  }
-
-  std::shared_ptr<jsi::Array> getAsArray() {
-    assert(_type == JsiWrapperValueType::Array);
-    return _arrayValue;
-  }
-
-  std::shared_ptr<jsi::Object> getAsObject() {
-    assert(_type == JsiWrapperValueType::Object);
-    return _objectValue;
-  }
-
-  std::shared_ptr<jsi::HostObject> getAsHostObject() {
-    assert(_type == JsiWrapperValueType::HostObject);
-    return _hostObjectValue;
-  }
-
-  JsiWrapperValueType getType() { return _type; }
-
-  bool equals(jsi::Runtime &runtime, const jsi::Value &value) {
-    if (value.isNumber() && _type == JsiWrapperValueType::Number) {
-      return _numberValue == value.asNumber();
-    } else if (value.isBool() && _type == JsiWrapperValueType::Bool) {
-      return _boolValue == value.getBool();
-    } else if (value.isUndefined()) {
-      return _type == JsiWrapperValueType::Undefined;
-    } else if (value.isNull()) {
-      return _type == JsiWrapperValueType::Null;
-    } else if (value.isString()) {
-      auto current = getCurrent(runtime);
-      if (current.isString()) {
-        return jsi::String::strictEquals(runtime, value.asString(runtime),
-                                         current.asString(runtime));
-      }
-      return false;
-    }
-    return false;
-  }
-
-private:
-  std::shared_ptr<jsi::Object> _valueHolder;
-
-  bool _boolValue;
-  double _numberValue;
-  std::string _stringValue;
-  std::shared_ptr<jsi::Object> _objectValue;
-  std::shared_ptr<jsi::Function> _functionValue;
-  std::shared_ptr<jsi::Array> _arrayValue;
-  std::shared_ptr<jsi::HostObject> _hostObjectValue;
-
-  JsiWrapperValueType _type;
-};
-} // namespace RNJsi