@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/rnskia/dom/base/JsiDomDeclarationNode.h

@@ -0,0 +1,176 @@
+
+#pragma once
+
+#include "DrawingContext.h"
+#include "JsiDomNode.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+class JsiBaseDomDeclarationNode : public JsiDomNode {
+public:
+  JsiBaseDomDeclarationNode(std::shared_ptr<RNSkPlatformContext> context,
+                            const char *type)
+      : JsiDomNode(context, type) {}
+
+  JSI_PROPERTY_GET(declarationType) {
+    return jsi::String::createFromUtf8(runtime, std::string(getType()));
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiBaseDomDeclarationNode,
+                                                  declarationType),
+                              JSI_EXPORT_PROP_GET(JsiDomNode, type))
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiDomNode, addChild),
+                       JSI_EXPORT_FUNC(JsiDomNode, removeChild),
+                       JSI_EXPORT_FUNC(JsiDomNode, insertChildBefore),
+                       JSI_EXPORT_FUNC(JsiDomNode, setProps),
+                       JSI_EXPORT_FUNC(JsiDomNode, setProp),
+                       JSI_EXPORT_FUNC(JsiDomNode, dispose),
+                       JSI_EXPORT_FUNC(JsiDomNode, children))
+
+  /**
+   Called when rendering the tree to create all derived values from all nodes.
+   */
+  virtual void decorateContext(DrawingContext *context) {
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "Begin Materialize");
+#endif
+    // Materialize children first so that any inner nodes get the opportunity
+    // to calculate their state before this node continues.
+    for (auto &child : getChildren()) {
+      auto decl = std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child);
+      if (decl != nullptr) {
+        decl->decorateContext(context);
+      }
+    }
+
+    // decorate drawing context
+    decorate(context);
+
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "End Materialize");
+#endif
+  }
+
+protected:
+  /**
+   Override to implement materialization
+   */
+  virtual void decorate(DrawingContext *context) = 0;
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void addChild(std::shared_ptr<JsiDomNode> child) override {
+    if (std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child) ==
+        nullptr) {
+      getContext()->raiseError(std::runtime_error(
+          "Cannot add a child of type \"" + std::string(child->getType()) +
+          "\" to a \"" + std::string(getType()) + "\"."));
+    }
+    JsiDomNode::addChild(child);
+  }
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void insertChildBefore(std::shared_ptr<JsiDomNode> child,
+                         std::shared_ptr<JsiDomNode> before) override {
+    if (std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child) ==
+        nullptr) {
+      getContext()->raiseError(std::runtime_error(
+          "Cannot add a child of type \"" + std::string(child->getType()) +
+          "\" to a \"" + std::string(getType()) + "\"."));
+    }
+    JsiDomNode::insertChildBefore(child, before);
+  }
+};
+
+template <typename T, typename ST>
+class JsiDomDeclarationNode : public JsiBaseDomDeclarationNode {
+public:
+  JsiDomDeclarationNode(std::shared_ptr<RNSkPlatformContext> context,
+                        const char *type)
+      : JsiBaseDomDeclarationNode(context, type) {}
+
+  bool isChanged(DrawingContext *context) {
+    return getCurrent() == nullptr || context->isChanged() ||
+           getPropsContainer()->isChanged();
+  }
+
+  /**
+   Returns the inner element
+   */
+  ST getCurrent() { return _current; }
+
+  /**
+   Clears the current
+   */
+  void clearCurrent() { _current = nullptr; }
+
+protected:
+  /**
+   Sets the current value
+   */
+  void setCurrent(ST c) { _current = c; }
+
+  /**
+   Returns a required child image filter by index
+   */
+  ST requireChild(size_t index) {
+    auto filter = optionalChild(index);
+    if (filter == nullptr) {
+      throw std::runtime_error("Expected child node at index " +
+                               std::to_string(index) + " in node " + getType());
+    }
+    return filter;
+  }
+
+  /**
+   Returns an optional child image filter by index
+   */
+  ST optionalChild(size_t index) {
+    if (index >= getChildren().size()) {
+      return nullptr;
+    }
+
+    auto child = getChildren()[index];
+    // Support all types here!! ImageFilters, ColorFilters
+    // package/src/dom/nodes/paint/ImageFilters.ts#80
+    return resolve(child);
+  }
+
+  /**
+   Returns child as inner type or nullptr
+   */
+  virtual ST resolve(std::shared_ptr<JsiDomNode> child) = 0;
+
+  /**
+   Sets or composes the image filter
+   */
+  virtual void set(DrawingContext *context, ST imageFilter) = 0;
+
+  void removeChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiBaseDomDeclarationNode::removeChild(child);
+    clearCurrent();
+  }
+
+  void addChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiBaseDomDeclarationNode::addChild(child);
+    clearCurrent();
+  }
+
+  void insertChildBefore(std::shared_ptr<JsiDomNode> child,
+                         std::shared_ptr<JsiDomNode> before) override {
+    JsiBaseDomDeclarationNode::insertChildBefore(child, before);
+    clearCurrent();
+  }
+
+private:
+  ST _current;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/base/JsiDomDrawingNode.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "JsiDomRenderNode.h"
+#include "JsiPaintNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiDomDrawingNode : public JsiDomRenderNode {
+public:
+  JsiDomDrawingNode(std::shared_ptr<RNSkPlatformContext> context,
+                    const char *type)
+      : JsiDomRenderNode(context, type) {}
+
+protected:
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomRenderNode::defineProperties(container);
+    container->defineProperty(std::make_shared<PaintProp>());
+  }
+
+  /**
+   Override to implement drawing.
+   */
+  virtual void draw(DrawingContext *context) = 0;
+
+  void renderNode(DrawingContext *context) override {
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "Begin Draw", 1);
+#endif
+
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, context->getDebugDescription(), 2);
+#endif
+    draw(context);
+
+    // Draw once more for each child paint node
+    for (auto &child : getChildren()) {
+      auto ptr = std::dynamic_pointer_cast<JsiPaintNode>(child);
+      if (ptr != nullptr) {
+        draw(ptr->getDrawingContext());
+      }
+    }
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "End Draw", 1);
+#endif
+  }
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/base/JsiDomNode.h

@@ -0,0 +1,384 @@
+#pragma once
+
+#include "JsiHostObject.h"
+#include "NodeProp.h"
+#include "NodePropsContainer.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "RNSkPlatformContext.h"
+
+namespace RNSkia {
+
+template <class TNode> class JsiDomNodeCtor {
+public:
+  /**
+   Constructor to add to the Api object
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      auto node = std::make_shared<TNode>(context);
+      node->initializeNode(runtime, thisValue, arguments, count);
+      return jsi::Object::createFromHostObject(runtime, std::move(node));
+    };
+  }
+};
+
+static std::atomic<size_t> NodeIdent = 1000;
+
+/**
+ Implements an abstract base class for nodes in the Skia Reconciler. This node
+ coresponds to the native implementation of the Node.ts class in Javascript.
+ */
+class JsiDomNode : public JsiHostObject,
+                   public std::enable_shared_from_this<JsiDomNode> {
+public:
+  /**
+   Contructor. Takes as parameters the values comming from the JS world that
+   initialized the class.
+   */
+  JsiDomNode(std::shared_ptr<RNSkPlatformContext> context, const char *type)
+      : _type(type), _context(context), _nodeId(NodeIdent++), JsiHostObject() {}
+
+  /**
+   Called when creating the node, resolves properties from the node constructor.
+   These properties are materialized, ie. no animated values or anything.
+   */
+  JSI_HOST_FUNCTION(initializeNode) {
+    return setProps(runtime, thisValue, arguments, count);
+  }
+
+  /**
+   JS-function for setting the properties from the JS reconciler on the node.
+   */
+  JSI_HOST_FUNCTION(setProps) {
+    if (count == 1) {
+      // Initialize properties container
+      setProps(runtime, getArgumentAsObject(runtime, arguments, count, 0));
+    } else {
+      setEmptyProps();
+    }
+    return jsi::Value::undefined();
+  }
+
+  /**
+   Empty setProp implementation - compatibility with JS node
+   */
+  JSI_HOST_FUNCTION(setProp) { return jsi::Value::undefined(); }
+
+  /**
+   JS Function to be called when the node is no longer part of the reconciler
+   tree. Use for cleaning up.
+   */
+  JSI_HOST_FUNCTION(dispose) {
+    dispose();
+    return jsi::Value::undefined();
+  }
+
+  /**
+   JS Function for adding a child node to this node.
+   */
+  JSI_HOST_FUNCTION(addChild) {
+    // child: Node<unknown>
+    auto newChild =
+        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 0);
+    addChild(newChild);
+    return jsi::Value::undefined();
+  }
+
+  /*
+   JS Function for removing a child node from this node
+   */
+  JSI_HOST_FUNCTION(removeChild) {
+    auto child =
+        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 0);
+    removeChild(child);
+    return jsi::Value::undefined();
+  }
+
+  /**
+   JS Function for insering a child node to a specific location in the children
+   array on this node
+   */
+  JSI_HOST_FUNCTION(insertChildBefore) {
+    // child: Node<unknown>, before: Node<unknown>
+    auto child =
+        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 0);
+    auto before =
+        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 1);
+    insertChildBefore(child, before);
+    return jsi::Value::undefined();
+  }
+
+  /**
+   JS Function for getting child nodes for this node
+   */
+  JSI_HOST_FUNCTION(children) {
+    auto array = jsi::Array(runtime, _children.size());
+
+    size_t index = 0;
+    for (auto child : _children) {
+      array.setValueAtIndex(runtime, index++, child->asHostObject(runtime));
+    }
+    return array;
+  }
+
+  /**
+   JS Property for getting the type of node
+   */
+  JSI_PROPERTY_GET(type) {
+    return jsi::String::createFromUtf8(runtime, getType());
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiDomNode, type))
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiDomNode, setProps),
+                       JSI_EXPORT_FUNC(JsiDomNode, setProp),
+                       JSI_EXPORT_FUNC(JsiDomNode, addChild),
+                       JSI_EXPORT_FUNC(JsiDomNode, removeChild),
+                       JSI_EXPORT_FUNC(JsiDomNode, insertChildBefore),
+                       JSI_EXPORT_FUNC(JsiDomNode, children),
+                       JSI_EXPORT_FUNC(JsiDomNode, dispose))
+
+  /**
+   Returns the node type.
+  */
+  const char *getType() { return _type; }
+
+  /**
+   Returns the identifier for the node
+   */
+  size_t getNodeId() { return _nodeId; }
+
+  /**
+   Returns the container for node properties
+   */
+  NodePropsContainer *getPropsContainer() { return _propsContainer.get(); }
+
+  /**
+   Callback that will be called when the node is disposed - typically registered
+   from the dependency manager so that nodes can be removed and unsubscribed
+   from when removed from the reconciler tree.
+   */
+  void setDisposeCallback(std::function<void()> disposeCallback) {
+    _disposeCallback = disposeCallback;
+  }
+
+  /**
+   Updates any pending property changes in all nodes and child nodes. This
+   function will swap any pending property changes in this and children with any
+   waiting values that has been set by the javascript thread. Props will also be
+   marked as changed so that we can calculate wether updates are required or
+   not.
+   */
+  void commitPendingChanges() {
+    // Update properties container
+    if (_propsContainer != nullptr) {
+      _propsContainer->updatePendingValues();
+    }
+
+    // Run all pending node operations
+    {
+      std::lock_guard<std::mutex> lock(_childrenLock);
+      for (auto &op : _queuedNodeOps) {
+        op();
+      }
+
+      _queuedNodeOps.clear();
+    }
+
+    // Update children
+    for (auto &child : _children) {
+      child->commitPendingChanges();
+    }
+  }
+
+  /**
+   When pending properties has been updated and all rendering is done, we call
+   this function to mark any changes as processed. This call also resolves all
+   child nodes
+   */
+  virtual void resetPendingChanges() {
+    // Mark self as resolved
+    if (_propsContainer != nullptr) {
+      _propsContainer->markAsResolved();
+    }
+
+    // Now let's dispose if needed
+    if (_isDisposed) {
+      // Callback signaling that we're done
+      if (_disposeCallback != nullptr) {
+        _disposeCallback();
+        _disposeCallback = nullptr;
+      }
+
+      // Clear props
+      if (_propsContainer != nullptr) {
+        _propsContainer->dispose();
+      }
+
+      // Remove children
+      std::vector<std::shared_ptr<JsiDomNode>> tmp;
+      {
+        std::lock_guard<std::mutex> lock(_childrenLock);
+        tmp.reserve(_children.size());
+        for (auto &child : _children) {
+          tmp.push_back(child);
+        }
+        _children.clear();
+      }
+      for (auto &child : tmp) {
+        child->dispose();
+      }
+    }
+
+    // Resolve children
+    for (auto &child : _children) {
+      child->resetPendingChanges();
+    }
+  }
+
+protected:
+  /**
+   Override to define properties in node implementations
+   */
+  virtual void defineProperties(NodePropsContainer *container) {}
+
+  /**
+   Returns the platform context
+   */
+  std::shared_ptr<RNSkPlatformContext> getContext() { return _context; }
+
+  /**
+   Returns this node as a host object that can be returned to the JS side.
+  */
+  jsi::Object asHostObject(jsi::Runtime &runtime) {
+    return jsi::Object::createFromHostObject(runtime, shared_from_this());
+  }
+
+  /**
+   Native implementation of the set properties method. This is called from the
+   reconciler when properties are set due to changes in React. This method will
+   always call the onPropsSet method as a signal that things have changed.
+   */
+  void setProps(jsi::Runtime &runtime, jsi::Object &&props) {
+    if (_propsContainer == nullptr) {
+
+      // Initialize properties container
+      _propsContainer = std::make_shared<NodePropsContainer>(getType());
+
+      // Ask sub classes to define their properties
+      defineProperties(_propsContainer.get());
+    }
+    // Update properties container
+    _propsContainer->setProps(runtime, std::move(props));
+  }
+
+  /**
+   Called for components that has no properties
+   */
+  void setEmptyProps() {
+    if (_propsContainer == nullptr) {
+
+      // Initialize properties container
+      _propsContainer = std::make_shared<NodePropsContainer>(getType());
+
+      // Ask sub classes to define their properties
+      defineProperties(_propsContainer.get());
+    }
+  }
+
+  /**
+   Returns all child JsiDomNodes for this node.
+   */
+  const std::vector<std::shared_ptr<JsiDomNode>> &getChildren() {
+    std::lock_guard<std::mutex> lock(_childrenLock);
+    return _children;
+  }
+
+  /**
+   Adds a child node to the array of children for this node
+   */
+  virtual void addChild(std::shared_ptr<JsiDomNode> child) {
+    std::lock_guard<std::mutex> lock(_childrenLock);
+    _queuedNodeOps.push_back([child, this]() { _children.push_back(child); });
+  }
+
+  /**
+   Inserts a child node before a given child node in the children array for this
+   node
+   */
+  virtual void insertChildBefore(std::shared_ptr<JsiDomNode> child,
+                                 std::shared_ptr<JsiDomNode> before) {
+    std::lock_guard<std::mutex> lock(_childrenLock);
+    _queuedNodeOps.push_back([child, before, this]() {
+      auto position = std::find(_children.begin(), _children.end(), before);
+      _children.insert(position, child);
+    });
+  }
+
+  /**
+   Removes a child. Removing a child will remove the child from the array of
+   children and call dispose on the child node.
+   */
+  virtual void removeChild(std::shared_ptr<JsiDomNode> child) {
+    std::lock_guard<std::mutex> lock(_childrenLock);
+    _queuedNodeOps.push_back([child, this]() {
+      // Delete child itself
+      _children.erase(
+          std::remove_if(_children.begin(), _children.end(),
+                         [child](const auto &node) { return node == child; }),
+          _children.end());
+
+      child->dispose();
+    });
+  }
+
+  /**
+   Called when a node has been removed from the dom tree and needs to be cleaned
+   up.
+   */
+  virtual void dispose() {
+    if (_isDisposed) {
+      return;
+    }
+
+    _isDisposed = true;
+  }
+
+#if SKIA_DOM_DEBUG
+  std::string getLevelIndentation(DrawingContext *ctx, size_t indentation = 0) {
+    return std::string((ctx->getLevel() + indentation), ' ');
+  }
+
+  void printDebugInfo(DrawingContext *context, const std::string &message,
+                      size_t indentation = 0) {
+    RNSkLogger::logToConsole("%s%s %lu: %s",
+                             getLevelIndentation(context, indentation).c_str(),
+                             getType(), getNodeId(), message.c_str());
+  }
+#endif
+
+private:
+  const char *_type;
+  std::shared_ptr<RNSkPlatformContext> _context;
+
+  std::shared_ptr<NodePropsContainer> _propsContainer;
+
+  std::function<void()> _disposeCallback;
+
+  std::vector<std::shared_ptr<JsiDomNode>> _children;
+  std::mutex _childrenLock;
+
+  std::atomic<bool> _isDisposed = {false};
+
+  size_t _nodeId;
+
+  std::vector<std::function<void()>> _queuedNodeOps;
+};
+
+} // namespace RNSkia