@shopify/react-native-skia 0.1.123 → 0.1.126

package/lib/typescript/src/skia/Color.d.ts

@@ -1,9 +1,8 @@
-export declare type SkColor = number;
-export declare type Color = string | number;
-export declare const alphaf: (c: number) => number;
-export declare const red: (c: number) => number;
-export declare const green: (c: number) => number;
-export declare const blue: (c: number) => number;
-export declare const rgbaColor: (r: number, g: number, b: number, af: number) => number;
-export declare const processColor: (cl: Color, currentOpacity: number) => number;
-export declare const processColorAsUnitArray: (cl: Color, currentOpacity: number) => readonly [number, number, number, number];
+export declare type SkColor = Float32Array;
+export declare type Color = string | Float32Array | number;
+export declare const RED = 0;
+export declare const GREEN = 1;
+export declare const BLUE = 2;
+export declare const ALPHA = 3;
+export declare const rgbaColor: (r: number, g: number, b: number, a: number) => Float32Array;
+export declare const processColor: (cl: Color, currentOpacity: number) => Float32Array;

package/lib/typescript/src/skia/ImageFilter/ImageFilterFactory.d.ts

@@ -3,6 +3,7 @@ import type { SkColorFilter } from "../ColorFilter/ColorFilter";
 import type { SkShader } from "../Shader/Shader";
 import type { SkRect } from "../Rect";
 import type { BlendMode } from "../Paint/BlendMode";
+import type { SkRuntimeShaderBuilder } from "../RuntimeEffect";
 import type { SkImageFilter, TileMode } from "./ImageFilter";
 export declare enum ColorChannel {
     R = 0,
@@ -111,4 +112,19 @@ export interface ImageFilterFactory {
      *  @cropRect         Optional rectangle to crop input and output.
      */
     MakeBlend: (mode: BlendMode, background: SkImageFilter, foreground: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     *  Create a filter that fills the output with the per-pixel evaluation of the SkShader produced
+     *  by the SkRuntimeShaderBuilder. The shader is defined in the image filter's local coordinate
+     *  system, so it will automatically be affected by SkCanvas' transform.
+     *
+     *  @param builder         The builder used to produce the runtime shader, that will in turn
+     *                         fill the result image
+     *  @param childShaderName The name of the child shader defined in the builder that will be
+     *                         bound to the input param (or the source image if the input param
+     *                         is null).  If null the builder can have exactly one child shader,
+     *                         which automatically binds the input param.
+     *  @param input           The image filter that will be provided as input to the runtime
+     *                         shader. If null the implicit source image is used instead
+     */
+    MakeRuntimeShader: (builder: SkRuntimeShaderBuilder, childShaderName: string | null, input: SkImageFilter | null) => SkImageFilter;
 }

package/lib/typescript/src/skia/Matrix.d.ts

@@ -1,3 +1,4 @@
+import type { SkJSIInstance } from "./JsiInstance";
 export declare enum MatrixIndex {
     ScaleX = 0,
     SkewX = 1,
@@ -9,7 +10,7 @@ export declare enum MatrixIndex {
     Persp1 = 7,
     persp2 = 8
 }
-export interface SkMatrix {
+export interface SkMatrix extends SkJSIInstance<"Matrix"> {
     0: number;
     1: number;
     2: number;
@@ -19,4 +20,9 @@ export interface SkMatrix {
     6: number;
     7: number;
     8: number;
+    preConcat: (matrix: SkMatrix) => void;
+    preTranslate: (x: number, y: number) => void;
+    preScale: (x: number, y: number) => void;
+    preSkew: (x: number, y: number) => void;
+    preRotate: (theta: number) => void;
 }

package/lib/typescript/src/skia/RuntimeEffect/RuntimeEffect.d.ts

@@ -8,7 +8,8 @@ export interface SkSLUniform {
     slot: number;
     isInteger: boolean;
 }
-export interface IRuntimeEffect extends SkJSIInstance<"RuntimeEffect"> {
+export declare type SkRuntimeShaderBuilder = SkJSIInstance<"RuntimeShaderBuilder">;
+export interface SkRuntimeEffect extends SkJSIInstance<"RuntimeEffect"> {
     /**
      * Returns a shader executed using the given uniform data.
      * @param uniforms

package/lib/typescript/src/skia/RuntimeEffect/RuntimeEffectFactory.d.ts

@@ -1,4 +1,4 @@
-import type { IRuntimeEffect } from "./RuntimeEffect";
+import type { SkRuntimeEffect } from "./RuntimeEffect";
 export interface RuntimeEffectFactory {
     /**
      * Compiles a RuntimeEffect from the given shader code.
@@ -6,5 +6,5 @@ export interface RuntimeEffectFactory {
      * @param callback - will be called with any compilation error. If not provided, errors will
      *                   be printed to console.log().
      */
-    Make: (sksl: string) => IRuntimeEffect | null;
+    Make: (sksl: string) => SkRuntimeEffect | null;
 }

package/lib/typescript/src/skia/Shader/useShader.d.ts

@@ -1 +1 @@
-export declare const useShader: (sksl: string) => import("..").IRuntimeEffect | null;
+export declare const useShader: (sksl: string) => import("..").SkRuntimeEffect | null;

package/lib/typescript/src/skia/Skia.d.ts

@@ -1,108 +1,41 @@
-import type { ImageFilterFactory } from "./ImageFilter";
-import type { PathFactory } from "./Path";
-import type { ColorFilterFactory } from "./ColorFilter";
-import type { SkFont } from "./Font";
-import type { SkTypeface, TypefaceFactory } from "./Typeface";
-import type { ImageFactory } from "./Image";
-import type { MaskFilterFactory } from "./MaskFilter";
-import type { SkPaint } from "./Paint";
-import type { SkRect } from "./Rect";
-import type { SkRRect } from "./RRect";
-import type { RuntimeEffectFactory } from "./RuntimeEffect";
-import type { ShaderFactory } from "./Shader";
-import type { SkMatrix } from "./Matrix";
-import type { PathEffectFactory } from "./PathEffect";
-import type { SkPoint } from "./Point";
-import type { SkVertices, VertexMode } from "./Vertices/Vertices";
-import type { DataFactory } from "./Data";
-import type { SVGFactory } from "./SVG";
-import type { TextBlobFactory } from "./TextBlob";
-import type { FontMgrFactory } from "./FontMgr/FontMgrFactory";
-import type { SurfaceFactory } from "./Surface";
 import "./NativeSetup";
-import type { SkRSXform } from "./RSXform";
-import type { SkPath } from "./Path/Path";
-import type { SkContourMeasureIter } from "./ContourMeasure";
-import type { PictureFactory, SkPictureRecorder } from "./Picture";
-import type { Color, SkColor } from "./Color";
-/**
- * Declares the interface for the native Skia API
- */
-export interface Skia {
-    Point: (x: number, y: number) => SkPoint;
-    XYWHRect: (x: number, y: number, width: number, height: number) => SkRect;
-    RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
-    RSXform: (scos: number, ssin: number, tx: number, ty: number) => SkRSXform;
-    Color: (color: Color) => SkColor;
-    parseColorString: (color: string) => SkColor | undefined;
-    ContourMeasureIter: (path: SkPath, forceClosed: boolean, resScale: number) => SkContourMeasureIter;
-    Paint: () => SkPaint;
-    PictureRecorder: () => SkPictureRecorder;
-    Picture: PictureFactory;
-    Path: PathFactory;
-    Matrix: () => SkMatrix;
-    ColorFilter: ColorFilterFactory;
-    Font: (typeface?: SkTypeface, size?: number) => SkFont;
-    Typeface: TypefaceFactory;
-    MaskFilter: MaskFilterFactory;
-    RuntimeEffect: RuntimeEffectFactory;
-    ImageFilter: ImageFilterFactory;
-    Shader: ShaderFactory;
-    PathEffect: PathEffectFactory;
-    /**
-     * Returns an Vertices based on the given positions and optional parameters.
-     * See SkVertices.h (especially the Builder) for more details.
-     * @param mode
-     * @param positions
-     * @param textureCoordinates
-     * @param colors - either a list of int colors or a flattened color array.
-     * @param indices
-     * @param isVolatile
-     */
-    MakeVertices(mode: VertexMode, positions: SkPoint[], textureCoordinates?: SkPoint[] | null, colors?: SkColor[], indices?: number[] | null, isVolatile?: boolean): SkVertices;
-    Data: DataFactory;
-    Image: ImageFactory;
-    SVG: SVGFactory;
-    FontMgr: FontMgrFactory;
-    TextBlob: TextBlobFactory;
-    Surface: SurfaceFactory;
-}
+import type { SkiaApi as SkSkiaApi } from "./SkiaApi";
 /**
  * Declares the SkiaApi as an available object in the global scope
  */
 declare global {
-    var SkiaApi: Skia;
+    var SkiaApi: SkSkiaApi;
 }
 /**
  * Declares the implemented API with overrides.
  */
 export declare const Skia: {
-    Typeface: TypefaceFactory;
-    MaskFilter: MaskFilterFactory;
-    RuntimeEffect: RuntimeEffectFactory;
-    Shader: ShaderFactory;
-    ImageFilter: ImageFilterFactory;
-    PathEffect: PathEffectFactory;
-    Data: DataFactory;
-    SVG: SVGFactory;
-    FontMgr: FontMgrFactory;
-    TextBlob: TextBlobFactory;
-    Matrix: () => SkMatrix;
-    Font: (typeface?: SkTypeface | undefined, size?: number | undefined) => SkFont;
-    Point: (x: number, y: number) => SkPoint;
-    XYWHRect: (x: number, y: number, width: number, height: number) => SkRect;
-    RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
-    Paint: () => SkPaint;
-    PictureRecorder: () => SkPictureRecorder;
-    Picture: PictureFactory;
-    Path: PathFactory;
-    ColorFilter: ColorFilterFactory;
-    ContourMeasureIter: (path: SkPath, forceClosed: boolean, resScale: number) => SkContourMeasureIter;
-    Color: (cl: Color) => number;
-    parseColorString: (color: string) => SkColor | undefined;
-    RSXform: (scos: number, ssin: number, tx: number, ty: number) => SkRSXform;
-    MakeSurface: (width: number, height: number) => import("./Surface").ISurface | null;
+    Typeface: import("./Typeface").TypefaceFactory;
+    MaskFilter: import("./MaskFilter").MaskFilterFactory;
+    RuntimeEffect: import("./RuntimeEffect").RuntimeEffectFactory;
+    Shader: import("./Shader").ShaderFactory;
+    ImageFilter: import("./ImageFilter").ImageFilterFactory;
+    PathEffect: import("./PathEffect").PathEffectFactory;
+    Data: import("./Data").DataFactory;
+    SVG: import("./SVG").SVGFactory;
+    FontMgr: import("./FontMgr").FontMgrFactory;
+    TextBlob: import("./TextBlob").TextBlobFactory;
+    Matrix: () => import("./Matrix").SkMatrix;
+    Font: (typeface?: import("./Typeface").SkTypeface | undefined, size?: number | undefined) => import("./Font").SkFont;
+    Point: (x: number, y: number) => import("./Point").SkPoint;
+    XYWHRect: (x: number, y: number, width: number, height: number) => import("./Rect").SkRect;
+    RRectXY: (rect: import("./Rect").SkRect, rx: number, ry: number) => import("./RRect").SkRRect;
+    RuntimeShaderBuilder: (rt: import("./RuntimeEffect").SkRuntimeEffect) => import("./RuntimeEffect").SkRuntimeShaderBuilder;
+    Paint: () => import("./Paint").SkPaint;
+    PictureRecorder: () => import("./Picture").SkPictureRecorder;
+    Picture: import("./Picture").PictureFactory;
+    Path: import("./Path").PathFactory;
+    ColorFilter: import("./ColorFilter").ColorFilterFactory;
+    ContourMeasureIter: (path: import("./Path").SkPath, forceClosed: boolean, resScale: number) => import("./ContourMeasure").SkContourMeasureIter;
+    Color: (color: import("./Color").Color) => Float32Array;
+    RSXform: (scos: number, ssin: number, tx: number, ty: number) => import("./RSXform").SkRSXform;
+    MakeSurface: (width: number, height: number) => import("./Surface").SkSurface | null;
     MakeImageFromEncoded: (encoded: import("./Data").Data) => import("./Image").SkImage | null;
     MakeImage: (info: import("./Image").ImageInfo, data: import("./Data").Data, bytesPerRow: number) => import("./Image").SkImage | null;
-    MakeVertices: (mode: VertexMode, positions: SkPoint[], textureCoordinates?: SkPoint[] | null | undefined, colors?: number[] | undefined, indices?: number[] | null | undefined, isVolatile?: boolean | undefined) => SkVertices;
+    MakeVertices: (mode: import("./Vertices").VertexMode, positions: import("./Point").SkPoint[], textureCoordinates?: import("./Point").SkPoint[] | null | undefined, colors?: Float32Array[] | undefined, indices?: number[] | null | undefined, isVolatile?: boolean | undefined) => import("./Vertices").SkVertices;
 };

package/lib/typescript/src/skia/SkiaApi.d.ts

@@ -0,0 +1,71 @@
+import type { ImageFilterFactory } from "./ImageFilter";
+import type { PathFactory } from "./Path";
+import type { ColorFilterFactory } from "./ColorFilter";
+import type { SkFont } from "./Font";
+import type { SkTypeface, TypefaceFactory } from "./Typeface";
+import type { ImageFactory } from "./Image";
+import type { MaskFilterFactory } from "./MaskFilter";
+import type { SkPaint } from "./Paint";
+import type { SkRect } from "./Rect";
+import type { SkRRect } from "./RRect";
+import type { RuntimeEffectFactory } from "./RuntimeEffect";
+import type { ShaderFactory } from "./Shader";
+import type { SkMatrix } from "./Matrix";
+import type { PathEffectFactory } from "./PathEffect";
+import type { SkPoint } from "./Point";
+import type { SkVertices, VertexMode } from "./Vertices/Vertices";
+import type { DataFactory } from "./Data";
+import type { SVGFactory } from "./SVG";
+import type { TextBlobFactory } from "./TextBlob";
+import type { FontMgrFactory } from "./FontMgr/FontMgrFactory";
+import type { SurfaceFactory } from "./Surface";
+import "./NativeSetup";
+import type { SkRSXform } from "./RSXform";
+import type { SkPath } from "./Path/Path";
+import type { SkContourMeasureIter } from "./ContourMeasure";
+import type { PictureFactory, SkPictureRecorder } from "./Picture";
+import type { Color, SkColor } from "./Color";
+import type { SkRuntimeShaderBuilder, SkRuntimeEffect } from "./RuntimeEffect/RuntimeEffect";
+/**
+ * Declares the interface for the native Skia API
+ */
+export interface SkiaApi {
+    Point: (x: number, y: number) => SkPoint;
+    XYWHRect: (x: number, y: number, width: number, height: number) => SkRect;
+    RuntimeShaderBuilder: (rt: SkRuntimeEffect) => SkRuntimeShaderBuilder;
+    RRectXY: (rect: SkRect, rx: number, ry: number) => SkRRect;
+    RSXform: (scos: number, ssin: number, tx: number, ty: number) => SkRSXform;
+    Color: (color: Color) => SkColor;
+    parseColorString: (color: string) => SkColor | undefined;
+    ContourMeasureIter: (path: SkPath, forceClosed: boolean, resScale: number) => SkContourMeasureIter;
+    Paint: () => SkPaint;
+    PictureRecorder: () => SkPictureRecorder;
+    Picture: PictureFactory;
+    Path: PathFactory;
+    Matrix: () => SkMatrix;
+    ColorFilter: ColorFilterFactory;
+    Font: (typeface?: SkTypeface, size?: number) => SkFont;
+    Typeface: TypefaceFactory;
+    MaskFilter: MaskFilterFactory;
+    RuntimeEffect: RuntimeEffectFactory;
+    ImageFilter: ImageFilterFactory;
+    Shader: ShaderFactory;
+    PathEffect: PathEffectFactory;
+    /**
+     * Returns an Vertices based on the given positions and optional parameters.
+     * See SkVertices.h (especially the Builder) for more details.
+     * @param mode
+     * @param positions
+     * @param textureCoordinates
+     * @param colors - either a list of int colors or a flattened color array.
+     * @param indices
+     * @param isVolatile
+     */
+    MakeVertices(mode: VertexMode, positions: SkPoint[], textureCoordinates?: SkPoint[] | null, colors?: SkColor[], indices?: number[] | null, isVolatile?: boolean): SkVertices;
+    Data: DataFactory;
+    Image: ImageFactory;
+    SVG: SVGFactory;
+    FontMgr: FontMgrFactory;
+    TextBlob: TextBlobFactory;
+    Surface: SurfaceFactory;
+}

package/lib/typescript/src/skia/Surface/Surface.d.ts

@@ -2,7 +2,7 @@ import type { SkImage } from "../Image";
 import type { SkCanvas } from "../Canvas";
 import type { SkJSIInstance } from "../JsiInstance";
 import type { SkRect } from "../Rect";
-export interface ISurface extends SkJSIInstance<"Surface"> {
+export interface SkSurface extends SkJSIInstance<"Surface"> {
     /** Returns Canvas that draws into the surface. Subsequent calls return the
        same Canvas. Canvas returned is managed and owned by Surface, and is
        deleted when Surface is deleted.

package/lib/typescript/src/skia/Surface/SurfaceFactory.d.ts

@@ -1,4 +1,4 @@
-import type { ISurface } from "./Surface";
+import type { SkSurface } from "./Surface";
 export interface SurfaceFactory {
     /**
      * Returns a CPU backed surface with the given dimensions, an SRGB colorspace, Unpremul
@@ -7,5 +7,5 @@ export interface SurfaceFactory {
      * @param width - number of pixels of the width of the drawable area.
      * @param height - number of pixels of the height of the drawable area.
      */
-    Make: (width: number, height: number) => ISurface | null;
+    Make: (width: number, height: number) => SkSurface | null;
 }

package/lib/typescript/src/values/api.d.ts

@@ -1,29 +1,6 @@
-import type { SkiaAnimation, AnimationState, SkiaReadonlyValue, SkiaClockValue, SkiaValue } from "./types";
-export interface ISkiaValueApi {
-    /**
-     * Creates a new value that holds the initial value and that
-     * can be changed.
-     */
-    createValue: <T>(initialValue: T) => SkiaValue<T>;
-    /**
-     * Creates a derived value. This is a calculated value that returns the result of
-     * a function that is called with the values of the dependencies.
-     */
-    createDerivedValue: <R>(cb: () => R, values: Array<SkiaReadonlyValue<unknown>>) => SkiaReadonlyValue<R>;
-    /**
-     * Creates a clock value where the value is the number of milliseconds elapsed
-     * since the clock was created
-     */
-    createClockValue: () => SkiaClockValue;
-    /**
-     * Creates an animation that is driven from a clock and updated every frame.
-     * @param cb Callback to calculate next value from time.
-     * @returns An animation object that can control a value.
-     */
-    createAnimation: <S extends AnimationState = AnimationState>(cb: (t: number, state: S | undefined) => S) => SkiaAnimation;
-}
+import type { ISkiaValueApi } from "./types";
 declare global {
     var SkiaValueApi: ISkiaValueApi;
 }
 export declare const ValueApi: ISkiaValueApi;
-export declare const createValue: <T>(initialValue: T) => SkiaValue<T>, createDerivedValue: <R>(cb: () => R, values: Array<SkiaReadonlyValue<unknown>>) => SkiaReadonlyValue<R>;
+export declare const createValue: <T>(initialValue: T) => import("./types").SkiaValue<T>, createDerivedValue: <R>(cb: () => R, values: import("./types").SkiaReadonlyValue<unknown>[]) => import("./types").SkiaReadonlyValue<R>;

package/lib/typescript/src/values/api.web.d.ts

@@ -0,0 +1,2 @@
+export declare const ValueApi: import("./types").ISkiaValueApi;
+export declare const createValue: <T>(initialValue: T) => import("./types").SkiaValue<T>, createDerivedValue: <R>(cb: () => R, values: import("./types").SkiaReadonlyValue<unknown>[]) => import("./types").SkiaReadonlyValue<R>;

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

@@ -1,4 +1,3 @@
 export * from "./types";
 export * from "./hooks";
-export * from "./animation";
 export * from "./api";

package/lib/typescript/src/values/types.d.ts

@@ -27,10 +27,33 @@ export interface SkiaClockValue extends SkiaReadonlyValue<number> {
     start: () => void;
     stop: () => void;
 }
-export interface SkiaAnimation {
+export interface SkiaAnimation extends SkiaClockValue {
     cancel: () => void;
 }
 export interface AnimationState {
     current: number;
     finished: boolean;
 }
+export interface ISkiaValueApi {
+    /**
+     * Creates a new value that holds the initial value and that
+     * can be changed.
+     */
+    createValue: <T>(initialValue: T) => SkiaValue<T>;
+    /**
+     * Creates a derived value. This is a calculated value that returns the result of
+     * a function that is called with the values of the dependencies.
+     */
+    createDerivedValue: <R>(cb: () => R, values: Array<SkiaReadonlyValue<unknown>>) => SkiaReadonlyValue<R>;
+    /**
+     * Creates a clock value where the value is the number of milliseconds elapsed
+     * since the clock was created
+     */
+    createClockValue: () => SkiaClockValue;
+    /**
+     * Creates an animation that is driven from a clock and updated every frame.
+     * @param cb Callback to calculate next value from time.
+     * @returns An animation object that can control a value.
+     */
+    createAnimation: <S extends AnimationState = AnimationState>(cb: (t: number, state: S | undefined) => S) => SkiaAnimation;
+}

package/lib/typescript/src/values/web/RNSkAnimation.d.ts

@@ -0,0 +1,9 @@
+import type { AnimationState, SkiaAnimation } from "../types";
+import { RNSkClockValue } from "./RNSkClockValue";
+export declare class RNSkAnimation<S extends AnimationState = AnimationState> extends RNSkClockValue implements SkiaAnimation {
+    constructor(callback: (t: number, state: S | undefined) => S, raf: (callback: (time: number) => void) => number);
+    private _callback;
+    private _animationState;
+    cancel(): void;
+    protected update(nextValue: number): void;
+}

package/lib/typescript/src/values/web/RNSkClockValue.d.ts

@@ -0,0 +1,13 @@
+import type { SkiaClockValue } from "../types";
+import { RNSkReadonlyValue } from "./RNSkReadonlyValue";
+export declare class RNSkClockValue extends RNSkReadonlyValue<number> implements SkiaClockValue {
+    constructor(raf: (callback: (time: number) => void) => number);
+    private _raf;
+    private _start;
+    private _stop;
+    private _state;
+    private notifyUpdate;
+    protected tick(value: number): void;
+    start(): void;
+    stop(): void;
+}

package/lib/typescript/src/values/web/RNSkDerivedValue.d.ts

@@ -0,0 +1,9 @@
+import type { DependencyList } from "react";
+import { RNSkReadonlyValue } from "./RNSkReadonlyValue";
+export declare class RNSkDerivedValue<T> extends RNSkReadonlyValue<T> {
+    constructor(callback: () => T, dependencies: DependencyList);
+    private dependecyUpdated;
+    private _callback;
+    private _unsubscribers;
+    unsubscribe(): void;
+}

package/lib/typescript/src/values/web/RNSkReadonlyValue.d.ts

@@ -0,0 +1,11 @@
+import type { SkiaReadonlyValue } from "../types";
+export declare class RNSkReadonlyValue<T> implements SkiaReadonlyValue<T> {
+    constructor(value: T);
+    private _current;
+    private _listeners;
+    private notifyListeners;
+    protected update(nextValue: T): void;
+    readonly __typename__ = "RNSkValue";
+    get current(): T;
+    addListener(cb: (value: T) => void): () => void;
+}

package/lib/typescript/src/values/web/RNSkValue.d.ts

@@ -0,0 +1,14 @@
+import type { SkiaAnimation, SkiaValue } from "../types";
+import { RNSkReadonlyValue } from "./RNSkReadonlyValue";
+export declare class RNSkValue<T> extends RNSkReadonlyValue<T> implements SkiaValue<T> {
+    constructor(value: T);
+    set current(value: T);
+    get current(): T;
+    private _unsubscribe;
+    private unsubscribe;
+    private subscribe;
+    private animationDidUpdate;
+    private _animation;
+    get animation(): SkiaAnimation | undefined;
+    set animation(v: SkiaAnimation | undefined);
+}

package/lib/typescript/src/values/web/api.d.ts

@@ -0,0 +1,2 @@
+import type { ISkiaValueApi } from "../types";
+export declare const ValueApi: ISkiaValueApi;

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

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

package/lib/typescript/src/views/SkiaView.d.ts

@@ -1,40 +1,7 @@
 import React from "react";
-import type { ViewProps } from "react-native";
-import type { SkImage, SkRect } from "../skia";
+import type { SkRect } from "../skia";
 import type { SkiaReadonlyValue } from "../values";
-import type { DrawMode, RNSkiaDrawCallback } from "./types";
-declare global {
-    var SkiaViewApi: {
-        invalidateSkiaView: (nativeId: number) => void;
-        makeImageSnapshot: (nativeId: number, rect?: SkRect) => SkImage;
-        setDrawCallback: (nativeId: number, callback: RNSkiaDrawCallback | undefined) => void;
-        setDrawMode: (nativeId: number, mode: DrawMode) => void;
-        registerValuesInView: (nativeId: number, values: SkiaReadonlyValue<unknown>[]) => () => void;
-    };
-}
-export interface SkiaViewProps extends ViewProps {
-    /**
-     * Sets the drawing mode for the skia view. There are two drawing
-     * modes, "continuous" and "default", where the continuous mode will
-     * continuously redraw the view, and the default mode will only
-     * redraw when any of the regular react properties are changed like
-     * sizes and margins.
-     */
-    mode?: DrawMode;
-    /**
-     * When set to true the view will display information about the
-     * average time it takes to render.
-     */
-    debug?: boolean;
-    /**
-     * Draw callback. Will be called whenever the view is invalidated and
-     * needs to redraw. This is either caused by a change in a react
-     * property, a touch event, or a call to redraw. If the view is in
-     * continuous mode the callback will be called 60 frames per second
-     * by the native view.
-     */
-    onDraw?: RNSkiaDrawCallback;
-}
+import type { DrawMode, SkiaViewProps } from "./types";
 export declare class SkiaView extends React.Component<SkiaViewProps> {
     constructor(props: SkiaViewProps);
     private _nativeId;
@@ -45,7 +12,7 @@ export declare class SkiaView extends React.Component<SkiaViewProps> {
      * @param rect Rect to use as bounds. Optional.
      * @returns An Image object.
      */
-    makeImageSnapshot(rect?: SkRect): SkImage;
+    makeImageSnapshot(rect?: SkRect): import("../skia").SkImage;
     /**
      * Sends a redraw request to the native SkiaView.
      */

package/lib/typescript/src/views/api.d.ts

@@ -0,0 +1,5 @@
+import type { ISkiaViewApi } from "./types";
+declare global {
+    var SkiaViewApi: ISkiaViewApi;
+}
+export declare const SkiaViewApi: ISkiaViewApi;

package/lib/typescript/src/views/types.d.ts

@@ -1,5 +1,7 @@
 import type { ViewProps } from "react-native";
+import type { SkImage, SkRect } from "../skia";
 import type { SkCanvas } from "../skia/Canvas";
+import type { SkiaReadonlyValue } from "../values";
 export declare type DrawMode = "continuous" | "default";
 export declare type NativeSkiaViewProps = ViewProps & {
     mode?: DrawMode;
@@ -42,3 +44,33 @@ export interface ValueListener {
     addListener: (callback: () => void) => number;
     removeListener: (id: number) => void;
 }
+export interface ISkiaViewApi {
+    invalidateSkiaView: (nativeId: number) => void;
+    makeImageSnapshot: (nativeId: number, rect?: SkRect) => SkImage;
+    setDrawCallback: (nativeId: number, callback: RNSkiaDrawCallback | undefined) => void;
+    setDrawMode: (nativeId: number, mode: DrawMode) => void;
+    registerValuesInView: (nativeId: number, values: SkiaReadonlyValue<unknown>[]) => () => void;
+}
+export interface SkiaViewProps extends ViewProps {
+    /**
+     * Sets the drawing mode for the skia view. There are two drawing
+     * modes, "continuous" and "default", where the continuous mode will
+     * continuously redraw the view, and the default mode will only
+     * redraw when any of the regular react properties are changed like
+     * sizes and margins.
+     */
+    mode?: DrawMode;
+    /**
+     * When set to true the view will display information about the
+     * average time it takes to render.
+     */
+    debug?: boolean;
+    /**
+     * Draw callback. Will be called whenever the view is invalidated and
+     * needs to redraw. This is either caused by a change in a react
+     * property, a touch event, or a call to redraw. If the view is in
+     * continuous mode the callback will be called 60 frames per second
+     * by the native view.
+     */
+    onDraw?: RNSkiaDrawCallback;
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "title": "React Native Skia",
-  "version": "0.1.123",
+  "version": "0.1.126",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "files": [
@@ -76,7 +76,7 @@
     "react-native": "0.66.2",
     "react-native-builder-bob": "^0.18.2",
     "ts-jest": "^27.0.7",
-    "typescript": "^4.6.2"
+    "typescript": "^4.6.4"
   },
   "dependencies": {
     "react-reconciler": "^0.26.2"

package/src/{values/animation → animation}/decay/runDecay.ts

@@ -1,5 +1,5 @@
-import { ValueApi } from "../../api";
-import type { SkiaValue } from "../../types";
+import { ValueApi } from "../../values/api";
+import type { SkiaValue } from "../../values/types";
 
 import { decay } from "./decay";
 import type { DecayConfig, DefaultDecayConfig, DecayState } from "./types";

package/src/{values/animation → animation}/decay/types.ts

@@ -1,4 +1,4 @@
-import type { AnimationState } from "../../types";
+import type { AnimationState } from "../../values/types";
 
 export interface DecayConfig {
   from?: number;