@shopify/react-native-skia 2.13.0 → 2.14.0

package/lib/typescript/src/skia/types/Path/Path.d.ts

@@ -1,8 +1,6 @@
 import type { SkRect } from "../Rect";
 import type { SkPoint } from "../Point";
-import type { InputRRect } from "../RRect";
 import type { StrokeJoin, StrokeCap } from "../Paint";
-import type { InputMatrix, SkMatrix } from "../Matrix";
 import type { SkJSIInstance } from "../JsiInstance";
 /**
  * Options used for Path.stroke(). If an option is omitted, a sensible default will be used.
@@ -43,166 +41,10 @@ export declare enum PathVerb {
 export type PathCommand = number[];
 export declare const isPath: (obj: SkJSIInstance<string> | null) => obj is SkPath;
 export interface SkPath extends SkJSIInstance<"Path"> {
-    /**
-     * Appends arc to Path, as the start of new contour. Arc added is part of ellipse
-     * bounded by oval, from startAngle through sweepAngle. Both startAngle and
-     * sweepAngle are measured in degrees, where zero degrees is aligned with the
-     * positive x-axis, and positive sweeps extends arc clockwise.
-     * Returns the modified path for easier chaining.
-     * @param oval
-     * @param startAngle
-     * @param sweepAngle
-     */
-    addArc(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number): SkPath;
-    /**
-     * Adds oval to Path, appending kMove_Verb, four kConic_Verb, and kClose_Verb.
-     * Oval is upright ellipse bounded by Rect oval with radii equal to half oval width
-     * and half oval height. Oval begins at start and continues clockwise by default.
-     * Returns the modified path for easier chaining.
-     * @param oval
-     * @param isCCW - if the path should be drawn counter-clockwise or not
-     * @param startIndex - index of initial point of ellipse
-     */
-    addOval(oval: SkRect, isCCW?: boolean, startIndex?: number): SkPath;
     /**
      * Returns the number of points in this path. Initially zero.
      */
     countPoints(): number;
-    /**
-     * Adds contour created from array of n points, adding (count - 1) line segments.
-     * Contour added starts at pts[0], then adds a line for every additional point
-     * in pts array. If close is true, appends kClose_Verb to Path, connecting
-     * pts[count - 1] and pts[0].
-     * Returns the modified path for easier chaining.
-     * @param points
-     * @param close - if true, will add a line connecting last point to the first point.
-     */
-    addPoly(points: SkPoint[], close: boolean): SkPath;
-    /** Adds beginning of contour at SkPoint (x, y).
-  
-          @param x  x-axis value of contour start
-          @param y  y-axis value of contour start
-          @return   reference to SkPath
-  
-          example: https://fiddle.skia.org/c/@Path_moveTo
-      */
-    moveTo(x: number, y: number): SkPath;
-    /** Adds line from last point to (x, y). If SkPath is empty, or last SkPath::Verb is
-          kClose_Verb, last point is set to (0, 0) before adding line.
-  
-          lineTo() appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed.
-          lineTo() then appends kLine_Verb to verb array and (x, y) to SkPoint array.
-  
-          @param x  end of added line on x-axis
-          @param y  end of added line on y-axis
-          @return   reference to SkPath
-  
-          example: https://fiddle.skia.org/c/@Path_lineTo
-      */
-    lineTo(x: number, y: number): SkPath;
-    /**
-     * Returns a new path that covers the same area as the original path, but with the
-     * Winding FillType. This may re-draw some contours in the path as counter-clockwise
-     * instead of clockwise to achieve that effect. If such a transformation cannot
-     * be done, null is returned.
-     */
-    makeAsWinding(): SkPath | null;
-    /**
-     * Translates all the points in the path by dx, dy.
-     * @param dx
-     * @param dy
-     */
-    offset(dx: number, dy: number): SkPath;
-    /**
-     * Relative version of arcToRotated.
-     * @param rx
-     * @param ry
-     * @param xAxisRotate
-     * @param useSmallArc
-     * @param isCCW
-     * @param dx
-     * @param dy
-     */
-    rArcTo(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): SkPath;
-    /**
-     * Relative version of conicTo.
-     * @param dx1
-     * @param dy1
-     * @param dx2
-     * @param dy2
-     * @param w
-     */
-    rConicTo(dx1: number, dy1: number, dx2: number, dy2: number, w: number): SkPath;
-    /**
-     * Relative version of cubicTo.
-     * @param cpx1
-     * @param cpy1
-     * @param cpx2
-     * @param cpy2
-     * @param x
-     * @param y
-     */
-    rCubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): SkPath;
-    /**
-     * Relative version of moveTo.
-     * @param x
-     * @param y
-     */
-    rMoveTo(x: number, y: number): SkPath;
-    /**
-     * Relative version of lineTo.
-     * @param x
-     * @param y
-     */
-    rLineTo(x: number, y: number): SkPath;
-    /**
-     * Relative version of quadTo.
-     * @param x1
-     * @param y1
-     * @param x2
-     * @param y2
-     */
-    rQuadTo(x1: number, y1: number, x2: number, y2: number): SkPath;
-    /**
-     * Sets FillType, the rule used to fill Path.
-     * @param fill
-     */
-    setFillType(fill: FillType): SkPath;
-    /**
-     * Specifies whether Path is volatile; whether it will be altered or discarded
-     * by the caller after it is drawn. Path by default have volatile set false.
-     *
-     * Mark animating or temporary paths as volatile to improve performance.
-     * Mark unchanging Path non-volatile to improve repeated rendering.
-     * @param volatile
-     */
-    setIsVolatile(volatile: boolean): SkPath;
-    /**
-     * Turns this path into the filled equivalent of the stroked path. Returns false if the operation
-     * fails (e.g. the path is a hairline).
-     * @param opts - describe how stroked path should look.
-     * If such a transformation cannot be done, null is returned.
-     */
-    stroke(opts?: StrokeOpts): null | SkPath;
-    /**
-     * Appends CLOSE_VERB to Path. A closed contour connects the first and last point
-     * with a line, forming a continuous loop.
-     */
-    close(): SkPath;
-    /**
-     * Sets Path to its initial state.
-     * Removes verb array, point array, and weights, and sets FillType to Winding.
-     * Internal storage associated with Path is released
-     */
-    reset(): SkPath;
-    /**
-     * Sets Path to its initial state.
-     * Removes verb array, point array, and weights, and sets FillType to Winding.
-     * Internal storage associated with Path is *not* released.
-     * Use rewind() instead of reset() if Path storage will be reused and performance
-     * is critical.
-     */
-    rewind(): SkPath;
     /**
      * Returns minimum and maximum axes values of the lines and curves in Path.
      * Returns (0, 0, 0, 0) if Path contains no points.
@@ -215,58 +57,6 @@ export interface SkPath extends SkJSIInstance<"Path"> {
      * and unlike getBounds(), does not cache the result.
      */
     computeTightBounds(): SkRect;
-    /**
-     * Appends arc to Path. Arc added is part of ellipse
-     * bounded by oval, from startAngle through sweepAngle. Both startAngle and
-     * sweepAngle are measured in degrees, where zero degrees is aligned with the
-     * positive x-axis, and positive sweeps extends arc clockwise.
-     * Returns the modified path for easier chaining.
-     * @param oval
-     * @param startAngleInDegrees
-     * @param sweepAngleInDegrees
-     * @param forceMoveTo
-     */
-    arcToOval(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number, forceMoveTo: boolean): SkPath;
-    /**
-     * Appends arc to Path. Arc is implemented by one or more conics weighted to
-     * describe part of oval with radii (rx, ry) rotated by xAxisRotate degrees. Arc
-     * curves from last Path Point to (x, y), choosing one of four possible routes:
-     * clockwise or counterclockwise, and smaller or larger. See SkPath.h for more details.
-     * Returns the modified path for easier chaining.
-     * @param rx
-     * @param ry
-     * @param xAxisRotate
-     * @param useSmallArc
-     * @param isCCW
-     * @param x
-     * @param y
-     */
-    arcToRotated(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): SkPath;
-    /**
-     * Appends arc to Path, after appending line if needed. Arc is implemented by conic
-     * weighted to describe part of circle. Arc is contained by tangent from
-     * last Path point to (x1, y1), and tangent from (x1, y1) to (x2, y2). Arc
-     * is part of circle sized to radius, positioned so it touches both tangent lines.
-     * Returns the modified path for easier chaining.
-     * @param x1
-     * @param y1
-     * @param x2
-     * @param y2
-     * @param radius
-     */
-    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): SkPath;
-    /**
-     * Adds conic from last point towards (x1, y1), to (x2, y2), weighted by w.
-     * If Path is empty, or path is closed, the last point is set to (0, 0)
-     * before adding conic.
-     * Returns the modified path for easier chaining.
-     * @param x1
-     * @param y1
-     * @param x2
-     * @param y2
-     * @param w
-     */
-    conicTo(x1: number, y1: number, x2: number, y2: number, w: number): SkPath;
     /**
      * Returns true if the point (x, y) is contained by Path, taking into
      * account FillType.
@@ -278,26 +68,6 @@ export interface SkPath extends SkJSIInstance<"Path"> {
      * Returns a copy of this Path.
      */
     copy(): SkPath;
-    /**
-     *  Adds cubic from last point towards (x1, y1), then towards (x2, y2), ending at
-     * (x3, y3). If Path is empty, or path is closed, the last point is set to
-     * (0, 0) before adding cubic.
-     * @param cpx1
-     * @param cpy1
-     * @param cpx2
-     * @param cpy2
-     * @param x
-     * @param y
-     */
-    cubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): SkPath;
-    /**
-     * Changes this path to be the dashed version of itself. This is the same effect as creating
-     * a DashPathEffect and calling filterPath on this path.
-     * @param on
-     * @param off
-     * @param phase
-     */
-    dash(on: number, off: number, phase: number): boolean;
     /**
      * Returns true if other path is equal to this path.
      * @param other
@@ -313,54 +83,6 @@ export interface SkPath extends SkJSIInstance<"Path"> {
      * Return the FillType for this path.
      */
     getFillType(): FillType;
-    /**
-     Adds quad from last point towards (x1, y1), to (x2, y2).
-  
-     If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding quad.
-  
-     Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kQuad_Verb to verb array;
-     and (x1, y1), (x2, y2) to SkPoint array.
-  
-     Parameters
-     x1	control SkPoint of quad on x-axis
-     y1	control SkPoint of quad on y-axis
-     x2	end SkPoint of quad on x-axis
-     y2	end SkPoint of quad on y-axis
-     Returns
-     reference to SkPath
-     example: https://fiddle.skia.org/c/@Path_quadTo
-    */
-    quadTo(x1: number, y1: number, x2: number, y2: number): SkPath;
-    /**
-     * Adds Rect to Path, appending kMove_Verb, three kLine_Verb, and kClose_Verb,
-     * starting with top-left corner of Rect; followed by top-right, bottom-right,
-     * and bottom-left if isCCW is false; or followed by bottom-left,
-     * bottom-right, and top-right if isCCW is true.
-     * Returns the modified path for easier chaining.
-     * @param rect
-     * @param isCCW
-     */
-    addRect(rect: SkRect, isCCW?: boolean): SkPath;
-    /**
-     * Adds rrect to Path, creating a new closed contour.
-     * Returns the modified path for easier chaining.
-     * @param rrect
-     * @param isCCW
-     */
-    addRRect(rrect: InputRRect, isCCW?: boolean): SkPath;
-    /** Appends src to SkPath, transformed by matrix. Transformed curves may have
-       different verbs, SkPoint, and conic weights.
-  
-        If mode is kAppend_AddPathMode, src verb array, SkPoint array, and conic
-       weights are added unaltered. If mode is kExtend_AddPathMode, add line
-       before appending verbs, SkPoint, and conic weights.
-  
-        @param src     SkPath verbs, SkPoint, and conic weights to add
-        @param matrix  transform applied to src
-        @param extend  extends path with line if true
-        @return        reference to SkPath
-    */
-    addPath(src: SkPath, matrix?: SkMatrix, extend?: boolean): SkPath;
     /**
      * Returns the Point at index in Point array. Valid range for index is
      * 0 to countPoints() - 1.
@@ -378,69 +100,14 @@ export interface SkPath extends SkJSIInstance<"Path"> {
      * may not speed repeated drawing.
      */
     isVolatile(): boolean;
-    /** Adds circle centered at (x, y) of size radius to SkPath, appending kMove_Verb,
-        four kConic_Verb, and kClose_Verb. Circle begins at: (x + radius, y), continuing
-        clockwise if dir is kCW_Direction, and counterclockwise if dir is kCCW_Direction.
-  
-        Has no effect if radius is zero or negative.
-  
-        @param x       center of circle
-        @param y       center of circle
-        @param radius  distance from center to edge
-        @return        reference to SkPath
-    */
-    addCircle(x: number, y: number, r: number): SkPath;
     getLastPt(): {
         x: number;
         y: number;
     };
-    /** Set this path to the result of applying the Op to this path and the
-      specified path: this = (this op operand).
-      The resulting path will be constructed from non-overlapping contours.
-      The curve order is reduced where possible so that cubics may be turned
-      into quadratics, and quadratics maybe turned into lines.
-  
-      Returns true if operation was able to produce a result;
-      otherwise, result is unmodified.
-  
-      @param path The second path (for difference, the subtrahend)
-      @param op The operator to apply.
-      @param result The product of the operands. The result may be one of the
-                    inputs.
-      @return True if the operation succeeded.
-      */
-    op(path: SkPath, op: PathOp): boolean;
-    /** Set this path to a set of non-overlapping contours that describe the
-      same area as the original path.
-      The curve order is reduced where possible so that cubics may
-      be turned into quadratics, and quadratics maybe turned into lines.
-  
-      Returns true if operation was able to produce a result;
-      otherwise, result is unmodified.
-  
-      @param result The simplified path. The result may be the input.
-      @return True if simplification succeeded.
-    */
-    simplify(): boolean;
     /**
      * Returns this path as an SVG string.
      */
     toSVGString(): string;
-    /**
-     * Take start and stop "t" values (values between 0...1), and modify this path such that
-     * it is a subset of the original path.
-     * The trim values apply to the entire path, so if it contains several contours, all of them
-     * are including in the calculation.
-     * Null is returned if either input value is NaN.
-     * @param startT - a value in the range [0.0, 1.0]. 0.0 is the beginning of the path.
-     * @param stopT  - a value in the range [0.0, 1.0]. 1.0 is the end of the path.
-     * @param isComplement
-     */
-    trim(startT: number, stopT: number, isComplement: boolean): null | SkPath;
-    /**
-     * Transforms the path by the specified matrix.
-     */
-    transform(m3: InputMatrix): SkPath;
     /**
      * Interpolates between Path with point array of equal size.
      * Copy verb array and weights to result, and set result path to a weighted
@@ -457,11 +124,10 @@ export interface SkPath extends SkJSIInstance<"Path"> {
      * @param ending  path to interpolate with
      * @param weight  contribution of this path, and
      *                 one minus contribution of ending path
-     * @param output  path to be replaced with the interpolated averages
-     * @return        Path replaced by interpolated averages or null if
+     * @return        New path of interpolated averages or null if
      *                not interpolatable
      * */
-    interpolate(end: SkPath, weight: number, output?: SkPath): SkPath | null;
+    interpolate(end: SkPath, weight: number): SkPath | null;
     /** Returns true if Path contain equal verbs and equal weights.
      *     @param compare  path to compare
      *     @return         true if Path can be interpolated equivalent

package/lib/typescript/src/skia/types/Recorder.d.ts

@@ -51,4 +51,14 @@ export interface JsiRecorder extends BaseRecorder {
     play(picture: SkPicture): void;
     applyUpdates(variables: SharedValue<unknown>[]): void;
     reset(): void;
+    /**
+     * Unique id of the native recording, used to tag the updates sent to the
+     * view that owns it.
+     */
+    getId(): number;
+    /**
+     * Releases the wrapper's reference to the native recorder. A recording
+     * that a view owns stays alive until the view replaces it or is torn down.
+     */
+    dispose(): void;
 }

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

@@ -23,4 +23,20 @@ export interface SurfaceFactory {
      * @param opts - optional surface options (e.g. colorSpace: "display-p3" | "srgb").
      */
     MakeOffscreen: (width: number, height: number, opts?: SurfaceOptions) => SkSurface | null;
+    /**
+     * Creates a GPU backed surface that draws directly into a WebGPU texture
+     * (zero-copy). The texture must be created on Skia's device
+     * (importDevice(Skia.getNativeDevice())) with RENDER_ATTACHMENT usage; add
+     * TEXTURE_BINDING to sample what Skia drew from WebGPU after each flush().
+     * The surface holds its own reference to the texture and keeps it alive
+     * for its lifetime, so the caller may release the GPUTexture once the
+     * surface exists. Calling destroy() on the GPUTexture still invalidates
+     * the surface.
+     *
+     * Note: This method is only available when the Graphite backend is enabled.
+     *
+     * @param pointer - The WGPUTexture pointer (texture.nativePointer)
+     * @returns An SkSurface rendering into the texture, or throws if the texture is invalid
+     */
+    MakeFromNativeTexture: (pointer: bigint) => SkSurface;
 }

package/lib/typescript/src/skia/web/JsiSkPath.d.ts

@@ -1,11 +1,11 @@
 import type { CanvasKit, PathBuilder as CKPathBuilder } from "canvaskit-wasm";
-import type { FillType, PathCommand, PathOp, SkMatrix, SkPath, SkPoint, SkRect, InputRRect, StrokeOpts, InputMatrix } from "../types";
+import type { FillType, PathCommand, SkPath, SkPoint, SkRect, InputMatrix } from "../types";
 import { HostObject } from "./Host";
 import { JsiSkRect } from "./JsiSkRect";
 export declare const toMatrix3x3: (m: InputMatrix) => number[];
 /**
- * SkPath wraps a CK PathBuilder internally, providing both mutable building
- * methods and immutable query methods. Use snapshot() internally to get
+ * SkPath wraps a CK PathBuilder internally, providing immutable query
+ * methods. Use snapshot() internally to get
  * an immutable CK Path for read-only operations.
  */
 export declare class JsiSkPath extends HostObject<CKPathBuilder, "Path"> implements SkPath {
@@ -14,40 +14,6 @@ export declare class JsiSkPath extends HostObject<CKPathBuilder, "Path"> impleme
     private asPath;
     /** Extract an immutable CK Path from a JsiSkPath value (for CK interop). */
     static pathFromValue(value: SkPath): import("canvaskit-wasm").Path;
-    addPath(src: SkPath, matrix?: SkMatrix, extend?: boolean): this;
-    addArc(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number): this;
-    addOval(oval: SkRect, isCCW?: boolean, startIndex?: number): this;
-    addPoly(points: SkPoint[], close: boolean): this;
-    addRect(rect: SkRect, isCCW?: boolean): this;
-    addRRect(rrect: InputRRect, isCCW?: boolean): this;
-    addCircle(x: number, y: number, r: number): this;
-    moveTo(x: number, y: number): this;
-    rMoveTo(x: number, y: number): this;
-    lineTo(x: number, y: number): this;
-    rLineTo(x: number, y: number): this;
-    quadTo(x1: number, y1: number, x2: number, y2: number): this;
-    rQuadTo(x1: number, y1: number, x2: number, y2: number): this;
-    conicTo(x1: number, y1: number, x2: number, y2: number, w: number): this;
-    rConicTo(x1: number, y1: number, x2: number, y2: number, w: number): this;
-    cubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): this;
-    rCubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): this;
-    close(): this;
-    reset(): this;
-    rewind(): this;
-    arcToOval(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number, forceMoveTo: boolean): this;
-    arcToRotated(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): this;
-    rArcTo(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): this;
-    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): this;
-    setFillType(fill: FillType): this;
-    setIsVolatile(_volatile: boolean): this;
-    offset(dx: number, dy: number): this;
-    transform(m: InputMatrix): this;
-    makeAsWinding(): this | null;
-    simplify(): boolean;
-    op(path: SkPath, op: PathOp): boolean;
-    dash(on: number, off: number, phase: number): boolean;
-    stroke(opts?: StrokeOpts): this | null;
-    trim(start: number, stop: number, isComplement: boolean): this | null;
     countPoints(): number;
     computeTightBounds(): SkRect;
     contains(x: number, y: number): boolean;
@@ -64,6 +30,6 @@ export declare class JsiSkPath extends HostObject<CKPathBuilder, "Path"> impleme
     };
     toSVGString(): string;
     isInterpolatable(path2: SkPath): boolean;
-    interpolate(end: SkPath, weight: number, output?: SkPath): SkPath | null;
+    interpolate(end: SkPath, weight: number): SkPath | null;
     toCmds(): PathCommand[];
 }

package/lib/typescript/src/skia/web/JsiSkSurfaceFactory.d.ts

@@ -1,9 +1,10 @@
 import type { CanvasKit } from "canvaskit-wasm";
-import type { SurfaceFactory } from "../types";
+import type { SkSurface, SurfaceFactory } from "../types";
 import { Host } from "./Host";
 import { JsiSkSurface } from "./JsiSkSurface";
 export declare class JsiSkSurfaceFactory extends Host implements SurfaceFactory {
     constructor(CanvasKit: CanvasKit);
     Make(width: number, height: number): JsiSkSurface;
     MakeOffscreen(width: number, height: number): JsiSkSurface | null;
+    MakeFromNativeTexture(_pointer: bigint): SkSurface;
 }

package/lib/typescript/src/sksg/Container.native.d.ts

@@ -2,11 +2,25 @@ import type { Skia } from "../skia/types";
 import { Container, StaticContainer } from "./StaticContainer";
 import "../skia/NativeSetup";
 import "../views/api";
+/**
+ * Records the scene graph on the JS thread and hands the native recorder to
+ * the view, which owns it and replays it on every draw. The Reanimated mapper
+ * only pushes the shared values into that recorder through the view id: no
+ * Skia object is captured by a worklet, so nothing on the UI runtime holds
+ * native memory. The JS wrapper is disposed right after the handoff, so the
+ * view is the sole owner and the resources referenced by the recording
+ * (images, pictures) are released when the view replaces it or is torn down,
+ * not when a garbage collector gets around to a wrapper.
+ *
+ * Unmounting does not clear the view: the native view can outlive the React
+ * tree (exit animations, screen transitions) and keeps showing its last frame
+ * until it is torn down, which is when the recording is released.
+ */
 declare class NativeReanimatedContainer extends Container {
     private nativeId;
     private mapperId;
-    private picture;
     constructor(Skia: Skia, nativeId: number);
+    private stopMapper;
     unmount(): void;
     redraw(): void;
 }

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

@@ -1,4 +1,5 @@
 import type { ViewProps } from "react-native";
+import type { SharedValue } from "react-native-reanimated";
 import type { SkImage, SkPicture, SkRect, SkSize } from "../skia/types";
 export type NativeSkiaViewProps = ViewProps & {
     debug?: boolean;
@@ -22,6 +23,14 @@ export interface ISkiaViewApi {
     web?: boolean;
     setJsiProperty: <T>(nativeId: number, name: string, value: T) => void;
     requestRedraw: (nativeId: number) => void;
+    /**
+     * Reads the shared values into the recording held for the view and
+     * schedules a redraw. Native only; called from a worklet on every frame.
+     * Until the view registers, the recording is queued for it and kept
+     * current all the same. Ignored when the recording `recorderId` is neither
+     * held by the view nor queued for it.
+     */
+    applyUpdates: (nativeId: number, recorderId: number, values: SharedValue<unknown>[]) => void;
     makeImageSnapshot: (nativeId: number, rect?: SkRect) => SkImage;
     makeImageSnapshotAsync: (nativeId: number, rect?: SkRect) => Promise<SkImage>;
     size: (nativeId: number) => SkSize;

package/package.json

@@ -8,7 +8,7 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",
@@ -115,7 +115,7 @@
     "@types/react-reconciler": "0.28.9",
     "@types/ws": "8.5.3",
     "eslint": "9.36.0",
-    "eslint-config-react-native-wcandillon": "4.0.1",
+    "eslint-config-react-native-wcandillon": "5.0.0",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-react-hooks": "^5.2.0",
     "extract-zip": "^2.0.1",

package/src/Platform/IPlatform.ts

@@ -8,10 +8,7 @@ export interface IPlatform {
   PixelRatio: number;
   findNodeHandle: (
     componentOrHandle:
-      | null
-      | number
-      | React.Component<any, any>
-      | React.ComponentClass<any>
+      null | number | React.Component<any, any> | React.ComponentClass<any>
   ) => null | NodeHandle;
   resolveAsset: (source: DataModule) => string;
   View: typeof ViewComponent;

package/src/animation/functions/interpolate.ts

@@ -22,10 +22,7 @@ interface RequiredExtrapolationConfig {
 }
 
 export type ExtrapolationType =
-  | ExtrapolationConfig
-  | Extrapolate
-  | string
-  | undefined;
+  ExtrapolationConfig | Extrapolate | string | undefined;
 
 function getVal(
   type: Extrapolate,

package/src/animation/functions/interpolatePaths.ts

@@ -12,6 +12,12 @@ const lerp = (
   p2: SkPath
 ) => {
   "worklet";
+  // Zero-width segment (duplicate input stops): t would be NaN or Infinity.
+  // Return the segment's end path (p2), i.e. the value jumps to p2 at the stop.
+  // reanimated's interpolate has no explicit guard here, so this is our choice.
+  if (to === from) {
+    return p2;
+  }
   const t = (value - from) / (to - from);
   // interpolate returns a new path (immutable operation)
   return p2.interpolate(p1, t)!;
@@ -41,12 +47,25 @@ export const interpolatePaths = (
   _output?: SkPath
 ) => {
   "worklet";
+  if (input.length < 2 || input.length !== outputRange.length) {
+    throw new Error(
+      `interpolatePaths() requires input and outputRange to have the same length and at least 2 entries, received ${input.length} and ${outputRange.length}`
+    );
+  }
+  if (Number.isNaN(value)) {
+    throw new Error("interpolatePaths() received NaN as value");
+  }
   const extrapolation = validateInterpolationOptions(options);
   if (value < input[0]) {
     switch (extrapolation.extrapolateLeft) {
       case Extrapolate.CLAMP:
         return outputRange[0];
       case Extrapolate.EXTEND:
+        if (!Number.isFinite(value)) {
+          throw new Error(
+            "interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead"
+          );
+        }
         return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);
       case Extrapolate.IDENTITY:
         throw new Error(
@@ -60,6 +79,11 @@ export const interpolatePaths = (
       case Extrapolate.CLAMP:
         return outputRange[outputRange.length - 1];
       case Extrapolate.EXTEND:
+        if (!Number.isFinite(value)) {
+          throw new Error(
+            "interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead"
+          );
+        }
         return lerp(
           value,
           input[input.length - 2],

package/src/skia/core/Image.ts

@@ -33,8 +33,7 @@ export const makeImageFromView = <
 >(
   viewRef: React.RefObject<T>,
   callback:
-    | null
-    | ((viewRef: React.RefObject<T>) => Promise<SkImage | null>) = null
+    null | ((viewRef: React.RefObject<T>) => Promise<SkImage | null>) = null
 ) => {
   // In web implementation we just delegate the work to the provided callback
   if (Platform.OS === "web") {