@shopify/react-native-skia 1.7.7 → 1.8.1

package/src/dom/types/DrawingContext.ts

@@ -1,322 +0,0 @@
-import type {
-  SkCanvas,
-  SkColor,
-  SkColorFilter,
-  SkImageFilter,
-  SkMaskFilter,
-  SkPaint,
-  SkPathEffect,
-  SkShader,
-  Skia,
-} from "../../skia/types";
-import { BlendMode, PaintStyle, StrokeCap, StrokeJoin } from "../../skia/types";
-import { enumKey } from "../nodes/datatypes/Enum";
-import { JsiDeclarationNode } from "../nodes/Node";
-
-import type { PaintProps, SkEnum } from "./Common";
-import { DeclarationContext } from "./DeclarationContext";
-import type { Node } from "./Node";
-
-export interface DrawingContext {
-  canvas: SkCanvas;
-  paint: SkPaint;
-  saveAndConcat(node: Node<PaintProps>, cache?: SkPaint): boolean;
-  restore(): void;
-  declarationCtx: DeclarationContext;
-}
-
-export class JsiDrawingContext implements DrawingContext {
-  paints: SkPaint[];
-
-  declarationCtx: DeclarationContext;
-
-  constructor(private readonly Skia: Skia, public readonly canvas: SkCanvas) {
-    const paint = this.Skia.Paint();
-    this.paints = [paint];
-    this.declarationCtx = new DeclarationContext(Skia);
-  }
-
-  get paint() {
-    return this.paints[this.paints.length - 1];
-  }
-
-  private save() {
-    const childPaint = this.paint.copy();
-    this.paints.push(childPaint);
-  }
-
-  restore(): void {
-    this.paints.pop();
-  }
-
-  saveAndConcat(node: Node<PaintProps>, cache?: SkPaint) {
-    if (cache) {
-      this.paints.push(cache);
-      return true;
-    }
-    const paint = new ConcatablePaint(this.Skia, this.declarationCtx, node);
-    if (!paint.isPristine()) {
-      this.save();
-      paint.concatTo(this.paint);
-      return true;
-    }
-    return false;
-  }
-}
-
-class ConcatablePaint {
-  private pristine = true;
-
-  _color?: SkColor;
-  _strokeWidth?: number;
-  _blendMode?: BlendMode;
-  _style?: PaintStyle;
-  _strokeJoin?: StrokeJoin;
-  _strokeCap?: StrokeCap;
-  _strokeMiter?: number;
-  _opacity = 1;
-  _antiAlias?: boolean;
-  _dither?: boolean;
-
-  _imageFilter?: SkImageFilter;
-  _shader?: SkShader;
-  _pathEffect?: SkPathEffect;
-  _colorFilter?: SkColorFilter;
-  _maskFilter?: SkMaskFilter;
-
-  constructor(Skia: Skia, declCtx: DeclarationContext, node: Node<PaintProps>) {
-    const props = node.getProps();
-    const children = node.children();
-    this.setColor(
-      props.color !== undefined ? Skia.Color(props.color) : props.color
-    );
-    this.setStrokeWidth(props.strokeWidth);
-    this.setBlendMode(props.blendMode);
-    this.setStyle(props.style);
-    this.setStrokeJoin(props.strokeJoin);
-    this.setStrokeCap(props.strokeCap);
-    this.setStrokeMiter(props.strokeMiter);
-    this.setOpacity(props.opacity);
-    this.setAntiAlias(props.antiAlias);
-    this.setDither(props.dither);
-    declCtx.save();
-    children.forEach((child) => {
-      if (child instanceof JsiDeclarationNode) {
-        child.decorate(declCtx);
-      }
-    });
-    const colorFilter = declCtx.colorFilters.popAllAsOne();
-    const imageFilter = declCtx.imageFilters.popAllAsOne();
-    const shader = declCtx.shaders.pop();
-    const maskFilter = declCtx.maskFilters.pop();
-    const pathEffect = declCtx.pathEffects.popAllAsOne();
-    declCtx.restore();
-    if (imageFilter) {
-      this.setImageFilter(imageFilter);
-    }
-    if (shader) {
-      this.setShader(shader);
-    }
-    if (pathEffect) {
-      this.setPathEffect(pathEffect);
-    }
-    if (colorFilter) {
-      this.setColorFilter(colorFilter);
-    }
-    if (maskFilter) {
-      this.setMaskFilter(maskFilter);
-    }
-  }
-
-  private enum<T>(value: T, key?: Uncapitalize<string>) {
-    if (key !== undefined) {
-      return value[enumKey(key) as keyof T];
-    }
-    return undefined;
-  }
-
-  private setValue<T extends keyof typeof this>(
-    key: T,
-    value?: (typeof this)[T]
-  ) {
-    if (value !== undefined) {
-      this[key] = value;
-      this.pristine = false;
-    }
-  }
-
-  setColor(color?: SkColor) {
-    this.setValue("_color", color);
-  }
-
-  getColor() {
-    return this._color;
-  }
-
-  setStrokeWidth(strokeWidth?: number) {
-    this.setValue("_strokeWidth", strokeWidth);
-  }
-
-  getStrokeWidth() {
-    return this._strokeWidth;
-  }
-
-  setBlendMode(blendMode?: SkEnum<typeof BlendMode>) {
-    this.setValue("_blendMode", this.enum(BlendMode, blendMode));
-  }
-
-  getBlendMode() {
-    return this._blendMode;
-  }
-
-  setStyle(style?: SkEnum<typeof PaintStyle>) {
-    this.setValue("_style", this.enum(PaintStyle, style));
-  }
-
-  getStyle() {
-    return this._style;
-  }
-
-  setStrokeJoin(strokeJoin?: SkEnum<typeof StrokeJoin>) {
-    this.setValue("_strokeJoin", this.enum(StrokeJoin, strokeJoin));
-  }
-
-  getStrokeJoin() {
-    return this._strokeJoin;
-  }
-
-  setStrokeCap(strokeCap?: SkEnum<typeof StrokeCap>) {
-    this.setValue("_strokeCap", this.enum(StrokeCap, strokeCap));
-  }
-
-  getStrokeCap() {
-    return this._strokeCap;
-  }
-
-  setStrokeMiter(strokeMiter?: number) {
-    this.setValue("_strokeMiter", strokeMiter);
-  }
-
-  getStrokeMiter() {
-    return this._strokeMiter;
-  }
-
-  setOpacity(opacity?: number) {
-    this.setValue("_opacity", opacity);
-  }
-
-  getOpacity() {
-    return this._opacity;
-  }
-
-  setAntiAlias(antiAlias?: boolean) {
-    this.setValue("_antiAlias", antiAlias);
-  }
-
-  getAntiAlias() {
-    return this._antiAlias;
-  }
-
-  setDither(dither?: boolean) {
-    this.setValue("_dither", dither);
-  }
-
-  getDither() {
-    return this._dither;
-  }
-
-  setImageFilter(imageFilter?: SkImageFilter) {
-    this.setValue("_imageFilter", imageFilter);
-  }
-
-  getImageFilter() {
-    return this._imageFilter;
-  }
-
-  setShader(shader?: SkShader) {
-    this.setValue("_shader", shader);
-  }
-
-  getShader() {
-    return this._shader;
-  }
-
-  setPathEffect(pathEffect?: SkPathEffect) {
-    this.setValue("_pathEffect", pathEffect);
-  }
-
-  getPathEffect() {
-    return this._pathEffect;
-  }
-
-  setColorFilter(colorFilter?: SkColorFilter) {
-    this.setValue("_colorFilter", colorFilter);
-  }
-
-  getColorFilter() {
-    return this._colorFilter;
-  }
-
-  setMaskFilter(maskFilter?: SkMaskFilter) {
-    this.setValue("_maskFilter", maskFilter);
-  }
-
-  getMaskFilter() {
-    return this._maskFilter;
-  }
-
-  isPristine() {
-    return this.pristine;
-  }
-
-  concatTo(paint: SkPaint) {
-    if (this._opacity !== undefined) {
-      paint.setAlphaf(paint.getAlphaf() * this._opacity);
-    }
-    if (this._color !== undefined) {
-      const currentOpacity = paint.getAlphaf();
-      paint.setShader(null);
-      paint.setColor(this._color);
-      paint.setAlphaf(currentOpacity * paint.getAlphaf());
-    }
-    if (this._strokeWidth !== undefined) {
-      paint.setStrokeWidth(this._strokeWidth);
-    }
-    if (this._blendMode !== undefined) {
-      paint.setBlendMode(this._blendMode);
-    }
-    if (this._style !== undefined) {
-      paint.setStyle(this._style);
-    }
-    if (this._strokeJoin !== undefined) {
-      paint.setStrokeJoin(this._strokeJoin);
-    }
-    if (this._strokeCap !== undefined) {
-      paint.setStrokeCap(this._strokeCap);
-    }
-    if (this._strokeMiter !== undefined) {
-      paint.setStrokeMiter(this._strokeMiter);
-    }
-    if (this._antiAlias !== undefined) {
-      paint.setAntiAlias(this._antiAlias);
-    }
-    if (this._dither !== undefined) {
-      paint.setDither(this._dither);
-    }
-    if (this._imageFilter !== undefined) {
-      paint.setImageFilter(this._imageFilter);
-    }
-    if (this._shader !== undefined) {
-      paint.setShader(this._shader);
-    }
-    if (this._pathEffect !== undefined) {
-      paint.setPathEffect(this._pathEffect);
-    }
-    if (this._colorFilter !== undefined) {
-      paint.setColorFilter(this._colorFilter);
-    }
-    if (this._maskFilter !== undefined) {
-      paint.setMaskFilter(this._maskFilter);
-    }
-  }
-}

package/src/external/reanimated/useDerivedValueOnJS.ts

@@ -1,20 +0,0 @@
-import { useEffect, useMemo } from "react";
-
-import Rea from "./ReanimatedProxy";
-
-export const useDerivedValueOnJS = (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  fn: () => any,
-  deps: unknown[]
-) => {
-  const init = useMemo(() => fn(), [fn]);
-  const value = Rea.useSharedValue(init);
-  useEffect(() => {
-    const mapperId = Rea.startMapper(() => {
-      "worklet";
-      Rea.runOnJS(fn)();
-    }, deps);
-    return () => Rea.stopMapper(mapperId);
-  }, [deps, fn]);
-  return value;
-};

package/src/renderer/DrawingContext.ts

@@ -1,8 +0,0 @@
-import type { DrawingInfo } from "../views";
-import type { Skia, SkCanvas, SkPaint } from "../skia/types";
-
-export interface DrawingContext extends Omit<DrawingInfo, "touches"> {
-  Skia: Skia;
-  canvas: SkCanvas;
-  paint: SkPaint;
-}

package/src/sksg/DrawingContext.ts

@@ -1,221 +0,0 @@
-"worklet";
-
-import {
-  enumKey,
-  isPathDef,
-  processPath,
-  processTransformProps2,
-} from "../dom/nodes";
-import type { ClipDef, DrawingNodeProps, GroupProps } from "../dom/types";
-import { DeclarationContext } from "../dom/types";
-import {
-  BlendMode,
-  ClipOp,
-  isRRect,
-  PaintStyle,
-  StrokeCap,
-  StrokeJoin,
-} from "../skia/types";
-import type {
-  SkPath,
-  SkRect,
-  SkRRect,
-  SkCanvas,
-  Skia,
-  SkPaint,
-} from "../skia/types";
-
-const computeClip = (
-  Skia: Skia,
-  clip: ClipDef | undefined
-):
-  | undefined
-  | { clipPath: SkPath }
-  | { clipRect: SkRect }
-  | { clipRRect: SkRRect } => {
-  if (clip) {
-    if (isPathDef(clip)) {
-      return { clipPath: processPath(Skia, clip) };
-    } else if (isRRect(clip)) {
-      return { clipRRect: clip };
-    } else {
-      return { clipRect: clip };
-    }
-  }
-  return undefined;
-};
-
-export class DrawingContext {
-  private paints: SkPaint[];
-  public declCtx: DeclarationContext;
-  public Skia: Skia;
-  public canvas: SkCanvas;
-
-  constructor(Skia: Skia, canvas: SkCanvas) {
-    this.Skia = Skia;
-    this.canvas = canvas;
-    this.paints = [Skia.Paint()];
-    this.declCtx = new DeclarationContext(this.Skia);
-  }
-
-  save() {
-    this.paints.push(this.paint.copy());
-  }
-
-  restore() {
-    this.paints.pop();
-  }
-
-  get paint() {
-    const paint = this.paints[this.paints.length - 1];
-    if (!paint) {
-      throw new Error("Paint is undefined");
-    }
-    return paint;
-  }
-
-  getLocalPaints() {
-    const { paint } = this;
-    return [paint, ...this.declCtx.paints.popAll()];
-  }
-
-  processPaint({
-    opacity,
-    color,
-    strokeWidth,
-    blendMode,
-    style,
-    strokeJoin,
-    strokeCap,
-    strokeMiter,
-    antiAlias,
-    dither,
-    paint: paintProp,
-  }: DrawingNodeProps) {
-    if (paintProp) {
-      this.declCtx.paints.push(paintProp);
-      return true;
-    }
-    let shouldRestore = false;
-    const colorFilter = this.declCtx.colorFilters.popAllAsOne();
-    const imageFilter = this.declCtx.imageFilters.popAllAsOne();
-    const shader = this.declCtx.shaders.pop();
-    const maskFilter = this.declCtx.maskFilters.pop();
-    const pathEffect = this.declCtx.pathEffects.popAllAsOne();
-    if (
-      opacity !== undefined ||
-      color !== undefined ||
-      strokeWidth !== undefined ||
-      blendMode !== undefined ||
-      style !== undefined ||
-      strokeJoin !== undefined ||
-      strokeCap !== undefined ||
-      strokeMiter !== undefined ||
-      antiAlias !== undefined ||
-      dither !== undefined ||
-      colorFilter !== undefined ||
-      imageFilter !== undefined ||
-      shader !== undefined ||
-      maskFilter !== undefined ||
-      pathEffect !== undefined
-    ) {
-      if (!shouldRestore) {
-        this.save();
-        shouldRestore = true;
-      }
-    }
-    const { paint } = this;
-    if (opacity !== undefined) {
-      paint.setAlphaf(paint.getAlphaf() * opacity);
-    }
-    if (color !== undefined) {
-      const currentOpacity = paint.getAlphaf();
-      paint.setShader(null);
-      if (typeof color === "string" || typeof color === "number") {
-        paint.setColor(this.Skia.Color(color));
-      } else if (Array.isArray(color)) {
-        paint.setColor(new Float32Array(color));
-      } else if (color instanceof Float32Array) {
-        paint.setColor(color);
-      } else {
-        throw new Error("Invalid color");
-      }
-      paint.setAlphaf(currentOpacity * paint.getAlphaf());
-    }
-    if (strokeWidth !== undefined) {
-      paint.setStrokeWidth(strokeWidth);
-    }
-    if (blendMode !== undefined) {
-      paint.setBlendMode(BlendMode[enumKey(blendMode)]);
-    }
-    if (style !== undefined) {
-      paint.setStyle(PaintStyle[enumKey(style)]);
-    }
-    if (strokeJoin !== undefined) {
-      paint.setStrokeJoin(StrokeJoin[enumKey(strokeJoin)]);
-    }
-    if (strokeCap !== undefined) {
-      paint.setStrokeCap(StrokeCap[enumKey(strokeCap)]);
-    }
-    if (strokeMiter !== undefined) {
-      paint.setStrokeMiter(strokeMiter);
-    }
-    if (antiAlias !== undefined) {
-      paint.setAntiAlias(antiAlias);
-    }
-    if (dither !== undefined) {
-      paint.setDither(dither);
-    }
-    if (colorFilter) {
-      paint.setColorFilter(colorFilter);
-    }
-    if (imageFilter) {
-      paint.setImageFilter(imageFilter);
-    }
-    if (shader) {
-      paint.setShader(shader);
-    }
-    if (maskFilter) {
-      paint.setMaskFilter(maskFilter);
-    }
-    if (pathEffect) {
-      paint.setPathEffect(pathEffect);
-    }
-    return shouldRestore;
-  }
-
-  processMatrixAndClipping(props: GroupProps, layer?: boolean | SkPaint) {
-    const hasTransform =
-      props.matrix !== undefined || props.transform !== undefined;
-    const clip = computeClip(this.Skia, props.clip);
-    const hasClip = clip !== undefined;
-    const op = props.invertClip ? ClipOp.Difference : ClipOp.Intersect;
-    const m3 = processTransformProps2(this.Skia, props);
-    const shouldSave = hasTransform || hasClip || !!layer;
-    if (shouldSave) {
-      if (layer) {
-        if (typeof layer === "boolean") {
-          this.canvas.saveLayer();
-        } else {
-          this.canvas.saveLayer(layer);
-        }
-      } else {
-        this.canvas.save();
-      }
-    }
-
-    if (m3) {
-      this.canvas.concat(m3);
-    }
-    if (clip) {
-      if ("clipRect" in clip) {
-        this.canvas.clipRect(clip.clipRect, op, true);
-      } else if ("clipRRect" in clip) {
-        this.canvas.clipRRect(clip.clipRRect, op, true);
-      } else {
-        this.canvas.clipPath(clip.clipPath, op, true);
-      }
-    }
-    return shouldSave;
-  }
-}