@shopify/react-native-skia 0.1.130 → 0.1.133

package/src/skia/web/JsiSkImage.ts

@@ -0,0 +1,87 @@
+/*global btoa, atob*/
+import type { CanvasKit, Image } from "canvaskit-wasm";
+
+import type {
+  ImageFormat,
+  FilterMode,
+  MipmapMode,
+  SkImage,
+  SkMatrix,
+  SkShader,
+  TileMode,
+} from "../types";
+
+import { ckEnum, HostObject, toValue } from "./Host";
+import { JsiSkShader } from "./JsiSkShader";
+
+export class JsiSkImage extends HostObject<Image, "Image"> implements SkImage {
+  constructor(CanvasKit: CanvasKit, ref: Image) {
+    super(CanvasKit, ref, "Image");
+  }
+
+  height() {
+    return this.ref.height();
+  }
+
+  width() {
+    return this.ref.width();
+  }
+
+  makeShaderOptions(
+    tx: TileMode,
+    ty: TileMode,
+    fm: FilterMode,
+    mm: MipmapMode,
+    localMatrix?: SkMatrix
+  ): SkShader {
+    return new JsiSkShader(
+      this.CanvasKit,
+      this.ref.makeShaderOptions(
+        ckEnum(tx),
+        ckEnum(ty),
+        ckEnum(fm),
+        ckEnum(mm),
+        localMatrix ? toValue(localMatrix) : undefined
+      )
+    );
+  }
+
+  makeShaderCubic(
+    tx: TileMode,
+    ty: TileMode,
+    B: number,
+    C: number,
+    localMatrix?: SkMatrix
+  ): SkShader {
+    return new JsiSkShader(
+      this.CanvasKit,
+      this.ref.makeShaderCubic(
+        ckEnum(tx),
+        ckEnum(ty),
+        B,
+        C,
+        localMatrix ? toValue(localMatrix) : undefined
+      )
+    );
+  }
+
+  encodeToBytes(fmt?: ImageFormat, quality?: number) {
+    let result: Uint8Array | null;
+    if (fmt && quality) {
+      result = this.ref.encodeToBytes(ckEnum(fmt), quality);
+    } else if (fmt) {
+      result = this.ref.encodeToBytes(ckEnum(fmt));
+    } else {
+      result = this.ref.encodeToBytes();
+    }
+    if (!result) {
+      throw new Error("encodeToBytes failed");
+    }
+    return result;
+  }
+
+  encodeToBase64(fmt?: ImageFormat, quality?: number) {
+    const bytes = this.encodeToBytes(fmt, quality);
+    return btoa(String.fromCharCode(...bytes));
+  }
+}

package/src/skia/web/JsiSkImageFactory.ts

@@ -0,0 +1,40 @@
+import type { CanvasKit } from "canvaskit-wasm";
+
+import type { SkData, ImageInfo } from "../types";
+import type { ImageFactory } from "../types/Image/ImageFactory";
+
+import { Host, toValue, ckEnum } from "./Host";
+import { JsiSkImage } from "./JsiSkImage";
+
+export class JsiSkImageFactory extends Host implements ImageFactory {
+  constructor(CanvasKit: CanvasKit) {
+    super(CanvasKit);
+  }
+
+  MakeImageFromEncoded(encoded: SkData) {
+    const image = this.CanvasKit.MakeImageFromEncoded(toValue(encoded));
+    if (image === null) {
+      return null;
+    }
+    return new JsiSkImage(this.CanvasKit, image);
+  }
+
+  MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number) {
+    // see toSkImageInfo() from canvaskit
+    const image = this.CanvasKit.MakeImage(
+      {
+        alphaType: ckEnum(info.alphaType),
+        colorSpace: this.CanvasKit.ColorSpace.SRGB,
+        colorType: ckEnum(info.colorType),
+        height: info.height,
+        width: info.width,
+      },
+      toValue(data),
+      bytesPerRow
+    );
+    if (image === null) {
+      return null;
+    }
+    return new JsiSkImage(this.CanvasKit, image);
+  }
+}

package/src/skia/web/JsiSkImageFilter.ts

@@ -0,0 +1,14 @@
+import type { CanvasKit, ImageFilter } from "canvaskit-wasm";
+
+import type { SkImageFilter } from "../types";
+
+import { HostObject } from "./Host";
+
+export class JsiSkImageFilter
+  extends HostObject<ImageFilter, "ImageFilter">
+  implements SkImageFilter
+{
+  constructor(CanvasKit: CanvasKit, ref: ImageFilter) {
+    super(CanvasKit, ref, "ImageFilter");
+  }
+}

package/src/skia/web/JsiSkImageFilterFactory.ts

@@ -0,0 +1,144 @@
+import type { CanvasKit } from "canvaskit-wasm";
+
+import type {
+  ColorChannel,
+  ImageFilterFactory,
+  SkColor,
+  SkColorFilter,
+  SkImageFilter,
+  BlendMode,
+  SkRect,
+  SkRuntimeShaderBuilder,
+  SkShader,
+  TileMode,
+} from "../types";
+
+import { Host, NotImplementedOnRNWeb, ckEnum, toValue } from "./Host";
+import { JsiSkImageFilter } from "./JsiSkImageFilter";
+
+export class JsiSkImageFilterFactory
+  extends Host
+  implements ImageFilterFactory
+{
+  constructor(CanvasKit: CanvasKit) {
+    super(CanvasKit);
+  }
+
+  MakeOffset(
+    _dx: number,
+    _dy: number,
+    _input: SkImageFilter | null
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeDisplacementMap(
+    _channelX: ColorChannel,
+    _channelY: ColorChannel,
+    _scale: number,
+    _in1: SkImageFilter,
+    _input: SkImageFilter | null
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeShader(_shader: SkShader, _input: SkImageFilter | null): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeBlur(
+    sigmaX: number,
+    sigmaY: number,
+    mode: TileMode,
+    input: SkImageFilter | null
+  ) {
+    return new JsiSkImageFilter(
+      this.CanvasKit,
+      this.CanvasKit.ImageFilter.MakeBlur(
+        sigmaX,
+        sigmaY,
+        ckEnum(mode),
+        input === null ? null : toValue(input)
+      )
+    );
+  }
+
+  MakeColorFilter(cf: SkColorFilter, input: SkImageFilter | null) {
+    return new JsiSkImageFilter(
+      this.CanvasKit,
+      this.CanvasKit.ImageFilter.MakeColorFilter(
+        toValue(cf),
+        input === null ? null : toValue(input)
+      )
+    );
+  }
+
+  MakeCompose(outer: SkImageFilter | null, inner: SkImageFilter | null) {
+    return new JsiSkImageFilter(
+      this.CanvasKit,
+      this.CanvasKit.ImageFilter.MakeCompose(
+        outer === null ? null : toValue(outer),
+        inner === null ? null : toValue(inner)
+      )
+    );
+  }
+
+  MakeDropShadow(
+    _dx: number,
+    _dy: number,
+    _sigmaX: number,
+    _sigmaY: number,
+    _color: SkColor,
+    _input: SkImageFilter | null,
+    _cropRect?: SkRect
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeDropShadowOnly(
+    _dx: number,
+    _dy: number,
+    _sigmaX: number,
+    _sigmaY: number,
+    _color: SkColor,
+    _input: SkImageFilter | null,
+    _cropRect?: SkRect
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeErode(
+    _rx: number,
+    _ry: number,
+    _input: SkImageFilter | null,
+    _cropRect?: SkRect
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeDilate(
+    _rx: number,
+    _ry: number,
+    _input: SkImageFilter | null,
+    _cropRect?: SkRect
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeBlend(
+    _mode: BlendMode,
+    _background: SkImageFilter,
+    _foreground: SkImageFilter | null,
+    _cropRect?: SkRect
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+
+  MakeRuntimeShader(
+    _builder: SkRuntimeShaderBuilder,
+    _childShaderName: string | null,
+    _input: SkImageFilter | null
+  ): SkImageFilter {
+    throw new NotImplementedOnRNWeb();
+  }
+}

package/src/skia/web/JsiSkMaskFilter.ts

@@ -0,0 +1,14 @@
+import type { CanvasKit, MaskFilter } from "canvaskit-wasm";
+
+import type { SkMaskFilter } from "../types";
+
+import { HostObject } from "./Host";
+
+export class JsiSkMaskFilter
+  extends HostObject<MaskFilter, "MaskFilter">
+  implements SkMaskFilter
+{
+  constructor(CanvasKit: CanvasKit, ref: MaskFilter) {
+    super(CanvasKit, ref, "MaskFilter");
+  }
+}

package/src/skia/web/JsiSkMaskFilterFactory.ts

@@ -0,0 +1,20 @@
+import type { CanvasKit } from "canvaskit-wasm";
+
+import type { BlurStyle } from "../types";
+import type { MaskFilterFactory } from "../types/MaskFilter";
+
+import { Host, ckEnum } from "./Host";
+import { JsiSkMaskFilter } from "./JsiSkMaskFilter";
+
+export class JsiSkMaskFilterFactory extends Host implements MaskFilterFactory {
+  constructor(CanvasKit: CanvasKit) {
+    super(CanvasKit);
+  }
+
+  MakeBlur(style: BlurStyle, sigma: number, respectCTM: boolean) {
+    return new JsiSkMaskFilter(
+      this.CanvasKit,
+      this.CanvasKit.MaskFilter.MakeBlur(ckEnum(style), sigma, respectCTM)
+    );
+  }
+}

package/src/skia/web/JsiSkMatrix.ts

@@ -0,0 +1,54 @@
+import type { CanvasKit, Matrix3x3 } from "canvaskit-wasm";
+
+import type { SkMatrix } from "../types";
+
+import { HostObject, toValue } from "./Host";
+
+export class JsiSkMatrix
+  extends HostObject<Matrix3x3, "Matrix">
+  implements SkMatrix
+{
+  constructor(CanvasKit: CanvasKit, ref: Matrix3x3) {
+    super(CanvasKit, ref, "Matrix");
+  }
+
+  concat(matrix: SkMatrix) {
+    this.ref.set(this.CanvasKit.Matrix.multiply(this.ref, toValue(matrix)));
+  }
+
+  translate(x: number, y: number) {
+    this.concat(
+      new JsiSkMatrix(
+        this.CanvasKit,
+        Float32Array.of(...this.CanvasKit.Matrix.translated(x, y))
+      )
+    );
+  }
+
+  scale(x: number, y?: number) {
+    this.concat(
+      new JsiSkMatrix(
+        this.CanvasKit,
+        Float32Array.of(...this.CanvasKit.Matrix.scaled(x, y ?? x))
+      )
+    );
+  }
+
+  skew(x: number, y: number) {
+    this.concat(
+      new JsiSkMatrix(
+        this.CanvasKit,
+        Float32Array.of(...this.CanvasKit.Matrix.skewed(x, y))
+      )
+    );
+  }
+
+  rotate(value: number) {
+    this.concat(
+      new JsiSkMatrix(
+        this.CanvasKit,
+        Float32Array.of(...this.CanvasKit.Matrix.rotated(value))
+      )
+    );
+  }
+}

package/src/skia/web/{api/JsiSkPaint.ts → JsiSkPaint.ts}

@@ -1,6 +1,7 @@
 import type { CanvasKit, Paint } from "canvaskit-wasm";
 
 import type {
+  StrokeJoin,
   BlendMode,
   SkColor,
   SkColorFilter,
@@ -8,16 +9,16 @@ import type {
   SkPaint,
   SkShader,
   StrokeCap,
-  StrokeJoin,
   PaintStyle,
   SkMaskFilter,
   SkPathEffect,
-} from "../../types";
+} from "../types";
 
-import { HostObject, toNullableValue } from "./Host";
+import { HostObject, toNullableValue, ckEnum } from "./Host";
 
 export class JsiSkPaint extends HostObject<Paint, "Paint"> implements SkPaint {
   constructor(CanvasKit: CanvasKit, ref: Paint) {
+    ref.setAntiAlias(true);
     super(CanvasKit, ref, "Paint");
   }
 
@@ -54,7 +55,7 @@ export class JsiSkPaint extends HostObject<Paint, "Paint"> implements SkPaint {
   }
 
   setBlendMode(blendMode: BlendMode) {
-    this.ref.setBlendMode({ value: blendMode });
+    this.ref.setBlendMode(ckEnum(blendMode));
   }
 
   setColor(color: SkColor) {
@@ -82,11 +83,11 @@ export class JsiSkPaint extends HostObject<Paint, "Paint"> implements SkPaint {
   }
 
   setStrokeCap(cap: StrokeCap) {
-    this.ref.setStrokeCap({ value: cap });
+    this.ref.setStrokeCap(ckEnum(cap));
   }
 
   setStrokeJoin(join: StrokeJoin) {
-    this.ref.setStrokeJoin({ value: join });
+    this.ref.setStrokeJoin(ckEnum(join));
   }
 
   setStrokeMiter(limit: number) {