@shopify/react-native-skia 0.0.135

package/src/skia/types/MaskFilter.ts

@@ -0,0 +1,27 @@
+import type { SkJSIInstance } from "./JsiInstance";
+
+export enum BlurStyle {
+  Normal, //!< fuzzy inside and outside
+  Solid, //!< solid inside, fuzzy outside
+  Outer, //!< nothing inside, fuzzy outside
+  Inner, //!< fuzzy inside, nothing outside
+}
+
+export const isMaskFilter = (
+  obj: SkJSIInstance<string> | null
+): obj is SkMaskFilter => obj !== null && obj.__typename__ === "MaskFilter";
+
+export type SkMaskFilter = SkJSIInstance<"MaskFilter">;
+
+/**
+ * See SkMaskFilter.h for more details.
+ */
+export interface MaskFilterFactory {
+  /**
+   * Create a blur maskfilter
+   * @param style
+   * @param sigma - Standard deviation of the Gaussian blur to apply. Must be > 0.
+   * @param respectCTM - if true the blur's sigma is modified by the CTM.
+   */
+  MakeBlur(style: BlurStyle, sigma: number, respectCTM: boolean): SkMaskFilter;
+}

package/src/skia/types/Matrix.ts

@@ -0,0 +1,95 @@
+import type { SkJSIInstance } from "./JsiInstance";
+export enum MatrixIndex {
+  ScaleX = 0,
+  SkewX = 1,
+  TransX = 2,
+  SkewY = 3,
+  ScaleY = 4,
+  TransY = 5,
+  Persp0 = 6,
+  Persp1 = 7,
+  persp2 = 8,
+}
+
+export interface SkMatrix extends SkJSIInstance<"Matrix"> {
+  concat: (matrix: SkMatrix) => void;
+  translate: (x: number, y: number) => void;
+  scale: (x: number, y?: number) => void;
+  skew: (x: number, y: number) => void;
+  rotate: (theta: number) => void;
+}
+
+type Transform2dName =
+  | "translateX"
+  | "translateY"
+  | "scale"
+  | "skewX"
+  | "skewY"
+  | "scaleX"
+  | "scaleY"
+  | "rotateZ"
+  | "rotate";
+
+type Transformations = {
+  readonly [Name in Transform2dName]: number;
+};
+
+export type Transforms2d = readonly (
+  | Pick<Transformations, "translateX">
+  | Pick<Transformations, "translateY">
+  | Pick<Transformations, "scale">
+  | Pick<Transformations, "scaleX">
+  | Pick<Transformations, "scaleY">
+  | Pick<Transformations, "skewX">
+  | Pick<Transformations, "skewY">
+  | Pick<Transformations, "rotate">
+)[];
+
+export interface TransformProp {
+  transform?: Transforms2d;
+}
+
+export const processTransform = (m: SkMatrix, transforms: Transforms2d) => {
+  for (const transform of transforms) {
+    const key = Object.keys(transform)[0] as Transform2dName;
+    const value = (transform as Pick<Transformations, typeof key>)[key];
+    if (key === "translateX") {
+      m.translate(value, 0);
+      continue;
+    }
+    if (key === "translateY") {
+      m.translate(0, value);
+      continue;
+    }
+    if (key === "scale") {
+      m.scale(value, value);
+      continue;
+    }
+    if (key === "scaleX") {
+      m.scale(value, 1);
+      continue;
+    }
+    if (key === "scaleY") {
+      m.scale(1, value);
+      continue;
+    }
+    if (key === "skewX") {
+      m.skew(value, 0);
+      continue;
+    }
+    if (key === "skewY") {
+      m.skew(0, value);
+      continue;
+    }
+    if (key === "rotate" || key === "rotateZ") {
+      m.rotate(value);
+      continue;
+    }
+    exhaustiveCheck(key);
+  }
+  return m;
+};
+
+const exhaustiveCheck = (a: never): never => {
+  throw new Error(`Unknown transformation: ${a}`);
+};

package/src/skia/types/Paint/BlendMode.ts

@@ -0,0 +1,61 @@
+/**
+ *  Blends are operators that take in two colors (source, destination) and
+ * return a new color. Many of these operate the same on all 4 components: red,
+ * green, blue, alpha. For these, we just document what happens to one
+ * component, rather than naming each one separately.
+ *
+ *  Different SkColorTypes have different representations for color components:
+ *      8-bit: 0..255
+ *      6-bit: 0..63
+ *      5-bit: 0..31
+ *      4-bit: 0..15
+ *     floats: 0...1
+ *
+ *  The documentation is expressed as if the component values are always 0..1
+ * (floats).
+ *
+ *  For brevity, the documentation uses the following abbreviations
+ *  s  : source
+ *  d  : destination
+ *  sa : source alpha
+ *  da : destination alpha
+ *
+ *  Results are abbreviated
+ *  r  : if all 4 components are computed in the same manner
+ *  ra : result alpha component
+ *  rc : result "color": red, green, blue components
+ */
+export enum BlendMode {
+  Clear, //!< r = 0
+  Src, //!< r = s
+  Dst, //!< r = d
+  SrcOver, //!< r = s + (1-sa)*d
+  DstOver, //!< r = d + (1-da)*s
+  SrcIn, //!< r = s * da
+  DstIn, //!< r = d * sa
+  SrcOut, //!< r = s * (1-da)
+  DstOut, //!< r = d * (1-sa)
+  SrcATop, //!< r = s*da + d*(1-sa)
+  DstATop, //!< r = d*sa + s*(1-da)
+  Xor, //!< r = s*(1-da) + d*(1-sa)
+  Plus, //!< r = min(s + d, 1)
+  Modulate, //!< r = s*d
+  Screen, //!< r = s + d - s*d
+
+  Overlay, //!< multiply or screen, depending on destination
+  Darken, //!< rc = s + d - max(s*da, d*sa), ra = kSrcOver
+  Lighten, //!< rc = s + d - min(s*da, d*sa), ra = kSrcOver
+  ColorDodge, //!< brighten destination to reflect source
+  ColorBurn, //!< darken destination to reflect source
+  HardLight, //!< multiply or screen, depending on source
+  SoftLight, //!< lighten or darken, depending on source
+  Difference, //!< rc = s + d - 2*(min(s*da, d*sa)), ra = kSrcOver
+  Exclusion, //!< rc = s + d - two(s*d), ra = kSrcOver
+  Multiply, //!< r = s*(1-da) + d*(1-sa) + s*d
+
+  Hue, //!< hue of source with saturation and luminosity of destination
+  Saturation, //!< saturation of source with hue and luminosity of
+  //!< destination
+  Color, //!< hue and saturation of source with luminosity of destination
+  Luminosity, //!< luminosity of source with hue and saturation of
+}

package/src/skia/types/Paint/Paint.ts

@@ -0,0 +1,153 @@
+import type { SkImageFilter } from "../ImageFilter";
+import type { SkMaskFilter } from "../MaskFilter";
+import type { SkColorFilter } from "../ColorFilter";
+import type { SkColor } from "../Color";
+import type { SkPathEffect } from "../PathEffect";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkShader } from "../Shader";
+
+import type { BlendMode } from "./BlendMode";
+
+export enum PaintStyle {
+  Fill,
+  Stroke,
+}
+
+export enum StrokeCap {
+  Butt,
+  Round,
+  Square,
+}
+
+export enum StrokeJoin {
+  Miter,
+  Round,
+  Bevel,
+}
+
+export const isPaint = (obj: SkJSIInstance<string> | null): obj is SkPaint =>
+  obj !== null && obj.__typename__ === "Paint";
+
+export interface SkPaint extends SkJSIInstance<"Paint"> {
+  /**
+   * Returns a copy of this paint.
+   */
+  copy(): SkPaint;
+
+  /**
+   * Retrieves the alpha and RGB unpremultiplied. RGB are extended sRGB values
+   * (sRGB gamut, and encoded with the sRGB transfer function).
+   */
+  getColor(): SkColor;
+
+  /**
+   * Returns the geometry drawn at the beginning and end of strokes.
+   */
+  getStrokeCap(): StrokeCap;
+
+  /**
+   * Returns the geometry drawn at the corners of strokes.
+   */
+  getStrokeJoin(): StrokeJoin;
+
+  /**
+   *  Returns the limit at which a sharp corner is drawn beveled.
+   */
+  getStrokeMiter(): number;
+
+  /**
+   * Returns the thickness of the pen used to outline the shape.
+   */
+  getStrokeWidth(): number;
+
+  /**
+   * Replaces alpha, leaving RGBA unchanged. 0 means fully transparent, 1.0 means opaque.
+   * @param alpha
+   */
+  setAlphaf(alpha: number): void;
+
+  /**
+   * Requests, but does not require, that edge pixels draw opaque or with
+   * partial transparency.
+   * @param aa
+   */
+  setAntiAlias: (aa: boolean) => void;
+
+  /**
+   * Sets the blend mode that is, the mode used to combine source color
+   * with destination color.
+   * @param mode
+   */
+  setBlendMode: (blendMode: BlendMode) => void;
+
+  /**
+   *  Sets alpha and RGB used when stroking and filling. The color is a 32-bit
+   *  value, unpremultiplied, packing 8-bit components for alpha, red, blue,
+   *  and green.
+   *
+   *   @param color  unpremultiplied ARGB
+   *
+   *    example: https://fiddle.skia.org/c/@Paint_setColor
+   */
+  setColor(color: SkColor): void;
+
+  /**
+   * Sets the current color filter, replacing the existing one if there was one.
+   * @param filter
+   */
+  setColorFilter(filter: SkColorFilter | null): void;
+
+  /**
+   * Sets the current image filter, replacing the existing one if there was one.
+   * @param filter
+   */
+  setImageFilter(filter: SkImageFilter | null): void;
+
+  /**
+   * Sets the current mask filter, replacing the existing one if there was one.
+   * @param filter
+   */
+  setMaskFilter(filter: SkMaskFilter | null): void;
+
+  /**
+   * Sets the current path effect, replacing the existing one if there was one.
+   * @param effect
+   */
+  setPathEffect(effect: SkPathEffect | null): void;
+
+  /**
+   * Sets the current shader, replacing the existing one if there was one.
+   * @param shader
+   */
+  setShader(shader: SkShader | null): void;
+
+  /**
+   * Sets the geometry drawn at the beginning and end of strokes.
+   * @param cap
+   */
+  setStrokeCap(cap: StrokeCap): void;
+
+  /**
+   * Sets the geometry drawn at the corners of strokes.
+   * @param join
+   */
+  setStrokeJoin(join: StrokeJoin): void;
+
+  /**
+   * Sets the limit at which a sharp corner is drawn beveled.
+   * @param limit
+   */
+  setStrokeMiter(limit: number): void;
+
+  /**
+   * Sets the thickness of the pen used to outline the shape.
+   * @param width
+   */
+  setStrokeWidth(width: number): void;
+
+  /**
+   * Sets whether the geometry is filled or stroked.
+   * @param style
+   */
+  setStyle(style: PaintStyle): void;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Paint";
+export * from "./BlendMode";