@shopify/react-native-skia 0.1.171 → 0.1.172

package/lib/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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;

package/lib/commonjs/renderer/components/Mask.d.ts

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

package/lib/commonjs/renderer/components/Paint.d.ts

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

package/lib/commonjs/renderer/components/Picture.d.ts

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

package/lib/commonjs/renderer/components/backdrop/BackdropBlur.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="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>) => JSX.Element;
+export {};

package/lib/commonjs/renderer/components/backdrop/BackdropFilter.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } 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, ...props }: SkiaProps<BackdropFilterProps, "filter">) => JSX.Element;

package/lib/commonjs/renderer/components/backdrop/index.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/BlendColor.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/Lerp.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/LinearToSRGBGamma.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/LumaColorFilter.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/Matrix.d.ts

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

package/lib/commonjs/renderer/components/colorFilters/SRGBToLinearGamma.d.ts

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

package/lib/commonjs/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/commonjs/renderer/components/image/Image.d.ts

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

package/lib/commonjs/renderer/components/image/ImageSVG.d.ts

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

package/lib/commonjs/renderer/components/image/ImageShader.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="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">) => JSX.Element;

package/lib/commonjs/renderer/components/image/index.d.ts

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

package/lib/commonjs/renderer/components/imageFilters/Blur.d.ts

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

package/lib/commonjs/renderer/components/imageFilters/DisplacementMap.d.ts

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

package/lib/commonjs/renderer/components/imageFilters/Morphology.d.ts

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

package/lib/commonjs/renderer/components/imageFilters/Offset.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="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">) => JSX.Element;

package/lib/commonjs/renderer/components/imageFilters/RuntimeShader.d.ts

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

package/lib/commonjs/renderer/components/imageFilters/Shadow.d.ts

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

package/lib/commonjs/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/commonjs/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 "./Drawing";

package/lib/commonjs/renderer/components/maskFilters/Blur.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="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">) => JSX.Element;

package/lib/commonjs/renderer/components/maskFilters/index.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Corner.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Dash.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Discrete.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Line2D.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Path1D.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Path2D.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/Sum.d.ts

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

package/lib/commonjs/renderer/components/pathEffects/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Discrete";
+export * from "./Dash";
+export * from "./Corner";
+export * from "./Sum";
+export * from "./Line2D";
+export * from "./Path1D";
+export * from "./Path2D";

package/lib/commonjs/renderer/components/shaders/Color.d.ts

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

package/lib/commonjs/renderer/components/shaders/FractalNoise.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { FractalNoiseProps } from "../../../dom/types";
+import type { SkiaDefaultProps } from "../../processors/Animations/Animations";
+export declare const FractalNoise: ({ seed, tileWidth, tileHeight, ...props }: SkiaDefaultProps<FractalNoiseProps, "seed" | "tileHeight" | "tileWidth">) => JSX.Element;

package/lib/commonjs/renderer/components/shaders/LinearGradient.d.ts

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

package/lib/commonjs/renderer/components/shaders/RadialGradient.d.ts

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

package/lib/commonjs/renderer/components/shaders/Shader.d.ts

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

package/lib/commonjs/renderer/components/shaders/ShaderLib.d.ts

@@ -0,0 +1,4 @@
+export declare const ShaderLib: {
+    Math: string;
+    Colors: string;
+};

package/lib/commonjs/renderer/components/shaders/SweepGradient.d.ts

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

package/lib/commonjs/renderer/components/shaders/Turbulence.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { TurbulenceProps } from "../../../dom/types";
+import type { SkiaDefaultProps } from "../../processors/Animations/Animations";
+export declare const Turbulence: ({ seed, tileWidth, tileHeight, ...props }: SkiaDefaultProps<TurbulenceProps, "seed" | "tileWidth" | "tileHeight">) => JSX.Element;

package/lib/commonjs/renderer/components/shaders/TwoPointConicalGradient.d.ts

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

package/lib/commonjs/renderer/components/shaders/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./RadialGradient";
+export * from "./LinearGradient";
+export * from "./TwoPointConicalGradient";
+export * from "./SweepGradient";
+export * from "./Color";
+export * from "./Turbulence";
+export * from "./FractalNoise";
+export * from "./Shader";
+export * from "./ShaderLib";

package/lib/commonjs/renderer/components/shapes/Box.d.ts

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

package/lib/commonjs/renderer/components/shapes/Circle.d.ts

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

package/lib/commonjs/renderer/components/shapes/DiffRect.d.ts

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

package/lib/commonjs/renderer/components/shapes/Fill.d.ts

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

package/lib/commonjs/renderer/components/shapes/FitBox.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { Fit } from "../../../dom/nodes";
+import type { SkRect } from "../../../skia/types";
+interface FitProps {
+    fit?: Fit;
+    src: SkRect;
+    dst: SkRect;
+    children: ReactNode | ReactNode[];
+}
+export declare const fitbox: (fit: Fit, src: SkRect, dst: SkRect) => readonly [{
+    readonly translateX: number;
+}, {
+    readonly translateY: number;
+}, {
+    readonly scaleX: number;
+}, {
+    readonly scaleY: number;
+}];
+export declare const FitBox: ({ fit, src, dst, children }: FitProps) => JSX.Element;
+export {};