@shopify/react-native-skia 1.7.6 → 1.8.0

package/src/dom/nodes/paint/ImageFilters.ts

@@ -1,221 +0,0 @@
-import type { SkImageFilter, SkColor, Skia } from "../../../skia/types";
-import {
-  BlendMode,
-  ColorChannel,
-  processUniforms,
-  TileMode,
-} from "../../../skia/types";
-import type {
-  BlendImageFilterProps,
-  BlurImageFilterProps,
-  DeclarationContext,
-  DisplacementMapImageFilterProps,
-  DropShadowImageFilterProps,
-  MorphologyImageFilterProps,
-  OffsetImageFilterProps,
-  RuntimeShaderImageFilterProps,
-} from "../../types";
-import { NodeType } from "../../types";
-import { processRadius, enumKey } from "../datatypes";
-import type { NodeContext } from "../Node";
-import { JsiDeclarationNode } from "../Node";
-
-const Black = Float32Array.of(0, 0, 0, 1);
-
-const MakeInnerShadow = (
-  Skia: Skia,
-  shadowOnly: boolean | undefined,
-  dx: number,
-  dy: number,
-  sigmaX: number,
-  sigmaY: number,
-  color: SkColor,
-  input: SkImageFilter | null
-) => {
-  const sourceGraphic = Skia.ImageFilter.MakeColorFilter(
-    Skia.ColorFilter.MakeBlend(Black, BlendMode.Dst),
-    null
-  );
-  const sourceAlpha = Skia.ImageFilter.MakeColorFilter(
-    Skia.ColorFilter.MakeBlend(Black, BlendMode.SrcIn),
-    null
-  );
-  const f1 = Skia.ImageFilter.MakeColorFilter(
-    Skia.ColorFilter.MakeBlend(color, BlendMode.SrcOut),
-    null
-  );
-  const f2 = Skia.ImageFilter.MakeOffset(dx, dy, f1);
-  const f3 = Skia.ImageFilter.MakeBlur(sigmaX, sigmaY, TileMode.Decal, f2);
-  const f4 = Skia.ImageFilter.MakeBlend(BlendMode.SrcIn, sourceAlpha, f3);
-  if (shadowOnly) {
-    return f4;
-  }
-  return Skia.ImageFilter.MakeCompose(
-    input,
-    Skia.ImageFilter.MakeBlend(BlendMode.SrcOver, sourceGraphic, f4)
-  );
-};
-
-export abstract class ImageFilterDeclaration<P> extends JsiDeclarationNode<P> {
-  constructor(ctx: NodeContext, type: NodeType, props: P) {
-    super(ctx, type, props);
-  }
-
-  protected input(ctx: DeclarationContext) {
-    return ctx.imageFilters.pop() ?? null;
-  }
-
-  protected composeAndPush(ctx: DeclarationContext, imgf1: SkImageFilter) {
-    ctx.save();
-    this.decorateChildren(ctx);
-    let imgf2 = ctx.imageFilters.popAllAsOne();
-    const cf = ctx.colorFilters.popAllAsOne();
-    ctx.restore();
-    if (cf) {
-      imgf2 = this.Skia.ImageFilter.MakeCompose(
-        imgf2 ?? null,
-        this.Skia.ImageFilter.MakeColorFilter(cf, null)
-      );
-    }
-    const imgf = imgf2
-      ? this.Skia.ImageFilter.MakeCompose(imgf1, imgf2)
-      : imgf1;
-    ctx.imageFilters.push(imgf);
-  }
-}
-
-export class OffsetImageFilterNode extends ImageFilterDeclaration<OffsetImageFilterProps> {
-  constructor(ctx: NodeContext, props: OffsetImageFilterProps) {
-    super(ctx, NodeType.OffsetImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    this.decorateChildren(ctx);
-    const { x, y } = this.props;
-    const imgf = this.Skia.ImageFilter.MakeOffset(x, y, null);
-    this.composeAndPush(ctx, imgf);
-  }
-}
-
-export class DisplacementMapImageFilterNode extends ImageFilterDeclaration<DisplacementMapImageFilterProps> {
-  constructor(ctx: NodeContext, props: DisplacementMapImageFilterProps) {
-    super(ctx, NodeType.DisplacementMapImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    this.decorateChildren(ctx);
-    const { channelX, channelY, scale } = this.props;
-    const shader = ctx.shaders.pop();
-    if (!shader) {
-      throw new Error("DisplacementMap expects a shader as child");
-    }
-    const map = this.Skia.ImageFilter.MakeShader(shader, null);
-    const imgf = this.Skia.ImageFilter.MakeDisplacementMap(
-      ColorChannel[enumKey(channelX)],
-      ColorChannel[enumKey(channelY)],
-      scale,
-      map,
-      this.input(ctx)
-    );
-    ctx.imageFilters.push(imgf);
-  }
-}
-
-export class BlurImageFilterNode extends ImageFilterDeclaration<BlurImageFilterProps> {
-  constructor(ctx: NodeContext, props: BlurImageFilterProps) {
-    super(ctx, NodeType.BlurImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { mode, blur } = this.props;
-    const sigma = processRadius(this.Skia, blur);
-    const imgf = this.Skia.ImageFilter.MakeBlur(
-      sigma.x,
-      sigma.y,
-      TileMode[enumKey(mode)],
-      this.input(ctx)
-    );
-    this.composeAndPush(ctx, imgf);
-  }
-}
-
-export class DropShadowImageFilterNode extends ImageFilterDeclaration<DropShadowImageFilterProps> {
-  constructor(ctx: NodeContext, props: DropShadowImageFilterProps) {
-    super(ctx, NodeType.DropShadowImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { dx, dy, blur, shadowOnly, color: cl, inner } = this.props;
-    const color = this.Skia.Color(cl);
-    let factory;
-    if (inner) {
-      factory = MakeInnerShadow.bind(null, this.Skia, shadowOnly);
-    } else {
-      factory = shadowOnly
-        ? this.Skia.ImageFilter.MakeDropShadowOnly.bind(this.Skia.ImageFilter)
-        : this.Skia.ImageFilter.MakeDropShadow.bind(this.Skia.ImageFilter);
-    }
-    const imgf = factory(dx, dy, blur, blur, color, this.input(ctx));
-    this.composeAndPush(ctx, imgf);
-  }
-}
-
-export enum MorphologyOperator {
-  Erode,
-  Dilate,
-}
-
-export class MorphologyImageFilterNode extends ImageFilterDeclaration<MorphologyImageFilterProps> {
-  constructor(ctx: NodeContext, props: MorphologyImageFilterProps) {
-    super(ctx, NodeType.MorphologyImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { operator } = this.props;
-    const r = processRadius(this.Skia, this.props.radius);
-    let imgf;
-    if (MorphologyOperator[enumKey(operator)] === MorphologyOperator.Erode) {
-      imgf = this.Skia.ImageFilter.MakeErode(r.x, r.y, this.input(ctx));
-    } else {
-      imgf = this.Skia.ImageFilter.MakeDilate(r.x, r.y, this.input(ctx));
-    }
-    this.composeAndPush(ctx, imgf);
-  }
-}
-
-export class BlendImageFilterNode extends ImageFilterDeclaration<BlendImageFilterProps> {
-  constructor(ctx: NodeContext, props: BlendImageFilterProps) {
-    super(ctx, NodeType.BlendImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { mode } = this.props;
-    const a = ctx.imageFilters.pop();
-    const b = ctx.imageFilters.pop();
-    if (!a || !b) {
-      throw new Error("BlendImageFilter requires two image filters");
-    }
-    const imgf = this.Skia.ImageFilter.MakeBlend(mode, a, b);
-    this.composeAndPush(ctx, imgf);
-  }
-}
-
-export class RuntimeShaderImageFilterNode extends ImageFilterDeclaration<RuntimeShaderImageFilterProps> {
-  constructor(ctx: NodeContext, props: RuntimeShaderImageFilterProps) {
-    super(ctx, NodeType.RuntimeShaderImageFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { source, uniforms } = this.props;
-    const rtb = this.Skia.RuntimeShaderBuilder(source);
-    if (uniforms) {
-      processUniforms(source, uniforms, rtb);
-    }
-    const imgf = this.Skia.ImageFilter.MakeRuntimeShader(
-      rtb,
-      null,
-      this.input(ctx)
-    );
-    this.composeAndPush(ctx, imgf);
-  }
-}

package/src/dom/nodes/paint/MaskFilters.ts

@@ -1,23 +0,0 @@
-import { BlurStyle } from "../../../skia/types";
-import type { NodeContext } from "../Node";
-import { JsiDeclarationNode } from "../Node";
-import type { BlurMaskFilterProps } from "../../types";
-import { NodeType } from "../../types";
-import { enumKey } from "../datatypes";
-import type { DeclarationContext } from "../../types/DeclarationContext";
-
-export class BlurMaskFilterNode extends JsiDeclarationNode<BlurMaskFilterProps> {
-  constructor(ctx: NodeContext, props: BlurMaskFilterProps) {
-    super(ctx, NodeType.BlurMaskFilter, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { style, blur, respectCTM } = this.props;
-    const mf = this.Skia.MaskFilter.MakeBlur(
-      BlurStyle[enumKey(style)],
-      blur,
-      respectCTM
-    );
-    ctx.maskFilters.push(mf);
-  }
-}

package/src/dom/nodes/paint/PathEffects.ts

@@ -1,139 +0,0 @@
-import { Path1DEffectStyle } from "../../../skia/types";
-import type { SkPathEffect } from "../../../skia/types";
-import type { NodeContext } from "../Node";
-import { JsiDeclarationNode } from "../Node";
-import type {
-  CornerPathEffectProps,
-  DashPathEffectProps,
-  DiscretePathEffectProps,
-  Line2DPathEffectProps,
-  Path1DPathEffectProps,
-  Path2DPathEffectProps,
-} from "../../types";
-import { NodeType } from "../../types";
-import { enumKey } from "../datatypes/Enum";
-import { processPath } from "../datatypes";
-import type { DeclarationContext } from "../../types/DeclarationContext";
-import { composeDeclarations } from "../../types/DeclarationContext";
-
-abstract class PathEffectDeclaration<P> extends JsiDeclarationNode<P> {
-  constructor(ctx: NodeContext, type: NodeType, props: P) {
-    super(ctx, type, props);
-  }
-
-  protected composeAndPush(ctx: DeclarationContext, pe1: SkPathEffect) {
-    ctx.save();
-    this.decorateChildren(ctx);
-    const pe2 = ctx.pathEffects.popAllAsOne();
-    ctx.restore();
-    const pe = pe2 ? this.Skia.PathEffect.MakeCompose(pe1, pe2) : pe1;
-    ctx.pathEffects.push(pe);
-  }
-}
-
-export class DiscretePathEffectNode extends PathEffectDeclaration<DiscretePathEffectProps> {
-  constructor(ctx: NodeContext, props: DiscretePathEffectProps) {
-    super(ctx, NodeType.DiscretePathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { length, deviation, seed } = this.props;
-    const pe = this.Skia.PathEffect.MakeDiscrete(length, deviation, seed);
-    this.composeAndPush(ctx, pe);
-  }
-}
-
-export class Path2DPathEffectNode extends PathEffectDeclaration<Path2DPathEffectProps> {
-  constructor(ctx: NodeContext, props: Path2DPathEffectProps) {
-    super(ctx, NodeType.Path2DPathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { matrix } = this.props;
-    const path = processPath(this.Skia, this.props.path);
-    const pe = this.Skia.PathEffect.MakePath2D(matrix, path);
-    if (pe === null) {
-      throw new Error("Path2DPathEffectNode: invalid path");
-    }
-    this.composeAndPush(ctx, pe);
-  }
-}
-
-export class DashPathEffectNode extends PathEffectDeclaration<DashPathEffectProps> {
-  constructor(ctx: NodeContext, props: DashPathEffectProps) {
-    super(ctx, NodeType.DashPathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { intervals, phase } = this.props;
-    const pe = this.Skia.PathEffect.MakeDash(intervals, phase);
-    this.composeAndPush(ctx, pe);
-  }
-}
-
-export class CornerPathEffectNode extends PathEffectDeclaration<CornerPathEffectProps> {
-  constructor(ctx: NodeContext, props: CornerPathEffectProps) {
-    super(ctx, NodeType.CornerPathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { r } = this.props;
-    const pe = this.Skia.PathEffect.MakeCorner(r);
-    if (pe === null) {
-      throw new Error("CornerPathEffectNode: couldn't create path effect");
-    }
-    this.composeAndPush(ctx, pe);
-  }
-}
-
-export class SumPathEffectNode extends PathEffectDeclaration<null> {
-  constructor(ctx: NodeContext) {
-    super(ctx, NodeType.SumPathEffect, null);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    this.decorateChildren(ctx);
-    const pes = ctx.pathEffects.popAll();
-    const pe = composeDeclarations(
-      pes,
-      this.Skia.PathEffect.MakeSum.bind(this.Skia.PathEffect)
-    );
-    ctx.pathEffects.push(pe);
-  }
-}
-
-export class Line2DPathEffectNode extends PathEffectDeclaration<Line2DPathEffectProps> {
-  constructor(ctx: NodeContext, props: Line2DPathEffectProps) {
-    super(ctx, NodeType.Line2DPathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { width, matrix } = this.props;
-    const pe = this.Skia.PathEffect.MakeLine2D(width, matrix);
-    if (pe === null) {
-      throw new Error("Line2DPathEffectNode: could not create path effect");
-    }
-    this.composeAndPush(ctx, pe);
-  }
-}
-
-export class Path1DPathEffectNode extends PathEffectDeclaration<Path1DPathEffectProps> {
-  constructor(ctx: NodeContext, props: Path1DPathEffectProps) {
-    super(ctx, NodeType.Path1DPathEffect, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { advance, phase, style } = this.props;
-    const path = processPath(this.Skia, this.props.path);
-    const pe = this.Skia.PathEffect.MakePath1D(
-      path,
-      advance,
-      phase,
-      Path1DEffectStyle[enumKey(style)]
-    );
-    if (pe === null) {
-      throw new Error("Path1DPathEffectNode: could not create path effect");
-    }
-    this.composeAndPush(ctx, pe);
-  }
-}

package/src/dom/nodes/paint/Shaders.ts

@@ -1,233 +0,0 @@
-import {
-  processUniforms,
-  FilterMode,
-  MipmapMode,
-  TileMode,
-} from "../../../skia/types";
-import type { NodeContext } from "../Node";
-import { JsiDeclarationNode } from "../Node";
-import type {
-  ColorProps,
-  DeclarationContext,
-  FractalNoiseProps,
-  ImageShaderProps,
-  LinearGradientProps,
-  RadialGradientProps,
-  ShaderProps,
-  SweepGradientProps,
-  TurbulenceProps,
-  TwoPointConicalGradientProps,
-} from "../../types";
-import { NodeType } from "../../types";
-import {
-  enumKey,
-  fitRects,
-  getRect,
-  processGradientProps,
-  processTransformProps,
-  rect2rect,
-} from "../datatypes";
-
-export abstract class ShaderDeclaration<P> extends JsiDeclarationNode<P> {
-  constructor(ctx: NodeContext, type: NodeType, props: P) {
-    super(ctx, type, props);
-  }
-}
-
-export class ShaderNode extends ShaderDeclaration<ShaderProps> {
-  constructor(ctx: NodeContext, props: ShaderProps) {
-    super(ctx, NodeType.Shader, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    this.decorateChildren(ctx);
-    const { source, uniforms, ...transform } = this.props;
-    const m3 = this.Skia.Matrix();
-    processTransformProps(m3, transform);
-    const shader = source.makeShaderWithChildren(
-      processUniforms(source, uniforms),
-      ctx.shaders.popAll(),
-      m3
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class ImageShaderNode extends ShaderDeclaration<ImageShaderProps> {
-  constructor(ctx: NodeContext, props: ImageShaderProps) {
-    super(ctx, NodeType.ImageShader, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { fit, image, tx, ty, fm, mm, ...imageShaderProps } = this.props;
-    if (!image) {
-      return;
-    }
-
-    const rct = getRect(this.Skia, imageShaderProps);
-    const m3 = this.Skia.Matrix();
-    if (rct) {
-      const rects = fitRects(
-        fit,
-        { x: 0, y: 0, width: image.width(), height: image.height() },
-        rct
-      );
-      const [x, y, sx, sy] = rect2rect(rects.src, rects.dst);
-      m3.translate(x.translateX, y.translateY);
-      m3.scale(sx.scaleX, sy.scaleY);
-    }
-    const lm = this.Skia.Matrix();
-    lm.concat(m3);
-    processTransformProps(lm, imageShaderProps);
-    const shader = image.makeShaderOptions(
-      TileMode[enumKey(tx)],
-      TileMode[enumKey(ty)],
-      FilterMode[enumKey(fm)],
-      MipmapMode[enumKey(mm)],
-      lm
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class ColorNode extends ShaderDeclaration<ColorProps> {
-  constructor(ctx: NodeContext, props: ColorProps) {
-    super(ctx, NodeType.ColorShader, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { color } = this.props;
-    const shader = this.Skia.Shader.MakeColor(this.Skia.Color(color));
-    ctx.shaders.push(shader);
-  }
-}
-
-export class TurbulenceNode extends ShaderDeclaration<TurbulenceProps> {
-  constructor(ctx: NodeContext, props: TurbulenceProps) {
-    super(ctx, NodeType.Turbulence, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { freqX, freqY, octaves, seed, tileWidth, tileHeight } = this.props;
-    const shader = this.Skia.Shader.MakeTurbulence(
-      freqX,
-      freqY,
-      octaves,
-      seed,
-      tileWidth,
-      tileHeight
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class FractalNoiseNode extends ShaderDeclaration<FractalNoiseProps> {
-  constructor(ctx: NodeContext, props: FractalNoiseProps) {
-    super(ctx, NodeType.FractalNoise, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { freqX, freqY, octaves, seed, tileWidth, tileHeight } = this.props;
-    const shader = this.Skia.Shader.MakeFractalNoise(
-      freqX,
-      freqY,
-      octaves,
-      seed,
-      tileWidth,
-      tileHeight
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class LinearGradientNode extends ShaderDeclaration<LinearGradientProps> {
-  constructor(ctx: NodeContext, props: LinearGradientProps) {
-    super(ctx, NodeType.LinearGradient, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { start, end } = this.props;
-    const { colors, positions, mode, localMatrix, flags } =
-      processGradientProps(this.Skia, this.props);
-    const shader = this.Skia.Shader.MakeLinearGradient(
-      start,
-      end,
-      colors,
-      positions ?? null,
-      mode,
-      localMatrix,
-      flags
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class RadialGradientNode extends ShaderDeclaration<RadialGradientProps> {
-  constructor(ctx: NodeContext, props: RadialGradientProps) {
-    super(ctx, NodeType.RadialGradient, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { c, r } = this.props;
-    const { colors, positions, mode, localMatrix, flags } =
-      processGradientProps(this.Skia, this.props);
-    const shader = this.Skia.Shader.MakeRadialGradient(
-      c,
-      r,
-      colors,
-      positions,
-      mode,
-      localMatrix,
-      flags
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class SweepGradientNode extends ShaderDeclaration<SweepGradientProps> {
-  constructor(ctx: NodeContext, props: SweepGradientProps) {
-    super(ctx, NodeType.SweepGradient, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { c, start, end } = this.props;
-    const { colors, positions, mode, localMatrix, flags } =
-      processGradientProps(this.Skia, this.props);
-    const shader = this.Skia.Shader.MakeSweepGradient(
-      c.x,
-      c.y,
-      colors,
-      positions,
-      mode,
-      localMatrix,
-      flags,
-      start,
-      end
-    );
-    ctx.shaders.push(shader);
-  }
-}
-
-export class TwoPointConicalGradientNode extends ShaderDeclaration<TwoPointConicalGradientProps> {
-  constructor(ctx: NodeContext, props: TwoPointConicalGradientProps) {
-    super(ctx, NodeType.TwoPointConicalGradient, props);
-  }
-
-  decorate(ctx: DeclarationContext) {
-    const { startR, endR, start, end } = this.props;
-    const { colors, positions, mode, localMatrix, flags } =
-      processGradientProps(this.Skia, this.props);
-    const shader = this.Skia.Shader.MakeTwoPointConicalGradient(
-      start,
-      startR,
-      end,
-      endR,
-      colors,
-      positions,
-      mode,
-      localMatrix,
-      flags
-    );
-    ctx.shaders.push(shader);
-  }
-}

package/src/dom/nodes/paint/index.ts

@@ -1,6 +0,0 @@
-export * from "./Shaders";
-export * from "./MaskFilters";
-export * from "./ColorFilters";
-export * from "./ImageFilters";
-export * from "./PathEffects";
-export * from "./BlendNode";