@shopify/react-native-skia 0.1.171 → 0.1.173

package/ios/RNSkia-iOS/SkiaPictureViewManager.mm

@@ -2,50 +2,50 @@
 #include "SkiaPictureViewManager.h"
 #include <React/RCTBridge+Private.h>
 
-#include <RNSkPlatformContext.h>
-#include <RNSkPictureView.h>
 #include <RNSkIOSView.h>
+#include <RNSkPictureView.h>
+#include <RNSkPlatformContext.h>
 
 #include "SkiaManager.h"
-#include <RNSkiaModule.h>
 #include "SkiaUIView.h"
-
-
+#include <RNSkiaModule.h>
 
 @implementation SkiaPictureViewManager
 
 RCT_EXPORT_MODULE(SkiaPictureView)
 
-- (SkiaManager*) skiaManager {
+- (SkiaManager *)skiaManager {
   auto bridge = [RCTBridge currentBridge];
-  auto skiaModule = (RNSkiaModule*)[bridge moduleForName:@"RNSkia"];
+  auto skiaModule = (RNSkiaModule *)[bridge moduleForName:@"RNSkia"];
   return [skiaModule manager];
 }
 
 RCT_CUSTOM_VIEW_PROPERTY(nativeID, NSNumber, SkiaUIView) {
   // Get parameter
   int nativeId = [[RCTConvert NSString:json] intValue];
-  [(SkiaUIView*)view setNativeId:nativeId];
+  [(SkiaUIView *)view setNativeId:nativeId];
 }
 
 RCT_CUSTOM_VIEW_PROPERTY(mode, NSString, SkiaUIView) {
-  std::string mode = json != NULL ? [[RCTConvert NSString:json] UTF8String] : "default";
-  [(SkiaUIView*)view setDrawingMode: mode];
+  std::string mode =
+      json != NULL ? [[RCTConvert NSString:json] UTF8String] : "default";
+  [(SkiaUIView *)view setDrawingMode:mode];
 }
 
 RCT_CUSTOM_VIEW_PROPERTY(debug, BOOL, SkiaUIView) {
   bool debug = json != NULL ? [RCTConvert BOOL:json] : false;
-  [(SkiaUIView*)view setDebugMode: debug];
+  [(SkiaUIView *)view setDebugMode:debug];
 }
 
-- (UIView *)view
-{
+- (UIView *)view {
   auto skManager = [[self skiaManager] skManager];
   // Pass SkManager as a raw pointer to avoid circular dependenciesr
-  return [[SkiaUIView alloc] initWithManager: skManager.get()
-                                     factory: [](std::shared_ptr<RNSkia::RNSkPlatformContext> context) {
-    return std::make_shared<RNSkiOSView<RNSkia::RNSkPictureView>>(context);
-  }];
+  return [[SkiaUIView alloc]
+      initWithManager:skManager.get()
+              factory:[](std::shared_ptr<RNSkia::RNSkPlatformContext> context) {
+                return std::make_shared<RNSkiOSView<RNSkia::RNSkPictureView>>(
+                    context);
+              }];
 }
 
 @end

package/ios/RNSkia-iOS/SkiaUIView.mm

@@ -9,19 +9,22 @@
 
 @implementation SkiaUIView {
   std::shared_ptr<RNSkBaseiOSView> _impl;
-  RNSkia::RNSkManager* _manager;
+  RNSkia::RNSkManager *_manager;
   RNSkia::RNSkDrawingMode _drawingMode;
-  std::function<std::shared_ptr<RNSkBaseiOSView>(std::shared_ptr<RNSkia::RNSkPlatformContext>)> _factory;
+  std::function<std::shared_ptr<RNSkBaseiOSView>(
+      std::shared_ptr<RNSkia::RNSkPlatformContext>)>
+      _factory;
   bool _debugMode;
   size_t _nativeId;
 }
 
 #pragma mark Initialization and destruction
 
-- (instancetype) initWithManager: (RNSkia::RNSkManager*)manager
-                         factory: (std::function<std::shared_ptr<RNSkBaseiOSView>(
-                                     std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory
-{
+- (instancetype)initWithManager:(RNSkia::RNSkManager *)manager
+                        factory:
+                            (std::function<std::shared_ptr<RNSkBaseiOSView>(
+                                 std::shared_ptr<RNSkia::RNSkPlatformContext>)>)
+                                factory {
   self = [super init];
   if (self) {
     _manager = manager;
@@ -31,28 +34,29 @@
     _factory = factory;
 
     // Listen to notifications about module invalidation
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(willInvalidateModules)
-                                                 name:RCTBridgeWillInvalidateModulesNotification
-                                               object:nil];
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(willInvalidateModules)
+               name:RCTBridgeWillInvalidateModulesNotification
+             object:nil];
   }
   return self;
 }
 
-- (void) willInvalidateModules {
+- (void)willInvalidateModules {
   _impl = nullptr;
   _manager = nullptr;
 }
 
 #pragma mark Lifecycle
 
-- (void) willMoveToSuperview:(UIView *)newWindow {
+- (void)willMoveToSuperview:(UIView *)newWindow {
   if (newWindow == NULL) {
     // Remove implementation view when the parent view is not set
-    if(_impl != nullptr) {
+    if (_impl != nullptr) {
       [_impl->getLayer() removeFromSuperlayer];
 
-      if(_nativeId != 0 && _manager != nullptr) {
+      if (_nativeId != 0 && _manager != nullptr) {
         _manager->setSkiaView(_nativeId, nullptr);
       }
 
@@ -60,13 +64,14 @@
     }
   } else {
     // Create implementation view when the parent view is set
-    if(_impl == nullptr && _manager != nullptr) {
+    if (_impl == nullptr && _manager != nullptr) {
       _impl = _factory(_manager->getPlatformContext());
-      if(_impl == nullptr) {
-        throw std::runtime_error("Expected Skia view implementation, got nullptr.");
+      if (_impl == nullptr) {
+        throw std::runtime_error(
+            "Expected Skia view implementation, got nullptr.");
       }
-      [self.layer addSublayer: _impl->getLayer()];
-      if(_nativeId != 0) {
+      [self.layer addSublayer:_impl->getLayer()];
+      if (_nativeId != 0) {
         _manager->setSkiaView(_nativeId, _impl->getDrawView());
       }
       _impl->getDrawView()->setDrawingMode(_drawingMode);
@@ -75,71 +80,76 @@
   }
 }
 
-- (void) dealloc {
-  if(_manager != nullptr && _nativeId != 0) {
+- (void)dealloc {
+  if (_manager != nullptr && _nativeId != 0) {
     _manager->unregisterSkiaView(_nativeId);
   }
 
-  [[NSNotificationCenter defaultCenter] removeObserver:self name:RCTBridgeWillInvalidateModulesNotification object:nil];
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:RCTBridgeWillInvalidateModulesNotification
+              object:nil];
 
   assert(_impl == nullptr);
 }
 
 #pragma mark Layout
 
-- (void) layoutSubviews {
+- (void)layoutSubviews {
   [super layoutSubviews];
-  if(_impl != nullptr) {
+  if (_impl != nullptr) {
     _impl->setSize(self.bounds.size.width, self.bounds.size.height);
   }
 }
 
 #pragma mark Properties
 
--(void) setDrawingMode:(std::string) mode {
-  _drawingMode = mode.compare("continuous") == 0 ? RNSkia::RNSkDrawingMode::Continuous : RNSkia::RNSkDrawingMode::Default;
+- (void)setDrawingMode:(std::string)mode {
+  _drawingMode = mode.compare("continuous") == 0
+                     ? RNSkia::RNSkDrawingMode::Continuous
+                     : RNSkia::RNSkDrawingMode::Default;
 
-  if(_impl != nullptr) {
+  if (_impl != nullptr) {
     _impl->getDrawView()->setDrawingMode(_drawingMode);
   }
 }
 
--(void) setDebugMode:(bool) debugMode {
+- (void)setDebugMode:(bool)debugMode {
   _debugMode = debugMode;
-  if(_impl != nullptr) {
+  if (_impl != nullptr) {
     _impl->getDrawView()->setShowDebugOverlays(debugMode);
   }
 }
 
-- (void) setNativeId:(size_t) nativeId {
+- (void)setNativeId:(size_t)nativeId {
   _nativeId = nativeId;
 
-  if(_impl != nullptr) {
+  if (_impl != nullptr) {
     _manager->registerSkiaView(nativeId, _impl->getDrawView());
   }
 }
 
 #pragma mark External API
 
-- (std::shared_ptr<RNSkBaseiOSView>) impl {
+- (std::shared_ptr<RNSkBaseiOSView>)impl {
   return _impl;
 }
 
 #pragma mark Touch handling
 
-- (void) touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
   [self handleTouches:touches withEvent:event];
 }
 
--(void) touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
   [self handleTouches:touches withEvent:event];
 }
 
--(void) touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
   [self handleTouches:touches withEvent:event];
 }
 
-- (void) handleTouches:(NSSet<UITouch*>*) touches withEvent:(UIEvent*) event {
+- (void)handleTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
   if (event.type == UIEventTypeTouches) {
     std::vector<RNSkia::RNSkTouchInfo> nextTouches;
     for (UITouch *touch in touches) {
@@ -150,27 +160,27 @@
       nextTouch.force = [touch force];
       nextTouch.id = [touch hash];
       auto phase = [touch phase];
-      switch(phase) {
-        case UITouchPhaseBegan:
-          nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Start;
-          break;
-        case UITouchPhaseMoved:
-          nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Active;
-          break;
-        case UITouchPhaseEnded:
-          nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::End;
-          break;
-        case UITouchPhaseCancelled:
-          nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Cancelled;
-          break;
-        default:
-          nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Active;
-          break;
+      switch (phase) {
+      case UITouchPhaseBegan:
+        nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Start;
+        break;
+      case UITouchPhaseMoved:
+        nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Active;
+        break;
+      case UITouchPhaseEnded:
+        nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::End;
+        break;
+      case UITouchPhaseCancelled:
+        nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Cancelled;
+        break;
+      default:
+        nextTouch.type = RNSkia::RNSkTouchInfo::TouchType::Active;
+        break;
       }
 
       nextTouches.push_back(nextTouch);
     }
-    if(_impl != nullptr) {
+    if (_impl != nullptr) {
       _impl->getDrawView()->updateTouchState(nextTouches);
     }
   }

package/ios/RNSkiaModule.mm

@@ -3,14 +3,14 @@
 #import <React/RCTBridge+Private.h>
 
 @implementation RNSkiaModule {
-  SkiaManager* skiaManager;
+  SkiaManager *skiaManager;
 }
 
 RCT_EXPORT_MODULE(RNSkia)
 
 #pragma Accessors
 
--(SkiaManager*) manager {
+- (SkiaManager *)manager {
   return skiaManager;
 }
 
@@ -20,21 +20,19 @@ RCT_EXPORT_MODULE(RNSkia)
   return YES;
 }
 
-- (void)invalidate
-{
+- (void)invalidate {
   if (skiaManager != nil) {
     [skiaManager invalidate];
   }
   skiaManager = nil;
 }
 
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
-{
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
   if (skiaManager != nil) {
     // Already initialized, ignore call.
     return @true;
   }
-  RCTBridge* bridge = [RCTBridge currentBridge];
+  RCTBridge *bridge = [RCTBridge currentBridge];
   skiaManager = [[SkiaManager alloc] initWithBridge:bridge];
   return @true;
 }

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";