@shopify/react-native-skia 0.1.123 → 0.1.126

package/cpp/api/third_party/CSSColorParser.cpp

@@ -0,0 +1,194 @@
+#include "CSSColorParser.h"
+
+namespace CSSColorParser {
+
+    template <typename T>
+    uint8_t clamp_css_byte(T i) {  // Clamp to integer 0 .. 255.
+        i = ::round(i);  // Seems to be what Chrome does (vs truncation).
+        return i < 0 ? 0 : i > 255 ? 255 : uint8_t(i);
+    }
+
+    template <typename T>
+    float clamp_css_float(T f) {  // Clamp to float 0.0 .. 1.0.
+        return f < 0 ? 0 : f > 1 ? 1 : float(f);
+    }
+
+    float parseFloat(const std::string& str) {
+        return strtof(str.c_str(), nullptr);
+    }
+
+    int64_t parseInt(const std::string& str, uint8_t base = 10) {
+        return strtoll(str.c_str(), nullptr, base);
+    }
+
+    uint8_t parse_css_int(const std::string& str) {  // int or percentage.
+        if (str.length() && str.back() == '%') {
+            return clamp_css_byte(parseFloat(str) / 100.0f * 255.0f);
+        } else {
+            return clamp_css_byte(parseInt(str));
+        }
+    }
+
+    float parse_css_float(const std::string& str) {  // float or percentage.
+        if (str.length() && str.back() == '%') {
+            return clamp_css_float(parseFloat(str) / 100.0f);
+        } else {
+            return clamp_css_float(parseFloat(str));
+        }
+    }
+
+    float css_hue_to_rgb(float m1, float m2, float h) {
+        if (h < 0.0f) {
+            h += 1.0f;
+        } else if (h > 1.0f) {
+            h -= 1.0f;
+        }
+
+        if (h * 6.0f < 1.0f) {
+            return m1 + (m2 - m1) * h * 6.0f;
+        }
+        if (h * 2.0f < 1.0f) {
+            return m2;
+        }
+        if (h * 3.0f < 2.0f) {
+            return m1 + (m2 - m1) * (2.0f / 3.0f - h) * 6.0f;
+        }
+        return m1;
+    }
+
+    std::vector<std::string> split(const std::string& s, char delim) {
+        std::vector<std::string> elems;
+        std::stringstream ss(s);
+        std::string item;
+        while (std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+        return elems;
+    }
+
+    Color parse(const std::string& css_str)  {
+        std::string str = css_str;
+
+        // Remove all whitespace, not compliant, but should just be more accepting.
+        str.erase(std::remove(str.begin(), str.end(), ' '), str.end());
+
+        // Convert to lowercase.
+        std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+
+        for (const auto& namedColor : namedColors) {
+            if (str == namedColor.name) {
+                return { namedColor.color };
+            }
+        }
+
+        // #abc and #abc123 syntax.
+        if (str.length() && str.front() == '#') {
+            auto iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
+            if (str.length() == 4) {
+                if (!(iv >= 0 && iv <= 0xfff)) {
+                    return {};
+                } else {
+                    return {
+                            static_cast<uint8_t>(((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8)),
+                            static_cast<uint8_t>((iv & 0xf0) | ((iv & 0xf0) >> 4)),
+                            static_cast<uint8_t>((iv & 0xf) | ((iv & 0xf) << 4)),
+                            1
+                    };
+                }
+            } else if (str.length() == 7) {
+                if (!(iv >= 0 && iv <= 0xffffff)) {
+                    return {};  // Covers NaN.
+                } else {
+                    return {
+                            static_cast<uint8_t>((iv & 0xff0000) >> 16),
+                            static_cast<uint8_t>((iv & 0xff00) >> 8),
+                            static_cast<uint8_t>(iv & 0xff),
+                            1
+                    };
+                }
+            }else if (str.length() == 5) {
+                // #rgba
+                if (!(iv >= 0 && iv <= 0xffff)) return {};  // Covers NaN.
+                return {
+                        static_cast<uint8_t>(((iv & 0xf000) >> 8) | ((iv & 0xf000) >> 12)),
+                        static_cast<uint8_t>(((iv & 0x0f00) >> 4) | ((iv & 0x0f00) >> 8)),
+                        static_cast<uint8_t>((iv & 0x00f0)       | ((iv & 0x00f0) >> 4)),
+                        static_cast<uint8_t>(((iv & 0x000f) << 4  |  (iv & 0x000f))) / 255.0f
+                };
+            } else if (str.length() == 9) {
+                // #rrggbbaa
+                if (!(iv >= 0 && iv <= 0xffffffff)) return {};  // Covers NaN.
+                return {
+                        static_cast<uint8_t>(((iv & 0xff000000) >> 24) & 0xff),
+                        static_cast<uint8_t>((iv & 0x00ff0000) >> 16),
+                        static_cast<uint8_t>((iv & 0x0000ff00) >> 8),
+                        static_cast<uint8_t>((iv & 0x000000ff)) / 255.0f
+                };
+            }
+
+            return {};
+        }
+
+        size_t op = str.find_first_of('('), ep = str.find_first_of(')');
+        if (op != std::string::npos && ep + 1 == str.length()) {
+            const std::string fname = str.substr(0, op);
+            const std::vector<std::string> params = split(str.substr(op + 1, ep - (op + 1)), ',');
+
+            float alpha = 1.0f;
+
+            if (fname == "rgba" || fname == "rgb") {
+                if (fname == "rgba") {
+                    if (params.size() != 4) {
+                        return { };
+                    }
+                    alpha = parse_css_float(params.back());
+                } else {
+                    if (params.size() != 3) {
+                        return { };
+                    }
+                }
+
+                return {
+                        parse_css_int(params[0]),
+                        parse_css_int(params[1]),
+                        parse_css_int(params[2]),
+                        alpha
+                };
+
+            } else if (fname == "hsla" || fname == "hsl") {
+                if (fname == "hsla") {
+                    if (params.size() != 4) {
+                        return { };
+                    }
+                    alpha = parse_css_float(params.back());
+                } else {
+                    if (params.size() != 3) {
+                        return { };
+                    }
+                }
+
+                float h = parseFloat(params[0]) / 360.0f;
+                float i;
+                // Normalize the hue to [0..1[
+                h = std::modf(h, &i);
+
+                // NOTE(deanm): According to the CSS spec s/l should only be
+                // percentages, but we don't bother and let float or percentage.
+                float s = parse_css_float(params[1]);
+                float l = parse_css_float(params[2]);
+
+                float m2 = l <= 0.5f ? l * (s + 1.0f) : l + s - l * s;
+                float m1 = l * 2.0f - m2;
+
+                return {
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h + 1.0f / 3.0f) * 255.0f),
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h) * 255.0f),
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h - 1.0f / 3.0f) * 255.0f),
+                        alpha
+                };
+            }
+        }
+
+        return { };
+    }
+}

package/cpp/api/third_party/CSSColorParser.h

@@ -122,71 +122,6 @@ namespace CSSColorParser {
             { "yellow", { 255, 255, 0, 1 } }, { "yellowgreen", { 154, 205, 50, 1 } }
     };
 
-    template <typename T>
-    uint8_t clamp_css_byte(T i) {  // Clamp to integer 0 .. 255.
-        i = ::round(i);  // Seems to be what Chrome does (vs truncation).
-        return i < 0 ? 0 : i > 255 ? 255 : uint8_t(i);
-    }
-
-    template <typename T>
-    float clamp_css_float(T f) {  // Clamp to float 0.0 .. 1.0.
-        return f < 0 ? 0 : f > 1 ? 1 : float(f);
-    }
-
-    float parseFloat(const std::string& str) {
-        return strtof(str.c_str(), nullptr);
-    }
-
-    int64_t parseInt(const std::string& str, uint8_t base = 10) {
-        return strtoll(str.c_str(), nullptr, base);
-    }
-
-    uint8_t parse_css_int(const std::string& str) {  // int or percentage.
-        if (str.length() && str.back() == '%') {
-            return clamp_css_byte(parseFloat(str) / 100.0f * 255.0f);
-        } else {
-            return clamp_css_byte(parseInt(str));
-        }
-    }
-
-    float parse_css_float(const std::string& str) {  // float or percentage.
-        if (str.length() && str.back() == '%') {
-            return clamp_css_float(parseFloat(str) / 100.0f);
-        } else {
-            return clamp_css_float(parseFloat(str));
-        }
-    }
-
-    float css_hue_to_rgb(float m1, float m2, float h) {
-        if (h < 0.0f) {
-            h += 1.0f;
-        } else if (h > 1.0f) {
-            h -= 1.0f;
-        }
-
-        if (h * 6.0f < 1.0f) {
-            return m1 + (m2 - m1) * h * 6.0f;
-        }
-        if (h * 2.0f < 1.0f) {
-            return m2;
-        }
-        if (h * 3.0f < 2.0f) {
-            return m1 + (m2 - m1) * (2.0f / 3.0f - h) * 6.0f;
-        }
-        return m1;
-    }
-
-    std::vector<std::string> split(const std::string& s, char delim) {
-        std::vector<std::string> elems;
-        std::stringstream ss(s);
-        std::string item;
-        while (std::getline(ss, item, delim)) {
-            elems.push_back(item);
-        }
-        return elems;
-    }
-
-
     inline bool operator==(const Color& lhs, const Color& rhs) {
         return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && ::fabs(lhs.a - rhs.a) < 0.0001f;
     }
@@ -195,130 +130,5 @@ namespace CSSColorParser {
         return !(lhs == rhs);
     }
 
-    Color parse(const std::string& css_str)  {
-        std::string str = css_str;
-
-        // Remove all whitespace, not compliant, but should just be more accepting.
-        str.erase(std::remove(str.begin(), str.end(), ' '), str.end());
-
-        // Convert to lowercase.
-        std::transform(str.begin(), str.end(), str.begin(), ::tolower);
-
-        for (const auto& namedColor : namedColors) {
-            if (str == namedColor.name) {
-                return { namedColor.color };
-            }
-        }
-
-        // #abc and #abc123 syntax.
-        if (str.length() && str.front() == '#') {
-            auto iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
-            if (str.length() == 4) {
-                if (!(iv >= 0 && iv <= 0xfff)) {
-                    return {};
-                } else {
-                    return {
-                    static_cast<uint8_t>(((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8)),
-                    static_cast<uint8_t>((iv & 0xf0) | ((iv & 0xf0) >> 4)),
-                    static_cast<uint8_t>((iv & 0xf) | ((iv & 0xf) << 4)),
-                    1
-                    };
-                }
-            } else if (str.length() == 7) {
-                if (!(iv >= 0 && iv <= 0xffffff)) {
-                    return {};  // Covers NaN.
-                } else {
-                    return {
-                    static_cast<uint8_t>((iv & 0xff0000) >> 16),
-                    static_cast<uint8_t>((iv & 0xff00) >> 8),
-                    static_cast<uint8_t>(iv & 0xff),
-                    1
-                    };
-                }
-            }else if (str.length() == 5) {
-                // #rgba
-                if (!(iv >= 0 && iv <= 0xffff)) return {};  // Covers NaN.
-                return {
-                static_cast<uint8_t>(((iv & 0xf000) >> 8) | ((iv & 0xf000) >> 12)),
-                static_cast<uint8_t>(((iv & 0x0f00) >> 4) | ((iv & 0x0f00) >> 8)),
-                static_cast<uint8_t>((iv & 0x00f0)       | ((iv & 0x00f0) >> 4)),
-                static_cast<uint8_t>(((iv & 0x000f) << 4  |  (iv & 0x000f))) / 255.0f
-                };
-            } else if (str.length() == 9) {
-                // #rrggbbaa
-                if (!(iv >= 0 && iv <= 0xffffffff)) return {};  // Covers NaN.
-                return {
-                static_cast<uint8_t>(((iv & 0xff000000) >> 24) & 0xff),
-                static_cast<uint8_t>((iv & 0x00ff0000) >> 16),
-                static_cast<uint8_t>((iv & 0x0000ff00) >> 8),
-                static_cast<uint8_t>((iv & 0x000000ff)) / 255.0f
-                };
-            }
-
-            return {};
-        }
-
-        size_t op = str.find_first_of('('), ep = str.find_first_of(')');
-        if (op != std::string::npos && ep + 1 == str.length()) {
-            const std::string fname = str.substr(0, op);
-            const std::vector<std::string> params = split(str.substr(op + 1, ep - (op + 1)), ',');
-
-            float alpha = 1.0f;
-
-            if (fname == "rgba" || fname == "rgb") {
-                if (fname == "rgba") {
-                    if (params.size() != 4) {
-                        return { };
-                    }
-                    alpha = parse_css_float(params.back());
-                } else {
-                    if (params.size() != 3) {
-                        return { };
-                    }
-                }
-
-                return {
-                        parse_css_int(params[0]),
-                        parse_css_int(params[1]),
-                        parse_css_int(params[2]),
-                        alpha
-                };
-
-            } else if (fname == "hsla" || fname == "hsl") {
-                if (fname == "hsla") {
-                    if (params.size() != 4) {
-                        return { };
-                    }
-                    alpha = parse_css_float(params.back());
-                } else {
-                    if (params.size() != 3) {
-                        return { };
-                    }
-                }
-
-                float h = parseFloat(params[0]) / 360.0f;
-                float i;
-                // Normalize the hue to [0..1[
-                h = std::modf(h, &i);
-
-                // NOTE(deanm): According to the CSS spec s/l should only be
-                // percentages, but we don't bother and let float or percentage.
-                float s = parse_css_float(params[1]);
-                float l = parse_css_float(params[2]);
-
-                float m2 = l <= 0.5f ? l * (s + 1.0f) : l + s - l * s;
-                float m1 = l * 2.0f - m2;
-
-                return {
-                        clamp_css_byte(css_hue_to_rgb(m1, m2, h + 1.0f / 3.0f) * 255.0f),
-                        clamp_css_byte(css_hue_to_rgb(m1, m2, h) * 255.0f),
-                        clamp_css_byte(css_hue_to_rgb(m1, m2, h - 1.0f / 3.0f) * 255.0f),
-                        alpha
-                };
-            }
-        }
-
-        return { };
-    }
-
+    Color parse(const std::string& css_str);
 } // namespace CSSColorParser

package/cpp/jsi/JsiSimpleValueWrapper.h

@@ -0,0 +1,108 @@
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace RNJsi
+{
+using namespace facebook;
+
+enum JsiWrapperValueType
+{
+    NonInitialized,
+    Undefined,
+    Null,
+    Bool,
+    Number,
+    JsiValue
+};
+
+/**
+ Implements a simple wrapper class for JSI primitives like numbers and boolean values. Objects,
+ strings and arrays are stored as values inside a property holder. The class also provides a method
+ for comparing values that will compare numbers, booleans and strings.
+ */
+class JsiSimpleValueWrapper
+{
+public:
+    JsiSimpleValueWrapper(jsi::Runtime& runtime) :
+      _type(JsiWrapperValueType::NonInitialized),
+      _propNameId(jsi::PropNameID::forUtf8(runtime, "value"))
+    {}
+
+    jsi::Value getCurrent(jsi::Runtime &runtime)
+    {
+      switch (_type)
+      {
+          case JsiWrapperValueType::NonInitialized:
+              return nullptr;
+          case JsiWrapperValueType::Undefined:
+            return jsi::Value::undefined();
+          case JsiWrapperValueType::Null:
+            return jsi::Value::null();
+          case JsiWrapperValueType::Bool:
+            return _boolValue;
+          case JsiWrapperValueType::Number:
+            return _numberValue;
+          case JsiWrapperValueType::JsiValue:
+            if (_valueHolder == nullptr) {
+                return jsi::Value::undefined();
+            }
+            return _valueHolder->getProperty(runtime, _propNameId);
+      }
+    }
+
+    void setCurrent(jsi::Runtime &runtime, const jsi::Value &value)
+    {
+      if(value.isNumber()) {
+        _type = JsiWrapperValueType::Number;
+        _numberValue = value.asNumber();
+      } else if(value.isBool()) {
+        _type = JsiWrapperValueType::Bool;
+        _boolValue = value.getBool();
+      } else if(value.isUndefined()) {
+        _type = JsiWrapperValueType::Undefined;
+      } else if(value.isNull()) {
+        _type = JsiWrapperValueType::Null;
+      } else {
+        _type = JsiWrapperValueType::JsiValue;
+        // Save as javascript object - we don't want to have to copy strings, objects and values
+        if(_valueHolder == nullptr) {
+            _valueHolder = std::make_shared<jsi::Object>(runtime);
+        }
+        _valueHolder->setProperty(runtime, _propNameId, value);
+      }
+    }
+
+    bool equals(jsi::Runtime& runtime, const jsi::Value &value) {
+      if (_type == JsiWrapperValueType::NonInitialized) {
+          return false;
+      }
+      if(value.isNumber() && _type == JsiWrapperValueType::Number) {
+        return _numberValue == value.asNumber();
+      } else if(value.isBool() && _type == JsiWrapperValueType::Bool) {
+        return _boolValue == value.getBool();
+      } else if(value.isUndefined()) {
+        return _type == JsiWrapperValueType::Undefined;
+      } else if(value.isNull()) {
+        return _type == JsiWrapperValueType::Null;
+      } else if(value.isString()) {
+          auto current = getCurrent(runtime);
+          if (current.isString()) {
+              return jsi::String::strictEquals(runtime, value.asString(runtime), current.asString(runtime));
+          }
+          return false;
+      }
+      return false;
+    }
+
+private:
+    jsi::PropNameID _propNameId;
+    std::shared_ptr<jsi::Object> _valueHolder;
+
+    bool _boolValue;
+    double _numberValue;
+
+    JsiWrapperValueType _type;
+};
+}

package/cpp/rnskia/RNSkAnimation.h

@@ -32,8 +32,6 @@ public:
     _args[1] = jsi::Value::undefined();
   }
   
-  virtual ~RNSkAnimation() {}
-  
   JSI_HOST_FUNCTION(cancel) {
     stopClock();
     return jsi::Value::undefined();

package/cpp/rnskia/RNSkDrawView.cpp

@@ -67,17 +67,9 @@ void RNSkDrawView::setDrawCallback(std::shared_ptr<jsi::Function> callback) {
   _jsTimingInfo.reset();
   _gpuTimingInfo.reset();
   
-  // Set up debug font/paints
-  auto font = SkFont();
-  font.setSize(14);
-  auto paint = SkPaint();
-  paint.setColor(SkColors::kRed);
-  
   // Create draw drawCallback wrapper
   _drawCallback = std::make_shared<RNSkDrawCallback>(
       [weakSelf = weak_from_this(),
-       paint = std::move(paint),
-       font = std::move(font),
        callback = std::move(callback)](std::shared_ptr<JsiSkCanvas> canvas,
                                        int width,
                                        int height,
@@ -121,7 +113,12 @@ void RNSkDrawView::setDrawCallback(std::shared_ptr<jsi::Function> callback) {
           stream << "js: " << jsAvg << "ms gpu: " << gpuAvg << "ms " << " total: " << total << "ms";
           
           std::string debugString = stream.str();
-          
+
+          // Set up debug font/paints
+          auto font = SkFont();
+          font.setSize(14);
+          auto paint = SkPaint();
+          paint.setColor(SkColors::kRed);
           canvas->getCanvas()->drawSimpleText(
            debugString.c_str(), debugString.size(), SkTextEncoding::kUTF8, 8,
            18, font, paint);
@@ -157,7 +154,7 @@ void RNSkDrawView::drawInCanvas(std::shared_ptr<JsiSkCanvas> canvas,
 
 sk_sp<SkImage> RNSkDrawView::makeImageSnapshot(std::shared_ptr<SkRect> bounds) {
   // Assert width/height
-  auto surface = SkSurface::MakeRasterN32Premul(getWidth(), getHeight());
+  auto surface = SkSurface::MakeRasterN32Premul(getScaledWidth(), getScaledHeight());
   auto canvas = surface->getCanvas();
   auto jsiCanvas = std::make_shared<JsiSkCanvas>(_platformContext);
   jsiCanvas->setCanvas(canvas);
@@ -165,7 +162,7 @@ sk_sp<SkImage> RNSkDrawView::makeImageSnapshot(std::shared_ptr<SkRect> bounds) {
   milliseconds ms = duration_cast<milliseconds>(
       system_clock::now().time_since_epoch());
   
-  drawInCanvas(jsiCanvas, getWidth(), getHeight(), ms.count() / 1000);
+  drawInCanvas(jsiCanvas, getScaledWidth(), getScaledHeight(), ms.count() / 1000);
   
   if(bounds != nullptr) {
     SkIRect b = SkIRect::MakeXYWH(bounds->x(), bounds->y(), bounds->width(), bounds->height());
@@ -188,7 +185,7 @@ void RNSkDrawView::performDraw() {
   // move the actual drawing onto the render thread later
   SkPictureRecorder recorder;
   SkRTreeFactory factory;
-  SkCanvas* canvas = recorder.beginRecording(getWidth(), getHeight(), &factory);
+  SkCanvas* canvas = recorder.beginRecording(getScaledWidth(), getScaledHeight(), &factory);
   _jsiCanvas->setCanvas(canvas);
   
   // Get current milliseconds
@@ -197,7 +194,7 @@ void RNSkDrawView::performDraw() {
   
   try {
     // Perform the javascript drawing
-    drawInCanvas(_jsiCanvas, getWidth(), getHeight(), ms.count() / 1000.0);
+    drawInCanvas(_jsiCanvas, getScaledWidth(), getScaledHeight(), ms.count() / 1000.0);
   } catch(...) {
     _jsTimingInfo.stopTiming();
     _jsDrawingLock->unlock();

package/cpp/rnskia/RNSkDrawView.h

@@ -97,12 +97,12 @@ protected:
   /**
    Returns the scaled width of the view
    */
-  virtual int getWidth() { return -1; };
+  virtual float getScaledWidth() = 0;
   
   /**
    Returns the scaled height of the view
    */
-  virtual int getHeight() { return -1; };
+  virtual float getScaledHeight() = 0;
   
   /**
    Override to render picture to GPU

package/cpp/rnskia/RNSkValueApi.h

@@ -34,8 +34,12 @@ public:
   }
   
   JSI_HOST_FUNCTION(createDerivedValue) {
-    return jsi::Object::createFromHostObject(runtime,
-      std::make_shared<RNSkDerivedValue>(_platformContext, runtime, arguments, count));
+    // Creation and initialization is done in two steps to be able to use weak references when setting
+    // up dependencies - since weak_from_this needs our instance to be a shared_ptr before calling
+    // weak_from_this().
+    auto derivedValue = std::make_shared<RNSkDerivedValue>(_platformContext, runtime, arguments, count);
+    derivedValue->initializeDependencies(runtime, arguments, count);
+    return jsi::Object::createFromHostObject(runtime, derivedValue);
   }
   
   JSI_HOST_FUNCTION(createAnimation) {

package/cpp/rnskia/values/RNSkClockValue.h

@@ -32,7 +32,6 @@ public:
                  size_t count) : RNSkReadonlyValue(platformContext),
         _runtime(runtime),
         _identifier(identifier) {
-    
     // Start by updating to zero (start value)
     update(_runtime, static_cast<double>(0));
   }
@@ -72,6 +71,7 @@ public:
     _start += timeSinceStop;
     
     _state = RNSkClockState::Running;
+    
     getContext()->beginDrawLoop(_identifier, [weakSelf = weak_from_this()](bool invalidated){
       auto self = weakSelf.lock();
       if(self) {
@@ -135,7 +135,7 @@ protected:
   size_t _identifier;
   std::chrono::time_point<std::chrono::steady_clock> _start;
   std::chrono::time_point<std::chrono::steady_clock> _stop;
-  std::atomic<RNSkClockState> _state;
+  std::atomic<RNSkClockState> _state = { RNSkClockState::NotStarted };
 };
 
 }

package/cpp/rnskia/values/RNSkDerivedValue.h

@@ -39,6 +39,11 @@ public:
       jsi::detail::throwJSError(runtime, "Expected array of dependencies as second parameter");
     }
         
+    // Get callback for calculating result
+    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+  }
+  
+  void initializeDependencies(jsi::Runtime &runtime, const jsi::Value *arguments, size_t count) {
     // Save dependencies
     std::vector<std::shared_ptr<RNSkReadonlyValue>> dependencies;
         
@@ -59,14 +64,16 @@ public:
       dependencies.push_back(value);
     }
     
-    // Get callback for calculating result
-    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
-
     // register change handler on dependencies
     _unsubscribers.reserve(_unsubscribers.size() + size);
     for(const auto &dep: dependencies) {
-      auto dispatcher = std::bind(&RNSkDerivedValue::dependencyUpdated, this, std::placeholders::_1);
-      _unsubscribers.push_back(dep->addListener(dispatcher));
+      _unsubscribers.push_back(dep->addListener([weakSelf = weak_from_this()](jsi::Runtime& runtime) {
+        auto self = weakSelf.lock();
+        if(self) {
+          auto selfAsThis = std::dynamic_pointer_cast<RNSkDerivedValue>(self);
+          selfAsThis->dependencyUpdated(runtime);
+        }
+      }));
     }
         
     // Set initial value