@shopify/react-native-skia 1.0.1 → 1.0.3

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

@@ -0,0 +1,73 @@
+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, LineProps, OvalProps, PatchProps, PointsProps, RectProps, RoundedRectProps, VerticesProps, TextProps, DiffRectProps, TextPathProps, TextBlobProps, GlyphsProps, PictureProps, ImageSVGProps, DrawingNodeProps, BoxProps, BoxShadowProps, AtlasProps } 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";
+import type { ParagraphProps } from "./Paragraph";
+type ImageFilterNode<P> = DeclarationNode<P>;
+type PathEffectNode<P> = DeclarationNode<P>;
+type NullablePathEffectNode<P> = DeclarationNode<P>;
+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>;
+    Fill(props?: DrawingNodeProps): DrawingNode<DrawingNodeProps>;
+    Image(props: ImageProps): DrawingNode<ImageProps>;
+    Circle(props: CircleProps): DrawingNode<CircleProps>;
+    Path(props: PathProps): DrawingNode<PathProps>;
+    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>;
+    Atlas(props: AtlasProps): DrawingNode<AtlasProps>;
+    BlurMaskFilter(props: BlurMaskFilterProps): DeclarationNode<BlurMaskFilterProps>;
+    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>;
+    BlendColorFilter(props: BlendColorFilterProps): DeclarationNode<BlendColorFilterProps>;
+    LumaColorFilter(): DeclarationNode<null>;
+    LinearToSRGBGammaColorFilter(): DeclarationNode<null>;
+    SRGBToLinearGammaColorFilter(): DeclarationNode<null>;
+    LerpColorFilter(props: LerpColorFilterProps): DeclarationNode<LerpColorFilterProps>;
+    Shader(props: ShaderProps): DeclarationNode<ShaderProps>;
+    ImageShader(props: ImageShaderProps): DeclarationNode<ImageShaderProps>;
+    ColorShader(props: ColorProps): DeclarationNode<ColorProps>;
+    Turbulence(props: TurbulenceProps): DeclarationNode<TurbulenceProps>;
+    FractalNoise(props: FractalNoiseProps): DeclarationNode<FractalNoiseProps>;
+    LinearGradient(props: LinearGradientProps): DeclarationNode<LinearGradientProps>;
+    RadialGradient(props: RadialGradientProps): DeclarationNode<RadialGradientProps>;
+    SweepGradient(props: SweepGradientProps): DeclarationNode<SweepGradientProps>;
+    TwoPointConicalGradient(props: TwoPointConicalGradientProps): DeclarationNode<TwoPointConicalGradientProps>;
+    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>;
+    BackdropFilter(props: ChildrenProps): RenderNode<ChildrenProps>;
+    Box(props: BoxProps): RenderNode<BoxProps>;
+    BoxShadow(props: BoxShadowProps): DeclarationNode<BoxShadowProps>;
+    Paragraph(props: ParagraphProps): RenderNode<ParagraphProps>;
+}
+export {};

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

@@ -0,0 +1,13 @@
+export * from "./DrawingContext";
+export * from "./DeclarationContext";
+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";
+export * from "./Paragraph";

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

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

package/lib/typescript/src/external/reanimated/buffers.d.ts

@@ -0,0 +1,7 @@
+import type { SkColor, SkHostRect, SkPoint, SkRSXform } from "../../skia/types";
+type Modifier<T> = (input: T, index: number) => void;
+export declare const useRectBuffer: (size: number, modifier: Modifier<SkHostRect>) => import("react-native-reanimated/lib/typescript/reanimated2/commonTypes").SharedValue<SkHostRect[]>;
+export declare const useRSXformBuffer: (size: number, modifier: Modifier<SkRSXform>) => import("react-native-reanimated/lib/typescript/reanimated2/commonTypes").SharedValue<SkRSXform[]>;
+export declare const usePointBuffer: (size: number, modifier: Modifier<SkPoint>) => import("react-native-reanimated/lib/typescript/reanimated2/commonTypes").SharedValue<SkPoint[]>;
+export declare const useColorBuffer: (size: number, modifier: Modifier<SkColor>) => import("react-native-reanimated/lib/typescript/reanimated2/commonTypes").SharedValue<Float32Array[]>;
+export {};

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

@@ -0,0 +1,6 @@
+export * from "./useAnimatedImageValue";
+export * from "./useDerivedValueOnJS";
+export * from "./renderHelpers";
+export * from "./interpolators";
+export * from "./textures";
+export * from "./buffers";

package/lib/typescript/src/external/reanimated/interpolators.d.ts

@@ -0,0 +1,10 @@
+import type { ExtrapolationType, SharedValue } from "react-native-reanimated";
+import type { SkPath, SkPoint } from "../../skia/types";
+export declare const notifyChange: (value: SharedValue<unknown>) => void;
+export declare const usePathValue: (cb: (path: SkPath) => void, init?: SkPath) => SharedValue<SkPath>;
+export declare const useClock: () => SharedValue<number>;
+export declare const usePathInterpolation: (value: SharedValue<number>, input: number[], outputRange: SkPath[], options?: ExtrapolationType) => SharedValue<SkPath>;
+export declare const useVectorInterpolation: (value: SharedValue<number>, input: number[], outputRange: SkPoint[], options?: ExtrapolationType) => SharedValue<{
+    x: number;
+    y: number;
+}>;

package/lib/typescript/src/external/reanimated/moduleWrapper.d.ts

@@ -0,0 +1,14 @@
+import type { DependencyList } from "react";
+import type { DerivedValue, FrameCallback, FrameInfo, SharedValue } from "react-native-reanimated";
+export declare const HAS_REANIMATED2: boolean;
+export declare const HAS_REANIMATED3: boolean;
+export declare function throwOnMissingReanimated(): void;
+export declare const useSharedValue: <T>(init: T, oneWayReadsOnly?: boolean) => SharedValue<T>;
+export declare const useDerivedValue: <T>(processor: () => T, dependencies?: DependencyList) => DerivedValue<T>;
+export declare const useFrameCallback: (callback: (frameInfo: FrameInfo) => void, autostart?: boolean) => FrameCallback;
+export declare const startMapper: (worklet: () => void, inputs?: unknown[], outputs?: unknown[]) => number;
+export declare const stopMapper: (mapperID: number) => void;
+export declare const runOnJS: any;
+export declare const runOnUI: any;
+export declare const useAnimatedReaction: <T>(prepare: () => T, react: (v: T) => void, dependencies?: DependencyList) => void;
+export declare const isSharedValue: <T>(value: unknown) => value is SharedValue<T>;

package/lib/typescript/src/external/reanimated/renderHelpers.d.ts

@@ -0,0 +1,6 @@
+import type { Container } from "../../renderer/Container";
+import type { AnimatedProps } from "../../renderer/processors";
+import type { Node } from "../../dom/types";
+export declare const unbindReanimatedNode: (node: Node<unknown>) => void;
+export declare function extractReanimatedProps(props: AnimatedProps<any>): AnimatedProps<any, never>[];
+export declare function bindReanimatedProps(container: Container, node: Node<any>, reanimatedProps: AnimatedProps<any>): void;

package/lib/typescript/src/external/reanimated/textures.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement } from "react";
+import type { SharedValue } from "react-native-reanimated";
+import type { DataSourceParam, SkImage, SkPicture, SkSize } from "../../skia/types";
+export declare const useTexture: (element: ReactElement, size: SkSize) => SharedValue<SkImage | null>;
+export declare const useTextureAsValue: (element: ReactElement, size: SkSize) => SharedValue<SkImage | null>;
+export declare const useTextureValueFromPicture: (picture: SkPicture | null, size: SkSize) => SharedValue<SkImage | null>;
+export declare const usePictureAsTexture: (picture: SkPicture | null, size: SkSize) => SharedValue<SkImage | null>;
+export declare const useImageAsTexture: (source: DataSourceParam) => SharedValue<SkImage | null>;

package/lib/typescript/src/external/reanimated/useAnimatedImageValue.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceParam, SkImage } from "../../skia/types";
+export declare const useAnimatedImageValue: (source: DataSourceParam) => import("react-native-reanimated").SharedValue<SkImage | null>;

package/lib/typescript/src/external/reanimated/useDerivedValueOnJS.d.ts

@@ -0,0 +1 @@
+export declare const useDerivedValueOnJS: (fn: () => any, deps: unknown[]) => import("react-native-reanimated").SharedValue<any>;

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

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+import type { SkSurface } from "../skia";
+export * from "../renderer/components";
+export declare const makeOffscreenSurface: (width: number, height: number) => any;
+export declare const drawOffscreen: (surface: SkSurface, element: ReactNode) => import("../skia").SkImage;

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

@@ -0,0 +1,11 @@
+import "./skia/NativeSetup";
+export { JsiSkImage } from "./skia/web/JsiSkImage";
+export * from "./renderer";
+export * from "./renderer/Canvas";
+export * from "./renderer/Offscreen";
+export * from "./views";
+export * from "./skia";
+export * from "./external";
+export * from "./animation";
+export * from "./dom/types";
+export * from "./dom/nodes";

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

@@ -0,0 +1,2 @@
+import type { CanvasKit } from "canvaskit-wasm";
+export declare const Mock: (CanvasKit: CanvasKit) => any;

package/lib/typescript/src/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.FunctionComponent<CanvasProps & React.RefAttributes<SkiaDomView>>;

package/lib/typescript/src/renderer/Container.d.ts

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

package/lib/typescript/src/renderer/DrawingContext.d.ts

@@ -0,0 +1,7 @@
+import type { DrawingInfo } from "../views";
+import type { Skia, SkCanvas, SkPaint } from "../skia/types";
+export interface DrawingContext extends Omit<DrawingInfo, "touches"> {
+    Skia: Skia;
+    canvas: SkCanvas;
+    paint: SkPaint;
+}

package/lib/typescript/src/renderer/HostComponents.d.ts

@@ -0,0 +1,132 @@
+import { NodeType } from "../dom/types";
+import type { DeclarationNode, FractalNoiseProps, RenderNode, CircleProps, DrawingNodeProps, ImageProps, PaintProps, PathProps, 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, ParagraphProps, AtlasProps } from "../dom/types";
+import type { ChildrenProps } from "../dom/types/Common";
+import type { BlendProps, MorphologyImageFilterProps } from "../dom/types/ImageFilters";
+import type { SkRect, SkRRect } from "../skia/types";
+import type { JsiDrawingNode } from "../dom/nodes/DrawingNode";
+import type { Container } from "./Container";
+import type { SkiaProps } from "./processors";
+export declare const NATIVE_DOM: boolean;
+declare global {
+    var SkiaDomApi: {
+        RectNode: (props: RectProps) => JsiDrawingNode<RectProps, SkRect>;
+        RRectNode: (props: RoundedRectProps) => JsiDrawingNode<RoundedRectProps, SkRRect>;
+        GroupNode: (props: GroupProps) => RenderNode<GroupProps>;
+        PaintNode: (props: PaintProps) => DeclarationNode<PaintProps>;
+        FillNode: (props: PaintProps) => RenderNode<PaintProps>;
+        CircleNode: (props: CircleProps) => RenderNode<CircleProps>;
+        PathNode: (props: PathProps) => RenderNode<PathProps>;
+        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>;
+        AtlasNode: (props: AtlasProps) => RenderNode<AtlasProps>;
+        BlurMaskFilterNode: (props: BlurMaskFilterProps) => DeclarationNode<BlurMaskFilterProps>;
+        DashPathEffectNode: (props: DashPathEffectProps) => DeclarationNode<DashPathEffectProps>;
+        DiscretePathEffectNode: (props: DiscretePathEffectProps) => DeclarationNode<DiscretePathEffectProps>;
+        CornerPathEffectNode: (props: CornerPathEffectProps) => DeclarationNode<CornerPathEffectProps>;
+        Path1DPathEffectNode: (props: Path1DPathEffectProps) => DeclarationNode<Path1DPathEffectProps>;
+        Path2DPathEffectNode: (props: Path2DPathEffectProps) => DeclarationNode<Path2DPathEffectProps>;
+        Line2DPathEffectNode: (props: Line2DPathEffectProps) => DeclarationNode<Line2DPathEffectProps>;
+        SumPathEffectNode: () => DeclarationNode<null>;
+        BlendImageFilterNode: (props: BlendImageFilterProps) => DeclarationNode<BlendImageFilterProps>;
+        DropShadowImageFilterNode: (props: DropShadowImageFilterProps) => DeclarationNode<DropShadowImageFilterProps>;
+        DisplacementMapImageFilterNode: (props: DisplacementMapImageFilterProps) => DeclarationNode<DisplacementMapImageFilterProps>;
+        BlurImageFilterNode: (props: BlurImageFilterProps) => DeclarationNode<BlurImageFilterProps>;
+        OffsetImageFilterNode: (props: OffsetImageFilterProps) => DeclarationNode<OffsetImageFilterProps>;
+        MorphologyImageFilterNode: (props: MorphologyImageFilterProps) => DeclarationNode<MorphologyImageFilterProps>;
+        RuntimeShaderImageFilterNode: (props: RuntimeShaderImageFilterProps) => DeclarationNode<RuntimeShaderImageFilterProps>;
+        MatrixColorFilterNode: (props: MatrixColorFilterProps) => DeclarationNode<MatrixColorFilterProps>;
+        BlendColorFilterNode: (props: BlendColorFilterProps) => DeclarationNode<BlendColorFilterProps>;
+        LinearToSRGBGammaColorFilterNode: () => DeclarationNode<null>;
+        SRGBToLinearGammaColorFilterNode: () => DeclarationNode<null>;
+        LumaColorFilterNode: () => DeclarationNode<null>;
+        LerpColorFilterNode: (props: LerpColorFilterProps) => DeclarationNode<LerpColorFilterProps>;
+        ShaderNode: (props: ShaderProps) => DeclarationNode<ShaderProps>;
+        ImageShaderNode: (props: ImageShaderProps) => DeclarationNode<ImageShaderProps>;
+        ColorShaderNode: (props: ColorProps) => DeclarationNode<ColorProps>;
+        TurbulenceNode: (props: TurbulenceProps) => DeclarationNode<TurbulenceProps>;
+        FractalNoiseNode: (props: FractalNoiseProps) => DeclarationNode<FractalNoiseProps>;
+        LinearGradientNode: (props: LinearGradientProps) => DeclarationNode<LinearGradientProps>;
+        RadialGradientNode: (props: RadialGradientProps) => DeclarationNode<RadialGradientProps>;
+        SweepGradientNode: (props: SweepGradientProps) => DeclarationNode<SweepGradientProps>;
+        TwoPointConicalGradientNode: (props: TwoPointConicalGradientProps) => DeclarationNode<TwoPointConicalGradientProps>;
+        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>;
+        BackdropFilterNode: (prop: ChildrenProps) => RenderNode<ChildrenProps>;
+        BoxNode: (prop: BoxProps) => RenderNode<BoxProps>;
+        BoxShadowNode: (prop: BoxShadowProps) => DeclarationNode<BoxShadowProps>;
+        LayerNode: (prop: ChildrenProps) => RenderNode<ChildrenProps>;
+        ParagraphNode: (props: ParagraphProps) => RenderNode<ParagraphProps>;
+    };
+    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>;
+            skLine: SkiaProps<LineProps>;
+            skOval: SkiaProps<OvalProps>;
+            skPatch: SkiaProps<PatchProps>;
+            skPoints: SkiaProps<PointsProps>;
+            skRect: SkiaProps<RectProps>;
+            skRRect: SkiaProps<RoundedRectProps>;
+            skAtlas: SkiaProps<AtlasProps>;
+            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>;
+            skParagraph: SkiaProps<ParagraphProps>;
+        }
+    }
+}
+export declare const createNode: (container: Container, type: NodeType, props: any) => RenderNode<ChildrenProps> | DeclarationNode<PaintProps> | DeclarationNode<BlurMaskFilterProps> | DeclarationNode<BlendImageFilterProps> | DeclarationNode<BlurImageFilterProps> | DeclarationNode<OffsetImageFilterProps> | DeclarationNode<MorphologyImageFilterProps> | DeclarationNode<DisplacementMapImageFilterProps> | DeclarationNode<RuntimeShaderImageFilterProps> | DeclarationNode<MatrixColorFilterProps> | DeclarationNode<null> | DeclarationNode<LerpColorFilterProps> | DeclarationNode<ImageShaderProps> | DeclarationNode<ColorProps> | DeclarationNode<TurbulenceProps> | DeclarationNode<LinearGradientProps> | DeclarationNode<RadialGradientProps> | DeclarationNode<SweepGradientProps> | DeclarationNode<CornerPathEffectProps> | DeclarationNode<DiscretePathEffectProps> | DeclarationNode<DashPathEffectProps> | DeclarationNode<Path1DPathEffectProps> | DeclarationNode<Path2DPathEffectProps> | DeclarationNode<Line2DPathEffectProps> | DeclarationNode<BlendProps> | DeclarationNode<BoxShadowProps>;

package/lib/typescript/src/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;
+type Instance = Node<unknown>;
+type Props = object;
+type TextInstance = Node<unknown>;
+type SuspenseInstance = Instance;
+type HydratableInstance = Instance;
+type PublicInstance = Instance;
+type HostContext = null;
+type UpdatePayload = Container;
+type ChildSet = unknown;
+type TimeoutHandle = NodeJS.Timeout;
+type NoTimeout = -1;
+type SkiaHostConfig = HostConfig<NodeType, Props, Container, Instance, TextInstance, SuspenseInstance, HydratableInstance, PublicInstance, HostContext, UpdatePayload, ChildSet, TimeoutHandle, NoTimeout>;
+export declare const skHostConfig: SkiaHostConfig;
+export {};

package/lib/typescript/src/renderer/Offscreen.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+import type { SkPicture, SkSize } from "../skia/types";
+export declare const isOnMainThread: () => boolean;
+export declare const drawAsPicture: (element: ReactElement) => SkPicture;
+export declare const drawAsImage: (element: ReactElement, size: SkSize) => import("../skia").SkImage;
+export declare const drawAsImageFromPicture: (picture: SkPicture, size: SkSize) => import("../skia").SkImage;

package/lib/typescript/src/renderer/Reconciler.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+import type { Skia } from "../skia/types";
+export declare class SkiaRoot {
+    private root;
+    private container;
+    constructor(Skia: Skia, native?: boolean, redraw?: () => void, getNativeId?: () => number);
+    render(element: ReactNode): void;
+    unmount(): void;
+    get dom(): import("..").RenderNode<import("..").GroupProps>;
+}

package/lib/typescript/src/renderer/components/Blend.d.ts

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

package/lib/typescript/src/renderer/components/Group.d.ts

@@ -0,0 +1,8 @@
+import React from "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>) => React.JSX.Element;

package/lib/typescript/src/renderer/components/Mask.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+import React from "react";
+interface MaskProps {
+    mode?: "luminance" | "alpha";
+    clip?: boolean;
+    mask: ReactNode | ReactNode[];
+    children: ReactNode | ReactNode[];
+}
+export declare const Mask: ({ children, mask, mode, clip, }: MaskProps) => React.JSX.Element;
+export {};

package/lib/typescript/src/renderer/components/Paint.d.ts

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

package/lib/typescript/src/renderer/components/Picture.d.ts

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

package/lib/typescript/src/renderer/components/backdrop/BackdropBlur.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { AnimatedProps } from "../../processors";
+import type { Radius } from "../../../dom/types";
+import type { BackdropFilterProps } from "./BackdropFilter";
+interface BackdropBlurProps extends Omit<BackdropFilterProps, "filter"> {
+    blur: Radius;
+}
+export declare const BackdropBlur: ({ blur, children, ...props }: AnimatedProps<BackdropBlurProps>) => React.JSX.Element;
+export {};

package/lib/typescript/src/renderer/components/backdrop/BackdropFilter.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+import React from "react";
+import type { GroupProps } from "../../../dom/types";
+import type { SkiaProps } from "../../processors/Animations/Animations";
+export interface BackdropFilterProps extends GroupProps {
+    filter: ReactNode | ReactNode[];
+}
+export declare const BackdropFilter: ({ filter, children: groupChildren, ...props }: SkiaProps<BackdropFilterProps, "filter">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/backdrop/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BackdropFilter";
+export * from "./BackdropBlur";

package/lib/typescript/src/renderer/components/colorFilters/BlendColor.d.ts

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

package/lib/typescript/src/renderer/components/colorFilters/Lerp.d.ts

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

package/lib/typescript/src/renderer/components/colorFilters/LinearToSRGBGamma.d.ts

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

package/lib/typescript/src/renderer/components/colorFilters/LumaColorFilter.d.ts

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

package/lib/typescript/src/renderer/components/colorFilters/Matrix.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { SkiaProps } from "../../processors";
+import type { MatrixColorFilterProps } from "../../../dom/types";
+export declare const ColorMatrix: (props: SkiaProps<MatrixColorFilterProps>) => React.JSX.Element;
+export declare const OpacityMatrix: (opacity: number) => number[];

package/lib/typescript/src/renderer/components/colorFilters/SRGBToLinearGamma.d.ts

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

package/lib/typescript/src/renderer/components/colorFilters/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Matrix";
+export * from "./BlendColor";
+export * from "./Lerp";
+export * from "./LinearToSRGBGamma";
+export * from "./SRGBToLinearGamma";
+export * from "./LumaColorFilter";

package/lib/typescript/src/renderer/components/image/Image.d.ts

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

package/lib/typescript/src/renderer/components/image/ImageSVG.d.ts

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

package/lib/typescript/src/renderer/components/image/ImageShader.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { ImageShaderProps } from "../../../dom/types";
+import type { SkiaDefaultProps } from "../../processors";
+export declare const ImageShader: ({ tx, ty, fm, mm, fit, transform, ...props }: SkiaDefaultProps<ImageShaderProps, "tx" | "ty" | "fm" | "mm" | "fit" | "transform">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/image/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Image";
+export * from "./ImageShader";
+export * from "./ImageSVG";

package/lib/typescript/src/renderer/components/imageFilters/Blur.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { SkiaDefaultProps } from "../../processors/Animations/Animations";
+import type { BlurImageFilterProps } from "../../../dom/types";
+export declare const Blur: ({ mode, ...props }: SkiaDefaultProps<BlurImageFilterProps, "mode">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/imageFilters/DisplacementMap.d.ts

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

package/lib/typescript/src/renderer/components/imageFilters/Morphology.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { MorphologyImageFilterProps } from "../../../dom/types";
+import type { SkiaDefaultProps } from "../../processors";
+export declare const Morphology: ({ operator, ...props }: SkiaDefaultProps<MorphologyImageFilterProps, "operator">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/imageFilters/Offset.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { SkiaDefaultProps } from "../../processors/Animations/Animations";
+import type { OffsetImageFilterProps } from "../../../dom/types";
+export declare const Offset: ({ x, y, ...props }: SkiaDefaultProps<OffsetImageFilterProps, "x" | "y">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/imageFilters/RuntimeShader.d.ts

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

package/lib/typescript/src/renderer/components/imageFilters/Shadow.d.ts

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

package/lib/typescript/src/renderer/components/imageFilters/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Blur";
+export * from "./Offset";
+export * from "./DisplacementMap";
+export * from "./Shadow";
+export * from "./Morphology";
+export * from "./RuntimeShader";

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

@@ -0,0 +1,16 @@
+export * from "./shapes";
+export * from "./backdrop";
+export * from "./image";
+export * from "./shaders";
+export * from "./text";
+export * from "./colorFilters";
+export * from "./maskFilters";
+export * from "./imageFilters";
+export * from "./pathEffects";
+export * from "../processors";
+export * from "./Picture";
+export * from "./Group";
+export * from "./Mask";
+export * from "./Paint";
+export * from "./Blend";
+export * from "./paragraph";

package/lib/typescript/src/renderer/components/maskFilters/Blur.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { BlurMaskFilterProps } from "../../../dom/types";
+import type { SkiaDefaultProps } from "../../processors/Animations/Animations";
+export declare const BlurMask: ({ style, respectCTM, ...props }: SkiaDefaultProps<BlurMaskFilterProps, "style" | "respectCTM">) => React.JSX.Element;

package/lib/typescript/src/renderer/components/maskFilters/index.d.ts

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