@pompadour/react-native-skia 1.4.0

package/src/skia/types/Picture/Picture.ts

@@ -0,0 +1,35 @@
+import type { FilterMode } from "../Image";
+import type { TileMode } from "../ImageFilter";
+import type { SkRect } from "../Rect";
+import type { SkShader } from "../Shader";
+import type { SkMatrix } from "../Matrix";
+import type { SkJSIInstance } from "../JsiInstance";
+
+export interface SkPicture extends SkJSIInstance<"Picture"> {
+  /**
+   *  Returns a new shader that will draw with this picture.
+   *
+   *  @param tmx  The tiling mode to use when sampling in the x-direction.
+   *  @param tmy  The tiling mode to use when sampling in the y-direction.
+   *  @param mode How to filter the tiles
+   *  @param localMatrix Optional matrix used when sampling
+   *  @param tileRect The tile rectangle in picture coordinates: this represents the subset
+   *              (or superset) of the picture used when building a tile. It is not
+   *              affected by localMatrix and does not imply scaling (only translation
+   *              and cropping). If null, the tile rect is considered equal to the picture
+   *              bounds.
+   */
+  makeShader(
+    tmx: TileMode,
+    tmy: TileMode,
+    mode: FilterMode,
+    localMatrix?: SkMatrix,
+    tileRect?: SkRect
+  ): SkShader;
+
+  /**
+   * Returns the serialized format of this SkPicture. The format may change at anytime and
+   * no promises are made for backwards or forward compatibility.
+   */
+  serialize(): Uint8Array | null;
+}

package/src/skia/types/Picture/PictureFactory.ts

@@ -0,0 +1,9 @@
+import type { SkPicture } from "./Picture";
+
+export interface PictureFactory {
+  /**
+   * Returns an SkPicture which has been serialized previously to the given bytes.
+   * @param bytes
+   */
+  MakePicture(bytes: Uint8Array | ArrayBuffer): SkPicture | null;
+}

package/src/skia/types/Picture/PictureRecorder.ts

@@ -0,0 +1,18 @@
+import type { SkCanvas } from "../Canvas";
+import type { SkRect } from "../Rect";
+
+import type { SkPicture } from "./Picture";
+
+export interface SkPictureRecorder {
+  /**
+   * Returns a canvas on which to draw. When done drawing, call finishRecordingAsPicture()
+   *
+   * @param bounds - a rect to cull the results.
+   */
+  beginRecording(bounds?: SkRect): SkCanvas;
+
+  /**
+   * Returns the captured draw commands as a picture and invalidates the canvas returned earlier.
+   */
+  finishRecordingAsPicture(): SkPicture;
+}

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

@@ -0,0 +1,3 @@
+export * from "./Picture";
+export * from "./PictureRecorder";
+export * from "./PictureFactory";

package/src/skia/types/Point.ts

@@ -0,0 +1,12 @@
+export enum PointMode {
+  Points,
+  Lines,
+  Polygon,
+}
+
+export interface SkPoint {
+  readonly x: number;
+  readonly y: number;
+}
+
+export type Vector = SkPoint;

package/src/skia/types/RRect.ts

@@ -0,0 +1,23 @@
+import type { SkPoint } from "./Point";
+import type { SkRect } from "./Rect";
+
+export interface SkRRect {
+  readonly rect: SkRect;
+  readonly rx: number;
+  readonly ry: number;
+}
+
+export interface NonUniformRRect {
+  readonly rect: SkRect;
+  readonly topLeft: SkPoint;
+  readonly topRight: SkPoint;
+  readonly bottomRight: SkPoint;
+  readonly bottomLeft: SkPoint;
+}
+
+export type InputRRect = SkRRect | NonUniformRRect;
+
+// We have an issue to check property existence on JSI backed instances
+export const isRRect = (def: SkRect | SkRRect): def is SkRRect =>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (def as any).rect !== undefined;

package/src/skia/types/RSXform.ts

@@ -0,0 +1,9 @@
+import type { SkJSIInstance } from "./JsiInstance";
+
+export interface SkRSXform extends SkJSIInstance<"RSXform"> {
+  readonly scos: number;
+  readonly ssin: number;
+  readonly tx: number;
+  readonly ty: number;
+  set(scos: number, ssin: number, tx: number, ty: number): void;
+}

package/src/skia/types/Rect.ts

@@ -0,0 +1,26 @@
+import type { SkJSIInstance } from "./JsiInstance";
+
+export interface SkRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface SkHostRect extends SkRect, SkJSIInstance<"Rect"> {
+  setXYWH(x: number, y: number, width: number, height: number): void;
+}
+
+export const isRect = (def: unknown): def is SkRect => {
+  "worklet";
+  if (typeof def === "object" && def !== null) {
+    const rect = def as SkRect;
+    return (
+      typeof rect.x === "number" &&
+      typeof rect.y === "number" &&
+      typeof rect.width === "number" &&
+      typeof rect.height === "number"
+    );
+  }
+  return false;
+};

package/src/skia/types/RuntimeEffect/RuntimeEffect.ts

@@ -0,0 +1,66 @@
+import type { SkShader } from "../Shader";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkMatrix } from "../Matrix";
+
+export interface SkSLUniform {
+  columns: number;
+  rows: number;
+  /** The index into the uniforms array that this uniform begins. */
+  slot: number;
+  isInteger: boolean;
+}
+
+export interface SkRuntimeShaderBuilder
+  extends SkJSIInstance<"RuntimeShaderBuilder"> {
+  setUniform(name: string, value: readonly number[]): void;
+}
+
+export interface SkRuntimeEffect extends SkJSIInstance<"RuntimeEffect"> {
+  /**
+   * Returns a shader executed using the given uniform data.
+   * @param uniforms
+   * @param localMatrix
+   */
+  makeShader(uniforms: number[], localMatrix?: SkMatrix): SkShader;
+
+  /**
+   * Returns a shader executed using the given uniform data and the children as inputs.
+   * @param uniforms
+   * @param children
+   * @param localMatrix
+   */
+  makeShaderWithChildren(
+    uniforms: number[],
+    children?: SkShader[],
+    localMatrix?: SkMatrix
+  ): SkShader;
+
+  /**
+   * Returns the nth uniform from the effect.
+   * @param index
+   */
+  getUniform(index: number): SkSLUniform;
+
+  /**
+   * Returns the number of uniforms in the effect.
+   */
+  getUniformCount(): number;
+
+  /**
+   * Returns the total number of floats across all uniforms on the effect. This is the length
+   * of the uniforms array expected by makeShader. For example, an effect with a single float3
+   * uniform, would return 1 from `getUniformCount()`, but 3 from `getUniformFloatCount()`.
+   */
+  getUniformFloatCount(): number;
+
+  /**
+   * Returns the name of the nth effect uniform.
+   * @param index
+   */
+  getUniformName(index: number): string;
+
+  /**
+   * Returns the SkSL source of the runtime effect shader.
+   */
+  source(): string;
+}

package/src/skia/types/RuntimeEffect/RuntimeEffectFactory.ts

@@ -0,0 +1,12 @@
+import type { SkRuntimeEffect } from "./RuntimeEffect";
+
+export interface RuntimeEffectFactory {
+  /**
+   * Compiles a RuntimeEffect from the given shader code.
+   * @param sksl - Source code for a shader written in SkSL
+   * @param callback - will be called with any compilation error. If not provided, errors will
+   *                   be printed to console.log().
+   */
+  Make: (sksl: string) => SkRuntimeEffect | null;
+  //Make(sksl: string, callback?: (err: string) => void): RuntimeEffect | null;
+}

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

@@ -0,0 +1,2 @@
+export * from "./RuntimeEffect";
+export * from "./RuntimeEffectFactory";

package/src/skia/types/SVG/SVG.ts

@@ -0,0 +1,6 @@
+import type { SkJSIInstance } from "../JsiInstance";
+
+export interface SkSVG extends SkJSIInstance<"SVG"> {
+  width(): number;
+  height(): number;
+}

package/src/skia/types/SVG/SVGFactory.ts

@@ -0,0 +1,8 @@
+import type { SkData } from "../Data";
+
+import type { SkSVG } from "./SVG";
+
+export interface SVGFactory {
+  MakeFromData(data: SkData): SkSVG | null;
+  MakeFromString(str: string): SkSVG | null;
+}

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

@@ -0,0 +1,2 @@
+export * from "./SVG";
+export * from "./SVGFactory";

package/src/skia/types/Shader/Shader.ts

@@ -0,0 +1,64 @@
+import type { SkJSIInstance } from "../JsiInstance";
+import type { Vector } from "../Point";
+import type { SkRuntimeEffect, SkRuntimeShaderBuilder } from "../RuntimeEffect";
+
+export const isShader = (obj: SkJSIInstance<string> | null): obj is SkShader =>
+  obj !== null && obj.__typename__ === "Shader";
+
+export type SkShader = SkJSIInstance<"Shader">;
+
+export type Uniform =
+  | number
+  | Vector
+  | Float32Array
+  | readonly Uniform[]
+  | Uniform[];
+
+export interface Uniforms {
+  [name: string]: Uniform;
+}
+
+const isVector = (obj: unknown): obj is Vector =>
+  // We have an issue to check property existence on JSI backed instances
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (obj as any).x !== undefined && (obj as any).y !== undefined;
+
+const processValue = (values: number[], value: Uniform) => {
+  if (typeof value === "number") {
+    values.push(value);
+  } else if (Array.isArray(value)) {
+    value.forEach((v) => processValue(values, v));
+  } else if (isVector(value)) {
+    values.push(value.x, value.y);
+  } else if (value instanceof Float32Array) {
+    values.push(...value);
+  }
+};
+
+export const processUniforms = (
+  source: SkRuntimeEffect,
+  uniforms: Uniforms,
+  builder?: SkRuntimeShaderBuilder
+) => {
+  const result: number[] = [];
+  const uniformsCount = source.getUniformCount();
+  for (let i = 0; i < uniformsCount; i++) {
+    const name = source.getUniformName(i);
+    const value = uniforms[name];
+    if (value === undefined) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `The runtime effect has the uniform value "${name}" declared, but it is missing from the uniforms property of the Runtime effect.`
+      );
+    }
+    if (builder === undefined) {
+      processValue(result, value);
+    } else {
+      const uniformValue: number[] = [];
+      processValue(uniformValue, value);
+      builder.setUniform(name, uniformValue);
+      result.push(...uniformValue);
+    }
+  }
+  return result;
+};

package/src/skia/types/Shader/ShaderFactory.ts

@@ -0,0 +1,169 @@
+import type { TileMode } from "../ImageFilter";
+import type { SkPoint } from "../Point";
+import type { SkMatrix } from "../Matrix";
+import type { SkColor } from "../Color";
+import type { BlendMode } from "../Paint/BlendMode";
+
+import type { SkShader } from "./Shader";
+
+export interface ShaderFactory {
+  /**
+   * Returns a shader that generates a linear gradient between the two specified points.
+   * See SkGradientShader.h for more.
+   * @param start
+   * @param end
+   * @param colors - colors to be distributed between start and end.
+   * @param pos - May be null. The relative positions of colors. If supplied must be same length
+   *              as colors.
+   * @param mode
+   * @param localMatrix
+   * @param flags - By default gradients will interpolate their colors in unpremul space
+   *                and then premultiply each of the results. By setting this to 1, the
+   *                gradients will premultiply their colors first, and then interpolate
+   *                between them.
+   */
+  MakeLinearGradient(
+    start: SkPoint,
+    end: SkPoint,
+    colors: SkColor[],
+    pos: number[] | null,
+    mode: TileMode,
+    localMatrix?: SkMatrix,
+    flags?: number
+    // colorSpace: ColorSpace
+  ): SkShader;
+
+  /**
+   * Returns a shader that generates a radial gradient given the center and radius.
+   * See SkGradientShader.h for more.
+   * @param center
+   * @param radius
+   * @param colors - colors to be distributed between the center and edge.
+   * @param pos - May be null. The relative positions of colors. If supplied must be same length
+   *              as colors. Range [0.0, 1.0]
+   * @param mode
+   * @param localMatrix
+   * @param flags - 0 to interpolate colors in unpremul, 1 to interpolate colors in premul.
+   */
+  MakeRadialGradient(
+    center: SkPoint,
+    radius: number,
+    colors: SkColor[],
+    pos: number[] | null,
+    mode: TileMode,
+    localMatrix?: SkMatrix,
+    flags?: number
+    // colorSpace?: ColorSpace
+  ): SkShader;
+
+  /**
+   * Returns a shader that generates a conical gradient given two circles.
+   * See SkGradientShader.h for more.
+   * @param start
+   * @param startRadius
+   * @param end
+   * @param endRadius
+   * @param colors
+   * @param pos
+   * @param mode
+   * @param localMatrix
+   * @param flags
+   */
+  MakeTwoPointConicalGradient(
+    start: SkPoint,
+    startRadius: number,
+    end: SkPoint,
+    endRadius: number,
+    colors: SkColor[],
+    pos: number[] | null,
+    mode: TileMode,
+    localMatrix?: SkMatrix,
+    flags?: number
+    //  colorSpace?: ColorSpace
+  ): SkShader;
+
+  /**
+   * Returns a shader that generates a sweep gradient given a center.
+   * See SkGradientShader.h for more.
+   * @param cx
+   * @param cy
+   * @param colors - colors to be distributed around the center, within the provided angles.
+   * @param pos - May be null. The relative positions of colors. If supplied must be same length
+   *              as colors. Range [0.0, 1.0]
+   * @param mode
+   * @param localMatrix
+   * @param flags - 0 to interpolate colors in unpremul, 1 to interpolate colors in premul.
+   * @param startAngle - angle corresponding to 0.0. Defaults to 0 degrees.
+   * @param endAngle - angle corresponding to 1.0. Defaults to 360 degrees.
+   */
+  MakeSweepGradient(
+    cx: number,
+    cy: number,
+    colors: SkColor[],
+    pos: number[] | null,
+    mode: TileMode,
+    localMatrix?: SkMatrix | null,
+    flags?: number,
+    startAngleInDegrees?: number,
+    endAngleInDegrees?: number
+    //  colorSpace?: ColorSpace
+  ): SkShader;
+
+  /**
+   * Returns a shader with Perlin Turbulence.
+   * See SkPerlinNoiseShader.h for more details
+   * @param baseFreqX - base frequency in the X direction; range [0.0, 1.0]
+   * @param baseFreqY - base frequency in the Y direction; range [0.0, 1.0]
+   * @param octaves
+   * @param seed
+   * @param tileW - if this and tileH are non-zero, the frequencies will be modified so that the
+   *                noise will be tileable for the given size.
+   * @param tileH - if this and tileW are non-zero, the frequencies will be modified so that the
+   *                noise will be tileable for the given size.
+   */
+  MakeTurbulence(
+    baseFreqX: number,
+    baseFreqY: number,
+    octaves: number,
+    seed: number,
+    tileW: number,
+    tileH: number
+  ): SkShader;
+
+  /**
+   * Returns a shader with Perlin Fractal Noise.
+   * See SkPerlinNoiseShader.h for more details
+   * @param baseFreqX - base frequency in the X direction; range [0.0, 1.0]
+   * @param baseFreqY - base frequency in the Y direction; range [0.0, 1.0]
+   * @param octaves
+   * @param seed
+   * @param tileW - if this and tileH are non-zero, the frequencies will be modified so that the
+   *                noise will be tileable for the given size.
+   * @param tileH - if this and tileW are non-zero, the frequencies will be modified so that the
+   *                noise will be tileable for the given size.
+   */
+  MakeFractalNoise(
+    baseFreqX: number,
+    baseFreqY: number,
+    octaves: number,
+    seed: number,
+    tileW: number,
+    tileH: number
+  ): SkShader;
+
+  /**
+   * Returns a shader that combines the given shaders with a BlendMode.
+   * @param mode
+   * @param one
+   * @param two
+   */
+  MakeBlend(mode: BlendMode, one: SkShader, two: SkShader): SkShader;
+
+  /**
+   * Returns a shader with a given color and colorspace.
+   * @param color
+   */
+  MakeColor(
+    color: SkColor //,space: ColorSpace
+  ): SkShader;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Shader";
+export * from "./ShaderFactory";

package/src/skia/types/Size.ts

@@ -0,0 +1,4 @@
+export interface SkSize {
+  width: number;
+  height: number;
+}

package/src/skia/types/Skia.ts

@@ -0,0 +1,101 @@
+import type { ImageFilterFactory } from "./ImageFilter";
+import type { PathFactory } from "./Path";
+import type { ColorFilterFactory } from "./ColorFilter";
+import type { SkFont, FontMgrFactory } from "./Font";
+import type { SkTypeface, TypefaceFactory } from "./Typeface";
+import type { ImageFactory } from "./Image";
+import type { MaskFilterFactory } from "./MaskFilter";
+import type { SkPaint } from "./Paint";
+import type { SkHostRect, SkRect } from "./Rect";
+import type { SkRRect } from "./RRect";
+import type {
+  RuntimeEffectFactory,
+  SkRuntimeEffect,
+  SkRuntimeShaderBuilder,
+} from "./RuntimeEffect";
+import type { ShaderFactory } from "./Shader";
+import type { SkMatrix } from "./Matrix";
+import type { PathEffectFactory } from "./PathEffect";
+import type { SkPoint } from "./Point";
+import type { SkVertices, VertexMode } from "./Vertices/Vertices";
+import type { DataFactory } from "./Data";
+import type { SVGFactory } from "./SVG";
+import type { TextBlobFactory } from "./TextBlob";
+import type { SurfaceFactory } from "./Surface";
+import type { SkRSXform } from "./RSXform";
+import type { SkPath } from "./Path/Path";
+import type { SkContourMeasureIter } from "./ContourMeasure";
+import type { PictureFactory, SkPictureRecorder } from "./Picture";
+import type { Color, SkColor } from "./Color";
+import type { TypefaceFontProviderFactory } from "./Paragraph/TypefaceFontProviderFactory";
+import type { AnimatedImageFactory } from "./AnimatedImage";
+import type { ParagraphBuilderFactory } from "./Paragraph/ParagraphBuilder";
+import type { Video } from "./Video";
+import type { NativeBufferFactory } from "./NativeBuffer";
+
+/**
+ * Declares the interface for the native Skia API
+ */
+export interface Skia {
+  Point: (x: number, y: number) => SkPoint;
+  XYWHRect: (x: number, y: number, width: number, height: number) => SkHostRect;
+  RuntimeShaderBuilder: (rt: SkRuntimeEffect) => SkRuntimeShaderBuilder;
+  RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
+  RSXform: (scos: number, ssin: number, tx: number, ty: number) => SkRSXform;
+  RSXformFromRadians: (
+    scale: number,
+    radians: number,
+    tx: number,
+    ty: number,
+    px: number,
+    py: number
+  ) => SkRSXform;
+  Color: (color: Color) => SkColor;
+  ContourMeasureIter: (
+    path: SkPath,
+    forceClosed: boolean,
+    resScale: number
+  ) => SkContourMeasureIter;
+  Paint: () => SkPaint;
+  PictureRecorder: () => SkPictureRecorder;
+  Picture: PictureFactory;
+  Path: PathFactory;
+  Matrix: (matrix?: readonly number[]) => SkMatrix;
+  ColorFilter: ColorFilterFactory;
+  Font: (typeface?: SkTypeface, size?: number) => SkFont;
+  Typeface: TypefaceFactory;
+  TypefaceFontProvider: TypefaceFontProviderFactory;
+  FontMgr: FontMgrFactory;
+  MaskFilter: MaskFilterFactory;
+  RuntimeEffect: RuntimeEffectFactory;
+  ImageFilter: ImageFilterFactory;
+  Shader: ShaderFactory;
+  PathEffect: PathEffectFactory;
+  /**
+   * Returns an Vertices based on the given positions and optional parameters.
+   * See SkVertices.h (especially the Builder) for more details.
+   * @param mode
+   * @param positions
+   * @param textureCoordinates
+   * @param colors - either a list of int colors or a flattened color array.
+   * @param indices
+   * @param isVolatile
+   */
+  MakeVertices(
+    mode: VertexMode,
+    positions: SkPoint[],
+    textureCoordinates?: SkPoint[] | null,
+    colors?: SkColor[],
+    indices?: number[] | null,
+    isVolatile?: boolean
+  ): SkVertices;
+  Data: DataFactory;
+  Image: ImageFactory;
+  AnimatedImage: AnimatedImageFactory;
+  SVG: SVGFactory;
+  TextBlob: TextBlobFactory;
+  Surface: SurfaceFactory;
+  ParagraphBuilder: ParagraphBuilderFactory;
+  Video: (url: string) => Promise<Video> | Video;
+  NativeBuffer: NativeBufferFactory;
+}

package/src/skia/types/Surface/Surface.ts

@@ -0,0 +1,42 @@
+import type { SkImage } from "../Image";
+import type { SkCanvas } from "../Canvas";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkRect } from "../Rect";
+
+export interface SkSurface extends SkJSIInstance<"Surface"> {
+  /** Returns Canvas that draws into the surface. Subsequent calls return the
+     same Canvas. Canvas returned is managed and owned by Surface, and is
+     deleted when Surface is deleted.
+
+      @return  drawing Canvas for Surface
+
+      example: https://fiddle.skia.org/c/@Surface_getCanvas
+  */
+  getCanvas(): SkCanvas;
+
+  /** Returns Image capturing Surface contents. Subsequent drawing to
+     Surface contents are not captured.
+
+      @param bounds A rectangle specifying the subset of the surface that
+   is of interest.
+      @return  Image initialized with Surface contents
+
+      example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot
+  */
+  makeImageSnapshot(bounds?: SkRect): SkImage;
+
+  /**
+   * Make sure any queued draws are sent to the screen or the GPU.
+   */
+  flush(): void;
+
+  /**
+   * Returns the possibly scaled width of the surface.
+   */
+  width(): number;
+
+  /**
+   * Returns the possibly scaled height of the surface.
+   */
+  height(): number;
+}

package/src/skia/types/Surface/SurfaceFactory.ts

@@ -0,0 +1,19 @@
+import type { SkSurface } from "./Surface";
+
+export interface SurfaceFactory {
+  /**
+   * Returns a CPU backed surface with the given dimensions, an SRGB colorspace, Unpremul
+   * alphaType and 8888 color type. The pixels belonging to this surface  will be in memory and
+   * not visible.
+   * @param width - number of pixels of the width of the drawable area.
+   * @param height - number of pixels of the height of the drawable area.
+   */
+  Make: (width: number, height: number) => SkSurface | null;
+
+  /**
+   * Creates a GPU backed surface.
+   * @param width - number of pixels of the width of the drawable area.
+   * @param height - number of pixels of the height of the drawable area.
+   */
+  MakeOffscreen: (width: number, height: number) => SkSurface | null;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Surface";
+export * from "./SurfaceFactory";