@shopify/react-native-skia 0.1.171 → 0.1.172

package/lib/commonjs/skia/types/PathEffect.d.ts

@@ -0,0 +1,75 @@
+import type { SkJSIInstance } from "./JsiInstance";
+import type { SkPath } from "./Path/Path";
+import type { SkMatrix } from "./Matrix";
+export declare type SkPathEffect = SkJSIInstance<"PathEffect">;
+export declare const isPathEffect: (obj: SkJSIInstance<string> | null) => obj is SkPathEffect;
+export declare enum Path1DEffectStyle {
+    Translate = 0,
+    Rotate = 1,
+    Morph = 2
+}
+export interface PathEffectFactory {
+    /**
+     * Returns a PathEffect that can turn sharp corners into rounded corners.
+     * @param radius - if <=0, returns null
+     */
+    MakeCorner(radius: number): SkPathEffect | null;
+    /**
+     * Returns a PathEffect that add dashes to the path.
+     *
+     * See SkDashPathEffect.h for more details.
+     *
+     * @param intervals - even number of entries with even indicies specifying the length of
+     *                    the "on" intervals, and the odd indices specifying the length of "off".
+     * @param phase - offset length into the intervals array. Defaults to 0.
+     */
+    MakeDash(intervals: number[], phase?: number): SkPathEffect;
+    /**
+     * Returns a PathEffect that breaks path into segments of segLength length, and randomly move
+     * the endpoints away from the original path by a maximum of deviation.
+     * @param segLength - length of the subsegments.
+     * @param dev - limit of the movement of the endpoints.
+     * @param seedAssist - modifies the randomness. See SkDiscretePathEffect.h for more.
+     */
+    MakeDiscrete(segLength: number, dev: number, seedAssist: number): SkPathEffect;
+    /**
+     *
+     * A pathEffect whose effect is to apply first the inner pathEffect and the the
+     * outer pathEffect (i.e. outer(inner(path))).
+     *
+     */
+    MakeCompose(outer: SkPathEffect, inner: SkPathEffect): SkPathEffect;
+    /**
+     *
+     * A pathEffect pathEffect whose effect is to apply two effects,
+     * in sequence (i.e. first(path) + second(path)).
+     *
+     */
+    MakeSum(outer: SkPathEffect, inner: SkPathEffect): SkPathEffect;
+    /**
+     * Returns a PathEffect that will fill the drawing path with a pattern made by applying
+     * the given matrix to a repeating set of infinitely long lines of the given width.
+     * For example, the scale of the provided matrix will determine how far apart the lines
+     * should be drawn its rotation affects the lines' orientation.
+     * @param width - must be >= 0
+     * @param matrix
+     */
+    MakeLine2D(width: number, matrix: SkMatrix): SkPathEffect | null;
+    /**
+     * Returns a PathEffect which implements dashing by replicating the specified path.
+     *   @param path The path to replicate (dash)
+     *   @param advance The space between instances of path
+     *   @param phase distance (mod advance) along path for its initial position
+     *   @param style how to transform path at each point (based on the current
+     *                position and tangent)
+     */
+    MakePath1D(path: SkPath, advance: number, phase: number, style: Path1DEffectStyle): SkPathEffect | null;
+    /**
+     * Returns a PathEffect that will fill the drawing path with a pattern by repeating the
+     * given path according to the provided matrix. For example, the scale of the matrix
+     * determines how far apart the path instances should be drawn.
+     * @param matrix
+     * @param path
+     */
+    MakePath2D(matrix: SkMatrix, path: SkPath): SkPathEffect | null;
+}

package/lib/commonjs/skia/types/Picture/Picture.d.ts

@@ -0,0 +1,27 @@
+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/lib/commonjs/skia/types/Picture/PictureFactory.d.ts

@@ -0,0 +1,8 @@
+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/lib/commonjs/skia/types/Picture/PictureRecorder.d.ts

@@ -0,0 +1,15 @@
+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/lib/commonjs/skia/types/Picture/index.d.ts

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

package/lib/commonjs/skia/types/Point.d.ts

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

package/lib/commonjs/skia/types/RRect.d.ts

@@ -0,0 +1,7 @@
+import type { SkRect } from "./Rect";
+export interface SkRRect {
+    readonly rect: SkRect;
+    readonly rx: number;
+    readonly ry: number;
+}
+export declare const isRRect: (def: SkRect | SkRRect) => def is SkRRect;

package/lib/commonjs/skia/types/RSXform.d.ts

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

package/lib/commonjs/skia/types/Rect.d.ts

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

package/lib/commonjs/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/commonjs/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/commonjs/skia/types/RuntimeEffect/index.d.ts

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

package/lib/commonjs/skia/types/SVG/SVG.d.ts

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

package/lib/commonjs/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/commonjs/skia/types/SVG/index.d.ts

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

package/lib/commonjs/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 declare type SkShader = SkJSIInstance<"Shader">;
+export declare type Uniform = number | Vector | Float32Array | Uniform[];
+export interface Uniforms {
+    [name: string]: Uniform;
+}
+export declare const processUniforms: (source: SkRuntimeEffect, uniforms: Uniforms, builder?: SkRuntimeShaderBuilder) => number[];

package/lib/commonjs/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/commonjs/skia/types/Shader/index.d.ts

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

package/lib/commonjs/skia/types/Size.d.ts

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

package/lib/commonjs/skia/types/Skia.d.ts

@@ -0,0 +1,66 @@
+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, 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";
+/**
+ * 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;
+    RuntimeShaderBuilder: (rt: SkRuntimeEffect) => SkRuntimeShaderBuilder;
+    RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
+    RSXform: (scos: number, ssin: number, tx: number, ty: 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;
+    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;
+    TextBlob: TextBlobFactory;
+    Surface: SurfaceFactory;
+}

package/lib/commonjs/skia/types/Surface/Surface.d.ts

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

package/lib/commonjs/skia/types/Surface/SurfaceFactory.d.ts

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

package/lib/commonjs/skia/types/Surface/index.d.ts

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

package/lib/commonjs/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 declare 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/commonjs/skia/types/Typeface/Typeface.d.ts

@@ -0,0 +1,2 @@
+import type { SkJSIInstance } from "../JsiInstance";
+export declare type SkTypeface = SkJSIInstance<"Typeface">;

package/lib/commonjs/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/commonjs/skia/types/Typeface/index.d.ts

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

package/lib/commonjs/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/commonjs/skia/types/Vertices/index.d.ts

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

package/lib/commonjs/skia/types/index.d.ts

@@ -0,0 +1,28 @@
+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 "./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";

package/lib/commonjs/skia/web/Host.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasKit, EmbindEnumEntity } 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);
+}
+export declare abstract class HostObject<T, N extends string> extends BaseHostObject<T, N> {
+    static fromValue<T>(value: SkJSIInstance<string>): T;
+}
+export declare const ckEnum: (value: number) => EmbindEnumEntity;
+export declare const optEnum: (value: number | undefined) => EmbindEnumEntity | undefined;