@shopify/react-native-skia 0.1.170 → 0.1.172

package/lib/module/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/module/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/module/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/module/dom/types/NodeType.d.ts

@@ -0,0 +1,67 @@
+export declare const enum NodeType {
+    Layer = "skLayer",
+    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/module/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/module/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/module/dom/types/SkDOM.d.ts

@@ -0,0 +1,72 @@
+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 {
+    Layer(props?: ChildrenProps): RenderNode<ChildrenProps>;
+    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/module/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/module/external/index.d.ts

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

package/lib/module/external/reanimated/index.d.ts

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

package/lib/module/external/reanimated/useSharedValueEffect.d.ts

@@ -0,0 +1,11 @@
+declare type SharedValueTypeWrapper<T = number> = {
+    value: T;
+};
+/**
+ * Connects a shared value from reanimated to a SkiaView or Canvas
+ * so whenever the shared value changes the SkiaView will redraw.
+ * @param cb Callback that will be called whenever the shared value changes.
+ * @param values One or more shared values to listen for.
+ */
+export declare const useSharedValueEffect: <T = number>(cb: () => void, value: SharedValueTypeWrapper<T>, ...values: SharedValueTypeWrapper<T>[]) => void;
+export {};

package/lib/module/index.d.ts

@@ -0,0 +1,10 @@
+import "./skia/NativeSetup";
+export * from "./renderer";
+export * from "./renderer/Canvas";
+export * from "./views";
+export * from "./skia";
+export * from "./external";
+export * from "./values";
+export * from "./animation";
+export * from "./dom/types";
+export * from "./dom/nodes";

package/lib/module/mock/index.d.ts

@@ -0,0 +1,16 @@
+import type { Skia as SkiaApi } from "../skia/types";
+import type * as SkiaExports from "../skia";
+import type * as ExternalExports from "../external";
+import type * as ValueExports from "../values";
+import type * as AnimationExports from "../animation";
+import { ShaderLib } from "../renderer/components/shaders/ShaderLib";
+export declare const Skia: SkiaApi;
+export declare const vec: (x?: number, y?: number) => {
+    x: number;
+    y: number;
+};
+export declare const Mock: typeof SkiaExports & typeof ExternalExports & typeof ValueExports & typeof AnimationExports & {
+    createDrawing: () => any;
+    createDeclaration: () => any;
+    ShaderLib: typeof ShaderLib;
+};

package/lib/module/renderer/Canvas.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { RefObject, ReactNode } from "react";
+import { SkiaDomView } from "../views";
+import type { TouchHandler, SkiaBaseViewProps } from "../views";
+export declare const useCanvasRef: () => React.RefObject<SkiaDomView>;
+export interface CanvasProps extends SkiaBaseViewProps {
+    ref?: RefObject<SkiaDomView>;
+    children: ReactNode;
+    onTouch?: TouchHandler;
+}
+export declare const Canvas: React.FC<CanvasProps & React.RefAttributes<SkiaDomView>>;

package/lib/module/renderer/Container.d.ts

@@ -0,0 +1,12 @@
+import type { GroupProps, DrawingContext, RenderNode, SkDOM } from "../dom/types";
+import type { Skia } from "../skia/types";
+import type { DependencyManager } from "./DependencyManager";
+export declare class Container {
+    depMgr: DependencyManager;
+    redraw: () => void;
+    private _root;
+    Sk: SkDOM;
+    constructor(Skia: Skia, depMgr: DependencyManager, redraw?: () => void);
+    draw(ctx: DrawingContext): void;
+    get root(): RenderNode<GroupProps>;
+}

package/lib/module/renderer/DependencyManager.d.ts

@@ -0,0 +1,46 @@
+import type { Node } from "../dom/types";
+import type { SkiaValue } from "../values";
+import type { AnimatedProps } from "./processors";
+declare type Unsubscribe = () => void;
+declare type Mutator = (value: unknown) => void;
+declare type SubscriptionState = {
+    nodes: Map<Node<unknown>, Mutator[]>;
+    unsubscribe: null | Unsubscribe;
+};
+export declare class DependencyManager {
+    registerValues: (values: Array<SkiaValue<unknown>>) => () => void;
+    subscriptions: Map<SkiaValue<unknown>, SubscriptionState>;
+    unregisterDependantValues: null | Unsubscribe;
+    constructor(registerValues: (values: Array<SkiaValue<unknown>>) => () => void);
+    /**
+     * Call to unsubscribe all value listeners from the given node based
+     * on the current list of subscriptions for the node. This function
+     * is typically called when the node is unmounted or when one or more
+     * properties have changed.
+     * @param node Node to unsubscribe value listeners from
+     */
+    unsubscribeNode(node: Node<unknown>): void;
+    /**
+     * Adds listeners to the provided values so that the node is notified
+     * when a value changes. This is done in an optimized way so that this
+     * class only needs to listen to the value once and then forwards the
+     * change to the node and its listener. This method is typically called
+     * when the node is mounted and when one or more props on the node changes.
+     * @param node Node to subscribe to value changes for
+     * @param props Node's properties
+     */
+    subscribeNode<P>(node: Node<unknown>, props: AnimatedProps<P>): void;
+    /**
+     * Called when the hosting container is mounted or updated. This ensures that we have
+     * a ref to the underlying SkiaView so that we can registers redraw listeners
+     * on values used in the current View automatically.
+     */
+    update(): void;
+    /**
+     * Called when the hosting container is unmounted or recreated. This ensures that we remove
+     * all subscriptions to Skia values so that we don't have any listeners left after
+     * the component is removed.
+     */
+    remove(): void;
+}
+export {};

package/lib/module/renderer/DrawingContext.d.ts

@@ -0,0 +1,6 @@
+import type { DrawingInfo } from "../views";
+import type { Skia } from "../skia/types";
+import type { DrawingContext as DOMDrawingContext } from "../dom/types";
+export interface DrawingContext extends Omit<DrawingInfo, "touches">, DOMDrawingContext {
+    Skia: Skia;
+}

package/lib/module/renderer/HostComponents.d.ts

@@ -0,0 +1,132 @@
+import { NodeType } from "../dom/types";
+import type { DeclarationNode, FractalNoiseProps, RenderNode, CircleProps, DrawingNodeProps, ImageProps, PaintProps, PathProps, CustomDrawingNodeProps, LineProps, OvalProps, DiffRectProps, PointsProps, RectProps, RoundedRectProps, TextProps, VerticesProps, BlurMaskFilterProps, BlendImageFilterProps, BlurImageFilterProps, DisplacementMapImageFilterProps, DropShadowImageFilterProps, OffsetImageFilterProps, RuntimeShaderImageFilterProps, MatrixColorFilterProps, ShaderProps, ImageShaderProps, LinearGradientProps, GroupProps, PatchProps, BlendColorFilterProps, DashPathEffectProps, DiscretePathEffectProps, CornerPathEffectProps, Line2DPathEffectProps, Path1DPathEffectProps, Path2DPathEffectProps, TextPathProps, TextBlobProps, GlyphsProps, TwoPointConicalGradientProps, TurbulenceProps, SweepGradientProps, RadialGradientProps, ColorProps, PictureProps, ImageSVGProps, LerpColorFilterProps, BoxProps, BoxShadowProps } from "../dom/types";
+import type { ChildrenProps } from "../dom/types/Common";
+import type { BlendProps, MorphologyImageFilterProps } from "../dom/types/ImageFilters";
+import type { SkColorFilter, SkImageFilter, SkMaskFilter, SkPaint, SkPathEffect, SkRect, SkRRect, SkShader } from "../skia";
+import type { JsiDrawingNode } from "../dom/nodes/DrawingNode";
+import type { SkiaValue } from "../values";
+import type { Container } from "./Container";
+import type { SkiaProps } from "./processors";
+import type { DependencyManager } from "./DependencyManager";
+declare global {
+    var SkiaDomApi: {
+        DependencyManager: (registerValues: (values: Array<SkiaValue<unknown>>) => () => void) => DependencyManager;
+        RectNode: (props: RectProps) => JsiDrawingNode<RectProps, SkRect>;
+        RRectNode: (props: RoundedRectProps) => JsiDrawingNode<RoundedRectProps, SkRRect>;
+        GroupNode: (props: GroupProps) => RenderNode<GroupProps>;
+        PaintNode: (props: PaintProps) => DeclarationNode<PaintProps, SkPaint>;
+        FillNode: (props: PaintProps) => RenderNode<PaintProps>;
+        CircleNode: (props: CircleProps) => RenderNode<CircleProps>;
+        PathNode: (props: PathProps) => RenderNode<PathProps>;
+        CustomDrawingNode: (props: CustomDrawingNodeProps) => RenderNode<CustomDrawingNodeProps>;
+        LineNode: (props: LineProps) => RenderNode<LineProps>;
+        ImageNode: (props: ImageProps) => RenderNode<ImageProps>;
+        OvalNode: (props: OvalProps) => RenderNode<OvalProps>;
+        PatchNode: (props: PatchProps) => RenderNode<PatchProps>;
+        PointsNode: (props: PointsProps) => RenderNode<PointsProps>;
+        DiffRectNode: (props: DiffRectProps) => RenderNode<DiffRectProps>;
+        BlurMaskFilterNode: (props: BlurMaskFilterProps) => DeclarationNode<BlurMaskFilterProps, SkMaskFilter>;
+        DashPathEffectNode: (props: DashPathEffectProps) => DeclarationNode<DashPathEffectProps, SkPathEffect>;
+        DiscretePathEffectNode: (props: DiscretePathEffectProps) => DeclarationNode<DiscretePathEffectProps, SkPathEffect>;
+        CornerPathEffectNode: (props: CornerPathEffectProps) => DeclarationNode<CornerPathEffectProps, SkPathEffect>;
+        Path1DPathEffectNode: (props: Path1DPathEffectProps) => DeclarationNode<Path1DPathEffectProps, SkPathEffect>;
+        Path2DPathEffectNode: (props: Path2DPathEffectProps) => DeclarationNode<Path2DPathEffectProps, SkPathEffect>;
+        Line2DPathEffectNode: (props: Line2DPathEffectProps) => DeclarationNode<Line2DPathEffectProps, SkPathEffect>;
+        SumPathEffectNode: () => DeclarationNode<null, SkPathEffect>;
+        BlendImageFilterNode: (props: BlendImageFilterProps) => DeclarationNode<BlendImageFilterProps, SkImageFilter>;
+        DropShadowImageFilterNode: (props: DropShadowImageFilterProps) => DeclarationNode<DropShadowImageFilterProps, SkImageFilter>;
+        DisplacementMapImageFilterNode: (props: DisplacementMapImageFilterProps) => DeclarationNode<DisplacementMapImageFilterProps, SkImageFilter>;
+        BlurImageFilterNode: (props: BlurImageFilterProps) => DeclarationNode<BlurImageFilterProps, SkImageFilter>;
+        OffsetImageFilterNode: (props: OffsetImageFilterProps) => DeclarationNode<OffsetImageFilterProps, SkImageFilter>;
+        MorphologyImageFilterNode: (props: MorphologyImageFilterProps) => DeclarationNode<MorphologyImageFilterProps, SkImageFilter>;
+        RuntimeShaderImageFilterNode: (props: RuntimeShaderImageFilterProps) => DeclarationNode<RuntimeShaderImageFilterProps, SkImageFilter>;
+        MatrixColorFilterNode: (props: MatrixColorFilterProps) => DeclarationNode<MatrixColorFilterProps, SkColorFilter>;
+        BlendColorFilterNode: (props: BlendColorFilterProps) => DeclarationNode<BlendColorFilterProps, SkColorFilter>;
+        LinearToSRGBGammaColorFilterNode: () => DeclarationNode<null, SkColorFilter>;
+        SRGBToLinearGammaColorFilterNode: () => DeclarationNode<null, SkColorFilter>;
+        LumaColorFilterNode: () => DeclarationNode<null, SkColorFilter>;
+        LerpColorFilterNode: (props: LerpColorFilterProps) => DeclarationNode<LerpColorFilterProps, SkColorFilter>;
+        ShaderNode: (props: ShaderProps) => DeclarationNode<ShaderProps, SkShader>;
+        ImageShaderNode: (props: ImageShaderProps) => DeclarationNode<ImageShaderProps, SkShader>;
+        ColorShaderNode: (props: ColorProps) => DeclarationNode<ColorProps, SkShader>;
+        TurbulenceNode: (props: TurbulenceProps) => DeclarationNode<TurbulenceProps, SkShader>;
+        FractalNoiseNode: (props: FractalNoiseProps) => DeclarationNode<FractalNoiseProps, SkShader>;
+        LinearGradientNode: (props: LinearGradientProps) => DeclarationNode<LinearGradientProps, SkShader>;
+        RadialGradientNode: (props: RadialGradientProps) => DeclarationNode<RadialGradientProps, SkShader>;
+        SweepGradientNode: (props: SweepGradientProps) => DeclarationNode<SweepGradientProps, SkShader>;
+        TwoPointConicalGradientNode: (props: TwoPointConicalGradientProps) => DeclarationNode<TwoPointConicalGradientProps, SkShader>;
+        PictureNode: (props: PictureProps) => RenderNode<PictureProps>;
+        ImageSVGNode: (props: ImageSVGProps) => RenderNode<ImageSVGProps>;
+        VerticesNode: (props: VerticesProps) => RenderNode<VerticesProps>;
+        TextNode: (prop: TextProps) => RenderNode<TextProps>;
+        TextPathNode: (prop: TextPathProps) => RenderNode<TextPathProps>;
+        TextBlobNode: (prop: TextBlobProps) => RenderNode<TextBlobProps>;
+        GlyphsNode: (prop: GlyphsProps) => RenderNode<GlyphsProps>;
+        BlendNode: (prop: BlendProps) => DeclarationNode<BlendProps, SkImageFilter>;
+        BackdropFilterNode: (prop: ChildrenProps) => RenderNode<ChildrenProps>;
+        BoxNode: (prop: BoxProps) => RenderNode<BoxProps>;
+        BoxShadowNode: (prop: BoxShadowProps) => DeclarationNode<BoxShadowProps, BoxShadowProps>;
+        LayerNode: (prop: ChildrenProps) => RenderNode<ChildrenProps>;
+    };
+    namespace JSX {
+        interface IntrinsicElements {
+            skGroup: SkiaProps<GroupProps>;
+            skLayer: SkiaProps<ChildrenProps>;
+            skPaint: SkiaProps<PaintProps>;
+            skFill: SkiaProps<DrawingNodeProps>;
+            skImage: SkiaProps<ImageProps>;
+            skCircle: SkiaProps<CircleProps>;
+            skPath: SkiaProps<PathProps>;
+            skDrawing: SkiaProps<CustomDrawingNodeProps>;
+            skLine: SkiaProps<LineProps>;
+            skOval: SkiaProps<OvalProps>;
+            skPatch: SkiaProps<PatchProps>;
+            skPoints: SkiaProps<PointsProps>;
+            skRect: SkiaProps<RectProps>;
+            skRRect: SkiaProps<RoundedRectProps>;
+            skVertices: SkiaProps<VerticesProps>;
+            skText: SkiaProps<TextProps>;
+            skTextPath: SkiaProps<TextPathProps>;
+            skTextBlob: SkiaProps<TextBlobProps>;
+            skGlyphs: SkiaProps<GlyphsProps>;
+            skDiffRect: SkiaProps<DiffRectProps>;
+            skPicture: SkiaProps<PictureProps>;
+            skImageSVG: SkiaProps<ImageSVGProps>;
+            skBlurMaskFilter: SkiaProps<BlurMaskFilterProps>;
+            skBlendImageFilter: SkiaProps<BlendImageFilterProps>;
+            skBlurImageFilter: SkiaProps<BlurImageFilterProps>;
+            skOffsetImageFilter: SkiaProps<OffsetImageFilterProps>;
+            skDropShadowImageFilter: SkiaProps<DropShadowImageFilterProps>;
+            skDisplacementMapImageFilter: SkiaProps<DisplacementMapImageFilterProps>;
+            skRuntimeShaderImageFilter: SkiaProps<RuntimeShaderImageFilterProps>;
+            skMorphologyImageFilter: SkiaProps<MorphologyImageFilterProps>;
+            skMatrixColorFilter: SkiaProps<MatrixColorFilterProps>;
+            skBlendColorFilter: SkiaProps<BlendColorFilterProps>;
+            skLinearToSRGBGammaColorFilter: SkiaProps<ChildrenProps>;
+            skSRGBToLinearGammaColorFilter: SkiaProps<ChildrenProps>;
+            skLumaColorFilter: SkiaProps<ChildrenProps>;
+            skLerpColorFilter: SkiaProps<LerpColorFilterProps>;
+            skShader: SkiaProps<ShaderProps>;
+            skImageShader: SkiaProps<ImageShaderProps>;
+            skColorShader: SkiaProps<ColorProps>;
+            skTurbulence: SkiaProps<TurbulenceProps>;
+            skFractalNoise: SkiaProps<FractalNoiseProps>;
+            skLinearGradient: SkiaProps<LinearGradientProps>;
+            skRadialGradient: SkiaProps<RadialGradientProps>;
+            skSweepGradient: SkiaProps<SweepGradientProps>;
+            skTwoPointConicalGradient: SkiaProps<TwoPointConicalGradientProps>;
+            skDiscretePathEffect: SkiaProps<DiscretePathEffectProps>;
+            skDashPathEffect: SkiaProps<DashPathEffectProps>;
+            skPath1DPathEffect: SkiaProps<Path1DPathEffectProps>;
+            skPath2DPathEffect: SkiaProps<Path2DPathEffectProps>;
+            skCornerPathEffect: SkiaProps<CornerPathEffectProps>;
+            skSumPathEffect: ChildrenProps;
+            skLine2DPathEffect: SkiaProps<Line2DPathEffectProps>;
+            skBlend: SkiaProps<BlendProps>;
+            skBackdropFilter: SkiaProps<ChildrenProps>;
+            skBox: SkiaProps<BoxProps>;
+            skBoxShadow: SkiaProps<BoxShadowProps>;
+        }
+    }
+}
+export declare const createNode: (container: Container, type: NodeType, props: any) => RenderNode<ChildrenProps> | DeclarationNode<PaintProps, SkPaint, never> | DeclarationNode<BlurMaskFilterProps, SkMaskFilter, never> | DeclarationNode<BlendImageFilterProps, SkImageFilter, never> | DeclarationNode<BlurImageFilterProps, SkImageFilter, never> | DeclarationNode<OffsetImageFilterProps, SkImageFilter, never> | DeclarationNode<DropShadowImageFilterProps, SkImageFilter, never> | DeclarationNode<MorphologyImageFilterProps, SkImageFilter, never> | DeclarationNode<DisplacementMapImageFilterProps, SkImageFilter, never> | DeclarationNode<RuntimeShaderImageFilterProps, SkImageFilter, never> | DeclarationNode<MatrixColorFilterProps, SkColorFilter, never> | DeclarationNode<BlendColorFilterProps, SkColorFilter, never> | DeclarationNode<null, SkColorFilter, never> | DeclarationNode<LerpColorFilterProps, SkColorFilter, never> | DeclarationNode<ShaderProps, SkShader, never> | DeclarationNode<ImageShaderProps, SkShader, never> | DeclarationNode<ColorProps, SkShader, never> | DeclarationNode<TurbulenceProps, SkShader, never> | DeclarationNode<LinearGradientProps, SkShader, never> | DeclarationNode<RadialGradientProps, SkShader, never> | DeclarationNode<SweepGradientProps, SkShader, never> | DeclarationNode<CornerPathEffectProps, SkPathEffect, null> | DeclarationNode<DiscretePathEffectProps, SkPathEffect, never> | DeclarationNode<DashPathEffectProps, SkPathEffect, never> | DeclarationNode<Path1DPathEffectProps, SkPathEffect, null> | DeclarationNode<Path2DPathEffectProps, SkPathEffect, null> | DeclarationNode<null, SkPathEffect, null> | DeclarationNode<Line2DPathEffectProps, SkPathEffect, null> | DeclarationNode<BlendProps, SkImageFilter | SkShader, never> | DeclarationNode<BoxShadowProps, BoxShadowProps, never>;

package/lib/module/renderer/HostConfig.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { HostConfig } from "react-reconciler";
+import type { NodeType, Node } from "../dom/types";
+import type { Container } from "./Container";
+export declare const debug: (message?: any, ...optionalParams: any[]) => void;
+declare type Instance = Node<unknown>;
+declare type Props = object;
+declare type TextInstance = Node<unknown>;
+declare type SuspenseInstance = Instance;
+declare type HydratableInstance = Instance;
+declare type PublicInstance = Instance;
+declare type HostContext = null;
+declare type UpdatePayload = Container;
+declare type ChildSet = unknown;
+declare type TimeoutHandle = NodeJS.Timeout;
+declare type NoTimeout = -1;
+declare type SkiaHostConfig = HostConfig<NodeType, Props, Container, Instance, TextInstance, SuspenseInstance, HydratableInstance, PublicInstance, HostContext, UpdatePayload, ChildSet, TimeoutHandle, NoTimeout>;
+export declare const skHostConfig: SkiaHostConfig;
+export {};

package/lib/module/renderer/Reconciler.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import type { Skia } from "../skia/types";
+import type { SkiaValue } from "../values/types";
+declare type RegisterValues = (values: Array<SkiaValue<unknown>>) => () => void;
+export declare class SkiaRoot {
+    private root;
+    private container;
+    constructor(Skia: Skia, registerValues?: RegisterValues, redraw?: () => void);
+    render(element: ReactNode): void;
+    unmount(): void;
+    get dom(): import("..").RenderNode<import("..").GroupProps>;
+}
+export {};

package/lib/module/renderer/components/Blend.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { BlendProps } from "../../dom/types";
+import type { SkiaProps } from "../processors";
+export declare const Blend: (props: SkiaProps<BlendProps>) => JSX.Element;

package/lib/module/renderer/components/Drawing.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { CustomDrawingNodeProps } from "../../dom/types";
+export declare const Drawing: (props: CustomDrawingNodeProps) => JSX.Element;

package/lib/module/renderer/components/Group.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { SkiaProps } from "../processors";
+import type { GroupProps } from "../../dom/types";
+import type { ChildrenProps } from "../../dom/types/Common";
+export interface PublicGroupProps extends Omit<GroupProps, "layer"> {
+    layer?: GroupProps["layer"] | ChildrenProps["children"];
+}
+export declare const Group: ({ layer, ...props }: SkiaProps<PublicGroupProps>) => JSX.Element;