@shopify/react-native-skia 0.1.170 → 0.1.172

package/android/CMakeLists.txt

@@ -12,6 +12,11 @@ set (SKIA_SKSHAPER_LIB "skshaper")
 #set (SKIA_SKPARAGRAPH_LIB "skparagraph")
 #set (SKIA_SKUNICODE_LIB "skunicode")
 
+# Clear some variables
+unset(LIBRN_DIR CACHE)
+unset(libfbjni_link_DIRS CACHE)
+unset(libfbjni_include_DIRS CACHE)
+
 set(build_DIR ${CMAKE_SOURCE_DIR}/build)
 file(GLOB LIBRN_DIR "${PREBUILT_DIR}/${ANDROID_ABI}")
 file(GLOB libfbjni_link_DIRS "${build_DIR}/fbjni*.aar/jni/${ANDROID_ABI}")
@@ -114,49 +119,72 @@ find_library(
         LOG_LIB
         log
 )
-
 message("-- LOG     : " ${LOG_LIB})
 
- if(${REACT_NATIVE_VERSION} LESS 66)
-         # JSI lib didn't exist on RN 0.65 and before. Simply omit it.
-         set (JSI_LIB "")
- else()
-         # RN 0.66 distributes libjsi.so, can be used instead of compiling jsi.cpp manually.
-         find_library(
-                 JSI_LIB
-                 jsi
-                 PATHS ${LIBRN_DIR}
-                 NO_CMAKE_FIND_ROOT_PATH
-         )
- endif()
-
- message("-- JSI     : " ${JSI_LIB})
+if(${REACT_NATIVE_VERSION} GREATER_EQUAL 71)
+    # We need to find packages since from RN 0.71 binaries are prebuilt
+    find_package(fbjni REQUIRED CONFIG)
+    find_package(ReactAndroid REQUIRED CONFIG)
+endif()
 
-find_library(
-        REACT_LIB
-        react_nativemodule_core
+unset(JSI_LIB CACHE)
+if(${REACT_NATIVE_VERSION} LESS 66)
+    # JSI lib didn't exist on RN 0.65 and before. Simply omit it.
+    set (JSI_LIB "")
+elseif(${REACT_NATIVE_VERSION} GREATER_EQUAL 71)
+    # RN 0.71 distributes prebuilt binaries.
+    set (JSI_LIB ReactAndroid::jsi)
+else()
+    # RN 0.66 distributes libjsi.so, can be used instead of compiling jsi.cpp manually.
+    find_library(
+        JSI_LIB
+        jsi
         PATHS ${LIBRN_DIR}
         NO_CMAKE_FIND_ROOT_PATH
-)
-
+    )
+endif()
+message("-- JSI     : " ${JSI_LIB})
+
+unset(REACT_LIB CACHE)
+if(${REACT_NATIVE_VERSION} GREATER_EQUAL 71)
+    # RN 0.71 distributes prebuilt binaries.
+    set (REACT_LIB ReactAndroid::react_nativemodule_core)
+else()
+    find_library(
+            REACT_LIB
+            react_nativemodule_core
+            PATHS ${LIBRN_DIR}
+            NO_CMAKE_FIND_ROOT_PATH
+    )
+endif()
 message("-- REACT   : " ${REACT_LIB})
 
-find_library(
-        FBJNI_LIBRARY 
-        fbjni 
-        PATHS ${libfbjni_link_DIRS}
-        NO_CMAKE_FIND_ROOT_PATH
-)
-
+unset(FBJNI_LIBRARY CACHE)
+if(${REACT_NATIVE_VERSION} GREATER_EQUAL 71)
+    # RN 0.71 distributes prebuilt binaries.
+    set (FBJNI_LIBRARY fbjni::fbjni)
+else()
+    find_library(
+            FBJNI_LIBRARY
+            fbjni
+            PATHS ${libfbjni_link_DIRS}
+            NO_CMAKE_FIND_ROOT_PATH
+    )
+endif()
 message("-- FBJNI   : " ${FBJNI_LIBRARY})
 
-find_library(
-        TURBOMODULES_LIB
-        turbomodulejsijni
-        PATHS ${LIBRN_DIR}
-        NO_CMAKE_FIND_ROOT_PATH
-)
-
+unset(TURBOMODULES_LIB CACHE)
+if(${REACT_NATIVE_VERSION} GREATER_EQUAL 71)
+    # RN 0.71 distributes prebuilt binaries.
+    set (TURBOMODULES_LIB "ReactAndroid::turbomodulejsijni")
+else()
+    find_library(
+            TURBOMODULES_LIB
+            turbomodulejsijni
+            PATHS ${LIBRN_DIR}
+            NO_CMAKE_FIND_ROOT_PATH
+    )
+endif()
 message("-- TURBO   : " ${TURBOMODULES_LIB})
 
 # Link

package/android/build.gradle

@@ -47,7 +47,7 @@ def nodeModules = findNodeModules(projectDir)
 logger.warn("react-native-skia: node_modules/ found at: ${nodeModules}")
 
 def sourceBuild = false
-def defaultDir = null
+def defaultDir
 
 if (rootProject.ext.has('reactNativeAndroidRoot')) {
   defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
@@ -55,7 +55,7 @@ if (rootProject.ext.has('reactNativeAndroidRoot')) {
     sourceBuild = true
     defaultDir = project(':ReactAndroid').projectDir
 } else {
-  defaultDir = file("$nodeModules/react-native/android")
+  defaultDir = file("$nodeModules/react-native")
 }
 
 if (!defaultDir.exists()) {
@@ -78,7 +78,7 @@ if (gradle.startParameter.taskRequests.args[0].toString().contains("Release")) {
 
 def reactProperties = new Properties()
 file("$nodeModules/react-native/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
-def FULL_RN_VERSION = reactProperties.getProperty("VERSION_NAME")
+def FULL_RN_VERSION =  (System.getenv("REACT_NATIVE_OVERRIDE_VERSION") ?: reactProperties.getProperty("VERSION_NAME"))
 def REACT_NATIVE_VERSION = FULL_RN_VERSION.split("\\.")[1].toInteger()
 
 logger.warn("react-native-skia: RN Version: ${REACT_NATIVE_VERSION} / ${FULL_RN_VERSION}")
@@ -136,6 +136,10 @@ android {
         }
     }
 
+    buildFeatures {
+        prefab true
+    }
+
     packagingOptions {
         excludes = [
              "**/libc++_shared.so",
@@ -146,8 +150,6 @@ android {
         ]
     }
 
-
-
     // Create new configurations that can be referred to in dependencies.
     // The Android Gradle Plugin 3.* does not allow hooking into existing
     // configurations like `implementation`.
@@ -181,17 +183,25 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
 
-    //noinspection GradleDynamicVersion
-    extractHeaders("com.facebook.fbjni:fbjni:0.2.2:headers")
-    //noinspection GradleDynamicVersion
-    extractJNI("com.facebook.fbjni:fbjni:0.2.2")
+    if (REACT_NATIVE_VERSION < 71) {
+        logger.warn("react-native-skia: Extracting files from AAR (pre RN 0.71)")
+        //noinspection GradleDynamicVersion
+        extractHeaders("com.facebook.fbjni:fbjni:0.2.2:headers")
+        //noinspection GradleDynamicVersion
+        extractJNI("com.facebook.fbjni:fbjni:0.2.2")
+    }
 
     if (!sourceBuild) {
         def rnAarMatcher = "**/react-native/**/*${buildType}.aar"
         if (REACT_NATIVE_VERSION < 69) {
+            logger.warn("react-native-skia: aar state pre 69. match **/**/*.aar")
             rnAarMatcher = "**/**/*.aar"
+        } else if (REACT_NATIVE_VERSION >= 71) {
+            logger.warn("react-native-skia: aar state post 70, do nothing")
+            return
         }
-        def rnAAR = fileTree("${nodeModules}/react-native/android").matching({ it.include rnAarMatcher }).singleFile        
+        def rnAAR = fileTree("${nodeModules}/react-native/android").matching({ it.include rnAarMatcher }).singleFile
+        logger.warn("react-native-skia: Extracting JNI files (pre RN 0.71) ${rnAAR}")
         extractJNI(files(rnAAR))
     }
 }

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -55,8 +55,8 @@ public:
     auto info = getEnsuredViewInfo(nativeId);
 
     std::lock_guard<std::mutex> lock(_mutex);
-    info->props.emplace(arguments[1].asString(runtime).utf8(runtime),
-                        RNJsi::JsiValueWrapper(runtime, arguments[2]));
+    info->props.insert_or_assign(arguments[1].asString(runtime).utf8(runtime),
+                                 RNJsi::JsiValueWrapper(runtime, arguments[2]));
 
     // Now let's see if we have a view that we can update
     if (info->view != nullptr) {

package/cpp/rnskia/dom/nodes/JsiCustomDrawingNode.h

@@ -7,6 +7,7 @@
 #include "JsiSkPaint.h"
 
 #include <memory>
+#include <mutex>
 #include <utility>
 
 namespace RNSkia {
@@ -76,7 +77,11 @@ protected:
                    static_cast<const jsi::Value *>(args.data()), 1);
 
           auto picture = recorder.finishRecordingAsPicture();
-          this->_drawingProp->setPicture(picture);
+          {
+            // Lock access to the picture property's setter
+            std::lock_guard<std::mutex> lock(_pictureLock);
+            this->_drawingProp->setPicture(picture);
+          }
 
           // Ask view to redraw itself
           _inRedrawCycle = true;
@@ -86,6 +91,7 @@ protected:
     }
 
     if (_drawingProp->isSet()) {
+      std::lock_guard<std::mutex> lock(_pictureLock);
       context->getCanvas()->drawPicture(_drawingProp->getDerivedValue());
       _inRedrawCycle = false;
     }
@@ -115,6 +121,7 @@ private:
   std::shared_ptr<JsiSkCanvas> _jsiCanvas;
 
   std::atomic<bool> _inRedrawCycle = {false};
+  std::mutex _pictureLock;
 };
 
 } // namespace RNSkia

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.mm

@@ -41,7 +41,7 @@ RNSkCanvasProvider(requestRedraw),
   _layer.opaque = false;
   _layer.contentsScale = _context->getPixelDensity();
   _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
-  _layer.contentsGravity = kCAGravityBottomRight;
+  _layer.contentsGravity = kCAGravityBottomLeft;
 }
 
 RNSkMetalCanvasProvider::~RNSkMetalCanvasProvider() {
@@ -73,6 +73,10 @@ void RNSkMetalCanvasProvider::renderToCanvas(const std::function<void(SkCanvas*)
   auto state = UIApplication.sharedApplication.applicationState;
   if (state == UIApplicationStateBackground || state == UIApplicationStateInactive)
   {
+    // Request a redraw in the next run loop callback
+    _requestRedraw();
+    // and don't draw now since it might cause errors in the metal renderer if 
+    // we try to render while in the background. (see above issue)
     return;
   }
   

package/lib/commonjs/animation/decay/decay.d.ts

@@ -0,0 +1,2 @@
+import type { DecayState, DefaultDecayConfig } from "./types";
+export declare const decay: (now: number, state: DecayState, config: DefaultDecayConfig) => DecayState;

package/lib/commonjs/animation/decay/index.d.ts

@@ -0,0 +1 @@
+export { runDecay } from "./runDecay";

package/lib/commonjs/animation/decay/runDecay.d.ts

@@ -0,0 +1,10 @@
+import type { SkiaMutableValue } from "../../values/types";
+import type { DecayConfig } from "./types";
+/**
+ * Runs a decay animation from the current value to zero with the given decay
+ * configuration.
+ * @param value value to animate
+ * @param config Configuration or default configuration
+ * @returns Animation
+ */
+export declare const runDecay: (value: SkiaMutableValue<number>, config?: DecayConfig) => import("../../values/types").SkiaAnimation;

package/lib/commonjs/animation/decay/types.d.ts

@@ -0,0 +1,21 @@
+import type { AnimationState } from "../../values/types";
+export interface DecayConfig {
+    from?: number;
+    deceleration?: number;
+    velocityFactor?: number;
+    clamp?: number[];
+    velocity?: number;
+}
+export interface DefaultDecayConfig {
+    from: number;
+    deceleration: number;
+    velocityFactor: number;
+    clamp?: number[];
+    velocity: number;
+}
+export interface DecayState extends AnimationState {
+    lastTimestamp: number;
+    startTimestamp: number;
+    initialVelocity: number;
+    velocity: number;
+}

package/lib/commonjs/animation/functions/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./interpolate";
+export * from "./interpolateColors";
+export * from "./interpolateVector";
+export * from "./interpolatePaths";

package/lib/commonjs/animation/functions/interpolate.d.ts

@@ -0,0 +1,17 @@
+export declare enum Extrapolate {
+    IDENTITY = "identity",
+    CLAMP = "clamp",
+    EXTEND = "extend"
+}
+export interface ExtrapolationConfig {
+    extrapolateLeft?: Extrapolate | string;
+    extrapolateRight?: Extrapolate | string;
+}
+interface RequiredExtrapolationConfig {
+    extrapolateLeft: Extrapolate;
+    extrapolateRight: Extrapolate;
+}
+export declare type ExtrapolationType = ExtrapolationConfig | Extrapolate | string | undefined;
+export declare function validateInterpolationOptions(type: ExtrapolationType): RequiredExtrapolationConfig;
+export declare function interpolate(x: number, input: readonly number[], output: readonly number[], type?: ExtrapolationType): number;
+export {};

package/lib/commonjs/animation/functions/interpolateColors.d.ts

@@ -0,0 +1,3 @@
+import type { Color } from "../../skia";
+export declare const interpolateColors: (value: number, inputRange: number[], _outputRange: Color[]) => Float32Array;
+export declare const mixColors: (value: number, x: Color, y: Color) => Float32Array;

package/lib/commonjs/animation/functions/interpolatePaths.d.ts

@@ -0,0 +1,19 @@
+import type { SkPath } from "../../skia/types";
+import type { ExtrapolationType } from "./interpolate";
+/**
+ * Maps an input value within a range to an output path within a path range.
+ * @param value - The input value.
+ * @param inputRange - The range of the input value.
+ * @param outputRange - The range of the output path.
+ * @param options - Extrapolation options
+ * @returns The output path.
+ * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>
+ * const path1 = new Path();
+ * path1.moveTo(0, 0);
+ * path1.lineTo(100, 0);
+ * const path2 = new Path();
+ * path2.moveTo(0, 0);
+ * path2.lineTo(0, 100);
+ * const path = interpolatePath(0.5, [0, 1], [path1, path2]);
+ */
+export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType) => SkPath;

package/lib/commonjs/animation/functions/interpolateVector.d.ts

@@ -0,0 +1,10 @@
+import type { Vector } from "../../skia/types";
+import { interpolate } from "./interpolate";
+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/commonjs/animation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./timing";
+export * from "./spring";
+export * from "./decay";
+export * from "./functions";

package/lib/commonjs/animation/spring/Spring.d.ts

@@ -0,0 +1,65 @@
+import type { SpringConfig } from "./types";
+export declare const Spring: {
+    Config: {
+        Gentle: {
+            mass: number;
+            stiffness: number;
+            damping: number;
+            velocity: number;
+        };
+        Wobbly: {
+            mass: number;
+            stiffness: number;
+            damping: number;
+            velocity: number;
+        };
+        WobblySlow: {
+            mass: number;
+            stiffness: number;
+            damping: number;
+            velocity: number;
+        };
+        Stiff: {
+            mass: number;
+            stiffness: number;
+            damping: number;
+            velocity: number;
+        };
+        Default: {
+            mass: number;
+            stiffness: number;
+            damping: number;
+            velocity: number;
+        };
+    };
+    Gentle: (config?: SpringConfig) => {
+        mass: number;
+        stiffness: number;
+        velocity: number;
+        damping: number;
+    };
+    Wobbly: (config?: SpringConfig) => {
+        mass: number;
+        stiffness: number;
+        velocity: number;
+        damping: number;
+    };
+    WobblySlow: (config?: SpringConfig) => {
+        mass: number;
+        stiffness: number;
+        velocity: number;
+        damping: number;
+    };
+    Stiff: (config?: SpringConfig) => {
+        mass: number;
+        stiffness: number;
+        velocity: number;
+        damping: number;
+    };
+    Default: (config?: SpringConfig) => {
+        mass: number;
+        stiffness: number;
+        velocity: number;
+        damping: number;
+    };
+};

package/lib/commonjs/animation/spring/functions/index.d.ts

@@ -0,0 +1 @@
+export { createSpringEasing } from "./spring";

package/lib/commonjs/animation/spring/functions/spring.d.ts

@@ -0,0 +1,10 @@
+import type { SpringConfig } from "../types";
+import type { TimingConfig } from "../../types";
+/**
+ * @description Returns a cached jsContext function for a spring with duration
+ * @param mass The mass of the spring
+ * @param stiffness The stiffness of the spring
+ * @param damping Spring damping
+ * @param velocity The initial velocity
+ */
+export declare const createSpringEasing: (params: Partial<SpringConfig>) => TimingConfig;

package/lib/commonjs/animation/spring/index.d.ts

@@ -0,0 +1,3 @@
+export { Spring } from "./Spring";
+export { runSpring } from "./runSpring";
+export { useSpring } from "./useSpring";

package/lib/commonjs/animation/spring/runSpring.d.ts

@@ -0,0 +1,16 @@
+import type { SkiaMutableValue, SkiaAnimation } from "../../values/types";
+import type { AnimationParams, SpringConfig, AnimationCallback } from "../types";
+/**
+ * Creates a new animation on an existing value that will be driven by
+ * an animation value. The value will be run from / to the value in
+ * params and modified by the provided easing curve for the length of
+ * the duration. When the value has reached its desired "to" value the
+ * animation will be stopped.
+ *
+ * @param value The value to animate
+ * @param toOrParams To value or Animation parameters
+ * @param config Spring configuration
+ * @returns an animation value that can be used to start/stop
+ * the animation.
+ */
+export declare const runSpring: (value: SkiaMutableValue<number>, toOrParams: number | AnimationParams, config?: SpringConfig, callback?: AnimationCallback) => SkiaAnimation;

package/lib/commonjs/animation/spring/types.d.ts

@@ -0,0 +1,6 @@
+export interface SpringConfig {
+    mass?: number;
+    stiffness?: number;
+    velocity?: number;
+    damping?: number;
+}

package/lib/commonjs/animation/spring/useSpring.d.ts

@@ -0,0 +1,10 @@
+import type { SkiaValue } from "../../values/types";
+import type { SpringConfig, AnimationParams, AnimationCallback } from "../types";
+/**
+ * Creats a spring based animation value that will run whenever
+ * the animation parameters change.
+ * @param toOrParams
+ * @param config
+ * @returns
+ */
+export declare const useSpring: (toOrParams: number | AnimationParams, config?: SpringConfig, callback?: AnimationCallback) => SkiaValue<number>;

package/lib/commonjs/animation/timing/Easing.d.ts

@@ -0,0 +1,19 @@
+export declare class Easing {
+    static step0(n: number): number;
+    static step1(n: number): number;
+    static linear(t: number): number;
+    static ease(t: number): number;
+    static quad(t: number): number;
+    static cubic(t: number): number;
+    static poly(n: number): (t: number) => number;
+    static sin(t: number): number;
+    static circle(t: number): number;
+    static exp(t: number): number;
+    static elastic(bounciness?: number): (t: number) => number;
+    static back(s?: number): (t: number) => number;
+    static bounce(t: number): number;
+    static bezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+    static in(easing: (t: number) => number): (t: number) => number;
+    static out(easing: (t: number) => number): (t: number) => number;
+    static inOut(easing: (t: number) => number): (t: number) => number;
+}

package/lib/commonjs/animation/timing/createTiming.d.ts

@@ -0,0 +1,17 @@
+import type { TimingConfig, RequiredAnimationParams, AnimationCallback } from "../types";
+import type { SkiaMutableValue } from "../../values/types";
+/**
+ * Creates an animation that is driven by a clock value.
+ * The value will be run from / to the value in params and modified
+ * by the provided easing curve for the length of the duration. When
+ * the value has reached its desired "to" value the animation
+ * will be stopped. If loop is set to true, the animation will continue
+ * to run until stopped.
+ *
+ * @param params Animation parameters
+ * @param config Spring or timing configuration
+ * @param value Optional value that the animation will update
+ * @params an animation value that can be used to start/stop
+ * the animation.
+ */
+export declare const createTiming: (params: RequiredAnimationParams & Required<TimingConfig>, value?: SkiaMutableValue<number>, callback?: AnimationCallback) => import("../../values/types").SkiaAnimation;

package/lib/commonjs/animation/timing/functions/bezier.d.ts

@@ -0,0 +1 @@
+export declare function bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;

package/lib/commonjs/animation/timing/functions/getResolvedParams.d.ts

@@ -0,0 +1,7 @@
+import type { RequiredAnimationParams, AnimationParams, TimingConfig } from "../../types";
+/**
+ * Resolves parameters from optional values to a single object
+ * @param toOrParams Params or to value
+ * @param config timing/spring configuration
+ */
+export declare const getResolvedParams: (toOrParams: number | AnimationParams, config?: TimingConfig) => RequiredAnimationParams & Required<TimingConfig>;

package/lib/commonjs/animation/timing/functions/index.d.ts

@@ -0,0 +1,4 @@
+export { bezier } from "./bezier";
+export { timing } from "./timing";
+export * from "./types";
+export * from "./getResolvedParams";

package/lib/commonjs/animation/timing/functions/timing.d.ts

@@ -0,0 +1,17 @@
+import type { AnimationState } from "../../../values/types";
+/**
+ * Calculates and returns a timing value based on the
+ * input parameters. The timing value is a number between
+ * 0 and 1.
+ * @param t
+ * @param duration
+ * @param easing
+ * @param loop
+ * @param yoyo
+ * @param onStop
+ * @returns
+ */
+export declare const timing: (t: number, duration: number, easing: (t: number) => number, loop: boolean, yoyo: boolean, state: AnimationState) => {
+    current: number;
+    finished: boolean;
+};

package/lib/commonjs/animation/timing/functions/types.d.ts

@@ -0,0 +1,7 @@
+export declare type EasingFunction = (value: number) => number;
+export interface TimingConfig {
+    from?: number;
+    to?: number;
+    duration?: number;
+    easing?: EasingFunction;
+}

package/lib/commonjs/animation/timing/index.d.ts

@@ -0,0 +1,4 @@
+export { Easing } from "./Easing";
+export { useTiming } from "./useTiming";
+export { useLoop } from "./useLoop";
+export { runTiming } from "./runTiming";

package/lib/commonjs/animation/timing/runTiming.d.ts

@@ -0,0 +1,16 @@
+import type { SkiaMutableValue, SkiaAnimation } from "../../values/types";
+import type { AnimationParams, TimingConfig, AnimationCallback } from "../types";
+/**
+ * Creates a new animation on an existing value that will be driven by
+ * an animation value. The value will be run from / to the value in
+ * params and modified by the provided easing curve for the length of
+ * the duration. When the value has reached its desired "to" value the
+ * animation will be stopped.
+ *
+ * @param value The value to animate
+ * @param toOrParams To value or Animation parameters
+ * @param config Spring or timing configuration
+ * @returns an animation value that can be used to start/stop
+ * the animation.
+ */
+export declare const runTiming: (value: SkiaMutableValue<number>, toOrParams: number | AnimationParams, config?: TimingConfig, callback?: AnimationCallback) => SkiaAnimation;

package/lib/commonjs/animation/timing/useLoop.d.ts

@@ -0,0 +1,8 @@
+import type { TimingConfig } from "../types";
+/**
+ * Configures a looped timing value. The value will go back and forth
+ * between 0 and 1 and back.
+ * @param config Timing configuration for easing and duration
+ * @returns A value that can be used for further animations
+ */
+export declare const useLoop: (config?: TimingConfig) => import("../..").SkiaValue<number>;

package/lib/commonjs/animation/timing/useTiming.d.ts

@@ -0,0 +1,10 @@
+import type { SkiaValue } from "../../values/types";
+import type { AnimationParams, TimingConfig, AnimationCallback } from "../types";
+/**
+ * Creats an animation value that will run whenever
+ * the animation parameters change. The animation start immediately.
+ * @param toOrParams
+ * @param config
+ * @returns A value that is animated
+ */
+export declare const useTiming: (toOrParams: number | AnimationParams, config?: TimingConfig, callback?: AnimationCallback) => SkiaValue<number>;

package/lib/commonjs/animation/types.d.ts

@@ -0,0 +1,18 @@
+export interface SpringConfig {
+    mass?: number;
+    stiffness?: number;
+    damping?: number;
+    velocity?: number;
+}
+export interface TimingConfig {
+    duration?: number;
+    easing?: (t: number) => number;
+}
+export interface AnimationParams {
+    from?: number;
+    to?: number;
+    loop?: boolean;
+    yoyo?: boolean;
+}
+export declare type RequiredAnimationParams = Required<Omit<AnimationParams, "from">> & Pick<AnimationParams, "from">;
+export declare type AnimationCallback = (current: number) => void;