@shopify/react-native-skia 0.1.115

package/src/skia/Point.ts

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

package/src/skia/RRect.ts

@@ -0,0 +1,7 @@
+import type { SkRect } from "./Rect";
+
+export interface SkRRect {
+  readonly rect: SkRect;
+  readonly rx: number;
+  readonly ry: number;
+}

package/src/skia/RSXform.ts

@@ -0,0 +1,3 @@
+import type { SkJSIInstance } from "./JsiInstance";
+
+export type SkRSXform = SkJSIInstance<"RSXform">;

package/src/skia/Rect.ts

@@ -0,0 +1,6 @@
+export interface SkRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}

package/src/skia/RuntimeEffect/RuntimeEffect.ts

@@ -0,0 +1,63 @@
+import type { IShader } 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 IRuntimeEffect extends SkJSIInstance<"RuntimeEffect"> {
+  /**
+   * Returns a shader executed using the given uniform data.
+   * @param uniforms
+   * @param isOpaque
+   * @param localMatrix
+   */
+  makeShader(
+    uniforms: number[],
+    isOpaque?: boolean,
+    localMatrix?: SkMatrix
+  ): IShader;
+
+  /**
+   * Returns a shader executed using the given uniform data and the children as inputs.
+   * @param uniforms
+   * @param isOpaque
+   * @param children
+   * @param localMatrix
+   */
+  makeShaderWithChildren(
+    uniforms: number[],
+    isOpaque?: boolean,
+    children?: IShader[],
+    localMatrix?: SkMatrix
+  ): IShader;
+
+  /**
+   * 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;
+}

package/src/skia/RuntimeEffect/RuntimeEffectFactory.ts

@@ -0,0 +1,12 @@
+import type { IRuntimeEffect } 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) => IRuntimeEffect | null;
+  //Make(sksl: string, callback?: (err: string) => void): RuntimeEffect | null;
+}

package/src/skia/RuntimeEffect/index.ts

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

package/src/skia/SVG/SVG.ts

@@ -0,0 +1,3 @@
+import type { SkJSIInstance } from "../JsiInstance";
+
+export type SkSVG = SkJSIInstance<"SVG">;

package/src/skia/SVG/SVGFactory.ts

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

package/src/skia/SVG/index.ts

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

package/src/skia/SVG/useSvg.ts

@@ -0,0 +1,6 @@
+import { Skia } from "../Skia";
+import type { DataSource } from "../Data/Data";
+import { useRawData } from "../Data/Data";
+
+export const useSVG = (source: DataSource) =>
+  useRawData(source, Skia.SVG.MakeFromData);

package/src/skia/Shader/Shader.ts

@@ -0,0 +1,6 @@
+import type { SkJSIInstance } from "../JsiInstance";
+
+export const isShader = (obj: SkJSIInstance<string> | null): obj is IShader =>
+  obj !== null && obj.__typename__ === "Shader";
+
+export type IShader = SkJSIInstance<"Shader">;

package/src/skia/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 { IShader } 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
+  ): IShader;
+
+  /**
+   * 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
+  ): IShader;
+
+  /**
+   * 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
+  ): IShader;
+
+  /**
+   * 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
+  ): IShader;
+
+  /**
+   * 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
+  ): IShader;
+
+  /**
+   * 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
+  ): IShader;
+
+  /**
+   * Returns a shader that combines the given shaders with a BlendMode.
+   * @param mode
+   * @param one
+   * @param two
+   */
+  MakeBlend(mode: BlendMode, one: IShader, two: IShader): IShader;
+
+  /**
+   * Returns a shader with a given color and colorspace.
+   * @param color
+   */
+  MakeColor(
+    color: SkColor //,space: ColorSpace
+  ): IShader;
+}

package/src/skia/Shader/index.ts

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

package/src/skia/Shader/useShader.ts

@@ -0,0 +1,6 @@
+import { useMemo } from "react";
+
+import { Skia } from "../Skia";
+
+export const useShader = (sksl: string) =>
+  useMemo(() => Skia.RuntimeEffect.Make(sksl), [sksl]);

package/src/skia/Skia.ts

@@ -0,0 +1,120 @@
+/*global SkiaApi*/
+import type { ImageFilterFactory } from "./ImageFilter";
+import type { PathFactory } from "./Path";
+import type { ColorFilterFactory } from "./ColorFilter";
+import type { SkFont } 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 { SkRect } from "./Rect";
+import type { SkRRect } from "./RRect";
+import type { RuntimeEffectFactory } from "./RuntimeEffect";
+import type { ShaderFactory } from "./Shader";
+import type { SkColor } from "./Color";
+import { processColor } from "./Color";
+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 { FontMgrFactory } from "./FontMgr/FontMgrFactory";
+import type { SurfaceFactory } from "./Surface";
+import "./NativeSetup";
+import type { SkRSXform } from "./RSXform";
+import type { SkPath } from "./Path/Path";
+import type { SkContourMeasureIter } from "./ContourMeasure";
+
+/**
+ * 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) => SkRect;
+  RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
+  RSXform: (scos: number, ssin: number, tx: number, ty: number) => SkRSXform;
+  ContourMeasureIter: (
+    path: SkPath,
+    forceClosed: boolean,
+    resScale: number
+  ) => SkContourMeasureIter;
+  Paint: () => SkPaint;
+  Path: PathFactory;
+  Matrix: () => SkMatrix;
+  ColorFilter: ColorFilterFactory;
+  Font: (typeface?: SkTypeface, size?: number) => SkFont;
+  Typeface: TypefaceFactory;
+  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;
+  SVG: SVGFactory;
+  FontMgr: FontMgrFactory;
+  TextBlob: TextBlobFactory;
+  Surface: SurfaceFactory;
+}
+
+/**
+ * Declares the SkiaApi as an available object in the global scope
+ */
+declare global {
+  var SkiaApi: Skia;
+}
+
+/**
+ * Declares the implemented API with overrides.
+ */
+export const Skia = {
+  // Factories
+  Typeface: SkiaApi.Typeface,
+  MaskFilter: SkiaApi.MaskFilter,
+  RuntimeEffect: SkiaApi.RuntimeEffect,
+  Shader: SkiaApi.Shader,
+  ImageFilter: SkiaApi.ImageFilter,
+  PathEffect: SkiaApi.PathEffect,
+  Data: SkiaApi.Data,
+  SVG: SkiaApi.SVG,
+  FontMgr: SkiaApi.FontMgr,
+  TextBlob: SkiaApi.TextBlob,
+  // Constructors
+  Matrix: SkiaApi.Matrix,
+  Font: SkiaApi.Font,
+  Point: SkiaApi.Point,
+  XYWHRect: SkiaApi.XYWHRect,
+  RRectXY: SkiaApi.RRectXY,
+  Paint: SkiaApi.Paint,
+  Path: SkiaApi.Path,
+  ColorFilter: SkiaApi.ColorFilter,
+  ContourMeasureIter: SkiaApi.ContourMeasureIter,
+  // Here are constructors for data types which are represented as typed arrays in CanvasKit
+  Color: (color: Parameters<typeof processColor>[0]) => processColor(color, 1),
+  RSXform: SkiaApi.RSXform,
+  // For the following methods the factory symmetry is broken to be comptatible with CanvasKit
+  MakeSurface: SkiaApi.Surface.Make,
+  MakeImageFromEncoded: SkiaApi.Image.MakeImageFromEncoded,
+  MakeImage: SkiaApi.Image.MakeImage,
+  MakeVertices: SkiaApi.MakeVertices,
+};

package/src/skia/Surface/Surface.ts

@@ -0,0 +1,27 @@
+import type { SkImage } from "../Image";
+import type { SkCanvas } from "../Canvas";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkRect } from "../Rect";
+
+export interface ISurface 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;
+}

package/src/skia/Surface/SurfaceFactory.ts

@@ -0,0 +1,12 @@
+import type { ISurface } 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) => ISurface | null;
+}

package/src/skia/Surface/index.ts

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

package/src/skia/TextBlob.ts

@@ -0,0 +1,52 @@
+import type { SkJSIInstance } from "./JsiInstance";
+import type { SkFont } from "./Font/Font";
+import type { SkRSXform } from "./RSXform";
+
+export type SkTextBlob = SkJSIInstance<"TextBlob">;
+
+export interface TextBlobFactory {
+  /**
+   * Return a TextBlob with a single run of text.
+   *
+   * It uses the default character-to-glyph mapping from the typeface in the font.
+   * It does not perform typeface fallback for characters not found in the Typeface.
+   * It does not perform kerning or other complex shaping; glyphs are positioned based on their
+   * default advances.
+   * @param str
+   * @param font
+   */
+  MakeFromText(str: string, font: SkFont): SkTextBlob;
+  /**
+   * Return a TextBlob with a single run of text.
+   *
+   * It does not perform typeface fallback for characters not found in the Typeface.
+   * It does not perform kerning or other complex shaping; glyphs are positioned based on their
+   * default advances.
+   * @param glyphs - if using Malloc'd array, be sure to use CanvasKit.MallocGlyphIDs().
+   * @param font
+   */
+  MakeFromGlyphs(glyphs: number[], font: SkFont): SkTextBlob;
+
+  /**
+   * Returns a TextBlob built from a single run of text with rotation, scale, and translations.
+   *
+   * It uses the default character-to-glyph mapping from the typeface in the font.
+   * @param str
+   * @param rsxforms
+   * @param font
+   */
+  MakeFromRSXform(str: string, rsxforms: SkRSXform[], font: SkFont): SkTextBlob;
+
+  /**
+   * Returns a TextBlob built from a single run of text with rotation, scale, and translations.
+   *
+   * @param glyphs - if using Malloc'd array, be sure to use CanvasKit.MallocGlyphIDs().
+   * @param rsxforms
+   * @param font
+   */
+  MakeFromRSXformGlyphs(
+    glyphs: number[],
+    rsxforms: SkRSXform[],
+    font: SkFont
+  ): SkTextBlob;
+}

package/src/skia/Typeface/Typeface.ts

@@ -0,0 +1,6 @@
+import type { SkJSIInstance } from "../JsiInstance";
+
+export interface SkTypeface extends SkJSIInstance<"Typeface"> {
+  readonly bold: boolean;
+  readonly italic: boolean;
+}

package/src/skia/Typeface/TypefaceFactory.ts

@@ -0,0 +1,7 @@
+import type { Data } from "../Data/Data";
+
+import type { SkTypeface } from "./Typeface";
+
+export interface TypefaceFactory {
+  MakeFreeTypeFaceFromData(data: Data): SkTypeface | null;
+}

package/src/skia/Typeface/index.ts

@@ -0,0 +1,3 @@
+export * from "./Typeface";
+export * from "./useTypeface";
+export * from "./TypefaceFactory";

package/src/skia/Typeface/useTypeface.ts

@@ -0,0 +1,9 @@
+import { Skia } from "../Skia";
+import type { DataSource } from "../Data/Data";
+import { useRawData } from "../Data/Data";
+
+/**
+ * Returns a Skia Typeface object
+ * */
+export const useTypeface = (source: DataSource) =>
+  useRawData(source, Skia.Typeface.MakeFreeTypeFaceFromData);

package/src/skia/Vertices/Vertices.tsx

@@ -0,0 +1,20 @@
+import type { SkRect } from "../Rect";
+import type { SkJSIInstance } from "../JsiInstance";
+
+export enum VertexMode {
+  Triangles,
+  TrianglesStrip,
+  TriangleFan,
+}
+
+export interface SkVertices extends SkJSIInstance<"Vertices"> {
+  /**
+   * Return the bounding area for the vertices.
+   */
+  bounds(): SkRect;
+
+  /**
+   * Return a unique ID for this vertices object.
+   */
+  uniqueID(): number;
+}

package/src/skia/Vertices/index.ts

@@ -0,0 +1 @@
+export * from "./Vertices";

package/src/skia/index.ts

@@ -0,0 +1,22 @@
+export { Skia } from "./Skia";
+export * from "./Canvas";
+export * from "./Paint";
+export * from "./Rect";
+export * from "./RRect";
+export * from "./Point";
+export * from "./Path";
+export * from "./Font";
+export * from "./Typeface";
+export * from "./MaskFilter";
+export * from "./ColorFilter";
+export * from "./ImageFilter";
+export * from "./PathEffect";
+export * from "./RuntimeEffect";
+export * from "./Shader";
+export * from "./Image";
+export * from "./Matrix";
+export * from "./SVG";
+export * from "./Surface";
+export * from "./FontMgr";
+export * from "./Vertices";
+export * from "./Color";

package/src/values/animation/decay/decay.ts

@@ -0,0 +1,35 @@
+import type { DecayState, DefaultDecayConfig } from "./types";
+
+const VELOCITY_EPS = 1;
+const SLOPE_FACTOR = 0.1;
+
+export const decay = (
+  now: number,
+  state: DecayState,
+  config: DefaultDecayConfig
+): DecayState => {
+  const { lastTimestamp, startTimestamp, initialVelocity, current, velocity } =
+    state;
+  const nextState = { ...state };
+  const deltaTime = Math.min(now - lastTimestamp, 64);
+  const v =
+    velocity *
+    Math.exp(
+      -(1 - config.deceleration) * (now - startTimestamp) * SLOPE_FACTOR
+    );
+  nextState.current = current + (v * config.velocityFactor * deltaTime) / 1000; // /1000 because time is in ms not in s
+  nextState.velocity = v;
+  nextState.lastTimestamp = now;
+
+  if (config.clamp) {
+    if (initialVelocity < 0 && nextState.current <= config.clamp[0]) {
+      nextState.current = config.clamp[0];
+      nextState.finished = true;
+    } else if (initialVelocity > 0 && nextState.current >= config.clamp[1]) {
+      nextState.current = config.clamp[1];
+      nextState.finished = true;
+    }
+  }
+  nextState.finished = Math.abs(v) < VELOCITY_EPS;
+  return nextState;
+};

package/src/values/animation/decay/index.ts

@@ -0,0 +1 @@
+export { runDecay } from "./runDecay";