@shopify/react-native-skia 1.7.7 → 1.8.1

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";

package/src/dom/types/DeclarationContext.ts

@@ -1,115 +0,0 @@
-"worklet";
-
-import type {
-  SkShader,
-  SkPaint,
-  SkImageFilter,
-  SkMaskFilter,
-  SkPathEffect,
-  Skia,
-  SkColorFilter,
-} from "../../skia/types";
-
-type Composer<T> = (outer: T, inner: T) => T;
-
-export const composeDeclarations = <T>(filters: T[], composer: Composer<T>) => {
-  if (filters.length <= 1) {
-    return filters[0];
-  }
-  return filters.reverse().reduce((inner, outer) => {
-    if (!inner) {
-      return outer;
-    }
-    return composer(outer, inner);
-  });
-};
-
-class Declaration<T> {
-  private decls: T[] = [];
-  private indexes = [0];
-  private composer?: Composer<T>;
-
-  constructor(composer?: Composer<T>) {
-    this.composer = composer;
-  }
-
-  private get index() {
-    return this.indexes[this.indexes.length - 1];
-  }
-
-  save() {
-    this.indexes.push(this.decls.length);
-  }
-
-  restore() {
-    this.indexes.pop();
-  }
-
-  pop() {
-    return this.decls.pop();
-  }
-
-  push(decl: T) {
-    this.decls.push(decl);
-  }
-
-  popAll() {
-    return this.decls.splice(this.index, this.decls.length - this.index);
-  }
-
-  popAllAsOne() {
-    if (this.decls.length === 0) {
-      return undefined;
-    }
-    if (!this.composer) {
-      throw new Error("No composer for this type of declaration");
-    }
-    const decls = this.popAll();
-    return composeDeclarations(decls, this.composer!);
-  }
-}
-
-export class DeclarationContext {
-  public Skia: Skia;
-  readonly paints: Declaration<SkPaint>;
-  readonly maskFilters: Declaration<SkMaskFilter>;
-  readonly shaders: Declaration<SkShader>;
-  readonly pathEffects: Declaration<SkPathEffect>;
-  readonly imageFilters: Declaration<SkImageFilter>;
-  readonly colorFilters: Declaration<SkColorFilter>;
-
-  constructor(Skia: Skia) {
-    this.Skia = Skia;
-    const peComp = this.Skia.PathEffect.MakeCompose.bind(this.Skia.PathEffect);
-    const ifComp = this.Skia.ImageFilter.MakeCompose.bind(
-      this.Skia.ImageFilter
-    );
-    const cfComp = this.Skia.ColorFilter.MakeCompose.bind(
-      this.Skia.ColorFilter
-    );
-    this.paints = new Declaration<SkPaint>();
-    this.maskFilters = new Declaration<SkMaskFilter>();
-    this.shaders = new Declaration<SkShader>();
-    this.pathEffects = new Declaration<SkPathEffect>(peComp);
-    this.imageFilters = new Declaration<SkImageFilter>(ifComp);
-    this.colorFilters = new Declaration<SkColorFilter>(cfComp);
-  }
-
-  save() {
-    this.paints.save();
-    this.maskFilters.save();
-    this.shaders.save();
-    this.pathEffects.save();
-    this.imageFilters.save();
-    this.colorFilters.save();
-  }
-
-  restore() {
-    this.paints.restore();
-    this.maskFilters.restore();
-    this.shaders.restore();
-    this.pathEffects.restore();
-    this.imageFilters.restore();
-    this.colorFilters.restore();
-  }
-}