@shopify/react-native-skia 1.0.1 → 1.0.3

package/lib/typescript/src/skia/types/Rect.d.ts

@@ -0,0 +1,11 @@
+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 declare const isRect: (def: unknown) => def is SkRect;

package/lib/typescript/src/skia/types/RuntimeEffect/RuntimeEffect.d.ts

@@ -0,0 +1,52 @@
+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/lib/typescript/src/skia/types/RuntimeEffect/RuntimeEffectFactory.d.ts

@@ -0,0 +1,10 @@
+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;
+}

package/lib/typescript/src/skia/types/RuntimeEffect/index.d.ts

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

package/lib/typescript/src/skia/types/SVG/SVG.d.ts

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

package/lib/typescript/src/skia/types/SVG/SVGFactory.d.ts

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

package/lib/typescript/src/skia/types/SVG/index.d.ts

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

package/lib/typescript/src/skia/types/Shader/Shader.d.ts

@@ -0,0 +1,10 @@
+import type { SkJSIInstance } from "../JsiInstance";
+import type { Vector } from "../Point";
+import type { SkRuntimeEffect, SkRuntimeShaderBuilder } from "../RuntimeEffect";
+export declare const isShader: (obj: SkJSIInstance<string> | null) => obj is SkShader;
+export type SkShader = SkJSIInstance<"Shader">;
+export type Uniform = number | Vector | Float32Array | readonly Uniform[] | Uniform[];
+export interface Uniforms {
+    [name: string]: Uniform;
+}
+export declare const processUniforms: (source: SkRuntimeEffect, uniforms: Uniforms, builder?: SkRuntimeShaderBuilder) => number[];

package/lib/typescript/src/skia/types/Shader/ShaderFactory.d.ts

@@ -0,0 +1,104 @@
+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): 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): 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): 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): 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): SkShader;
+}

package/lib/typescript/src/skia/types/Shader/index.d.ts

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

package/lib/typescript/src/skia/types/Size.d.ts

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

package/lib/typescript/src/skia/types/Skia.d.ts

@@ -0,0 +1,74 @@
+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";
+/**
+ * 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;
+}

package/lib/typescript/src/skia/types/Surface/Surface.d.ts

@@ -0,0 +1,29 @@
+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;
+}

package/lib/typescript/src/skia/types/Surface/SurfaceFactory.d.ts

@@ -0,0 +1,17 @@
+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/lib/typescript/src/skia/types/Surface/index.d.ts

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

package/lib/typescript/src/skia/types/TextBlob.d.ts

@@ -0,0 +1,44 @@
+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/lib/typescript/src/skia/types/Typeface/Typeface.d.ts

@@ -0,0 +1,11 @@
+import type { SkJSIInstance } from "../JsiInstance";
+export interface SkTypeface extends SkJSIInstance<"Typeface"> {
+    /**
+     * Retrieves the glyph ids for each code point in the provided string. This call is passed to
+     * the typeface of this font. Note that glyph IDs are typeface-dependent; different faces
+     * may have different ids for the same code point.
+     * @param str
+     * @param numCodePoints - the number of code points in the string. Defaults to str.length.
+     */
+    getGlyphIDs(str: string, numCodePoints?: number): number[];
+}

package/lib/typescript/src/skia/types/Typeface/TypefaceFactory.d.ts

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

package/lib/typescript/src/skia/types/Typeface/index.d.ts

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

package/lib/typescript/src/skia/types/Vertices/Vertices.d.ts

@@ -0,0 +1,17 @@
+import type { SkRect } from "../Rect";
+import type { SkJSIInstance } from "../JsiInstance";
+export declare enum VertexMode {
+    Triangles = 0,
+    TrianglesStrip = 1,
+    TriangleFan = 2
+}
+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/lib/typescript/src/skia/types/Vertices/index.d.ts

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

package/lib/typescript/src/skia/types/index.d.ts

@@ -0,0 +1,31 @@
+export * from "./Picture";
+export * from "./Data";
+export * from "./SVG";
+export * from "./Surface";
+export * from "./Vertices";
+export * from "./RuntimeEffect";
+export * from "./Shader";
+export * from "./Image";
+export * from "./AnimatedImage";
+export * from "./ColorFilter";
+export * from "./ImageFilter";
+export * from "./Font";
+export * from "./Typeface";
+export * from "./Paint";
+export * from "./Path";
+export * from "./Color";
+export * from "./Canvas";
+export * from "./ContourMeasure";
+export * from "./MaskFilter";
+export * from "./Matrix";
+export * from "./PathEffect";
+export * from "./Point";
+export * from "./Rect";
+export * from "./RRect";
+export * from "./RSXform";
+export * from "./JsiInstance";
+export * from "./Skia";
+export * from "./TextBlob";
+export * from "./Size";
+export * from "./Paragraph";
+export * from "./Matrix4";

package/lib/typescript/src/skia/web/Host.d.ts

@@ -0,0 +1,20 @@
+import type { CanvasKit, EmbindEnumEntity, EmbindEnum } from "canvaskit-wasm";
+import type { SkJSIInstance } from "../types";
+export declare class NotImplementedOnRNWeb extends Error {
+    constructor(msg?: string);
+}
+export declare abstract class Host {
+    readonly CanvasKit: CanvasKit;
+    constructor(CanvasKit: CanvasKit);
+}
+export declare abstract class BaseHostObject<T, N extends string> extends Host implements SkJSIInstance<N> {
+    readonly __typename__: N;
+    ref: T;
+    constructor(CanvasKit: CanvasKit, ref: T, typename: N);
+    abstract dispose(): void;
+}
+export declare abstract class HostObject<T, N extends string> extends BaseHostObject<T, N> {
+    static fromValue<T>(value: SkJSIInstance<string>): T;
+}
+export declare const getEnum: (e: EmbindEnum, v: number) => EmbindEnumEntity;
+export declare const optEnum: (e: EmbindEnum, value: number | undefined) => EmbindEnumEntity | undefined;

package/lib/typescript/src/skia/web/JsiSkAnimatedImage.d.ts

@@ -0,0 +1,11 @@
+import type { AnimatedImage, CanvasKit } from "canvaskit-wasm";
+import type { SkAnimatedImage } from "../types/AnimatedImage";
+import { HostObject } from "./Host";
+import { JsiSkImage } from "./JsiSkImage";
+export declare class JsiSkAnimatedImage extends HostObject<AnimatedImage, "AnimatedImage"> implements SkAnimatedImage {
+    constructor(CanvasKit: CanvasKit, ref: AnimatedImage);
+    decodeNextFrame(): number;
+    currentFrameDuration(): number;
+    getCurrentFrame(): JsiSkImage | null;
+    dispose: () => void;
+}

package/lib/typescript/src/skia/web/JsiSkAnimatedImageFactory.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData } from "../types";
+import type { AnimatedImageFactory } from "../types/AnimatedImage/AnimatedImageFactory";
+import { Host } from "./Host";
+import { JsiSkAnimatedImage } from "./JsiSkAnimatedImage";
+export declare class JsiSkAnimatedImageFactory extends Host implements AnimatedImageFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeAnimatedImageFromEncoded(encoded: SkData): JsiSkAnimatedImage | null;
+}

package/lib/typescript/src/skia/web/JsiSkCanvas.d.ts

@@ -0,0 +1,47 @@
+import type { Canvas, CanvasKit } from "canvaskit-wasm";
+import { type BlendMode, type ClipOp, type FilterMode, type MipmapMode, type PointMode, type SaveLayerFlag, type ImageInfo, type SkCanvas, type SkColor, type SkFont, type SkImage, type SkImageFilter, type SkMatrix, type SkPaint, type SkPath, type SkPicture, type SkPoint, type SkRect, type InputRRect, type SkSVG, type SkTextBlob, type SkVertices, type SkRSXform, type CubicResampler, type FilterOptions } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkCanvas extends HostObject<Canvas, "Canvas"> implements SkCanvas {
+    constructor(CanvasKit: CanvasKit, ref: Canvas);
+    dispose: () => void;
+    drawRect(rect: SkRect, paint: SkPaint): void;
+    drawImage(image: SkImage, x: number, y: number, paint?: SkPaint): void;
+    drawImageRect(img: SkImage, src: SkRect, dest: SkRect, paint: SkPaint, fastSample?: boolean): void;
+    drawImageCubic(img: SkImage, left: number, top: number, B: number, C: number, paint?: SkPaint | null): void;
+    drawImageOptions(img: SkImage, left: number, top: number, fm: FilterMode, mm: MipmapMode, paint?: SkPaint | null): void;
+    drawImageNine(img: SkImage, center: SkRect, dest: SkRect, filter: FilterMode, paint?: SkPaint | null): void;
+    drawImageRectCubic(img: SkImage, src: SkRect, dest: SkRect, B: number, C: number, paint?: SkPaint | null): void;
+    drawImageRectOptions(img: SkImage, src: SkRect, dest: SkRect, fm: FilterMode, mm: MipmapMode, paint?: SkPaint | null): void;
+    drawPaint(paint: SkPaint): void;
+    drawLine(x0: number, y0: number, x1: number, y1: number, paint: SkPaint): void;
+    drawCircle(cx: number, cy: number, radius: number, paint: SkPaint): void;
+    drawVertices(verts: SkVertices, mode: BlendMode, paint: SkPaint): void;
+    drawPatch(cubics: SkPoint[], colors?: SkColor[] | null, texs?: SkPoint[] | null, mode?: BlendMode | null, paint?: SkPaint): void;
+    restoreToCount(saveCount: number): void;
+    drawPoints(mode: PointMode, points: SkPoint[], paint: SkPaint): void;
+    drawArc(oval: SkRect, startAngle: number, sweepAngle: number, useCenter: boolean, paint: SkPaint): void;
+    drawRRect(rrect: InputRRect, paint: SkPaint): void;
+    drawDRRect(outer: InputRRect, inner: InputRRect, paint: SkPaint): void;
+    drawOval(oval: SkRect, paint: SkPaint): void;
+    drawPath(path: SkPath, paint: SkPaint): void;
+    drawText(str: string, x: number, y: number, paint: SkPaint, font: SkFont): void;
+    drawTextBlob(blob: SkTextBlob, x: number, y: number, paint: SkPaint): void;
+    drawGlyphs(glyphs: number[], positions: SkPoint[], x: number, y: number, font: SkFont, paint: SkPaint): void;
+    drawSvg(_svgDom: SkSVG, _width?: number, _height?: number): void;
+    save(): number;
+    saveLayer(paint?: SkPaint, bounds?: SkRect | null, backdrop?: SkImageFilter | null, flags?: SaveLayerFlag): number;
+    restore(): void;
+    rotate(rotationInDegrees: number, rx: number, ry: number): void;
+    scale(sx: number, sy: number): void;
+    skew(sx: number, sy: number): void;
+    translate(dx: number, dy: number): void;
+    drawColor(color: SkColor, blendMode?: BlendMode): void;
+    clear(color: SkColor): void;
+    clipPath(path: SkPath, op: ClipOp, doAntiAlias: boolean): void;
+    clipRect(rect: SkRect, op: ClipOp, doAntiAlias: boolean): void;
+    clipRRect(rrect: InputRRect, op: ClipOp, doAntiAlias: boolean): void;
+    concat(m: SkMatrix | number[]): void;
+    drawPicture(skp: SkPicture): void;
+    drawAtlas(atlas: SkImage, srcs: SkRect[], dsts: SkRSXform[], paint: SkPaint, blendMode?: BlendMode, colors?: SkColor[], _sampling?: CubicResampler | FilterOptions): void;
+    readPixels(srcX: number, srcY: number, imageInfo: ImageInfo): Float32Array | Uint8Array | null;
+}

package/lib/typescript/src/skia/web/JsiSkColor.d.ts

@@ -0,0 +1,2 @@
+import type { SkColor, Color as InputColor } from "../types";
+export declare const Color: (color: InputColor) => SkColor;

package/lib/typescript/src/skia/web/JsiSkColorFilter.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasKit, ColorFilter } from "canvaskit-wasm";
+import type { SkColorFilter } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkColorFilter extends HostObject<ColorFilter, "ColorFilter"> implements SkColorFilter {
+    constructor(CanvasKit: CanvasKit, ref: ColorFilter);
+    dispose: () => void;
+}

package/lib/typescript/src/skia/web/JsiSkColorFilterFactory.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { ColorFilterFactory, SkColorFilter, InputColorMatrix, SkColor, BlendMode } from "../types";
+import { Host } from "./Host";
+import { JsiSkColorFilter } from "./JsiSkColorFilter";
+export declare class JsiSkColorFilterFactory extends Host implements ColorFilterFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeMatrix(cMatrix: InputColorMatrix): JsiSkColorFilter;
+    MakeBlend(color: SkColor, mode: BlendMode): JsiSkColorFilter;
+    MakeCompose(outer: SkColorFilter, inner: SkColorFilter): JsiSkColorFilter;
+    MakeLerp(t: number, dst: SkColorFilter, src: SkColorFilter): JsiSkColorFilter;
+    MakeLinearToSRGBGamma(): JsiSkColorFilter;
+    MakeSRGBToLinearGamma(): JsiSkColorFilter;
+    MakeLumaColorFilter(): SkColorFilter;
+}

package/lib/typescript/src/skia/web/JsiSkContourMeasure.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasKit, ContourMeasure } from "canvaskit-wasm";
+import type { SkContourMeasure } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkPath } from "./JsiSkPath";
+import { JsiSkPoint } from "./JsiSkPoint";
+export declare class JsiSkContourMeasure extends HostObject<ContourMeasure, "ContourMeasure"> implements SkContourMeasure {
+    constructor(CanvasKit: CanvasKit, ref: ContourMeasure);
+    getPosTan(distance: number): [position: JsiSkPoint, tangent: JsiSkPoint];
+    getSegment(startD: number, stopD: number, startWithMoveTo: boolean): JsiSkPath;
+    isClosed(): boolean;
+    length(): number;
+    dispose: () => void;
+}

package/lib/typescript/src/skia/web/JsiSkContourMeasureIter.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit, ContourMeasureIter } from "canvaskit-wasm";
+import type { SkContourMeasureIter } from "../types/ContourMeasure";
+import { HostObject } from "./Host";
+import { JsiSkContourMeasure } from "./JsiSkContourMeasure";
+export declare class JsiSkContourMeasureIter extends HostObject<ContourMeasureIter, "ContourMeasureIter"> implements SkContourMeasureIter {
+    constructor(CanvasKit: CanvasKit, ref: ContourMeasureIter);
+    next(): JsiSkContourMeasure | null;
+    dispose: () => void;
+}

package/lib/typescript/src/skia/web/JsiSkData.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData } from "../types";
+import { HostObject } from "./Host";
+type Data = ArrayBuffer;
+export declare class JsiSkData extends HostObject<Data, "Data"> implements SkData {
+    constructor(CanvasKit: CanvasKit, ref: Data);
+    dispose: () => void;
+}
+export {};