@shopify/react-native-skia 2.13.0 → 2.13.1

package/android/cpp/rnskia-android/OpenGLContext.h

@@ -28,7 +28,7 @@ public:
 
   gl::Display *getDisplay() { return _glDisplay.get(); }
   gl::Context *getContext() { return _glContext.get(); }
-  gl::Surface *getSurface() { return _glSurface.get(); };
+  gl::Surface *getSurface() { return _glSurface.get(); }
   EGLConfig getConfig() { return _glConfig; }
 
 private:

package/android/cpp/rnskia-android/gl/Surface.h

@@ -40,4 +40,4 @@ private:
   Surface &operator=(const Surface &) = delete;
 };
 
-} // Namespace gl
+} // namespace gl

package/cpp/api/JsiSkImage.h

@@ -66,7 +66,7 @@ static sk_sp<SkData> replaceJpegICCWithAppleP3(sk_sp<SkData> jpegData) {
     return jpegData;
 
   const uint8_t *iccBytes = CFDataGetBytePtr(cfICC);
-  size_t iccLen = (size_t)CFDataGetLength(cfICC);
+  size_t iccLen = static_cast<size_t>(CFDataGetLength(cfICC));
 
   // "ICC_PROFILE\0" APP2 marker signature (12 bytes)
   static const uint8_t iccSig[] = {0x49, 0x43, 0x43, 0x5F, 0x50, 0x52,

package/cpp/api/JsiSkImageFilter.h

@@ -28,7 +28,9 @@ public:
       : JsiSkWrappingSkPtrNativeObject<JsiSkImageFilter, SkImageFilter>(
             std::move(context), std::move(imageFilter)) {}
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // A image filter node is a few hundred bytes; the images it may reference
+  // are reported by their own wrappers.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);

package/cpp/api/JsiSkParagraph.h

@@ -277,7 +277,8 @@ public:
                       &JsiSkParagraph::extendedVisit);
   }
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // Shaped glyph runs and line metrics; there is no exact API for this.
+  size_t getMemoryPressure() override { return 16 * 1024; }
 
   explicit JsiSkParagraph(std::shared_ptr<RNSkPlatformContext> context,
                           para::ParagraphBuilder *paragraphBuilder)

package/cpp/api/JsiSkParagraphBuilder.h

@@ -93,7 +93,7 @@ public:
                            &JsiSkParagraphBuilder::pop);
   }
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   explicit JsiSkParagraphBuilder(std::shared_ptr<RNSkPlatformContext> context,
                                  para::ParagraphStyle paragraphStyle,

package/cpp/api/JsiSkParagraphBuilderFactory.h

@@ -47,7 +47,7 @@ public:
                   &JsiSkParagraphBuilderFactory::Make);
   }
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   explicit JsiSkParagraphBuilderFactory(
       std::shared_ptr<RNSkPlatformContext> context)

package/cpp/api/JsiSkPath.h

@@ -640,11 +640,18 @@ public:
       : JsiSkPath(std::move(context), SkPathBuilder(path)) {}
 
   size_t getMemoryPressure() override {
-    auto builder = getObject();
-    if (!builder)
+    if (isDisposed()) {
       return 0;
-
-    return builder->snapshot().approximateBytesUsed();
+    }
+    auto builder = getObjectUnchecked();
+    if (!builder) {
+      return 0;
+    }
+    // The point, verb and conic weight arrays of the builder. Snapshotting
+    // the path to measure it would copy them, and this runs on every round
+    // trip of the object to JS.
+    return builder->points().size_bytes() + builder->verbs().size_bytes() +
+           builder->conicWeights().size_bytes();
   }
 
   /**

package/cpp/api/JsiSkPathBuilder.h

@@ -271,11 +271,18 @@ public:
             std::make_shared<SkPathBuilder>(std::move(builder))) {}
 
   size_t getMemoryPressure() override {
-    auto builder = getObject();
-    if (!builder)
+    if (isDisposed()) {
       return 0;
-    // Estimate memory usage based on snapshot
-    return builder->snapshot().approximateBytesUsed();
+    }
+    auto builder = getObjectUnchecked();
+    if (!builder) {
+      return 0;
+    }
+    // The point, verb and conic weight arrays of the builder. Snapshotting
+    // the path to measure it would copy them, and this runs on every round
+    // trip of the object to JS.
+    return builder->points().size_bytes() + builder->verbs().size_bytes() +
+           builder->conicWeights().size_bytes();
   }
 
   static jsi::Value toValue(jsi::Runtime &runtime,

package/cpp/api/JsiSkPictureRecorder.h

@@ -58,7 +58,8 @@ public:
                   &JsiSkPictureRecorder::finishRecordingAsPicture);
   }
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // The recorded picture reports its own size once finished.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {

package/cpp/api/JsiSkShader.h

@@ -29,7 +29,9 @@ public:
       : JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader>(
             std::move(context), std::move(shader)) {}
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // A shader node is a few hundred bytes; the images it may reference
+  // are reported by their own wrappers.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static sk_sp<SkShader> fromValue(jsi::Runtime &runtime,
                                    const jsi::Value &obj) {

package/cpp/api/JsiSkSkottie.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <optional>
 #include <string>
@@ -31,7 +32,7 @@
 #pragma clang diagnostic pop
 
 namespace RNSkia {
-using namespace facebook;
+namespace jsi = facebook::jsi;
 
 std::unique_ptr<SkCodec> DecodeImageData(sk_sp<SkData> data) {
   if (data == nullptr) {
@@ -74,6 +75,8 @@ public:
       if (!codec) {
         return nullptr;
       }
+      // The asset keeps its decoded frame for the lifetime of the animation.
+      _decodedImageBytes += codec->getInfo().computeMinByteSize();
       return skresources::MultiFrameImageAsset::Make(std::move(codec));
     }
 
@@ -102,11 +105,16 @@ public:
     return this->findAsset(name);
   }
 
+  // Bytes of the decoded images for the assets loaded so far.
+  size_t decodedImageBytes() const { return _decodedImageBytes; }
+
 private:
   explicit SkottieAssetProvider(AssetMap assets, sk_sp<SkFontMgr> fontMgr)
       : fAssets(std::move(assets)), fFontMgr(std::move(fontMgr)) {}
   const AssetMap fAssets;
   const sk_sp<SkFontMgr> fFontMgr;
+  // loadImageAsset() is const in skottie::ResourceProvider.
+  mutable size_t _decodedImageBytes = 0;
 
   sk_sp<SkData> findAsset(const char name[]) const {
     auto it = fAssets.find(name);
@@ -121,6 +129,12 @@ class ManagedAnimation {
 public:
   ManagedAnimation(std::string json, SkottieAssetProvider::AssetMap assets,
                    sk_sp<SkFontMgr> fontMgr) {
+    _approximateBytesUsed = json.size();
+    for (const auto &asset : assets) {
+      if (asset.second) {
+        _approximateBytesUsed += asset.second->size();
+      }
+    }
     _propManager = std::make_unique<CustomPropertyManager>(
         CustomPropertyManager::Mode::kCollapseProperties, "");
     _resourceProvider =
@@ -132,6 +146,8 @@ public:
     builder->setPropertyObserver(_propManager->getPropertyObserver());
     _animation = builder->make(json.c_str(), json.size());
     _slotManager = builder->getSlotManager();
+    // Image assets are loaded while the animation is built.
+    _approximateBytesUsed += _resourceProvider->decodedImageBytes();
   }
 
   ~ManagedAnimation() {
@@ -151,6 +167,10 @@ public:
   sk_sp<skottie::SlotManager> _slotManager = nullptr;
   sk_sp<SkottieAssetProvider> _resourceProvider = nullptr;
   std::unique_ptr<CustomPropertyManager> _propManager = nullptr;
+  // Size of the animation JSON, its encoded assets and its decoded images:
+  // the memory the animation actually owns (the scene graph is in the same
+  // order as the JSON). Used as the GC hint for the wrapper.
+  size_t _approximateBytesUsed = 0;
 };
 
 class JsiSkSkottie
@@ -579,31 +599,13 @@ public:
 
   size_t getMemoryPressure() override {
     auto animation = getObject();
-    if (!animation || !animation->_animation) {
-      return 1024; // Base size if no animation
+    if (!animation) {
+      return kMinMemoryPressure;
     }
-
-    auto size = animation->_animation->size();
-    auto duration = animation->_animation->duration();
-    auto fps = animation->_animation->fps();
-
-    // Estimate memory usage based on animation properties
-    // Base calculation: width * height * 4 bytes per pixel * estimated frame
-    // count
-    size_t frameCount = static_cast<size_t>(duration * fps);
-    size_t estimatedFrameSize =
-        static_cast<size_t>(size.width() * size.height() * 4);
-
-    // Conservative estimate: assume some frames are cached
-    size_t cachedFrames =
-        std::min(frameCount, static_cast<size_t>(60)); // Max 60 cached frames
-    size_t animationMemory = estimatedFrameSize * cachedFrames;
-
-    // Add base overhead for animation data structures
-    size_t baseOverhead =
-        64 * 1024; // 64KB for metadata, property managers, etc.
-
-    return animationMemory + baseOverhead;
+    // Skottie keeps no frame cache: report the bytes the animation owns.
+    // Estimating a pixel cache here (width * height * 4 * 60 frames) charged
+    // hundreds of MB per wrapper, and each capture in a worklet repeated it.
+    return std::max(animation->_approximateBytesUsed, kMinMemoryPressure);
   }
 };
 } // namespace RNSkia

package/cpp/api/recorder/Command.h

@@ -55,7 +55,7 @@ public:
   CommandType type;
   std::string nodeType;
 
-  Command(CommandType t) : type(t) {}
+  explicit Command(CommandType t) : type(t) {}
   Command(CommandType t, std::string nodeT) : type(t), nodeType(nodeT) {}
   virtual ~Command() = default;
 };

package/cpp/api/recorder/Convertor.h

@@ -692,7 +692,7 @@ SkPath1DPathEffect::Style getPropertyValue(jsi::Runtime &runtime,
 // specialization
 struct BlendModeValue {
   int value;
-  BlendModeValue(int v = 0) : value(v) {}
+  explicit BlendModeValue(int v = 0) : value(v) {}
   operator int() const { return value; }
 };
 

package/cpp/api/recorder/DataTypes.h

@@ -78,7 +78,7 @@ SkPoint processPoint(jsi::Runtime &runtime, const jsi::Value &value) {
     }
   }
   throw std::runtime_error("Couldn't read point value");
-};
+}
 
 // TODO: return the SkRRect directly
 std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,

package/cpp/api/recorder/DrawingCtx.h

@@ -52,7 +52,7 @@ struct Composers {
 
 class DrawingCtx {
 public:
-  DrawingCtx(SkCanvas *canvas) : canvas(canvas) {
+  explicit DrawingCtx(SkCanvas *canvas) : canvas(canvas) {
     SkPaint paint;
     paint.setAntiAlias(true);
     paints.push_back(paint);

package/cpp/api/recorder/JsiRecorder.h

@@ -24,7 +24,7 @@ class JsiRecorder
 public:
   static constexpr const char *CLASS_NAME = "Recorder";
 
-  JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
+  explicit JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder>(
             std::move(context), std::make_shared<Recorder>()) {
     getObject()->_context = getContext();
@@ -379,9 +379,12 @@ public:
     installHostMethod(runtime, prototype, "reset", &JsiRecorder::reset);
   }
 
-  // This has no basis in reality but since since these are private long-lived
-  // objects, we think it is more than fine.
-  size_t getMemoryPressure() override { return 5 * 1024 * 1024; }
+  // The recorder itself is a small command list. The resources it references
+  // (images, pictures, paths) report their own size through their wrappers
+  // and the pictures produced by play() report theirs. Do not put a made-up
+  // number here: a new recorder is created on every React commit and the
+  // charge is repeated each time it is unboxed on the UI runtime.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {

package/cpp/api/third_party/base64.cpp

@@ -4,7 +4,7 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-#include "base64.h"
+#include "api/third_party/base64.h"
 
 #include <cstdint>
 

package/cpp/jsi/JSICache.cpp

@@ -1,5 +1,6 @@
 #include "JSICache.h"
 
+#include <algorithm>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
@@ -96,4 +97,26 @@ jsi::Object &JSICache::setPrototype(PrototypeKey key, jsi::Object prototype) {
   return it->second;
 }
 
+jsi::Value JSICache::lockWrapper(jsi::Runtime &runtime,
+                                 const void *nativeObject) {
+  auto it = _wrappers.find(nativeObject);
+  if (it == _wrappers.end()) {
+    return jsi::Value::undefined();
+  }
+  return it->second.lock(runtime);
+}
+
+void JSICache::setWrapper(jsi::Runtime &runtime, const void *nativeObject,
+                          const jsi::Object &wrapper) {
+  _wrappers.insert_or_assign(nativeObject, jsi::WeakObject(runtime, wrapper));
+  if (_wrappers.size() < _pruneWrappersAt) {
+    return;
+  }
+  for (auto it = _wrappers.begin(); it != _wrappers.end();) {
+    it = it->second.lock(runtime).isUndefined() ? _wrappers.erase(it)
+                                                : std::next(it);
+  }
+  _pruneWrappersAt = std::max(kMinPruneWrappersAt, _wrappers.size() * 2);
+}
+
 } // namespace RNJsi

package/cpp/jsi/JSICache.h

@@ -13,7 +13,8 @@ namespace jsi = facebook::jsi;
 
 /**
  * Per-runtime store for JSI values that native code wants to keep across
- * calls (currently: the prototype object of every NativeObject class).
+ * calls: the prototype object of every NativeObject class, and the JS
+ * wrapper of every native object that has one on the runtime.
  *
  * Ownership model (borrowed from react-native-nitro-modules' JSICache):
  *
@@ -72,6 +73,26 @@ public:
    */
   jsi::Object &setPrototype(PrototypeKey key, jsi::Object prototype);
 
+  /**
+   * Returns the JS wrapper stored for `nativeObject` on this runtime, or
+   * undefined if none was stored or the wrapper has been collected.
+   *
+   * The key is the native object's address. A live wrapper keeps its native
+   * object alive (the object is the wrapper's NativeState), so as long as
+   * the entry locks it still belongs to that object. Once the wrapper has
+   * been collected the entry is stale and is skipped or replaced, so an
+   * address reused by a new object can never resolve to the old wrapper.
+   */
+  jsi::Value lockWrapper(jsi::Runtime &runtime, const void *nativeObject);
+
+  /**
+   * Stores `wrapper` as the JS wrapper of `nativeObject` on this runtime.
+   * Only a weak reference is kept: the wrapper stays collectable, and the
+   * native object is released when it goes away.
+   */
+  void setWrapper(jsi::Runtime &runtime, const void *nativeObject,
+                  const jsi::Object &wrapper);
+
   JSICache() = default;
   ~JSICache() override = default;
   JSICache(const JSICache &) = delete;
@@ -81,6 +102,12 @@ private:
   static std::shared_ptr<JSICache> getOrCreateOnGlobal(jsi::Runtime &runtime);
 
   std::unordered_map<PrototypeKey, jsi::Object> _prototypes;
+  // Native object -> its wrapper on this runtime. Entries of collected
+  // wrappers are pruned in setWrapper once the map has doubled since the
+  // last pruning, so it stays proportional to the number of live wrappers.
+  std::unordered_map<const void *, jsi::WeakObject> _wrappers;
+  size_t _pruneWrappersAt = kMinPruneWrappersAt;
+  static constexpr size_t kMinPruneWrappersAt = 64;
 
   // Runtime -> cache. Weak on purpose: the runtime's global owns the cache.
   static std::mutex _registryMutex;

package/cpp/jsi/NativeObject.h

@@ -210,12 +210,12 @@ public:
             if (instance == nullptr) {
               throw jsi::JSError(rt, "Invalid boxed native object state");
             }
-            // Unboxing creates a *view* of the object on the target runtime.
-            // Keep the runtime the object was originally created on: async
-            // native code (e.g. GPUDevice error/lost events) delivers into
-            // the creation runtime, and rebinding it to a worklet runtime
-            // would invoke main-runtime jsi::Functions on the wrong runtime
-            // and thread.
+            // Unboxing hands back the wrapper cached for the target runtime,
+            // creating it on first use. Keep the runtime the object was
+            // originally created on: async native code (e.g. GPUDevice
+            // error/lost events) delivers into the creation runtime, and
+            // rebinding it to a worklet runtime would invoke main-runtime
+            // jsi::Functions on the wrong runtime and thread.
             auto *originalRuntime = instance->getCreationRuntime();
             auto value = Derived::create(rt, instance);
             if (originalRuntime != nullptr) {
@@ -262,10 +262,37 @@ public:
   }
 
   /**
-   * Create a JS object with native state attached.
+   * Returns the JS wrapper of `instance` on `runtime`, creating it on first
+   * use.
+   *
+   * A native object has at most one live wrapper per runtime. The wrapper is
+   * cached (weakly, so it stays collectable) in the runtime's JSICache, and
+   * converting the same object again (returning it from another native
+   * call, unboxing it in a worklet on every frame, ...) hands back that
+   * wrapper instead of a new one. Each wrapper reports the native memory the
+   * object owns to the GC of its runtime through setExternalMemoryPressure,
+   * so the memory is charged exactly once per runtime that can reach the
+   * object, however often it is converted; charging every conversion used
+   * to multiply the amount by the number of captures in a worklet until
+   * Hermes hit its max heap size. The hint is refreshed on every round trip
+   * for objects whose size changes after creation (path and paragraph
+   * builders).
    */
   static jsi::Value create(jsi::Runtime &runtime,
                            std::shared_ptr<Derived> instance) {
+    auto &cache = JSICache::get(runtime);
+    const void *key = instance.get();
+
+    auto existing = cache.lockWrapper(runtime, key);
+    if (existing.isObject()) {
+      auto pressure = instance->getMemoryPressure();
+      if (pressure > 0) {
+        existing.getObject(runtime).setExternalMemoryPressure(runtime,
+                                                              pressure);
+      }
+      return existing;
+    }
+
     // Store creation runtime for logging etc.
     instance->setCreationRuntime(&runtime);
 
@@ -290,9 +317,11 @@ public:
       obj.setExternalMemoryPressure(runtime, pressure);
     }
 
+    cache.setWrapper(runtime, key, obj);
     return std::move(obj);
   }
 
+public:
   /**
    * Get the native state from a JS value.
    * Throws if the value doesn't have the expected native state.

package/cpp/rnskia/RNDawnContext.h

@@ -112,7 +112,7 @@ public:
     int height = static_cast<int>(IOSurfaceGetHeight(ioSurface));
 #else
     wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc;
-    auto ahb = (AHardwareBuffer *)buffer;
+    auto ahb = reinterpret_cast<AHardwareBuffer *>(buffer);
     platformDesc.handle = ahb;
     AHardwareBuffer_Desc adesc;
     AHardwareBuffer_describe(ahb, &adesc);

package/lib/commonjs/animation/functions/interpolatePaths.js

@@ -9,6 +9,12 @@ var _interpolate = require("./interpolate");
 const lerp = (value, from, to, p1, p2) => {
   "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);
@@ -33,12 +39,21 @@ const lerp = (value, from, to, p1, p2) => {
 const interpolatePaths = (value, input, outputRange, options, _output) => {
   "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 = (0, _interpolate.validateInterpolationOptions)(options);
   if (value < input[0]) {
     switch (extrapolation.extrapolateLeft) {
       case _interpolate.Extrapolate.CLAMP:
         return outputRange[0];
       case _interpolate.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 _interpolate.Extrapolate.IDENTITY:
         throw new Error("Identity is not a supported extrapolation type for interpolatePaths()");
@@ -50,6 +65,9 @@ const interpolatePaths = (value, input, outputRange, options, _output) => {
       case _interpolate.Extrapolate.CLAMP:
         return outputRange[outputRange.length - 1];
       case _interpolate.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], input[input.length - 1], outputRange[input.length - 2], outputRange[input.length - 1]);
       case _interpolate.Extrapolate.IDENTITY:
         throw new Error("Identity is not a supported extrapolation type for interpolatePaths()");

package/lib/commonjs/animation/functions/interpolatePaths.js.map

@@ -1 +1 @@
-{"version":3,"names":["_typeddash","require","_interpolate","lerp","value","from","to","p1","p2","t","interpolate","interpolatePaths","input","outputRange","options","_output","extrapolation","validateInterpolationOptions","extrapolateLeft","Extrapolate","CLAMP","EXTEND","IDENTITY","Error","exhaustiveCheck","length","extrapolateRight","i","exports"],"sources":["interpolatePaths.ts"],"sourcesContent":["import type { SkPath } from \"../../skia/types\";\nimport { exhaustiveCheck } from \"../../renderer/typeddash\";\n\nimport type { ExtrapolationType } from \"./interpolate\";\nimport { validateInterpolationOptions, Extrapolate } from \"./interpolate\";\n\nconst lerp = (\n  value: number,\n  from: number,\n  to: number,\n  p1: SkPath,\n  p2: SkPath\n) => {\n  \"worklet\";\n  const t = (value - from) / (to - from);\n  // interpolate returns a new path (immutable operation)\n  return p2.interpolate(p1, t)!;\n};\n\n/**\n * Maps an input value within a range to an output path within a path range.\n * @param value - The input value.\n * @param inputRange - The range of the input value.\n * @param outputRange - The range of the output path.\n * @param options - Extrapolation options\n * @returns The output path.\n * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>\n * const path1 = new Path();\n * path1.moveTo(0, 0);\n * path1.lineTo(100, 0);\n * const path2 = new Path();\n * path2.moveTo(0, 0);\n * path2.lineTo(0, 100);\n * const path = interpolatePath(0.5, [0, 1], [path1, path2]);\n */\nexport const interpolatePaths = (\n  value: number,\n  input: number[],\n  outputRange: SkPath[],\n  options?: ExtrapolationType,\n  _output?: SkPath\n) => {\n  \"worklet\";\n  const extrapolation = validateInterpolationOptions(options);\n  if (value < input[0]) {\n    switch (extrapolation.extrapolateLeft) {\n      case Extrapolate.CLAMP:\n        return outputRange[0];\n      case Extrapolate.EXTEND:\n        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateLeft);\n    }\n  } else if (value > input[input.length - 1]) {\n    switch (extrapolation.extrapolateRight) {\n      case Extrapolate.CLAMP:\n        return outputRange[outputRange.length - 1];\n      case Extrapolate.EXTEND:\n        return lerp(\n          value,\n          input[input.length - 2],\n          input[input.length - 1],\n          outputRange[input.length - 2],\n          outputRange[input.length - 1]\n        );\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateRight);\n    }\n  }\n  let i = 0;\n  for (; i <= input.length - 1; i++) {\n    if (value >= input[i] && value <= input[i + 1]) {\n      break;\n    }\n  }\n  return lerp(\n    value,\n    input[i],\n    input[i + 1],\n    outputRange[i],\n    outputRange[i + 1]\n  );\n};\n"],"mappings":";;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA;AAGA,IAAAC,YAAA,GAAAD,OAAA;AAEA,MAAME,IAAI,GAAGA,CACXC,KAAa,EACbC,IAAY,EACZC,EAAU,EACVC,EAAU,EACVC,EAAU,KACP;EACH,SAAS;;EACT,MAAMC,CAAC,GAAG,CAACL,KAAK,GAAGC,IAAI,KAAKC,EAAE,GAAGD,IAAI,CAAC;EACtC;EACA,OAAOG,EAAE,CAACE,WAAW,CAACH,EAAE,EAAEE,CAAC,CAAC;AAC9B,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,gBAAgB,GAAGA,CAC9BP,KAAa,EACbQ,KAAe,EACfC,WAAqB,EACrBC,OAA2B,EAC3BC,OAAgB,KACb;EACH,SAAS;;EACT,MAAMC,aAAa,GAAG,IAAAC,yCAA4B,EAACH,OAAO,CAAC;EAC3D,IAAIV,KAAK,GAAGQ,KAAK,CAAC,CAAC,CAAC,EAAE;IACpB,QAAQI,aAAa,CAACE,eAAe;MACnC,KAAKC,wBAAW,CAACC,KAAK;QACpB,OAAOP,WAAW,CAAC,CAAC,CAAC;MACvB,KAAKM,wBAAW,CAACE,MAAM;QACrB,OAAOlB,IAAI,CAACC,KAAK,EAAEQ,KAAK,CAAC,CAAC,CAAC,EAAEA,KAAK,CAAC,CAAC,CAAC,EAAEC,WAAW,CAAC,CAAC,CAAC,EAAEA,WAAW,CAAC,CAAC,CAAC,CAAC;MACxE,KAAKM,wBAAW,CAACG,QAAQ;QACvB,MAAM,IAAIC,KAAK,CACb,uEACF,CAAC;MACH;QACE,IAAAC,0BAAe,EAACR,aAAa,CAACE,eAAe,CAAC;IAClD;EACF,CAAC,MAAM,IAAId,KAAK,GAAGQ,KAAK,CAACA,KAAK,CAACa,MAAM,GAAG,CAAC,CAAC,EAAE;IAC1C,QAAQT,aAAa,CAACU,gBAAgB;MACpC,KAAKP,wBAAW,CAACC,KAAK;QACpB,OAAOP,WAAW,CAACA,WAAW,CAACY,MAAM,GAAG,CAAC,CAAC;MAC5C,KAAKN,wBAAW,CAACE,MAAM;QACrB,OAAOlB,IAAI,CACTC,KAAK,EACLQ,KAAK,CAACA,KAAK,CAACa,MAAM,GAAG,CAAC,CAAC,EACvBb,KAAK,CAACA,KAAK,CAACa,MAAM,GAAG,CAAC,CAAC,EACvBZ,WAAW,CAACD,KAAK,CAACa,MAAM,GAAG,CAAC,CAAC,EAC7BZ,WAAW,CAACD,KAAK,CAACa,MAAM,GAAG,CAAC,CAC9B,CAAC;MACH,KAAKN,wBAAW,CAACG,QAAQ;QACvB,MAAM,IAAIC,KAAK,CACb,uEACF,CAAC;MACH;QACE,IAAAC,0BAAe,EAACR,aAAa,CAACU,gBAAgB,CAAC;IACnD;EACF;EACA,IAAIC,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,IAAIf,KAAK,CAACa,MAAM,GAAG,CAAC,EAAEE,CAAC,EAAE,EAAE;IACjC,IAAIvB,KAAK,IAAIQ,KAAK,CAACe,CAAC,CAAC,IAAIvB,KAAK,IAAIQ,KAAK,CAACe,CAAC,GAAG,CAAC,CAAC,EAAE;MAC9C;IACF;EACF;EACA,OAAOxB,IAAI,CACTC,KAAK,EACLQ,KAAK,CAACe,CAAC,CAAC,EACRf,KAAK,CAACe,CAAC,GAAG,CAAC,CAAC,EACZd,WAAW,CAACc,CAAC,CAAC,EACdd,WAAW,CAACc,CAAC,GAAG,CAAC,CACnB,CAAC;AACH,CAAC;AAACC,OAAA,CAAAjB,gBAAA,GAAAA,gBAAA","ignoreList":[]}
+{"version":3,"names":["_typeddash","require","_interpolate","lerp","value","from","to","p1","p2","t","interpolate","interpolatePaths","input","outputRange","options","_output","length","Error","Number","isNaN","extrapolation","validateInterpolationOptions","extrapolateLeft","Extrapolate","CLAMP","EXTEND","isFinite","IDENTITY","exhaustiveCheck","extrapolateRight","i","exports"],"sources":["interpolatePaths.ts"],"sourcesContent":["import type { SkPath } from \"../../skia/types\";\nimport { exhaustiveCheck } from \"../../renderer/typeddash\";\n\nimport type { ExtrapolationType } from \"./interpolate\";\nimport { validateInterpolationOptions, Extrapolate } from \"./interpolate\";\n\nconst lerp = (\n  value: number,\n  from: number,\n  to: number,\n  p1: SkPath,\n  p2: SkPath\n) => {\n  \"worklet\";\n  // Zero-width segment (duplicate input stops): t would be NaN or Infinity.\n  // Return the segment's end path (p2), i.e. the value jumps to p2 at the stop.\n  // reanimated's interpolate has no explicit guard here, so this is our choice.\n  if (to === from) {\n    return p2;\n  }\n  const t = (value - from) / (to - from);\n  // interpolate returns a new path (immutable operation)\n  return p2.interpolate(p1, t)!;\n};\n\n/**\n * Maps an input value within a range to an output path within a path range.\n * @param value - The input value.\n * @param inputRange - The range of the input value.\n * @param outputRange - The range of the output path.\n * @param options - Extrapolation options\n * @returns The output path.\n * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>\n * const path1 = new Path();\n * path1.moveTo(0, 0);\n * path1.lineTo(100, 0);\n * const path2 = new Path();\n * path2.moveTo(0, 0);\n * path2.lineTo(0, 100);\n * const path = interpolatePath(0.5, [0, 1], [path1, path2]);\n */\nexport const interpolatePaths = (\n  value: number,\n  input: number[],\n  outputRange: SkPath[],\n  options?: ExtrapolationType,\n  _output?: SkPath\n) => {\n  \"worklet\";\n  if (input.length < 2 || input.length !== outputRange.length) {\n    throw new Error(\n      `interpolatePaths() requires input and outputRange to have the same length and at least 2 entries, received ${input.length} and ${outputRange.length}`\n    );\n  }\n  if (Number.isNaN(value)) {\n    throw new Error(\"interpolatePaths() received NaN as value\");\n  }\n  const extrapolation = validateInterpolationOptions(options);\n  if (value < input[0]) {\n    switch (extrapolation.extrapolateLeft) {\n      case Extrapolate.CLAMP:\n        return outputRange[0];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateLeft);\n    }\n  } else if (value > input[input.length - 1]) {\n    switch (extrapolation.extrapolateRight) {\n      case Extrapolate.CLAMP:\n        return outputRange[outputRange.length - 1];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(\n          value,\n          input[input.length - 2],\n          input[input.length - 1],\n          outputRange[input.length - 2],\n          outputRange[input.length - 1]\n        );\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateRight);\n    }\n  }\n  let i = 0;\n  for (; i <= input.length - 1; i++) {\n    if (value >= input[i] && value <= input[i + 1]) {\n      break;\n    }\n  }\n  return lerp(\n    value,\n    input[i],\n    input[i + 1],\n    outputRange[i],\n    outputRange[i + 1]\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/module/animation/functions/interpolatePaths.js

@@ -3,6 +3,12 @@ import { validateInterpolationOptions, Extrapolate } from "./interpolate";
 const lerp = (value, from, to, p1, p2) => {
   "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);
@@ -27,12 +33,21 @@ const lerp = (value, from, to, p1, p2) => {
 export const interpolatePaths = (value, input, outputRange, options, _output) => {
   "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("Identity is not a supported extrapolation type for interpolatePaths()");
@@ -44,6 +59,9 @@ export const interpolatePaths = (value, input, outputRange, options, _output) =>
       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], input[input.length - 1], outputRange[input.length - 2], outputRange[input.length - 1]);
       case Extrapolate.IDENTITY:
         throw new Error("Identity is not a supported extrapolation type for interpolatePaths()");

package/lib/module/animation/functions/interpolatePaths.js.map

@@ -1 +1 @@
-{"version":3,"names":["exhaustiveCheck","validateInterpolationOptions","Extrapolate","lerp","value","from","to","p1","p2","t","interpolate","interpolatePaths","input","outputRange","options","_output","extrapolation","extrapolateLeft","CLAMP","EXTEND","IDENTITY","Error","length","extrapolateRight","i"],"sources":["interpolatePaths.ts"],"sourcesContent":["import type { SkPath } from \"../../skia/types\";\nimport { exhaustiveCheck } from \"../../renderer/typeddash\";\n\nimport type { ExtrapolationType } from \"./interpolate\";\nimport { validateInterpolationOptions, Extrapolate } from \"./interpolate\";\n\nconst lerp = (\n  value: number,\n  from: number,\n  to: number,\n  p1: SkPath,\n  p2: SkPath\n) => {\n  \"worklet\";\n  const t = (value - from) / (to - from);\n  // interpolate returns a new path (immutable operation)\n  return p2.interpolate(p1, t)!;\n};\n\n/**\n * Maps an input value within a range to an output path within a path range.\n * @param value - The input value.\n * @param inputRange - The range of the input value.\n * @param outputRange - The range of the output path.\n * @param options - Extrapolation options\n * @returns The output path.\n * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>\n * const path1 = new Path();\n * path1.moveTo(0, 0);\n * path1.lineTo(100, 0);\n * const path2 = new Path();\n * path2.moveTo(0, 0);\n * path2.lineTo(0, 100);\n * const path = interpolatePath(0.5, [0, 1], [path1, path2]);\n */\nexport const interpolatePaths = (\n  value: number,\n  input: number[],\n  outputRange: SkPath[],\n  options?: ExtrapolationType,\n  _output?: SkPath\n) => {\n  \"worklet\";\n  const extrapolation = validateInterpolationOptions(options);\n  if (value < input[0]) {\n    switch (extrapolation.extrapolateLeft) {\n      case Extrapolate.CLAMP:\n        return outputRange[0];\n      case Extrapolate.EXTEND:\n        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateLeft);\n    }\n  } else if (value > input[input.length - 1]) {\n    switch (extrapolation.extrapolateRight) {\n      case Extrapolate.CLAMP:\n        return outputRange[outputRange.length - 1];\n      case Extrapolate.EXTEND:\n        return lerp(\n          value,\n          input[input.length - 2],\n          input[input.length - 1],\n          outputRange[input.length - 2],\n          outputRange[input.length - 1]\n        );\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateRight);\n    }\n  }\n  let i = 0;\n  for (; i <= input.length - 1; i++) {\n    if (value >= input[i] && value <= input[i + 1]) {\n      break;\n    }\n  }\n  return lerp(\n    value,\n    input[i],\n    input[i + 1],\n    outputRange[i],\n    outputRange[i + 1]\n  );\n};\n"],"mappings":"AACA,SAASA,eAAe,QAAQ,0BAA0B;AAG1D,SAASC,4BAA4B,EAAEC,WAAW,QAAQ,eAAe;AAEzE,MAAMC,IAAI,GAAGA,CACXC,KAAa,EACbC,IAAY,EACZC,EAAU,EACVC,EAAU,EACVC,EAAU,KACP;EACH,SAAS;;EACT,MAAMC,CAAC,GAAG,CAACL,KAAK,GAAGC,IAAI,KAAKC,EAAE,GAAGD,IAAI,CAAC;EACtC;EACA,OAAOG,EAAE,CAACE,WAAW,CAACH,EAAE,EAAEE,CAAC,CAAC;AAC9B,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,gBAAgB,GAAGA,CAC9BP,KAAa,EACbQ,KAAe,EACfC,WAAqB,EACrBC,OAA2B,EAC3BC,OAAgB,KACb;EACH,SAAS;;EACT,MAAMC,aAAa,GAAGf,4BAA4B,CAACa,OAAO,CAAC;EAC3D,IAAIV,KAAK,GAAGQ,KAAK,CAAC,CAAC,CAAC,EAAE;IACpB,QAAQI,aAAa,CAACC,eAAe;MACnC,KAAKf,WAAW,CAACgB,KAAK;QACpB,OAAOL,WAAW,CAAC,CAAC,CAAC;MACvB,KAAKX,WAAW,CAACiB,MAAM;QACrB,OAAOhB,IAAI,CAACC,KAAK,EAAEQ,KAAK,CAAC,CAAC,CAAC,EAAEA,KAAK,CAAC,CAAC,CAAC,EAAEC,WAAW,CAAC,CAAC,CAAC,EAAEA,WAAW,CAAC,CAAC,CAAC,CAAC;MACxE,KAAKX,WAAW,CAACkB,QAAQ;QACvB,MAAM,IAAIC,KAAK,CACb,uEACF,CAAC;MACH;QACErB,eAAe,CAACgB,aAAa,CAACC,eAAe,CAAC;IAClD;EACF,CAAC,MAAM,IAAIb,KAAK,GAAGQ,KAAK,CAACA,KAAK,CAACU,MAAM,GAAG,CAAC,CAAC,EAAE;IAC1C,QAAQN,aAAa,CAACO,gBAAgB;MACpC,KAAKrB,WAAW,CAACgB,KAAK;QACpB,OAAOL,WAAW,CAACA,WAAW,CAACS,MAAM,GAAG,CAAC,CAAC;MAC5C,KAAKpB,WAAW,CAACiB,MAAM;QACrB,OAAOhB,IAAI,CACTC,KAAK,EACLQ,KAAK,CAACA,KAAK,CAACU,MAAM,GAAG,CAAC,CAAC,EACvBV,KAAK,CAACA,KAAK,CAACU,MAAM,GAAG,CAAC,CAAC,EACvBT,WAAW,CAACD,KAAK,CAACU,MAAM,GAAG,CAAC,CAAC,EAC7BT,WAAW,CAACD,KAAK,CAACU,MAAM,GAAG,CAAC,CAC9B,CAAC;MACH,KAAKpB,WAAW,CAACkB,QAAQ;QACvB,MAAM,IAAIC,KAAK,CACb,uEACF,CAAC;MACH;QACErB,eAAe,CAACgB,aAAa,CAACO,gBAAgB,CAAC;IACnD;EACF;EACA,IAAIC,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,IAAIZ,KAAK,CAACU,MAAM,GAAG,CAAC,EAAEE,CAAC,EAAE,EAAE;IACjC,IAAIpB,KAAK,IAAIQ,KAAK,CAACY,CAAC,CAAC,IAAIpB,KAAK,IAAIQ,KAAK,CAACY,CAAC,GAAG,CAAC,CAAC,EAAE;MAC9C;IACF;EACF;EACA,OAAOrB,IAAI,CACTC,KAAK,EACLQ,KAAK,CAACY,CAAC,CAAC,EACRZ,KAAK,CAACY,CAAC,GAAG,CAAC,CAAC,EACZX,WAAW,CAACW,CAAC,CAAC,EACdX,WAAW,CAACW,CAAC,GAAG,CAAC,CACnB,CAAC;AACH,CAAC","ignoreList":[]}
+{"version":3,"names":["exhaustiveCheck","validateInterpolationOptions","Extrapolate","lerp","value","from","to","p1","p2","t","interpolate","interpolatePaths","input","outputRange","options","_output","length","Error","Number","isNaN","extrapolation","extrapolateLeft","CLAMP","EXTEND","isFinite","IDENTITY","extrapolateRight","i"],"sources":["interpolatePaths.ts"],"sourcesContent":["import type { SkPath } from \"../../skia/types\";\nimport { exhaustiveCheck } from \"../../renderer/typeddash\";\n\nimport type { ExtrapolationType } from \"./interpolate\";\nimport { validateInterpolationOptions, Extrapolate } from \"./interpolate\";\n\nconst lerp = (\n  value: number,\n  from: number,\n  to: number,\n  p1: SkPath,\n  p2: SkPath\n) => {\n  \"worklet\";\n  // Zero-width segment (duplicate input stops): t would be NaN or Infinity.\n  // Return the segment's end path (p2), i.e. the value jumps to p2 at the stop.\n  // reanimated's interpolate has no explicit guard here, so this is our choice.\n  if (to === from) {\n    return p2;\n  }\n  const t = (value - from) / (to - from);\n  // interpolate returns a new path (immutable operation)\n  return p2.interpolate(p1, t)!;\n};\n\n/**\n * Maps an input value within a range to an output path within a path range.\n * @param value - The input value.\n * @param inputRange - The range of the input value.\n * @param outputRange - The range of the output path.\n * @param options - Extrapolation options\n * @returns The output path.\n * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>\n * const path1 = new Path();\n * path1.moveTo(0, 0);\n * path1.lineTo(100, 0);\n * const path2 = new Path();\n * path2.moveTo(0, 0);\n * path2.lineTo(0, 100);\n * const path = interpolatePath(0.5, [0, 1], [path1, path2]);\n */\nexport const interpolatePaths = (\n  value: number,\n  input: number[],\n  outputRange: SkPath[],\n  options?: ExtrapolationType,\n  _output?: SkPath\n) => {\n  \"worklet\";\n  if (input.length < 2 || input.length !== outputRange.length) {\n    throw new Error(\n      `interpolatePaths() requires input and outputRange to have the same length and at least 2 entries, received ${input.length} and ${outputRange.length}`\n    );\n  }\n  if (Number.isNaN(value)) {\n    throw new Error(\"interpolatePaths() received NaN as value\");\n  }\n  const extrapolation = validateInterpolationOptions(options);\n  if (value < input[0]) {\n    switch (extrapolation.extrapolateLeft) {\n      case Extrapolate.CLAMP:\n        return outputRange[0];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateLeft);\n    }\n  } else if (value > input[input.length - 1]) {\n    switch (extrapolation.extrapolateRight) {\n      case Extrapolate.CLAMP:\n        return outputRange[outputRange.length - 1];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(\n          value,\n          input[input.length - 2],\n          input[input.length - 1],\n          outputRange[input.length - 2],\n          outputRange[input.length - 1]\n        );\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateRight);\n    }\n  }\n  let i = 0;\n  for (; i <= input.length - 1; i++) {\n    if (value >= input[i] && value <= input[i + 1]) {\n      break;\n    }\n  }\n  return lerp(\n    value,\n    input[i],\n    input[i + 1],\n    outputRange[i],\n    outputRange[i + 1]\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/package.json

@@ -8,7 +8,7 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.13.0",
+  "version": "2.13.1",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",

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],