@shopify/react-native-skia 0.1.115

package/lib/typescript/src/renderer/components/text/TextPath.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { CustomPaintProps, AnimatedProps } from "../../processors";
+import type { SkPath } from "../../../skia/Path";
+import type { FontDef } from "../../processors/Font";
+export declare type TextPathProps = CustomPaintProps & FontDef & {
+    text: string;
+    path: SkPath | string;
+    initialOffset: number;
+};
+export declare const TextPath: {
+    (props: AnimatedProps<TextPathProps>): JSX.Element;
+    defaultProps: {
+        initialOffset: number;
+    };
+};

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

@@ -0,0 +1,4 @@
+export * from "./Text";
+export * from "./Glyphs";
+export * from "./TextBlob";
+export * from "./TextPath";

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

@@ -0,0 +1,3 @@
+export * from "./Canvas";
+export * from "./components";
+export * from "./nodes";

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

@@ -0,0 +1,8 @@
+import type { DependencyManager } from "../DependencyManager";
+import type { DrawingContext } from "../DrawingContext";
+import { Node } from "./Node";
+export declare class Container extends Node {
+    redraw: () => void;
+    constructor(depMgr: DependencyManager, redraw: () => void);
+    draw(ctx: DrawingContext): void;
+}

package/lib/typescript/src/renderer/nodes/Declaration.d.ts

@@ -0,0 +1,19 @@
+import type { DrawingContext } from "../DrawingContext";
+import type { SkJSIInstance } from "../../skia/JsiInstance";
+import type { AnimatedProps } from "../processors";
+import type { DependencyManager } from "../DependencyManager";
+import { Node } from "./Node";
+export declare type DeclarationResult = SkJSIInstance<string> | null;
+declare type DeclarationCallback<T> = (props: T, children: DeclarationResult[], ctx: DrawingContext) => DeclarationResult;
+export declare const createDeclaration: <T>(cb: DeclarationCallback<T>) => DeclarationCallback<T>;
+export interface DeclarationProps<P> {
+    onDeclare: DeclarationCallback<P>;
+}
+export declare class DeclarationNode<P> extends Node<P> {
+    private onDeclare;
+    constructor(depMgr: DependencyManager, onDeclare: DeclarationCallback<P>, props: AnimatedProps<P>);
+    set props(props: AnimatedProps<P>);
+    get props(): AnimatedProps<P>;
+    draw(ctx: DrawingContext): DeclarationResult;
+}
+export {};

package/lib/typescript/src/renderer/nodes/Drawing.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import type { DrawingContext } from "../DrawingContext";
+import type { AnimatedProps } from "../processors/Animations/Animations";
+import type { DependencyManager } from "../DependencyManager";
+import { Node } from "./Node";
+declare type DrawingCallback<P> = (ctx: DrawingContext, props: P, node: Node<P>) => void;
+declare type OnDrawCallback<P> = (ctx: DrawingContext, props: P, node: Node<P>) => void;
+export declare const createDrawing: <P>(cb: OnDrawCallback<P>) => DrawingCallback<P>;
+export declare type DrawingProps<T> = {
+    onDraw: DrawingCallback<T>;
+    skipProcessing?: boolean;
+    children?: ReactNode | ReactNode[];
+};
+export declare const Drawing: <P>(props: DrawingProps<P>) => JSX.Element;
+export declare class DrawingNode<P> extends Node<P> {
+    onDraw: DrawingCallback<P>;
+    skipProcessing: boolean;
+    constructor(depMgr: DependencyManager, onDraw: DrawingCallback<P>, skipProcessing: boolean, props: AnimatedProps<P>);
+    draw(ctx: DrawingContext): void;
+}
+export {};

package/lib/typescript/src/renderer/nodes/Node.d.ts

@@ -0,0 +1,23 @@
+import type { SkJSIInstance } from "../../skia/JsiInstance";
+import type { DependencyManager } from "../DependencyManager";
+import type { DrawingContext } from "../DrawingContext";
+import type { AnimatedProps } from "../processors";
+export declare enum NodeType {
+    Declaration = "skDeclaration",
+    Drawing = "skDrawing"
+}
+declare type DeclarationResult = SkJSIInstance<string> | null;
+export declare abstract class Node<P = unknown> {
+    readonly children: Node[];
+    _props: AnimatedProps<P>;
+    memoizable: boolean;
+    memoized: boolean;
+    parent?: Node;
+    depMgr: DependencyManager;
+    constructor(depMgr: DependencyManager, props: AnimatedProps<P>);
+    abstract draw(ctx: DrawingContext): void | DeclarationResult;
+    set props(props: AnimatedProps<P>);
+    get props(): AnimatedProps<P>;
+    visit(ctx: DrawingContext): SkJSIInstance<string>[];
+}
+export {};

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

@@ -0,0 +1,4 @@
+export * from "./Drawing";
+export * from "./Declaration";
+export * from "./Container";
+export * from "./Node";

package/lib/typescript/src/renderer/processors/Animations/Animations.d.ts

@@ -0,0 +1,9 @@
+import type { SkiaReadonlyValue } from "../../../values";
+import type { DrawingContext } from "../../DrawingContext";
+export declare type FrameValue<T> = (ctx: DrawingContext) => T;
+export declare const isValue: (value: unknown) => value is SkiaReadonlyValue<unknown>;
+export declare const isAnimated: <T>(props: AnimatedProps<T>) => boolean;
+export declare const materialize: <T>(props: AnimatedProps<T>) => T;
+export declare type AnimatedProps<T> = {
+    [K in keyof T]: T[K] | SkiaReadonlyValue<T[K]>;
+};

package/lib/typescript/src/renderer/processors/Animations/index.d.ts

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

package/lib/typescript/src/renderer/processors/Circles.d.ts

@@ -0,0 +1,13 @@
+import type { Vector } from "./math/Vector";
+interface PointCircleDef {
+    c: Vector;
+    r: number;
+}
+interface ScalarCircleDef {
+    cx: number;
+    cy: number;
+    r: number;
+}
+export declare type CircleDef = PointCircleDef | ScalarCircleDef;
+export declare const processCircle: (def: CircleDef) => PointCircleDef;
+export {};

package/lib/typescript/src/renderer/processors/Clips.d.ts

@@ -0,0 +1,5 @@
+import type { SkCanvas, ClipOp } from "../../skia/Canvas";
+import type { SkRect, SkRRect } from "../../skia";
+import type { PathDef } from "./Paths";
+export declare type ClipDef = SkRRect | SkRect | PathDef;
+export declare const processClip: (canvas: SkCanvas, def: ClipDef, op: ClipOp) => void;

package/lib/typescript/src/renderer/processors/Font.d.ts

@@ -0,0 +1,12 @@
+import type { SkFont } from "../../skia";
+import type { FontMgr } from "../../skia/FontMgr/FontMgr";
+export declare type FontDef = {
+    font: SkFont;
+} | {
+    familyName: string;
+    size: number;
+};
+export declare const isFont: (fontDef: FontDef) => fontDef is {
+    font: SkFont;
+};
+export declare const processFont: (fontMgr: FontMgr, fontDef: FontDef) => SkFont;

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

@@ -0,0 +1,21 @@
+import type { ReactNode, RefObject } from "react";
+import { BlendMode, PaintStyle, StrokeJoin, StrokeCap } from "../../skia";
+import type { SkPaint, Color } from "../../skia";
+export declare type SkEnum<T> = Uncapitalize<keyof T extends string ? keyof T : never>;
+export interface ChildrenProps {
+    children?: ReactNode | ReactNode[];
+}
+export interface CustomPaintProps extends ChildrenProps {
+    paint?: RefObject<SkPaint>;
+    color?: Color;
+    strokeWidth?: number;
+    blendMode?: SkEnum<typeof BlendMode>;
+    style?: SkEnum<typeof PaintStyle>;
+    strokeJoin?: SkEnum<typeof StrokeJoin>;
+    strokeCap?: SkEnum<typeof StrokeCap>;
+    strokeMiter?: number;
+    opacity?: number;
+}
+export declare const enumKey: <K extends string>(k: K) => Capitalize<K>;
+export declare const processPaint: (paint: SkPaint, currentOpacity: number, { color, blendMode, style, strokeWidth, strokeJoin, strokeCap, strokeMiter, opacity, }: CustomPaintProps) => void;
+export declare const selectPaint: (currentPaint: SkPaint, { paint, color: cl, blendMode, style: paintStyle, strokeWidth, strokeJoin, strokeCap, strokeMiter, opacity, }: CustomPaintProps) => SkPaint;

package/lib/typescript/src/renderer/processors/Paths.d.ts

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

package/lib/typescript/src/renderer/processors/Radius.d.ts

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

package/lib/typescript/src/renderer/processors/Rects.d.ts

@@ -0,0 +1,61 @@
+import type { SkRect, SkRRect } from "../../skia";
+import type { Radius } from "./Radius";
+export declare const point: (x: number, y: number) => {
+    x: number;
+    y: number;
+};
+export declare const rect: (x: number, y: number, width: number, height: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const rrect: (r: SkRect, rx: number, ry: number) => {
+    rect: SkRect;
+    rx: number;
+    ry: number;
+};
+export declare const bounds: (rects: SkRect[]) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const topLeft: (r: SkRect | SkRRect) => {
+    x: number;
+    y: number;
+};
+export declare const topRight: (r: SkRect | SkRRect) => {
+    x: number;
+    y: number;
+};
+export declare const bottomLeft: (r: SkRect | SkRRect) => {
+    x: number;
+    y: number;
+};
+export declare const bottomRight: (r: SkRect | SkRRect) => {
+    x: number;
+    y: number;
+};
+export declare const center: (r: SkRect | SkRRect) => {
+    x: number;
+    y: number;
+};
+export declare const isRRect: (def: SkRect | SkRRect) => def is SkRRect;
+export interface RectCtor {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface RRectCtor extends RectCtor {
+    r: Radius;
+}
+export declare type RectDef = RectCtor | {
+    rect: SkRect;
+};
+export declare type RRectDef = RRectCtor | {
+    rect: SkRRect;
+};
+export declare const processRect: (def: RectDef) => SkRect;
+export declare const processRRect: (def: RRectDef) => SkRRect;

package/lib/typescript/src/renderer/processors/Transform.d.ts

@@ -0,0 +1,91 @@
+import type { DrawingContext } from "../DrawingContext";
+import type { SkMatrix } from "../../skia/Matrix";
+import type { Transforms2d, Vector } from "./math";
+export interface TransformProps {
+    transform?: Transforms2d;
+    origin?: Vector;
+    matrix?: SkMatrix;
+}
+export declare const processTransform: ({ canvas }: DrawingContext, { transform, origin, matrix }: TransformProps) => void;
+export declare const localMatrix: ({ transform, origin }: TransformProps) => SkMatrix | undefined;
+export declare const transformOrigin: (origin: Vector, transform: Transforms2d) => (Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "translateX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "translateY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scale"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scaleX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "scaleY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "skewX"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "skewY"> | Pick<{
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly scale: number;
+    readonly skewX: number;
+    readonly skewY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotateZ: number;
+    readonly rotate: number;
+}, "rotate">)[];

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

@@ -0,0 +1,10 @@
+export * from "./Paint";
+export * from "./Transform";
+export * from "./Animations";
+export * from "./Circles";
+export * from "./Rects";
+export * from "./math";
+export * from "./Font";
+export * from "./Paths";
+export * from "./Clips";
+export * from "./Radius";

package/lib/typescript/src/renderer/processors/math/Coordinates.d.ts

@@ -0,0 +1,29 @@
+import type { Vector } from "./Vector";
+export interface PolarPoint {
+    theta: number;
+    radius: number;
+}
+export declare const canvas2Cartesian: (v: Vector, center: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const cartesian2Canvas: (v: Vector, center: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const cartesian2Polar: (v: Vector) => {
+    theta: number;
+    radius: number;
+};
+export declare const polar2Cartesian: (p: PolarPoint) => {
+    x: number;
+    y: number;
+};
+export declare const polar2Canvas: (p: PolarPoint, center: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const canvas2Polar: (v: Vector, center: Vector) => {
+    theta: number;
+    radius: number;
+};

package/lib/typescript/src/renderer/processors/math/Math.d.ts

@@ -0,0 +1 @@
+export declare const mix: (value: number, x: number, y: number) => number;

package/lib/typescript/src/renderer/processors/math/Matrix3.d.ts

@@ -0,0 +1,13 @@
+import type { SkMatrix } from "../../../skia/Matrix";
+export declare type Vec3 = readonly [number, number, number];
+export declare type Matrix3 = readonly [Vec3, Vec3, Vec3];
+declare type Transform2dName = "translateX" | "translateY" | "scale" | "skewX" | "skewY" | "scaleX" | "scaleY" | "rotateZ" | "rotate";
+export interface TransformProp {
+    transform?: Transforms2d;
+}
+declare type Transformations = {
+    readonly [Name in Transform2dName]: number;
+};
+export declare type Transforms2d = readonly (Pick<Transformations, "translateX"> | Pick<Transformations, "translateY"> | Pick<Transformations, "scale"> | Pick<Transformations, "scaleX"> | Pick<Transformations, "scaleY"> | Pick<Transformations, "skewX"> | Pick<Transformations, "skewY"> | Pick<Transformations, "rotate">)[];
+export declare const processTransform2d: (transforms: Transforms2d) => SkMatrix;
+export {};

package/lib/typescript/src/renderer/processors/math/Transforms.d.ts

@@ -0,0 +1,5 @@
+import type { Vector } from "./Vector";
+export declare const rotate: (tr: Vector, origin: Vector, rotation: number) => {
+    x: number;
+    y: number;
+};

package/lib/typescript/src/renderer/processors/math/Vector.d.ts

@@ -0,0 +1,35 @@
+import { interpolate } from "../../../values/animation/functions/interpolate";
+export interface Vector {
+    x: number;
+    y: number;
+}
+export declare const vec: (x?: number, y?: number | undefined) => {
+    x: number;
+    y: number;
+};
+export declare const neg: (a: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const add: (a: Vector, b: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const sub: (a: Vector, b: Vector) => {
+    x: number;
+    y: number;
+};
+export declare const dist: (a: Vector, b: Vector) => number;
+export declare const translate: ({ x, y }: Vector) => readonly [{
+    readonly translateX: number;
+}, {
+    readonly translateY: number;
+}];
+export declare const interpolateVector: (value: number, inputRange: readonly number[], outputRange: readonly Vector[], options?: Parameters<typeof interpolate>[3]) => {
+    x: number;
+    y: number;
+};
+export declare const mixVector: (value: number, from: Vector, to: Vector) => {
+    x: number;
+    y: number;
+};

package/lib/typescript/src/renderer/processors/math/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Vector";
+export * from "./Coordinates";
+export * from "./Matrix3";
+export * from "./Math";
+export * from "./Transforms";

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

@@ -0,0 +1,2 @@
+export declare const mapKeys: <T>(obj: T) => (keyof T)[];
+export declare const exhaustiveCheck: (a: never) => never;