@shopify/react-native-skia 0.1.170 → 0.1.172

package/lib/commonjs/dom/nodes/DrawingNode.d.ts

@@ -0,0 +1,14 @@
+import type { DrawingContext, DrawingNodeProps, Node, NodeType, RenderNode } from "../types";
+import type { NodeContext } from "./Node";
+import { JsiRenderNode } from "./RenderNode";
+export declare abstract class JsiDrawingNode<P extends DrawingNodeProps, C> extends JsiRenderNode<P> implements RenderNode<P> {
+    protected derived?: C;
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    setProps(props: P): void;
+    setProp<K extends keyof P>(name: K, value: P[K]): boolean;
+    addChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+    renderNode(ctx: DrawingContext): void;
+    protected abstract draw(ctx: DrawingContext): void;
+    protected abstract deriveProps(): C;
+}

package/lib/commonjs/dom/nodes/GroupNode.d.ts

@@ -0,0 +1,7 @@
+import type { DrawingContext, GroupProps } from "../types";
+import { JsiRenderNode } from "./RenderNode";
+import type { NodeContext } from "./Node";
+export declare class GroupNode extends JsiRenderNode<GroupProps> {
+    constructor(ctx: NodeContext, props: GroupProps);
+    renderNode(ctx: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/JsiSkDOM.d.ts

@@ -0,0 +1,65 @@
+import type { PathProps, SkDOM, GroupProps, ImageProps, BlurImageFilterProps, MatrixColorFilterProps, CircleProps, BlurMaskFilterProps, LinearGradientProps, PaintProps, ShaderProps, ImageShaderProps, CustomDrawingNodeProps, LineProps, OvalProps, PatchProps, PointsProps, RectProps, RoundedRectProps, VerticesProps, TextProps, DiffRectProps, OffsetImageFilterProps, BlendColorFilterProps, TextPathProps, TextBlobProps, GlyphsProps, TwoPointConicalGradientProps, TurbulenceProps, SweepGradientProps, RadialGradientProps, FractalNoiseProps, ColorProps, PictureProps, ImageSVGProps, LerpColorFilterProps, DrawingNodeProps, BoxProps, BoxShadowProps, ChildrenProps } from "../types";
+import type { BlendImageFilterProps, BlendProps, DisplacementMapImageFilterProps, DropShadowImageFilterProps, MorphologyImageFilterProps, RuntimeShaderImageFilterProps } from "../types/ImageFilters";
+import type { CornerPathEffectProps, DashPathEffectProps, DiscretePathEffectProps, Line2DPathEffectProps, Path1DPathEffectProps, Path2DPathEffectProps } from "../types/PathEffects";
+import { CornerPathEffectNode, Path1DPathEffectNode, Path2DPathEffectNode, Line2DPathEffectNode, BlendNode } from "./paint";
+import type { NodeContext } from "./Node";
+export declare class JsiSkDOM implements SkDOM {
+    private ctx;
+    constructor(ctx: NodeContext);
+    Layer(props?: ChildrenProps): import("../types").RenderNode<ChildrenProps>;
+    Group(props?: GroupProps): import("../types").RenderNode<GroupProps>;
+    Paint(props: PaintProps): import("../types").DeclarationNode<PaintProps, import("../..").SkPaint, never>;
+    Fill(props?: DrawingNodeProps): import("../types").RenderNode<PaintProps>;
+    Image(props: ImageProps): import("../types").RenderNode<ImageProps>;
+    Circle(props: CircleProps): import("../types").RenderNode<CircleProps>;
+    Path(props: PathProps): import("../types").RenderNode<PathProps>;
+    CustomDrawing(props: CustomDrawingNodeProps): import("../types").RenderNode<CustomDrawingNodeProps>;
+    Line(props: LineProps): import("../types").RenderNode<LineProps>;
+    Oval(props: OvalProps): import("../types").RenderNode<OvalProps>;
+    Patch(props: PatchProps): import("../types").RenderNode<PatchProps>;
+    Points(props: PointsProps): import("../types").RenderNode<PointsProps>;
+    Rect(props: RectProps): import("./DrawingNode").JsiDrawingNode<RectProps, import("../..").SkRect>;
+    RRect(props: RoundedRectProps): import("./DrawingNode").JsiDrawingNode<RoundedRectProps, import("../..").SkRRect>;
+    Vertices(props: VerticesProps): import("../types").RenderNode<VerticesProps>;
+    Text(props: TextProps): import("../types").RenderNode<TextProps>;
+    TextPath(props: TextPathProps): import("../types").RenderNode<TextPathProps>;
+    TextBlob(props: TextBlobProps): import("../types").RenderNode<TextBlobProps>;
+    Glyphs(props: GlyphsProps): import("../types").RenderNode<GlyphsProps>;
+    DiffRect(props: DiffRectProps): import("../types").RenderNode<DiffRectProps>;
+    Picture(props: PictureProps): import("../types").RenderNode<PictureProps>;
+    ImageSVG(props: ImageSVGProps): import("../types").RenderNode<ImageSVGProps>;
+    BlurMaskFilter(props: BlurMaskFilterProps): import("../types").DeclarationNode<BlurMaskFilterProps, import("../..").SkMaskFilter, never>;
+    BlendImageFilter(props: BlendImageFilterProps): import("../types").DeclarationNode<BlendImageFilterProps, import("../..").SkImageFilter, never>;
+    DropShadowImageFilter(props: DropShadowImageFilterProps): import("../types").DeclarationNode<DropShadowImageFilterProps, import("../..").SkImageFilter, never>;
+    DisplacementMapImageFilter(props: DisplacementMapImageFilterProps): import("../types").DeclarationNode<DisplacementMapImageFilterProps, import("../..").SkImageFilter, never>;
+    BlurImageFilter(props: BlurImageFilterProps): import("../types").DeclarationNode<BlurImageFilterProps, import("../..").SkImageFilter, never>;
+    OffsetImageFilter(props: OffsetImageFilterProps): import("../types").DeclarationNode<OffsetImageFilterProps, import("../..").SkImageFilter, never>;
+    MorphologyImageFilter(props: MorphologyImageFilterProps): import("../types").DeclarationNode<MorphologyImageFilterProps, import("../..").SkImageFilter, never>;
+    RuntimeShaderImageFilter(props: RuntimeShaderImageFilterProps): import("../types").DeclarationNode<RuntimeShaderImageFilterProps, import("../..").SkImageFilter, never>;
+    MatrixColorFilter(props: MatrixColorFilterProps): import("../types").DeclarationNode<MatrixColorFilterProps, import("../..").SkColorFilter, never>;
+    BlendColorFilter(props: BlendColorFilterProps): import("../types").DeclarationNode<BlendColorFilterProps, import("../..").SkColorFilter, never>;
+    LumaColorFilter(): import("../types").DeclarationNode<null, import("../..").SkColorFilter, never>;
+    LinearToSRGBGammaColorFilter(): import("../types").DeclarationNode<null, import("../..").SkColorFilter, never>;
+    SRGBToLinearGammaColorFilter(): import("../types").DeclarationNode<null, import("../..").SkColorFilter, never>;
+    LerpColorFilter(props: LerpColorFilterProps): import("../types").DeclarationNode<LerpColorFilterProps, import("../..").SkColorFilter, never>;
+    Shader(props: ShaderProps): import("../types").DeclarationNode<ShaderProps, import("../..").SkShader, never>;
+    ImageShader(props: ImageShaderProps): import("../types").DeclarationNode<ImageShaderProps, import("../..").SkShader, never>;
+    ColorShader(props: ColorProps): import("../types").DeclarationNode<ColorProps, import("../..").SkShader, never>;
+    SweepGradient(props: SweepGradientProps): import("../types").DeclarationNode<SweepGradientProps, import("../..").SkShader, never>;
+    Turbulence(props: TurbulenceProps): import("../types").DeclarationNode<TurbulenceProps, import("../..").SkShader, never>;
+    FractalNoise(props: FractalNoiseProps): import("../types").DeclarationNode<FractalNoiseProps, import("../..").SkShader, never>;
+    LinearGradient(props: LinearGradientProps): import("../types").DeclarationNode<LinearGradientProps, import("../..").SkShader, never>;
+    RadialGradient(props: RadialGradientProps): import("../types").DeclarationNode<RadialGradientProps, import("../..").SkShader, never>;
+    TwoPointConicalGradient(props: TwoPointConicalGradientProps): import("../types").DeclarationNode<TwoPointConicalGradientProps, import("../..").SkShader, never>;
+    CornerPathEffect(props: CornerPathEffectProps): CornerPathEffectNode | import("../types").DeclarationNode<CornerPathEffectProps, import("../..").SkPathEffect, never>;
+    DiscretePathEffect(props: DiscretePathEffectProps): import("../types").DeclarationNode<DiscretePathEffectProps, import("../..").SkPathEffect, never>;
+    DashPathEffect(props: DashPathEffectProps): import("../types").DeclarationNode<DashPathEffectProps, import("../..").SkPathEffect, never>;
+    Path1DPathEffect(props: Path1DPathEffectProps): Path1DPathEffectNode | import("../types").DeclarationNode<Path1DPathEffectProps, import("../..").SkPathEffect, never>;
+    Path2DPathEffect(props: Path2DPathEffectProps): Path2DPathEffectNode | import("../types").DeclarationNode<Path2DPathEffectProps, import("../..").SkPathEffect, never>;
+    SumPathEffect(): import("../types").DeclarationNode<null, import("../..").SkPathEffect, never>;
+    Line2DPathEffect(props: Line2DPathEffectProps): Line2DPathEffectNode | import("../types").DeclarationNode<Line2DPathEffectProps, import("../..").SkPathEffect, never>;
+    Blend(props: BlendProps): BlendNode | import("../types").DeclarationNode<BlendProps, import("../..").SkImageFilter, never>;
+    BackdropFilter(props: ChildrenProps): import("../types").RenderNode<ChildrenProps>;
+    Box(props: BoxProps): import("../types").RenderNode<BoxProps>;
+    BoxShadow(props: BoxShadowProps): import("../types").DeclarationNode<BoxShadowProps, BoxShadowProps, never>;
+}

package/lib/commonjs/dom/nodes/LayerNode.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext } from "../types";
+import type { ChildrenProps } from "../types/Common";
+import { JsiRenderNode } from "./RenderNode";
+import type { NodeContext } from "./Node";
+export declare class LayerNode extends JsiRenderNode<ChildrenProps> {
+    constructor(ctx: NodeContext, props: ChildrenProps);
+    renderNode(ctx: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/Node.d.ts

@@ -0,0 +1,43 @@
+import type { SkColorFilter, Skia, SkImageFilter, SkMaskFilter, SkShader, SkPathEffect, SkPaint } from "../../skia/types";
+import type { Node, DeclarationNode, NodeType } from "../types";
+import { DeclarationType } from "../types";
+import type { DependencyManager } from "../../renderer/DependencyManager";
+export interface NodeContext {
+    Skia: Skia;
+    depMgr: DependencyManager;
+}
+export declare abstract class JsiNode<P> implements Node<P> {
+    type: NodeType;
+    protected props: P;
+    protected _children: JsiNode<unknown>[];
+    protected Skia: Skia;
+    protected depMgr: DependencyManager;
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    setProps(props: P): void;
+    setProp<K extends keyof P>(name: K, v: P[K]): boolean;
+    getProps(): P;
+    children(): JsiNode<unknown>[];
+    addChild(child: Node<unknown>): void;
+    dispose(): void;
+    removeChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+}
+export declare type Invalidate = () => void;
+export declare abstract class JsiDeclarationNode<P, T, Nullable extends null | never = never> extends JsiNode<P> implements DeclarationNode<P, T, Nullable> {
+    declarationType: DeclarationType;
+    private invalidate;
+    constructor(ctx: NodeContext, declarationType: DeclarationType, type: NodeType, props: P);
+    abstract materialize(): T | Nullable;
+    addChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+    dispose(): void;
+    setInvalidate(invalidate: Invalidate): void;
+    setProps(props: P): void;
+    setProp<K extends keyof P>(name: K, v: P[K]): boolean;
+    isPaint(): this is DeclarationNode<unknown, SkPaint>;
+    isImageFilter(): this is DeclarationNode<unknown, SkImageFilter>;
+    isColorFilter(): this is DeclarationNode<unknown, SkColorFilter>;
+    isShader(): this is DeclarationNode<unknown, SkShader>;
+    isMaskFilter(): this is DeclarationNode<unknown, SkMaskFilter>;
+    isPathEffect(): this is DeclarationNode<unknown, SkPathEffect>;
+}

package/lib/commonjs/dom/nodes/PaintContext.d.ts

@@ -0,0 +1,18 @@
+import type { BlendMode, PaintStyle, SkColorFilter, SkImageFilter, SkMaskFilter, SkPathEffect, SkShader, StrokeCap, StrokeJoin } from "../../skia/types";
+import type { SkColor } from "../../skia/types/Color";
+export interface PaintContext {
+    color?: SkColor;
+    strokeWidth?: number;
+    blendMode?: BlendMode;
+    style?: PaintStyle;
+    strokeJoin?: StrokeJoin;
+    strokeCap?: StrokeCap;
+    strokeMiter?: number;
+    opacity?: number;
+    antiAlias?: boolean;
+    shader?: SkShader;
+    colorFilter?: SkColorFilter;
+    imageFilter?: SkImageFilter;
+    maskFilter?: SkMaskFilter;
+    pathEffect?: SkPathEffect;
+}

package/lib/commonjs/dom/nodes/PaintNode.d.ts

@@ -0,0 +1,8 @@
+import type { SkPaint } from "../../skia/types";
+import type { DeclarationNode, PaintProps } from "../types";
+import type { NodeContext } from "./Node";
+import { JsiDeclarationNode } from "./Node";
+export declare class PaintNode extends JsiDeclarationNode<PaintProps, SkPaint> implements DeclarationNode<PaintProps, SkPaint> {
+    constructor(ctx: NodeContext, props?: PaintProps);
+    materialize(): SkPaint;
+}

package/lib/commonjs/dom/nodes/RenderNode.d.ts

@@ -0,0 +1,27 @@
+import type { SkMatrix, SkRect, SkRRect, SkPath, SkPaint } from "../../skia/types";
+import type { RenderNode, GroupProps, DrawingContext, NodeType, Node } from "../types";
+import type { NodeContext } from "./Node";
+import { JsiNode } from "./Node";
+interface PaintCache {
+    parent: SkPaint;
+    child: SkPaint;
+}
+export declare abstract class JsiRenderNode<P extends GroupProps> extends JsiNode<P> implements RenderNode<P> {
+    paintCache: PaintCache | null;
+    matrix: SkMatrix;
+    clipRect?: SkRect;
+    clipRRect?: SkRRect;
+    clipPath?: SkPath;
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    setProps(props: P): void;
+    setProp<K extends keyof P>(key: K, value: P[K]): boolean;
+    protected onPropChange(): void;
+    addChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+    private computeClip;
+    private computeMatrix;
+    private getPaintCtx;
+    render(parentCtx: DrawingContext): void;
+    abstract renderNode(ctx: DrawingContext): void;
+}
+export {};

package/lib/commonjs/dom/nodes/datatypes/Circle.d.ts

@@ -0,0 +1,7 @@
+import type { Skia } from "../../../skia/types";
+import type { CircleDef, ScalarCircleDef } from "../../types";
+export declare const isCircleScalarDef: (def: CircleDef) => def is ScalarCircleDef;
+export declare const processCircle: (Skia: Skia, def: CircleDef) => {
+    c: import("../../../skia/types").SkPoint;
+    r: number;
+};

package/lib/commonjs/dom/nodes/datatypes/Enum.d.ts

@@ -0,0 +1 @@
+export declare const enumKey: <K extends string>(k: K) => Capitalize<K>;

package/lib/commonjs/dom/nodes/datatypes/Fitting.d.ts

@@ -0,0 +1,33 @@
+import type { SkRect } from "../../../skia/types";
+import type { Fit } from "../../types";
+export interface Size {
+    width: number;
+    height: number;
+}
+export declare const size: (width?: number, height?: number) => {
+    width: number;
+    height: number;
+};
+export declare const rect2rect: (src: SkRect, dst: SkRect) => readonly [{
+    readonly translateX: number;
+}, {
+    readonly translateY: number;
+}, {
+    readonly scaleX: number;
+}, {
+    readonly scaleY: number;
+}];
+export declare const fitRects: (fit: Fit, rect: SkRect, { x, y, width, height }: SkRect) => {
+    src: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    dst: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};

package/lib/commonjs/dom/nodes/datatypes/Gradient.d.ts

@@ -0,0 +1,92 @@
+import type { Skia, SkRect, Transforms2d, Vector } from "../../../skia/types";
+import { TileMode } from "../../../skia/types";
+import type { GradientProps, ImageShaderProps } from "../../types";
+export declare const transformOrigin: (origin: Vector, transform: Transforms2d) => (Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "translateX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "translateY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scale"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scaleX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scaleY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "skewX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "skewY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "rotate">)[];
+export declare const processGradientProps: (Skia: Skia, { colors, positions, mode, flags, ...transform }: GradientProps) => {
+    colors: Float32Array[];
+    positions: number[] | null;
+    mode: TileMode;
+    flags: number | undefined;
+    localMatrix: import("../../../skia/types").SkMatrix;
+};
+export declare const getRect: (Skia: Skia, props: Omit<ImageShaderProps, "tx" | "ty" | "fm" | "mm" | "fit" | "image">) => SkRect | undefined;

package/lib/commonjs/dom/nodes/datatypes/Path.d.ts

@@ -0,0 +1,4 @@
+import type { Skia } from "../../../skia/types";
+import type { PathDef } from "../../types";
+export declare const processPath: (Skia: Skia, rawPath: PathDef) => import("../../../skia/types").SkPath;
+export declare const isPathDef: (def: any) => def is PathDef;

package/lib/commonjs/dom/nodes/datatypes/Radius.d.ts

@@ -0,0 +1,3 @@
+import type { Skia, Vector } from "../../../skia/types";
+import type { Radius } from "../../types";
+export declare const processRadius: (Skia: Skia, radius: Radius) => Vector;

package/lib/commonjs/dom/nodes/datatypes/Rect.d.ts

@@ -0,0 +1,5 @@
+import type { Skia, SkRect, Vector } from "../../../skia/types";
+import type { RectDef, RRectDef } from "../../types";
+export declare const isEdge: (pos: Vector, b: SkRect) => boolean;
+export declare const processRect: (Skia: Skia, def: RectDef) => SkRect;
+export declare const processRRect: (Skia: Skia, def: RRectDef) => import("../../../skia/types").SkRRect;

package/lib/commonjs/dom/nodes/datatypes/Transform.d.ts

@@ -0,0 +1,3 @@
+import type { TransformProps } from "../../types";
+import type { SkMatrix } from "../../../skia/types";
+export declare const processTransformProps: (m3: SkMatrix, props: TransformProps) => void;

package/lib/commonjs/dom/nodes/datatypes/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Enum";
+export * from "./Path";
+export * from "./Fitting";
+export * from "./Rect";
+export * from "./Radius";
+export * from "./Circle";
+export * from "./Gradient";
+export * from "./Transform";

package/lib/commonjs/dom/nodes/drawings/BackdropFilterNode.d.ts

@@ -0,0 +1,8 @@
+import type { ChildrenProps, DrawingContext } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class BackdropFilterNode extends JsiDrawingNode<ChildrenProps, null> {
+    constructor(ctx: NodeContext, props: ChildrenProps);
+    protected deriveProps(): null;
+    draw({ canvas }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/Box.d.ts

@@ -0,0 +1,13 @@
+import type { DrawingContext } from "../../types";
+import type { BoxShadowProps, BoxProps } from "../../types/Drawings";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import { JsiRenderNode } from "../RenderNode";
+export declare class BoxShadowNode extends JsiDeclarationNode<BoxShadowProps, BoxShadowProps> {
+    constructor(ctx: NodeContext, props: BoxShadowProps);
+    materialize(): BoxShadowProps;
+}
+export declare class BoxNode extends JsiRenderNode<BoxProps> {
+    constructor(ctx: NodeContext, props: BoxProps);
+    renderNode({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/CircleNode.d.ts

@@ -0,0 +1,9 @@
+import type { SkPoint } from "../../../skia/types";
+import type { CircleProps, DrawingContext } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class CircleNode extends JsiDrawingNode<CircleProps, SkPoint> {
+    constructor(ctx: NodeContext, props: CircleProps);
+    protected deriveProps(): SkPoint;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/CustomDrawingNode.d.ts

@@ -0,0 +1,8 @@
+import type { CustomDrawingNodeProps, DrawingContext } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class CustomDrawingNode extends JsiDrawingNode<CustomDrawingNodeProps, null> {
+    constructor(ctx: NodeContext, props: CustomDrawingNodeProps);
+    deriveProps(): null;
+    draw(ctx: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/DiffRectNode.d.ts

@@ -0,0 +1,8 @@
+import type { DiffRectProps, DrawingContext } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class DiffRectNode extends JsiDrawingNode<DiffRectProps, null> {
+    constructor(ctx: NodeContext, props: DiffRectProps);
+    deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/FillNode.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext, DrawingNodeProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class FillNode extends JsiDrawingNode<DrawingNodeProps, null> {
+    constructor(ctx: NodeContext, props?: DrawingNodeProps);
+    deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/ImageNode.d.ts

@@ -0,0 +1,25 @@
+import type { SkRect } from "../../../skia/types";
+import type { DrawingContext, ImageProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class ImageNode extends JsiDrawingNode<ImageProps, {
+    src: SkRect;
+    dst: SkRect;
+}> {
+    constructor(ctx: NodeContext, props: ImageProps);
+    deriveProps(): {
+        src: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        dst: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/ImageSVG.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext, ImageSVGProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class ImageSVGNode extends JsiDrawingNode<ImageSVGProps, null> {
+    constructor(ctx: NodeContext, props: ImageSVGProps);
+    deriveProps(): null;
+    draw({ canvas }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/LineNode.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext, LineProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class LineNode extends JsiDrawingNode<LineProps, null> {
+    constructor(ctx: NodeContext, props: LineProps);
+    deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/OvalNode.d.ts

@@ -0,0 +1,9 @@
+import type { SkRect } from "../../../skia/types";
+import type { DrawingContext, OvalProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class OvalNode extends JsiDrawingNode<OvalProps, SkRect> {
+    constructor(ctx: NodeContext, props: OvalProps);
+    deriveProps(): SkRect;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/PatchNode.d.ts

@@ -0,0 +1,18 @@
+import type { SkColor, SkPoint } from "../../../skia/types";
+import { BlendMode } from "../../../skia/types";
+import type { DrawingContext, PatchProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class PatchNode extends JsiDrawingNode<PatchProps, {
+    points: SkPoint[];
+    colors: SkColor[] | undefined;
+    mode: BlendMode;
+}> {
+    constructor(ctx: NodeContext, props: PatchProps);
+    deriveProps(): {
+        mode: BlendMode;
+        points: SkPoint[];
+        colors: Float32Array[] | undefined;
+    };
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/PathNode.d.ts

@@ -0,0 +1,9 @@
+import type { SkPath } from "../../../skia/types";
+import type { DrawingContext, PathProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class PathNode extends JsiDrawingNode<PathProps, SkPath> {
+    constructor(ctx: NodeContext, props: PathProps);
+    protected deriveProps(): SkPath;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/PictureNode.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext, PictureProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class PictureNode extends JsiDrawingNode<PictureProps, null> {
+    constructor(ctx: NodeContext, props: PictureProps);
+    deriveProps(): null;
+    draw({ canvas }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/PointsNode.d.ts

@@ -0,0 +1,8 @@
+import type { DrawingContext, PointsProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class PointsNode extends JsiDrawingNode<PointsProps, null> {
+    constructor(ctx: NodeContext, props: PointsProps);
+    deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/RRectNode.d.ts

@@ -0,0 +1,10 @@
+import type { SkRRect } from "../../../skia/types";
+import type { DrawingContext, RoundedRectProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class RRectNode extends JsiDrawingNode<RoundedRectProps, SkRRect> {
+    rect?: SkRRect;
+    constructor(ctx: NodeContext, props: RoundedRectProps);
+    protected deriveProps(): SkRRect;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/RectNode.d.ts

@@ -0,0 +1,9 @@
+import type { SkRect } from "../../../skia/types/Rect";
+import type { DrawingContext, RectProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class RectNode extends JsiDrawingNode<RectProps, SkRect> {
+    constructor(ctx: NodeContext, props: RectProps);
+    deriveProps(): SkRect;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/Text.d.ts

@@ -0,0 +1,30 @@
+import type { SkTextBlob, SkPoint } from "../../../skia/types";
+import type { DrawingContext, TextBlobProps, TextPathProps, TextProps } from "../../types";
+import type { GlyphsProps } from "../../types/Drawings";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class TextNode extends JsiDrawingNode<TextProps, null> {
+    constructor(ctx: NodeContext, props: TextProps);
+    protected deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}
+export declare class TextPathNode extends JsiDrawingNode<TextPathProps, SkTextBlob> {
+    constructor(ctx: NodeContext, props: TextPathProps);
+    deriveProps(): SkTextBlob;
+    draw({ canvas, paint }: DrawingContext): void;
+}
+export declare class TextBlobNode extends JsiDrawingNode<TextBlobProps, null> {
+    constructor(ctx: NodeContext, props: TextBlobProps);
+    protected deriveProps(): null;
+    draw({ canvas, paint }: DrawingContext): void;
+}
+interface ProcessedGlyphs {
+    glyphs: number[];
+    positions: SkPoint[];
+}
+export declare class GlyphsNode extends JsiDrawingNode<GlyphsProps, ProcessedGlyphs> {
+    constructor(ctx: NodeContext, props: GlyphsProps);
+    deriveProps(): ProcessedGlyphs;
+    draw({ canvas, paint }: DrawingContext): void;
+}
+export {};

package/lib/commonjs/dom/nodes/drawings/VerticesNode.d.ts

@@ -0,0 +1,9 @@
+import type { SkVertices } from "../../../skia/types";
+import type { DrawingContext, VerticesProps } from "../../types";
+import { JsiDrawingNode } from "../DrawingNode";
+import type { NodeContext } from "../Node";
+export declare class VerticesNode extends JsiDrawingNode<VerticesProps, SkVertices> {
+    constructor(ctx: NodeContext, props: VerticesProps);
+    protected deriveProps(): SkVertices;
+    draw({ canvas, paint }: DrawingContext): void;
+}

package/lib/commonjs/dom/nodes/drawings/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./CircleNode";
+export * from "./FillNode";
+export * from "./ImageNode";
+export * from "./PointsNode";
+export * from "./PathNode";
+export * from "./RectNode";
+export * from "./RRectNode";
+export * from "./OvalNode";
+export * from "./LineNode";
+export * from "./PatchNode";
+export * from "./VerticesNode";
+export * from "./CustomDrawingNode";
+export * from "./Text";
+export * from "./PictureNode";
+export * from "./DiffRectNode";
+export * from "./ImageSVG";
+export * from "./BackdropFilterNode";
+export * from "./Box";