@shopify/react-native-skia 0.1.170 → 0.1.172

package/lib/commonjs/values/hooks/useClockValue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @returns A new value that will be updated on every frame redraw with the
+ * number of milliseconds elapsed since the value was started.
+ * The clock is created in the stopped state.
+ */
+export declare const useClockValue: () => import("..").SkiaClockValue;

package/lib/commonjs/values/hooks/useComputedValue.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a new computed value - a value that will calculate its value depending
+ * on other values.
+ * @param cb Callback to calculate new value
+ * @param values Dependant values
+ * @returns A readonly value
+ */
+export declare const useComputedValue: <R>(cb: () => R, values: unknown[]) => import("..").SkiaValue<R>;

package/lib/commonjs/values/hooks/useValue.d.ts

@@ -0,0 +1,7 @@
+import type { SkiaMutableValue } from "../types";
+/**
+ * Creates a new value that holds some data.
+ * @param v Value to hold
+ * @returns A Value of type of v
+ */
+export declare const useValue: <T>(v: T) => SkiaMutableValue<T>;

package/lib/commonjs/values/hooks/useValueEffect.d.ts

@@ -0,0 +1,7 @@
+import type { SkiaValue } from "../types";
+/**
+ * Sets up an effect that will be run whenever the value changes
+ * @param value Value to subscribe to changes on
+ * @param cb Callback to run when value changes
+ */
+export declare const useValueEffect: <T>(value: SkiaValue<T>, cb: (v: T) => void) => void;

package/lib/commonjs/values/index.d.ts

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

package/lib/commonjs/values/selector.d.ts

@@ -0,0 +1,14 @@
+import type { SkiaValue } from "./types";
+export declare type SkiaSelector<TReturn, TInput = unknown> = {
+    value: SkiaValue<TInput>;
+    selector: (v: TInput) => TReturn;
+};
+/**
+ * Wraps a Skia Value with a selector function. The selector function can access the
+ * inner values of the Skia Value so that we can dynamically ready array values and
+ * object values when doing animations in Skia.
+ * @param value Dependant value
+ * @param selector Selector function to calculate new value from the Skia Value's value
+ * @returns A descriptor that will be used by the reconciler to calculate the value
+ */
+export declare const Selector: <TInput, TReturn>(value: SkiaValue<TInput>, selector: (v: TInput) => TReturn) => SkiaSelector<TReturn, TInput>;

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

@@ -0,0 +1,63 @@
+export interface SkiaValue<T = number> {
+    /**
+     * Gets the value hold by the Value object
+     */
+    readonly current: T;
+    /**
+     * Adds a listener that is called when value changes.
+     * Returns unsubscribe method.
+     */
+    addListener: (cb: (value: T) => void) => () => void;
+    /**
+     * Invalidates the value. Has different meaning depending on the type of the value.
+     */
+    __invalidate: () => void;
+    /**
+     * Field to make typechecking easier
+     */
+    __typename__: "RNSkValue";
+}
+export interface SkiaMutableValue<T = number> extends SkiaValue<T> {
+    /**
+     * Get/sets the value hold by the Value object
+     */
+    current: T;
+    /**
+     * Get/sets the animation controlling the value
+     * */
+    animation: SkiaAnimation | undefined;
+}
+export interface SkiaClockValue extends SkiaValue<number> {
+    start: () => void;
+    stop: () => void;
+}
+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) => SkiaMutableValue<T>;
+    /**
+     * Creates a computed value. This is a calculated value that returns the result of
+     * a function that is called with the values of the dependencies.
+     */
+    createComputedValue: <R>(cb: () => R, values: Array<SkiaValue<unknown>>) => SkiaValue<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/commonjs/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/commonjs/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/commonjs/values/web/RNSkComputedValue.d.ts

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

package/lib/commonjs/values/web/RNSkReadonlyValue.d.ts

@@ -0,0 +1,12 @@
+import type { SkiaValue } from "../types";
+export declare class RNSkReadonlyValue<T> implements SkiaValue<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;
+    __invalidate(): void;
+}

package/lib/commonjs/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/commonjs/values/web/api.d.ts

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

package/lib/commonjs/values/web/index.d.ts

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

package/lib/commonjs/views/SkiaBaseWebView.d.ts

@@ -0,0 +1,62 @@
+import React from "react";
+import type { PointerEvent } from "react";
+import type { SkRect, SkCanvas } from "../skia/types";
+import type { SkiaValue } from "../values";
+import type { DrawMode, SkiaBaseViewProps, TouchInfo } from "./types";
+import { TouchType } from "./types";
+export declare abstract class SkiaBaseWebView<TProps extends SkiaBaseViewProps> extends React.Component<TProps> {
+    constructor(props: TProps);
+    private _surface;
+    private _unsubscriptions;
+    private _touches;
+    private _canvas;
+    private _canvasRef;
+    private _mode;
+    private _redrawRequests;
+    private requestId;
+    protected width: number;
+    protected height: number;
+    private unsubscribeAll;
+    private onLayout;
+    protected getSize(): {
+        width: number;
+        height: number;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    /**
+     * Creates a snapshot from the canvas in the surface
+     * @param rect Rect to use as bounds. Optional.
+     * @returns An Image object.
+     */
+    makeImageSnapshot(rect?: SkRect): import("../skia/types").SkImage | undefined;
+    /**
+     * Override to render
+     */
+    protected abstract renderInCanvas(canvas: SkCanvas, touches: TouchInfo[]): void;
+    /**
+     * Sends a redraw request to the native SkiaView.
+     */
+    private tick;
+    redraw(): void;
+    /**
+     * Updates the drawing mode for the skia view. This is the same
+     * as declaratively setting the mode property on the SkiaView.
+     * 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 size and margins.
+     * @param mode Drawing mode to use.
+     */
+    setDrawMode(mode: DrawMode): void;
+    /**
+     * Registers one or move values as a dependant value of the Skia View. The view will
+     * The view will redraw itself when any of the values change.
+     * @param values Values to register
+     */
+    registerValues(_values: SkiaValue<unknown>[]): void;
+    private handleTouchEvent;
+    createTouchHandler(touchType: TouchType): (evt: PointerEvent) => void;
+    render(): JSX.Element;
+}

package/lib/commonjs/views/SkiaDomView.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import type { SkRect } from "../skia/types";
+import type { SkiaValue } from "../values";
+import type { SkiaDomViewProps } from "./types";
+export declare class SkiaDomView extends React.Component<SkiaDomViewProps> {
+    constructor(props: SkiaDomViewProps);
+    private _nativeId;
+    get nativeId(): number;
+    componentDidUpdate(prevProps: SkiaDomViewProps): void;
+    /**
+     * Creates a snapshot from the canvas in the surface
+     * @param rect Rect to use as bounds. Optional.
+     * @returns An Image object.
+     */
+    makeImageSnapshot(rect?: SkRect): import("../skia/types").SkImage;
+    /**
+     * Sends a redraw request to the native SkiaView.
+     */
+    redraw(): void;
+    /**
+     * Registers one or move values as a dependant value of the Skia View. The view will
+     * The view will redraw itself when any of the values change.
+     * @param values Values to register
+     */
+    registerValues(values: SkiaValue<unknown>[]): () => void;
+    /**
+     * Clear up the dom node when unmounting to release resources.
+     */
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}

package/lib/commonjs/views/SkiaDomView.web.d.ts

@@ -0,0 +1,7 @@
+import type { SkCanvas } from "../skia/types";
+import { SkiaBaseWebView } from "./SkiaBaseWebView";
+import type { SkiaDomViewProps, TouchInfo } from "./types";
+export declare class SkiaDomView extends SkiaBaseWebView<SkiaDomViewProps> {
+    constructor(props: SkiaDomViewProps);
+    protected renderInCanvas(canvas: SkCanvas, touches: TouchInfo[]): void;
+}

package/lib/commonjs/views/SkiaPictureView.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import type { SkRect } from "../skia/types";
+import type { SkiaValue } from "../values";
+import type { SkiaPictureViewProps } from "./types";
+export declare class SkiaPictureView extends React.Component<SkiaPictureViewProps> {
+    constructor(props: SkiaPictureViewProps);
+    private _nativeId;
+    get nativeId(): number;
+    componentDidUpdate(prevProps: SkiaPictureViewProps): void;
+    /**
+     * Creates a snapshot from the canvas in the surface
+     * @param rect Rect to use as bounds. Optional.
+     * @returns An Image object.
+     */
+    makeImageSnapshot(rect?: SkRect): import("../skia/types").SkImage;
+    /**
+     * Sends a redraw request to the native SkiaView.
+     */
+    redraw(): void;
+    /**
+     * Registers one or move values as a dependant value of the Skia View. The view will
+     * The view will redraw itself when any of the values change.
+     * @param values Values to register
+     */
+    registerValues(values: SkiaValue<unknown>[]): () => void;
+    render(): JSX.Element;
+}

package/lib/commonjs/views/SkiaPictureView.web.d.ts

@@ -0,0 +1,7 @@
+import type { SkCanvas } from "../skia/types";
+import type { SkiaPictureViewProps } from "./types";
+import { SkiaBaseWebView } from "./SkiaBaseWebView";
+export declare class SkiaPictureView extends SkiaBaseWebView<SkiaPictureViewProps> {
+    constructor(props: SkiaPictureViewProps);
+    protected renderInCanvas(canvas: SkCanvas): void;
+}

package/lib/commonjs/views/SkiaView.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import type { SkRect } from "../skia/types";
+import type { SkiaValue } from "../values";
+import type { SkiaDrawViewProps } from "./types";
+export declare const SkiaViewNativeId: {
+    current: number;
+};
+export declare class SkiaView extends React.Component<SkiaDrawViewProps> {
+    constructor(props: SkiaDrawViewProps);
+    private _nativeId;
+    get nativeId(): number;
+    componentDidUpdate(prevProps: SkiaDrawViewProps): void;
+    /**
+     * Creates a snapshot from the canvas in the surface
+     * @param rect Rect to use as bounds. Optional.
+     * @returns An Image object.
+     */
+    makeImageSnapshot(rect?: SkRect): import("../skia/types").SkImage;
+    /**
+     * Sends a redraw request to the native SkiaView.
+     */
+    redraw(): void;
+    /**
+     * Registers one or move values as a dependant value of the Skia View. The view will
+     * The view will redraw itself when any of the values change.
+     * @param values Values to register
+     */
+    registerValues(values: SkiaValue<unknown>[]): () => void;
+    render(): JSX.Element;
+}

package/lib/commonjs/views/SkiaView.web.d.ts

@@ -0,0 +1,7 @@
+import type { SkCanvas } from "../skia/types";
+import type { SkiaDrawViewProps, TouchInfo } from "./types";
+import { SkiaBaseWebView } from "./SkiaBaseWebView";
+export declare class SkiaView extends SkiaBaseWebView<SkiaDrawViewProps> {
+    constructor(props: SkiaDrawViewProps);
+    protected renderInCanvas(canvas: SkCanvas, touches: TouchInfo[]): void;
+}

package/lib/commonjs/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/commonjs/views/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./SkiaView";
+export * from "./SkiaPictureView";
+export * from "./SkiaDomView";
+export * from "./types";
+export * from "./useDrawCallback";
+export * from "./useTouchHandler";

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

@@ -0,0 +1,91 @@
+import type { ViewProps } from "react-native";
+import type { GroupProps, RenderNode } from "../dom/types";
+import type { SkCanvas, SkImage, SkPicture, SkRect, SkSize } from "../skia/types";
+import type { SkiaMutableValue, SkiaValue } from "../values";
+export declare type DrawMode = "continuous" | "default";
+export declare type NativeSkiaViewProps = ViewProps & {
+    mode?: DrawMode;
+    debug?: boolean;
+};
+export declare enum TouchType {
+    Start = 0,
+    Active = 1,
+    End = 2,
+    Cancelled = 3
+}
+export interface TouchInfo {
+    x: number;
+    y: number;
+    force: number;
+    type: TouchType;
+    id: number;
+    timestamp: number;
+}
+export interface DrawingInfo {
+    width: number;
+    height: number;
+    timestamp: number;
+    touches: Array<Array<TouchInfo>>;
+}
+export declare type ExtendedTouchInfo = TouchInfo & {
+    velocityX: number;
+    velocityY: number;
+};
+export declare type TouchHandlers = {
+    onStart?: (touchInfo: TouchInfo) => void;
+    onActive?: (touchInfo: ExtendedTouchInfo) => void;
+    onEnd?: (touchInfo: ExtendedTouchInfo) => void;
+};
+export declare type TouchHandler = (touchInfo: Array<Array<TouchInfo>>) => void;
+export declare type RNSkiaDrawCallback = (canvas: SkCanvas, info: DrawingInfo) => void;
+/**
+ * Listener interface for value changes
+ */
+export interface ValueListener {
+    addListener: (callback: () => void) => number;
+    removeListener: (id: number) => void;
+}
+export interface ISkiaViewApi {
+    setJsiProperty: <T>(nativeId: number, name: string, value: T) => void;
+    callJsiMethod: <T extends Array<unknown>>(nativeId: number, name: string, ...args: T) => void;
+    registerValuesInView: (nativeId: number, values: SkiaValue<unknown>[]) => () => void;
+    requestRedraw: (nativeId: number) => void;
+    makeImageSnapshot: (nativeId: number, rect?: SkRect) => SkImage;
+}
+export interface SkiaBaseViewProps 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;
+    /**
+     * Pass an animated value to the onSize property to get updates when
+     * the Skia view is resized.
+     */
+    onSize?: SkiaMutableValue<SkSize>;
+}
+export interface SkiaDrawViewProps extends SkiaBaseViewProps {
+    /**
+     * 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;
+}
+export interface SkiaPictureViewProps extends SkiaBaseViewProps {
+    picture?: SkPicture;
+}
+export interface SkiaDomViewProps extends SkiaBaseViewProps {
+    root?: RenderNode<GroupProps>;
+    onTouch?: TouchHandler;
+}

package/lib/commonjs/views/useDrawCallback.d.ts

@@ -0,0 +1,8 @@
+import type { DependencyList } from "react";
+import type { RNSkiaDrawCallback } from "./types";
+/**
+ * Creates a memoized callback for the onDraw handler of a Skia component.
+ * @param callback The callback to memoize.
+ * @param deps Dependencies for the callback.
+ * */
+export declare const useDrawCallback: (callback: RNSkiaDrawCallback, deps?: DependencyList) => RNSkiaDrawCallback;

package/lib/commonjs/views/useTouchHandler.d.ts

@@ -0,0 +1,22 @@
+import type { DependencyList } from "react";
+import type { TouchHandlers, TouchHandler } from "./types";
+/**
+ * Provides a callback for handling touch events in the Skia View.
+ * This touch handler only handles single touches.
+ * @param handlers Callbacks for the different touch states
+ * @param deps optional Dependency array to update the handlers
+ * @returns A function that can be used from within the onDraw callback to
+ * update and handle touch events. Call it with the touches property from
+ * the info object.
+ */
+export declare const useTouchHandler: (handlers: TouchHandlers, deps?: DependencyList) => TouchHandler;
+/**
+ * Provides a callback for handling touch events in the Skia View.
+ * This touch handler handles multiple touches.
+ * @param handlers Callbacks for the different touch states
+ * @param deps optional Dependency array to update the handlers
+ * @returns A function that can be used from within the onDraw callback to
+ * update and handle touch events. Call it with the touches property from
+ * the info object.
+ */
+export declare const useMultiTouchHandler: (handlers: TouchHandlers, deps?: DependencyList) => TouchHandler;

package/lib/commonjs/web/LoadSkiaWeb.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit as CanvasKitType, CanvasKitInitOptions } from "canvaskit-wasm";
+declare global {
+    var CanvasKit: CanvasKitType;
+}
+export declare const LoadSkiaWeb: (opts?: CanvasKitInitOptions) => Promise<void>;
+export declare const LoadSkia: (opts?: CanvasKitInitOptions) => Promise<void>;

package/lib/commonjs/web/WithSkiaWeb.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentProps, ComponentType } from "react";
+import { Suspense } from "react";
+import { LoadSkiaWeb } from "./LoadSkiaWeb";
+interface WithSkiaProps {
+    fallback?: ComponentProps<typeof Suspense>["fallback"];
+    getComponent: () => Promise<{
+        default: ComponentType;
+    }>;
+    opts?: Parameters<typeof LoadSkiaWeb>[0];
+}
+export declare const WithSkiaWeb: ({ getComponent, fallback, opts, }: WithSkiaProps) => JSX.Element;
+export {};

package/lib/commonjs/web/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LoadSkiaWeb";
+export * from "./WithSkiaWeb";

package/lib/module/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/module/animation/decay/index.d.ts

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

package/lib/module/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/module/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/module/animation/functions/index.d.ts

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

package/lib/module/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/module/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/module/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/module/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/module/animation/index.d.ts

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