react-native-skia 0.0.1 → 3.0.0

package/lib/typescript/src/skia/types/Path/PathBuilder.d.ts

@@ -0,0 +1,201 @@
+import type { SkRect } from "../Rect";
+import type { SkPoint } from "../Point";
+import type { InputRRect } from "../RRect";
+import type { InputMatrix, SkMatrix } from "../Matrix";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { FillType, SkPath } from "./Path";
+/**
+ * SkPathBuilder is a mutable builder for constructing SkPath objects.
+ * Once construction is complete, call build() or detach() to get the immutable SkPath.
+ */
+export interface SkPathBuilder extends SkJSIInstance<"PathBuilder"> {
+    /**
+     * Adds beginning of contour at point (x, y).
+     * @param x - x-axis value of contour start
+     * @param y - y-axis value of contour start
+     * @returns reference to this PathBuilder for chaining
+     */
+    moveTo(x: number, y: number): SkPathBuilder;
+    /**
+     * Adds beginning of contour relative to the last point.
+     * @param x - offset from last point on x-axis
+     * @param y - offset from last point on y-axis
+     * @returns reference to this PathBuilder for chaining
+     */
+    rMoveTo(x: number, y: number): SkPathBuilder;
+    /**
+     * Adds line from last point to (x, y).
+     * @param x - end of line on x-axis
+     * @param y - end of line on y-axis
+     * @returns reference to this PathBuilder for chaining
+     */
+    lineTo(x: number, y: number): SkPathBuilder;
+    /**
+     * Adds line from last point, relative to last point.
+     * @param x - offset from last point on x-axis
+     * @param y - offset from last point on y-axis
+     * @returns reference to this PathBuilder for chaining
+     */
+    rLineTo(x: number, y: number): SkPathBuilder;
+    /**
+     * Adds quad from last point towards (x1, y1), to (x2, y2).
+     */
+    quadTo(x1: number, y1: number, x2: number, y2: number): SkPathBuilder;
+    /**
+     * Relative version of quadTo.
+     */
+    rQuadTo(x1: number, y1: number, x2: number, y2: number): SkPathBuilder;
+    /**
+     * Adds conic from last point towards (x1, y1), to (x2, y2), weighted by w.
+     */
+    conicTo(x1: number, y1: number, x2: number, y2: number, w: number): SkPathBuilder;
+    /**
+     * Relative version of conicTo.
+     */
+    rConicTo(x1: number, y1: number, x2: number, y2: number, w: number): SkPathBuilder;
+    /**
+     * Adds cubic from last point towards (x1, y1), then towards (x2, y2), ending at (x3, y3).
+     */
+    cubicTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): SkPathBuilder;
+    /**
+     * Relative version of cubicTo.
+     */
+    rCubicTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): SkPathBuilder;
+    /**
+     * Appends CLOSE_VERB to the builder, connecting first and last points.
+     */
+    close(): SkPathBuilder;
+    /**
+     * Appends arc to the builder. Arc is part of ellipse bounded by oval.
+     * @param oval - bounds of ellipse containing arc
+     * @param startAngleInDegrees - starting angle of arc in degrees
+     * @param sweepAngleInDegrees - sweep, in degrees. Positive is clockwise
+     * @param forceMoveTo - true to start a new contour with arc
+     */
+    arcToOval(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number, forceMoveTo: boolean): SkPathBuilder;
+    /**
+     * Appends arc to the builder with SVG-style parameters.
+     * @param rx - x-radius of ellipse
+     * @param ry - y-radius of ellipse
+     * @param xAxisRotateInDegrees - rotation of ellipse
+     * @param useSmallArc - if true, use smaller of two arcs
+     * @param isCCW - if true, arc sweeps counter-clockwise
+     * @param x - end point x
+     * @param y - end point y
+     */
+    arcToRotated(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): SkPathBuilder;
+    /**
+     * Relative version of arcToRotated.
+     */
+    rArcTo(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): SkPathBuilder;
+    /**
+     * Appends arc to the builder, tangent to two lines.
+     * @param x1 - x of first tangent point
+     * @param y1 - y of first tangent point
+     * @param x2 - x of second tangent point
+     * @param y2 - y of second tangent point
+     * @param radius - arc radius
+     */
+    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): SkPathBuilder;
+    /**
+     * Adds Rect to the builder.
+     * @param rect - rectangle to add
+     * @param isCCW - if true, draws counter-clockwise
+     */
+    addRect(rect: SkRect, isCCW?: boolean): SkPathBuilder;
+    /**
+     * Adds oval to the builder.
+     * @param oval - bounds of ellipse
+     * @param isCCW - if true, draws counter-clockwise
+     * @param startIndex - index of initial point
+     */
+    addOval(oval: SkRect, isCCW?: boolean, startIndex?: number): SkPathBuilder;
+    /**
+     * Appends arc to the builder as a new contour.
+     * @param oval - bounds of ellipse
+     * @param startAngleInDegrees - starting angle
+     * @param sweepAngleInDegrees - sweep angle
+     */
+    addArc(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number): SkPathBuilder;
+    /**
+     * Adds rounded rectangle to the builder.
+     * @param rrect - rounded rectangle to add
+     * @param isCCW - if true, draws counter-clockwise
+     */
+    addRRect(rrect: InputRRect, isCCW?: boolean): SkPathBuilder;
+    /**
+     * Adds circle to the builder.
+     * @param x - center x
+     * @param y - center y
+     * @param r - radius
+     * @param isCCW - if true, draws counter-clockwise
+     */
+    addCircle(x: number, y: number, r: number, isCCW?: boolean): SkPathBuilder;
+    /**
+     * Adds polygon to the builder from array of points.
+     * @param points - array of points
+     * @param close - if true, close the polygon
+     */
+    addPoly(points: SkPoint[], close: boolean): SkPathBuilder;
+    /**
+     * Adds the path to the builder.
+     * @param src - path to add
+     * @param matrix - optional transform matrix
+     * @param extend - if true, extend rather than append
+     */
+    addPath(src: SkPath, matrix?: SkMatrix, extend?: boolean): SkPathBuilder;
+    /**
+     * Sets the fill type for the path.
+     * @param fill - fill type to set
+     */
+    setFillType(fill: FillType): SkPathBuilder;
+    /**
+     * Sets whether the path is volatile (temporary/animating).
+     * @param isVolatile - true if path will be altered frequently
+     */
+    setIsVolatile(isVolatile: boolean): SkPathBuilder;
+    /**
+     * Resets the builder to empty state.
+     */
+    reset(): SkPathBuilder;
+    /**
+     * Translates all points in the builder.
+     * @param dx - translation in x
+     * @param dy - translation in y
+     */
+    offset(dx: number, dy: number): SkPathBuilder;
+    /**
+     * Transforms all points in the builder by the matrix.
+     * @param m - transformation matrix
+     */
+    transform(m: InputMatrix): SkPathBuilder;
+    /**
+     * Returns the bounds of the path being built.
+     */
+    computeBounds(): SkRect;
+    /**
+     * Returns true if the builder has no verbs.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the last point added to the builder.
+     */
+    getLastPt(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Returns the number of points in the builder.
+     */
+    countPoints(): number;
+    /**
+     * Returns a new SkPath with the current builder state.
+     * The builder is NOT reset and can continue to be used.
+     */
+    build(): SkPath;
+    /**
+     * Returns a new SkPath with the current builder state and resets the builder.
+     * More efficient than build() when you're done with this builder.
+     */
+    detach(): SkPath;
+}

package/lib/typescript/src/skia/types/Path/PathBuilderFactory.d.ts

@@ -0,0 +1,13 @@
+import type { SkPath } from "./Path";
+import type { SkPathBuilder } from "./PathBuilder";
+export interface PathBuilderFactory {
+    /**
+     * Creates a new empty PathBuilder.
+     */
+    Make(): SkPathBuilder;
+    /**
+     * Creates a new PathBuilder initialized with the given path's contents.
+     * @param path - path to copy into the builder
+     */
+    MakeFromPath(path: SkPath): SkPathBuilder;
+}

package/lib/typescript/src/skia/types/Path/PathFactory.d.ts

@@ -0,0 +1,115 @@
+import type { SkFont } from "../Font";
+import type { SkRect } from "../Rect";
+import type { SkPoint } from "../Point";
+import type { InputRRect } from "../RRect";
+import type { SkPath, PathOp, PathCommand, StrokeOpts } from "./Path";
+export interface PathFactory {
+    Make(): SkPath;
+    /**
+     * Creates a new path from the provided SVG string. If this fails, null will be
+     * returned instead.
+     * @param str
+     */
+    MakeFromSVGString(str: string): SkPath | null;
+    /**
+     * Creates a new path by combining the given paths according to op. If this fails, null will
+     * be returned instead.
+     * @param one
+     * @param two
+     * @param op
+     */
+    MakeFromOp(one: SkPath, two: SkPath, op: PathOp): SkPath | null;
+    /**
+     * Creates a new path from the given list of path commands. If this fails, null will be
+     * returned instead.
+     * @param cmds
+     */
+    MakeFromCmds(cmds: PathCommand[]): SkPath | null;
+    /**
+     * Converts the text to a path with the given font at location x / y.
+     */
+    MakeFromText(text: string, x: number, y: number, font: SkFont): SkPath | null;
+    /**
+     * Creates a path containing a rectangle.
+     * @param rect - the rectangle
+     * @param isCCW - if true, draws counter-clockwise
+     */
+    Rect(rect: SkRect, isCCW?: boolean): SkPath;
+    /**
+     * Creates a path containing an oval (ellipse).
+     * @param rect - bounds of the oval
+     * @param isCCW - if true, draws counter-clockwise
+     * @param startIndex - index of initial point
+     */
+    Oval(rect: SkRect, isCCW?: boolean, startIndex?: number): SkPath;
+    /**
+     * Creates a path containing a circle.
+     * @param x - center x
+     * @param y - center y
+     * @param r - radius
+     */
+    Circle(x: number, y: number, r: number): SkPath;
+    /**
+     * Creates a path containing a rounded rectangle.
+     * @param rrect - the rounded rectangle
+     * @param isCCW - if true, draws counter-clockwise
+     */
+    RRect(rrect: InputRRect, isCCW?: boolean): SkPath;
+    /**
+     * Creates a path containing a line segment.
+     * @param p1 - start point
+     * @param p2 - end point
+     */
+    Line(p1: SkPoint, p2: SkPoint): SkPath;
+    /**
+     * Creates a path containing a polygon from the given points.
+     * @param points - array of points
+     * @param close - if true, close the polygon
+     */
+    Polygon(points: SkPoint[], close: boolean): SkPath;
+    /**
+     * Creates a new stroked path from the input path.
+     * @param path - source path to stroke
+     * @param opts - stroke options (width, cap, join, miter_limit, precision)
+     * @returns stroked path or null if operation fails
+     */
+    Stroke(path: SkPath, opts?: StrokeOpts): SkPath | null;
+    /**
+     * Creates a trimmed path from the input path.
+     * @param path - source path
+     * @param start - start of trim (0-1)
+     * @param end - end of trim (0-1)
+     * @param isComplement - if true, returns the complement
+     * @returns trimmed path or null if operation fails
+     */
+    Trim(path: SkPath, start: number, end: number, isComplement: boolean): SkPath | null;
+    /**
+     * Simplifies the path to non-overlapping contours.
+     * @param path - source path
+     * @returns simplified path or null if operation fails
+     */
+    Simplify(path: SkPath): SkPath | null;
+    /**
+     * Creates a dashed version of the path.
+     * @param path - source path
+     * @param on - length of dash
+     * @param off - length of gap
+     * @param phase - offset into dash pattern
+     * @returns dashed path or null if operation fails
+     */
+    Dash(path: SkPath, on: number, off: number, phase: number): SkPath | null;
+    /**
+     * Creates a path with Winding fill type.
+     * @param path - source path
+     * @returns path with winding fill or null if operation fails
+     */
+    AsWinding(path: SkPath): SkPath | null;
+    /**
+     * Interpolates between two paths.
+     * @param start - starting path
+     * @param end - ending path
+     * @param weight - interpolation weight (0 = start, 1 = end)
+     * @returns interpolated path or null if paths are not interpolatable
+     */
+    Interpolate(start: SkPath, end: SkPath, weight: number): SkPath | null;
+}

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

@@ -0,0 +1,4 @@
+export * from "./Path";
+export * from "./PathBuilder";
+export * from "./PathBuilderFactory";
+export * from "./PathFactory";

package/lib/typescript/src/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 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/typescript/src/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/typescript/src/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 | null): SkPicture | null;
+}

package/lib/typescript/src/skia/types/Picture/PictureRecorder.d.ts

@@ -0,0 +1,16 @@
+import type { SkCanvas } from "../Canvas";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkRect } from "../Rect";
+import type { SkPicture } from "./Picture";
+export interface SkPictureRecorder extends SkJSIInstance<"PictureRecorder"> {
+    /**
+     * 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/typescript/src/skia/types/Picture/index.d.ts

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

package/lib/typescript/src/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 type Vector = SkPoint;

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

@@ -0,0 +1,16 @@
+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;
+export declare const isRRect: (def: unknown) => def is SkRRect;

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

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

@@ -0,0 +1,64 @@
+import type { SharedValue } from "react-native-reanimated";
+import type { TextProps, AtlasProps, BlurMaskFilterProps, BoxProps, BoxShadowProps, CircleProps, CTMProps, DiffRectProps, GlyphsProps, ImageProps, ImageSVGProps, LineProps, NodeType, OvalProps, PaintProps, ParagraphProps, PatchProps, PathProps, PictureProps, PointsProps, RectProps, RoundedRectProps, TextBlobProps, TextPathProps, VerticesProps, SkottieProps, DrawingNodeProps } from "../../dom/types";
+import type { AnimatedProps } from "../../renderer/processors/Animations/Animations";
+import type { SkPicture } from "./Picture";
+export interface BaseRecorder {
+    saveGroup(props?: AnimatedProps<Pick<DrawingNodeProps, "zIndex">>): void;
+    restoreGroup(): void;
+    savePaint(props: AnimatedProps<PaintProps>, standalone: boolean): void;
+    restorePaint(): void;
+    restorePaintDeclaration(): void;
+    materializePaint(): void;
+    pushPathEffect(pathEffectType: NodeType, props: AnimatedProps<unknown>): void;
+    pushImageFilter(imageFilterType: NodeType, props: AnimatedProps<unknown>): void;
+    pushColorFilter(colorFilterType: NodeType, props: AnimatedProps<unknown>): void;
+    pushShader(shaderType: NodeType, props: AnimatedProps<unknown>, children: number): void;
+    pushBlurMaskFilter(props: AnimatedProps<BlurMaskFilterProps>): void;
+    composePathEffect(): void;
+    composeColorFilter(): void;
+    composeImageFilter(): void;
+    saveCTM(props: AnimatedProps<CTMProps>): void;
+    restoreCTM(): void;
+    drawPaint(): void;
+    saveLayer(): void;
+    saveBackdropFilter(): void;
+    drawBox(boxProps: AnimatedProps<BoxProps>, shadows: {
+        props: BoxShadowProps;
+        animatedProps?: Record<string, SharedValue<unknown>>;
+    }[]): void;
+    drawImage(props: AnimatedProps<ImageProps>): void;
+    drawCircle(props: AnimatedProps<CircleProps>): void;
+    drawPoints(props: AnimatedProps<PointsProps>): void;
+    drawPath(props: AnimatedProps<PathProps>): void;
+    drawRect(props: AnimatedProps<RectProps>): void;
+    drawRRect(props: AnimatedProps<RoundedRectProps>): void;
+    drawOval(props: AnimatedProps<OvalProps>): void;
+    drawLine(props: AnimatedProps<LineProps>): void;
+    drawPatch(props: AnimatedProps<PatchProps>): void;
+    drawVertices(props: AnimatedProps<VerticesProps>): void;
+    drawDiffRect(props: AnimatedProps<DiffRectProps>): void;
+    drawText(props: AnimatedProps<TextProps>): void;
+    drawTextPath(props: AnimatedProps<TextPathProps>): void;
+    drawTextBlob(props: AnimatedProps<TextBlobProps>): void;
+    drawGlyphs(props: AnimatedProps<GlyphsProps>): void;
+    drawPicture(props: AnimatedProps<PictureProps>): void;
+    drawImageSVG(props: AnimatedProps<ImageSVGProps>): void;
+    drawParagraph(props: AnimatedProps<ParagraphProps>): void;
+    drawSkottie(props: AnimatedProps<SkottieProps>): void;
+    drawAtlas(props: AnimatedProps<AtlasProps>): void;
+}
+export interface JsiRecorder extends BaseRecorder {
+    play(picture: SkPicture): void;
+    applyUpdates(variables: SharedValue<unknown>[]): void;
+    reset(): void;
+    /**
+     * Unique id of the native recording, used to tag the updates sent to the
+     * view that owns it.
+     */
+    getId(): number;
+    /**
+     * Releases the wrapper's reference to the native recorder. A recording
+     * that a view owns stays alive until the view replaces it or is torn down.
+     */
+    dispose(): void;
+}

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,7 @@
+import type { SkData } from "../Data";
+import type { SkFontMgr } from "../Font/FontMgr";
+import type { SkSVG } from "./SVG";
+export interface SVGFactory {
+    MakeFromData(data: SkData, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
+    MakeFromString(str: string, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
+}