@shopify/react-native-skia 0.1.146 → 0.1.148

package/lib/typescript/src/dom/nodes/paint/ImageFilters.d.ts

@@ -0,0 +1,42 @@
+import type { SkImageFilter } from "../../../skia/types";
+import type { BlendImageFilterProps, BlurImageFilterProps, DisplacementMapImageFilterProps, DropShadowImageFilterProps, MorphologyImageFilterProps, OffsetImageFilterProps, RuntimeShaderImageFilterProps } from "../../types";
+import { NodeType } from "../../types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+export declare abstract class ImageFilterDeclaration<P, Nullable extends null | never = never> extends JsiDeclarationNode<P, SkImageFilter, Nullable> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    getOptionalChildInstance(index: number): any;
+    getMandatoryChildInstance(index: number): any;
+}
+export declare class OffsetImageFilterNode extends ImageFilterDeclaration<OffsetImageFilterProps> {
+    constructor(ctx: NodeContext, props: OffsetImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare class DisplacementMapImageFilterNode extends ImageFilterDeclaration<DisplacementMapImageFilterProps> {
+    constructor(ctx: NodeContext, props: DisplacementMapImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare class BlurImageFilterNode extends ImageFilterDeclaration<BlurImageFilterProps> {
+    constructor(ctx: NodeContext, props: BlurImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare class DropShadowImageFilterNode extends ImageFilterDeclaration<DropShadowImageFilterProps> {
+    constructor(ctx: NodeContext, props: DropShadowImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare enum MorphologyOperator {
+    Erode = 0,
+    Dilate = 1
+}
+export declare class MorphologyImageFilterNode extends ImageFilterDeclaration<MorphologyImageFilterProps> {
+    constructor(ctx: NodeContext, props: MorphologyImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare class BlendImageFilterNode extends ImageFilterDeclaration<BlendImageFilterProps> {
+    constructor(ctx: NodeContext, props: BlendImageFilterProps);
+    materialize(): SkImageFilter;
+}
+export declare class RuntimeShaderImageFilterNode extends ImageFilterDeclaration<RuntimeShaderImageFilterProps> {
+    constructor(ctx: NodeContext, props: RuntimeShaderImageFilterProps);
+    materialize(): SkImageFilter;
+}

package/lib/typescript/src/dom/nodes/paint/MaskFilters.d.ts

@@ -0,0 +1,8 @@
+import type { SkMaskFilter } from "../../../skia/types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { BlurMaskFilterProps } from "../../types";
+export declare class BlurMaskFilterNode extends JsiDeclarationNode<BlurMaskFilterProps, SkMaskFilter> {
+    constructor(ctx: NodeContext, props: BlurMaskFilterProps);
+    materialize(): SkMaskFilter;
+}

package/lib/typescript/src/dom/nodes/paint/PathEffects.d.ts

@@ -0,0 +1,42 @@
+import type { SkPathEffect } from "../../../skia/types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { CornerPathEffectProps, DashPathEffectProps, DiscretePathEffectProps, Line2DPathEffectProps, Node, Path1DPathEffectProps, Path2DPathEffectProps } from "../../types";
+import { NodeType } from "../../types";
+declare abstract class PathEffectDeclaration<P, Nullable extends null | never = never> extends JsiDeclarationNode<P, SkPathEffect, Nullable> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    addChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+    compose(pe: SkPathEffect): SkPathEffect;
+    getOptionalChildInstance(index: number): any;
+    getMandatoryChildInstance(index: number): any;
+}
+export declare class DiscretePathEffectNode extends PathEffectDeclaration<DiscretePathEffectProps> {
+    constructor(ctx: NodeContext, props: DiscretePathEffectProps);
+    materialize(): SkPathEffect;
+}
+export declare class Path2DPathEffectNode extends PathEffectDeclaration<Path2DPathEffectProps, null> {
+    constructor(ctx: NodeContext, props: Path2DPathEffectProps);
+    materialize(): SkPathEffect | null;
+}
+export declare class DashPathEffectNode extends PathEffectDeclaration<DashPathEffectProps> {
+    constructor(ctx: NodeContext, props: DashPathEffectProps);
+    materialize(): SkPathEffect;
+}
+export declare class CornerPathEffectNode extends PathEffectDeclaration<CornerPathEffectProps, null> {
+    constructor(ctx: NodeContext, props: CornerPathEffectProps);
+    materialize(): SkPathEffect | null;
+}
+export declare class SumPathEffectNode extends PathEffectDeclaration<null> {
+    constructor(ctx: NodeContext);
+    materialize(): SkPathEffect;
+}
+export declare class Line2DPathEffectNode extends PathEffectDeclaration<Line2DPathEffectProps, null> {
+    constructor(ctx: NodeContext, props: Line2DPathEffectProps);
+    materialize(): SkPathEffect | null;
+}
+export declare class Path1DPathEffectNode extends PathEffectDeclaration<Path1DPathEffectProps, null> {
+    constructor(ctx: NodeContext, props: Path1DPathEffectProps);
+    materialize(): SkPathEffect | null;
+}
+export {};

package/lib/typescript/src/dom/nodes/paint/Shaders.d.ts

@@ -0,0 +1,44 @@
+import type { SkShader } from "../../../skia/types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { ColorProps, FractalNoiseProps, ImageShaderProps, LinearGradientProps, RadialGradientProps, ShaderProps, SweepGradientProps, TurbulenceProps, TwoPointConicalGradientProps } from "../../types";
+import { NodeType } from "../../types";
+export declare abstract class ShaderDeclaration<P> extends JsiDeclarationNode<P, SkShader> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+}
+export declare class ShaderNode extends ShaderDeclaration<ShaderProps> {
+    constructor(ctx: NodeContext, props: ShaderProps);
+    materialize(): SkShader;
+}
+export declare class ImageShaderNode extends ShaderDeclaration<ImageShaderProps> {
+    constructor(ctx: NodeContext, props: ImageShaderProps);
+    materialize(): SkShader;
+}
+export declare class ColorNode extends ShaderDeclaration<ColorProps> {
+    constructor(ctx: NodeContext, props: ColorProps);
+    materialize(): SkShader;
+}
+export declare class TurbulenceNode extends ShaderDeclaration<TurbulenceProps> {
+    constructor(ctx: NodeContext, props: TurbulenceProps);
+    materialize(): SkShader;
+}
+export declare class FractalNoiseNode extends ShaderDeclaration<FractalNoiseProps> {
+    constructor(ctx: NodeContext, props: FractalNoiseProps);
+    materialize(): SkShader;
+}
+export declare class LinearGradientNode extends ShaderDeclaration<LinearGradientProps> {
+    constructor(ctx: NodeContext, props: LinearGradientProps);
+    materialize(): SkShader;
+}
+export declare class RadialGradientNode extends ShaderDeclaration<RadialGradientProps> {
+    constructor(ctx: NodeContext, props: RadialGradientProps);
+    materialize(): SkShader;
+}
+export declare class SweepGradientNode extends ShaderDeclaration<SweepGradientProps> {
+    constructor(ctx: NodeContext, props: SweepGradientProps);
+    materialize(): SkShader;
+}
+export declare class TwoPointConicalGradientNode extends ShaderDeclaration<TwoPointConicalGradientProps> {
+    constructor(ctx: NodeContext, props: TwoPointConicalGradientProps);
+    materialize(): SkShader;
+}

package/lib/typescript/src/dom/nodes/paint/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Shaders";
+export * from "./MaskFilters";
+export * from "./ColorFilters";
+export * from "./ImageFilters";
+export * from "./PathEffects";
+export * from "./BlendNode";

package/lib/typescript/src/dom/types/ColorFilters.d.ts

@@ -0,0 +1,12 @@
+import type { BlendMode, Color } from "../../skia/types";
+import type { ChildrenProps, SkEnum } from "./Common";
+export interface MatrixColorFilterProps extends ChildrenProps {
+    matrix: number[];
+}
+export interface BlendColorFilterProps extends ChildrenProps {
+    mode: SkEnum<typeof BlendMode>;
+    color: Color;
+}
+export interface LerpColorFilterProps extends ChildrenProps {
+    t: number;
+}

package/lib/typescript/src/dom/types/Common.d.ts

@@ -0,0 +1,57 @@
+import type { ReactNode, RefObject } from "react";
+import type { BlendMode, Color, PaintStyle, SkMatrix, SkPaint, SkPath, SkRect, SkRRect, StrokeCap, StrokeJoin, Transforms2d, Vector } from "../../skia/types";
+import type { DeclarationNode } from "./Node";
+export declare type SkEnum<T> = Uncapitalize<keyof T extends string ? keyof T : never>;
+export declare type PathDef = string | SkPath;
+export declare type ClipDef = SkRRect | SkRect | PathDef;
+export declare type Fit = "cover" | "contain" | "fill" | "fitHeight" | "fitWidth" | "none" | "scaleDown";
+export declare type Radius = number | Vector;
+export interface ChildrenProps {
+    children?: ReactNode | ReactNode[];
+}
+export interface RectCtor {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface RRectCtor extends RectCtor {
+    r: Radius;
+}
+export declare type RectDef = RectCtor | {
+    rect: SkRect;
+};
+export declare type RRectDef = RRectCtor | {
+    rect: SkRRect;
+};
+export interface PointCircleDef {
+    c: Vector;
+    r: number;
+}
+export interface ScalarCircleDef {
+    cx: number;
+    cy: number;
+    r: number;
+}
+export declare type CircleDef = PointCircleDef | ScalarCircleDef;
+export interface TransformProps {
+    transform?: Transforms2d;
+    origin?: Vector;
+    matrix?: SkMatrix;
+}
+export interface PaintProps extends ChildrenProps {
+    color?: Color;
+    strokeWidth?: number;
+    blendMode?: SkEnum<typeof BlendMode>;
+    style?: SkEnum<typeof PaintStyle>;
+    strokeJoin?: SkEnum<typeof StrokeJoin>;
+    strokeCap?: SkEnum<typeof StrokeCap>;
+    strokeMiter?: number;
+    opacity?: number;
+    antiAlias?: boolean;
+}
+export interface GroupProps extends PaintProps, TransformProps {
+    clip?: ClipDef;
+    invertClip?: boolean;
+    layer?: RefObject<DeclarationNode<unknown, SkPaint>> | SkPaint | boolean;
+}

package/lib/typescript/src/dom/types/DrawingContext.d.ts

@@ -0,0 +1,6 @@
+import type { SkCanvas, SkPaint } from "../../skia/types";
+export interface DrawingContext {
+    canvas: SkCanvas;
+    paint: SkPaint;
+    opacity: number;
+}

package/lib/typescript/src/dom/types/Drawings.d.ts

@@ -0,0 +1,106 @@
+import type { RefObject } from "react";
+import type { FillType, SkImage, StrokeOpts, Vector, Color, SkPoint, BlendMode, PointMode, VertexMode, SkFont, SkRRect, SkTextBlob, SkPicture, SkSVG, SkPaint, SkRect } from "../../skia/types";
+import type { CircleDef, Fit, GroupProps, PathDef, RectDef, RRectDef, SkEnum } from "./Common";
+import type { DrawingContext } from "./DrawingContext";
+import type { DeclarationNode } from "./Node";
+export interface DrawingNodeProps extends GroupProps {
+    paint?: SkPaint | RefObject<DeclarationNode<unknown, SkPaint>>;
+}
+export declare type ImageProps = DrawingNodeProps & RectDef & {
+    fit: Fit;
+    image: SkImage;
+};
+export declare type CircleProps = CircleDef & DrawingNodeProps;
+export interface PathProps extends DrawingNodeProps {
+    path: PathDef;
+    start: number;
+    end: number;
+    stroke?: StrokeOpts;
+    fillType?: SkEnum<typeof FillType>;
+}
+export interface CustomDrawingNodeProps extends DrawingNodeProps {
+    drawing: (ctx: DrawingContext) => void;
+}
+export interface LineProps extends DrawingNodeProps {
+    p1: Vector;
+    p2: Vector;
+}
+export declare type OvalProps = RectDef & DrawingNodeProps;
+export declare type RectProps = RectDef & DrawingNodeProps;
+export declare type RoundedRectProps = RRectDef & DrawingNodeProps;
+export interface CubicBezierHandle {
+    pos: Vector;
+    c1: Vector;
+    c2: Vector;
+}
+export interface PatchProps extends DrawingNodeProps {
+    colors?: Color[];
+    patch: [
+        CubicBezierHandle,
+        CubicBezierHandle,
+        CubicBezierHandle,
+        CubicBezierHandle
+    ];
+    texture?: readonly [SkPoint, SkPoint, SkPoint, SkPoint];
+    blendMode?: SkEnum<typeof BlendMode>;
+}
+export interface VerticesProps extends DrawingNodeProps {
+    colors?: string[];
+    vertices: SkPoint[];
+    textures?: SkPoint[];
+    mode: SkEnum<typeof VertexMode>;
+    blendMode?: SkEnum<typeof BlendMode>;
+    indices?: number[];
+}
+export declare type ImageSVGProps = RectDef & {
+    svg: SkSVG;
+} & DrawingNodeProps;
+export interface PictureProps extends DrawingNodeProps {
+    picture: SkPicture;
+}
+export interface PointsProps extends DrawingNodeProps {
+    points: SkPoint[];
+    mode: SkEnum<typeof PointMode>;
+}
+export interface DiffRectProps extends DrawingNodeProps {
+    inner: SkRRect;
+    outer: SkRRect;
+}
+export interface TextProps extends DrawingNodeProps {
+    font: SkFont;
+    text: string;
+    x: number;
+    y: number;
+}
+export interface TextPathProps extends DrawingNodeProps {
+    font: SkFont;
+    text: string;
+    path: PathDef;
+    initialOffset: number;
+}
+export interface TextBlobProps extends DrawingNodeProps {
+    blob: SkTextBlob;
+    x: number;
+    y: number;
+}
+export interface Glyph {
+    id: number;
+    pos: SkPoint;
+}
+export interface GlyphsProps extends DrawingNodeProps {
+    font: SkFont;
+    x: number;
+    y: number;
+    glyphs: Glyph[];
+}
+export interface BoxProps extends DrawingNodeProps {
+    box: SkRRect | SkRect;
+}
+export interface BoxShadowProps {
+    dx?: number;
+    dy?: number;
+    spread?: number;
+    blur: number;
+    color?: Color;
+    inner?: boolean;
+}

package/lib/typescript/src/dom/types/ImageFilters.d.ts

@@ -0,0 +1,37 @@
+import type { BlendMode, Color, ColorChannel, SkRuntimeEffect, TileMode, Uniforms } from "../../skia/types";
+import type { Radius, SkEnum, ChildrenProps } from "./Common";
+export interface BlurImageFilterProps extends ChildrenProps {
+    blur: Radius;
+    mode: SkEnum<typeof TileMode>;
+}
+export interface OffsetImageFilterProps extends ChildrenProps {
+    x: number;
+    y: number;
+}
+export interface RuntimeShaderImageFilterProps extends ChildrenProps {
+    source: SkRuntimeEffect;
+    uniforms?: Uniforms;
+}
+export interface BlendImageFilterProps extends ChildrenProps {
+    mode: BlendMode;
+}
+export interface MorphologyImageFilterProps extends ChildrenProps {
+    operator: "erode" | "dilate";
+    radius: Radius;
+}
+export interface DropShadowImageFilterProps extends ChildrenProps {
+    dx: number;
+    dy: number;
+    blur: number;
+    color: Color;
+    inner?: boolean;
+    shadowOnly?: boolean;
+}
+export interface DisplacementMapImageFilterProps extends ChildrenProps {
+    channelX: SkEnum<typeof ColorChannel>;
+    channelY: SkEnum<typeof ColorChannel>;
+    scale: number;
+}
+export interface BlendProps extends ChildrenProps {
+    mode: SkEnum<typeof BlendMode>;
+}

package/lib/typescript/src/dom/types/MaskFilters.d.ts

@@ -0,0 +1,7 @@
+import type { BlurStyle } from "../../skia/types";
+import type { SkEnum } from "./Common";
+export interface BlurMaskFilterProps {
+    style: SkEnum<typeof BlurStyle>;
+    blur: number;
+    respectCTM: boolean;
+}

package/lib/typescript/src/dom/types/Node.d.ts

@@ -0,0 +1,29 @@
+import type { SkColorFilter, SkImageFilter, SkMaskFilter, SkPaint, SkPathEffect, SkShader } from "../../skia/types";
+import type { GroupProps } from "./Common";
+import type { DrawingContext } from "./DrawingContext";
+import type { DeclarationType, NodeType } from "./NodeType";
+export interface Node<P> {
+    type: NodeType;
+    setProps(props: P): void;
+    setProp<K extends keyof P>(name: K, v: P[K]): boolean;
+    getProps(): P;
+    children(): Node<unknown>[];
+    addChild(child: Node<unknown>): void;
+    removeChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+}
+export declare type Invalidate = () => void;
+export interface DeclarationNode<P, T, Nullable extends null | never = never> extends Node<P> {
+    declarationType: DeclarationType;
+    materialize(): T | Nullable;
+    setInvalidate(invalidate: Invalidate): void;
+    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>;
+}
+export interface RenderNode<P extends GroupProps> extends Node<P> {
+    render(ctx: DrawingContext): void;
+}

package/lib/typescript/src/dom/types/NodeType.d.ts

@@ -0,0 +1,66 @@
+export declare const enum NodeType {
+    Shader = "skShader",
+    ImageShader = "skImageShader",
+    ColorShader = "skColorShader",
+    Turbulence = "skTurbulence",
+    FractalNoise = "skFractalNoise",
+    LinearGradient = "skLinearGradient",
+    RadialGradient = "skRadialGradient",
+    SweepGradient = "skSweepGradient",
+    TwoPointConicalGradient = "skTwoPointConicalGradient",
+    BlurMaskFilter = "skBlurMaskFilter",
+    DiscretePathEffect = "skDiscretePathEffect",
+    DashPathEffect = "skDashPathEffect",
+    Path1DPathEffect = "skPath1DPathEffect",
+    Path2DPathEffect = "skPath2DPathEffect",
+    CornerPathEffect = "skCornerPathEffect",
+    SumPathEffect = "skSumPathEffect",
+    Line2DPathEffect = "skLine2DPathEffect",
+    MatrixColorFilter = "skMatrixColorFilter",
+    BlendColorFilter = "skBlendColorFilter",
+    LinearToSRGBGammaColorFilter = "skLinearToSRGBGammaColorFilter",
+    SRGBToLinearGammaColorFilter = "skSRGBToLinearGammaColorFilter",
+    LumaColorFilter = "skLumaColorFilter",
+    LerpColorFilter = "skLerpColorFilter",
+    OffsetImageFilter = "skOffsetImageFilter",
+    DisplacementMapImageFilter = "skDisplacementMapImageFilter",
+    BlurImageFilter = "skBlurImageFilter",
+    DropShadowImageFilter = "skDropShadowImageFilter",
+    MorphologyImageFilter = "skMorphologyImageFilter",
+    BlendImageFilter = "skBlendImageFilter",
+    RuntimeShaderImageFilter = "skRuntimeShaderImageFilter",
+    Blend = "skBlend",
+    BackdropFilter = "skBackdropFilter",
+    Box = "skBox",
+    BoxShadow = "skBoxShadow",
+    Group = "skGroup",
+    Drawing = "skDrawing",
+    Paint = "skPaint",
+    Circle = "skCircle",
+    Fill = "skFill",
+    Image = "skImage",
+    Points = "skPoints",
+    Path = "skPath",
+    Rect = "skRect",
+    RRect = "skRRect",
+    Oval = "skOval",
+    Line = "skLine",
+    Patch = "skPatch",
+    Vertices = "skVertices",
+    DiffRect = "skDiffRect",
+    Text = "skText",
+    TextPath = "skTextPath",
+    TextBlob = "skTextBlob",
+    Glyphs = "skGlyphs",
+    Picture = "skPicture",
+    ImageSVG = "skImageSVG"
+}
+export declare const enum DeclarationType {
+    Paint = 0,
+    Shader = 1,
+    ImageFilter = 2,
+    ColorFilter = 3,
+    PathEffect = 4,
+    MaskFilter = 5,
+    Unknown = 6
+}

package/lib/typescript/src/dom/types/PathEffects.d.ts

@@ -0,0 +1,28 @@
+import type { Path1DEffectStyle, SkMatrix } from "../../skia/types";
+import type { ChildrenProps, PathDef, SkEnum } from "./Common";
+export interface CornerPathEffectProps extends ChildrenProps {
+    r: number;
+}
+export interface DiscretePathEffectProps extends ChildrenProps {
+    length: number;
+    deviation: number;
+    seed: number;
+}
+export interface DashPathEffectProps extends ChildrenProps {
+    intervals: number[];
+    phase?: number;
+}
+export interface Path1DPathEffectProps extends ChildrenProps {
+    path: PathDef;
+    advance: number;
+    phase: number;
+    style: SkEnum<typeof Path1DEffectStyle>;
+}
+export interface Path2DPathEffectProps extends ChildrenProps {
+    matrix: SkMatrix;
+    path: PathDef;
+}
+export interface Line2DPathEffectProps extends ChildrenProps {
+    width: number;
+    matrix: SkMatrix;
+}

package/lib/typescript/src/dom/types/Shaders.d.ts

@@ -0,0 +1,59 @@
+import type { Color, FilterMode, MipmapMode, SkImage, SkRect, SkRuntimeEffect, TileMode, Uniforms, Vector } from "../../skia/types";
+import type { SkEnum, TransformProps, ChildrenProps, RectCtor, Fit } from "./Common";
+export interface ShaderProps extends TransformProps, ChildrenProps {
+    source: SkRuntimeEffect;
+    uniforms: Uniforms;
+}
+export interface ImageShaderProps extends TransformProps, Partial<RectCtor> {
+    tx: SkEnum<typeof TileMode>;
+    ty: SkEnum<typeof TileMode>;
+    fm: SkEnum<typeof FilterMode>;
+    mm: SkEnum<typeof MipmapMode>;
+    fit: Fit;
+    rect?: SkRect;
+    image: SkImage;
+}
+export interface ColorProps {
+    color: Color;
+}
+export interface TurbulenceProps {
+    freqX: number;
+    freqY: number;
+    octaves: number;
+    seed: number;
+    tileWidth: number;
+    tileHeight: number;
+}
+export interface FractalNoiseProps {
+    freqX: number;
+    freqY: number;
+    octaves: number;
+    seed: number;
+    tileWidth: number;
+    tileHeight: number;
+}
+export interface GradientProps extends TransformProps {
+    colors: Color[];
+    positions?: number[];
+    mode?: SkEnum<typeof TileMode>;
+    flags?: number;
+}
+export interface LinearGradientProps extends GradientProps {
+    start: Vector;
+    end: Vector;
+}
+export interface RadialGradientProps extends GradientProps {
+    c: Vector;
+    r: number;
+}
+export interface SweepGradientProps extends GradientProps {
+    c: Vector;
+    start?: number;
+    end?: number;
+}
+export interface TwoPointConicalGradientProps extends GradientProps {
+    start: Vector;
+    startR: number;
+    end: Vector;
+    endR: number;
+}

package/lib/typescript/src/dom/types/SkDOM.d.ts

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

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

@@ -0,0 +1,11 @@
+export * from "./DrawingContext";
+export * from "./Node";
+export * from "./NodeType";
+export * from "./SkDOM";
+export * from "./Common";
+export * from "./Drawings";
+export * from "./ImageFilters";
+export * from "./ColorFilters";
+export * from "./MaskFilters";
+export * from "./PathEffects";
+export * from "./Shaders";

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

@@ -6,3 +6,5 @@ export * from "./skia";
 export * from "./external";
 export * from "./values";
 export * from "./animation";
+export * from "./dom/types";
+export * from "./dom/nodes";