@leonsilicon/react-native-wishlist 0.0.0

package/cpp/ItemProvider/ShadowNodeBinding.cpp

@@ -0,0 +1,356 @@
+#include "ShadowNodeBinding.h"
+
+#include "ComponentsPool.h"
+
+#include <iostream>
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace Wishlist {
+
+ShadowNodeBinding::ShadowNodeBinding(
+    std::shared_ptr<const ShadowNode> sn,
+    std::weak_ptr<ComponentsPool> wcp,
+    const std::string &type,
+    const std::string &key)
+    : sn_(sn), wcp_(wcp), parent_(nullptr), type_(type), key_(key) {}
+
+ShadowNodeBinding::ShadowNodeBinding(
+    std::shared_ptr<const ShadowNode> sn,
+    std::weak_ptr<ComponentsPool> wcp,
+    std::shared_ptr<ShadowNodeBinding> parent)
+    : sn_(sn),
+      wcp_(wcp),
+      parent_(parent),
+      type_(parent->type_),
+      key_(parent->key_) {}
+
+std::string ShadowNodeBinding::getType() const {
+  return type_;
+}
+
+std::string ShadowNodeBinding::getKey() const {
+  return key_;
+}
+
+std::shared_ptr<ShadowNode const> ShadowNodeBinding::getShadowNode() const {
+  return sn_;
+}
+
+void ShadowNodeBinding::describe(
+    std::stringstream &ss,
+    const std::shared_ptr<const ShadowNode> n,
+    int level) {
+  for (auto i = 0; i < level; ++i) {
+    ss << " ";
+  }
+  ss << n->getComponentName();
+  if (n->getProps()->nativeId.length() > 0) {
+    ss << " (" << n->getProps()->nativeId << ")";
+  }
+#if DEBUG
+  ss << " " << n->getProps()->getDebugDescription();
+#endif
+  ss << "\n";
+  for (auto child : n->getChildren()) {
+    describe(ss, child, level + 2);
+  }
+};
+
+std::shared_ptr<ShadowNodeBinding> ShadowNodeBinding::findNodeByWishId(
+    const std::string &nativeId,
+    std::shared_ptr<ShadowNodeBinding> p) {
+  for (auto child : p->sn_->getChildren()) {
+    // Create binding
+    auto bc = std::make_shared<ShadowNodeBinding>(child, wcp_, p);
+
+    // Test against native id
+    if (child->getProps()->nativeId == nativeId) {
+      return bc;
+    }
+
+    // Test child's children
+    auto binding = findNodeByWishId(nativeId, bc);
+    if (binding != nullptr) {
+      return binding;
+    }
+  }
+  return nullptr;
+}
+
+Value ShadowNodeBinding::get(Runtime &rt, const PropNameID &nameProp) {
+  std::string name = nameProp.utf8(rt);
+
+  if (name == "setCallback") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          std::string callbackName = args[0].asString(rt).utf8(rt);
+          int tag = sn_->getTag();
+          std::string eventName = std::to_string(tag) + callbackName;
+          jsi::Function callback = args[1].asObject(rt).asFunction(rt);
+
+          auto handlerRegistry = rt.global()
+                                     .getPropertyAsObject(rt, "global")
+                                     .getPropertyAsObject(rt, "handlers");
+          handlerRegistry.setProperty(rt, eventName.c_str(), callback);
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "addProps") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          // TODO: Avoid this extra call into JS by wrapping this function in
+          // JS.
+          auto processProps =
+              rt.global()
+                  .getPropertyAsObject(rt, "global")
+                  .getPropertyAsObject(rt, "__wishlistInflatorRegistry")
+                  .getPropertyAsFunction(rt, "processProps");
+          auto props = processProps.call(rt, args[0]);
+          RawProps rawProps(rt, props);
+
+          auto &cd = sn_->getComponentDescriptor();
+
+          PropsParserContext propsParserContext{
+              sn_->getFamily().getSurfaceId(), *cd.getContextContainer().get()};
+
+          auto nextProps = cd.cloneProps(
+              propsParserContext, sn_->getProps(), std::move(rawProps));
+
+          auto clonedShadowNode = cd.cloneShadowNode(
+              *sn_,
+              {
+                  nextProps,
+                  nullptr,
+              });
+
+          sn_ = clonedShadowNode;
+
+          std::shared_ptr<ShadowNodeBinding> currentParent = parent_;
+          std::shared_ptr<ShadowNode> currentSN = clonedShadowNode;
+          while (currentParent != nullptr) {
+            auto &cd = currentParent->sn_->getComponentDescriptor();
+            auto children = currentParent->sn_->getChildren();
+            for (int i = 0; i < children.size(); ++i) {
+              if (children[i]->getTag() == currentSN->getTag()) {
+                children[i] = currentSN;
+                break;
+              }
+            }
+            currentSN = cd.cloneShadowNode(
+                *(currentParent->sn_),
+                {nullptr,
+                 std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children)});
+            currentParent->sn_ = currentSN;
+            currentParent = currentParent->parent_;
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setChildren") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          if (!args[0].isObject() or !args[0].getObject(rt).isArray(rt)) {
+            return jsi::Value::undefined();
+          }
+          jsi::Array subItems = args[0].asObject(rt).asArray(rt);
+
+          auto &cd = sn_->getComponentDescriptor();
+
+          auto newChildren =
+              std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+
+          for (int i = 0; i < subItems.size(rt); ++i) {
+            std::shared_ptr<ShadowNodeBinding> child =
+                subItems.getValueAtIndex(rt, i)
+                    .getObject(rt)
+                    .getHostObject<ShadowNodeBinding>(rt);
+            ShadowNodeCopyMachine::clearParent(child->sn_);
+            newChildren->push_back(child->sn_);
+            child->parent_ = shared_from_this();
+          }
+
+          auto clonedShadowNode = cd.cloneShadowNode(
+              *sn_,
+              {
+                  nullptr,
+                  newChildren,
+              });
+
+          auto oldChildren = sn_->getChildren();
+          auto cp = wcp_.lock();
+          for (int i = 0; i < oldChildren.size(); ++i) {
+            if (cp) {
+              cp->returnToPool(oldChildren[i]);
+            }
+          }
+
+          sn_ = clonedShadowNode;
+
+          std::shared_ptr<ShadowNodeBinding> currentParent = parent_;
+          std::shared_ptr<ShadowNode> currentSN = clonedShadowNode;
+          while (currentParent != nullptr) {
+            auto &cd = currentParent->sn_->getComponentDescriptor();
+            auto children = currentParent->sn_->getChildren();
+            for (int i = 0; i < children.size(); ++i) {
+              if (children[i]->getTag() == currentSN->getTag()) {
+                children[i] = currentSN;
+                break;
+              }
+            }
+            currentSN = cd.cloneShadowNode(
+                *(currentParent->sn_),
+                {nullptr,
+                 std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children)});
+            currentParent->sn_ = currentSN;
+            currentParent = currentParent->parent_;
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "getName") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          return jsi::String::createFromUtf8(rt, sn_->getComponentName());
+        });
+  }
+
+  if (name == "describe") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          std::stringstream ss;
+          describe(ss, sn_, 0);
+          return jsi::String::createFromUtf8(rt, ss.str());
+        });
+  }
+
+  if (name == "getByWishId") { // TODO(Szymon) That can be optimised to O(depth)
+    // when template preprocessing
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          auto binding = findNodeByWishId(
+              args[0].asString(rt).utf8(rt), shared_from_this());
+          if (binding != nullptr) {
+            return jsi::Object::createFromHostObject(rt, binding);
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "at") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value {
+          int index = (int)(args[0].getNumber());
+          std::string type = sn_->getComponentName();
+
+          int i = 0;
+
+          for (auto sibiling : parent_->sn_->getChildren()) {
+            if (sibiling->getComponentName() == type) {
+              if (i == index) {
+                return jsi::Object::createFromHostObject(
+                    rt,
+                    std::make_shared<ShadowNodeBinding>(
+                        sibiling, wcp_, parent_));
+              }
+              i++;
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "getTag") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        0,
+        [=](jsi::Runtime &rt,
+            jsi::Value const &thisValue,
+            jsi::Value const *args,
+            size_t count) -> jsi::Value { return jsi::Value(sn_->getTag()); });
+  }
+
+  if (name == "key") {
+    return jsi::String::createFromUtf8(rt, key_);
+  }
+
+  if (name == "type") {
+    return jsi::String::createFromUtf8(rt, type_);
+  }
+
+  for (auto child : sn_->getChildren()) {
+    if (child->getComponentName() == name) {
+      return jsi::Object::createFromHostObject(
+          rt,
+          std::make_shared<ShadowNodeBinding>(child, wcp_, shared_from_this()));
+    }
+  }
+
+  return jsi::Value::undefined();
+}
+
+void ShadowNodeBinding::set(
+    Runtime &rt,
+    const PropNameID &name,
+    const Value &value) {
+  std::string str = name.utf8(rt);
+  if (str == "key") {
+    key_ = value.asString(rt).utf8(rt);
+  } else if (str == "type") {
+    type_ = value.asString(rt).utf8(rt);
+  }
+}
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ShadowNodeBinding.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <stdio.h>
+#include <map>
+#include <memory>
+#include <sstream>
+#include "ShadowNodeCopyMachine.h"
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace Wishlist {
+
+class ComponentsPool;
+
+class ShadowNodeBinding
+    : public jsi::HostObject,
+      public std::enable_shared_from_this<ShadowNodeBinding> {
+ public:
+  ShadowNodeBinding(
+      std::shared_ptr<const ShadowNode> sn,
+      std::weak_ptr<ComponentsPool> wcp,
+      const std::string &type,
+      const std::string &key);
+
+  ShadowNodeBinding(
+      std::shared_ptr<const ShadowNode> sn,
+      std::weak_ptr<ComponentsPool> wcp,
+      std::shared_ptr<ShadowNodeBinding> parent);
+
+  virtual jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &nameProp);
+
+  virtual void
+  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
+
+  std::string getType() const;
+  std::string getKey() const;
+  std::shared_ptr<ShadowNode const> getShadowNode() const;
+
+ private:
+  void describe(
+      std::stringstream &ss,
+      const std::shared_ptr<const ShadowNode> n,
+      int level);
+
+  std::shared_ptr<ShadowNodeBinding> findNodeByWishId(
+      const std::string &nativeId,
+      std::shared_ptr<ShadowNodeBinding> p);
+
+ private:
+  std::shared_ptr<const ShadowNode> sn_;
+  std::weak_ptr<ComponentsPool> wcp_;
+  std::shared_ptr<ShadowNodeBinding> parent_;
+  std::string type_;
+  std::string key_;
+};
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ShadowNodeCopyMachine.cpp

@@ -0,0 +1,95 @@
+#include "ShadowNodeCopyMachine.h"
+#include "MGWishlistComponentDescriptor.h"
+#include "WishlistJsRuntime.h"
+
+namespace Wishlist {
+namespace {
+
+// dirty hack don't do it at home
+//
+// NOTE: This mirrors the private layout of `facebook::react::ShadowNodeFamily`
+// for React Native 0.83. We only use it via `reinterpret_cast` to reach the
+// private `parent_`/`hasParent_` slots. RN 0.83 made `ShadowNodeFamily` derive
+// from `jsi::NativeState` and moved `nativeProps_DEPRECATED` to a public field
+// at the top of the class, so the order below differs from older versions of
+// the library.
+class ShadowNodeFamilyHack final : public jsi::NativeState {
+ public:
+  using Shared = std::shared_ptr<ShadowNodeFamily const>;
+  using Weak = std::weak_ptr<ShadowNodeFamily const>;
+
+  ShadowNodeFamilyHack() = delete;
+
+  mutable std::unique_ptr<folly::dynamic> nativeProps_DEPRECATED;
+
+ private:
+  [[maybe_unused]] EventDispatcher::Weak eventDispatcher_;
+  [[maybe_unused]] mutable std::shared_ptr<State const> mostRecentState_;
+  [[maybe_unused]] mutable std::shared_mutex mutex_;
+  [[maybe_unused]] mutable std::function<void(ShadowNodeFamily &family)>
+      onUnmountedFamilyDestroyedCallback_;
+  [[maybe_unused]] Tag const tag_;
+  [[maybe_unused]] SurfaceId const surfaceId_;
+  [[maybe_unused]] mutable InstanceHandle::Shared instanceHandle_;
+  [[maybe_unused]] SharedEventEmitter const eventEmitter_;
+  [[maybe_unused]] ComponentDescriptor const &componentDescriptor_;
+  [[maybe_unused]] ComponentHandle componentHandle_;
+  [[maybe_unused]] ComponentName componentName_;
+
+ public:
+  mutable ShadowNodeFamily::Weak parent_{};
+  mutable bool hasParent_{false};
+
+ private:
+  [[maybe_unused]] mutable bool hasBeenMounted_{false};
+};
+
+} // namespace
+
+int tag = -2;
+
+std::shared_ptr<ShadowNode> ShadowNodeCopyMachine::copyShadowSubtree(
+    const std::shared_ptr<const ShadowNode> &sn) {
+  auto const &cd = sn->getComponentDescriptor();
+
+  PropsParserContext propsParserContext{
+      sn->getSurfaceId(), *cd.getContextContainer().get()};
+
+  if (tag < -2e9) {
+    tag = -2;
+  }
+
+  auto const fragment =
+      ShadowNodeFamilyFragment{tag -= 2, sn->getSurfaceId(), nullptr};
+
+  auto const family = cd.createFamily(fragment);
+  auto const props =
+      cd.cloneProps(propsParserContext, sn->getProps(), RawProps());
+  auto const state = cd.createInitialState(props, family);
+
+  auto shadowNode = cd.createShadowNode(
+      ShadowNodeFragment{
+          /* .props = */
+          props,
+          /* .children = */ ShadowNodeFragment::childrenPlaceholder(),
+          /* .state = */ state,
+      },
+      family);
+
+  for (const auto &child : sn->getChildren()) {
+    auto const clonedChild = copyShadowSubtree(child);
+    cd.appendChild(shadowNode, clonedChild);
+  }
+
+  return shadowNode;
+}
+
+void ShadowNodeCopyMachine::clearParent(
+    const std::shared_ptr<const ShadowNode> &sn) {
+  auto *family =
+      reinterpret_cast<const ShadowNodeFamilyHack *>(&sn->getFamily());
+  family->hasParent_ = false;
+  family->parent_.reset();
+}
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ShadowNodeCopyMachine.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/wishlist/Props.h>
+#include <react/renderer/core/InstanceHandle.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+#include <stdio.h>
+#include <iostream>
+
+using namespace facebook;
+using namespace facebook::react;
+
+namespace Wishlist {
+
+class ShadowNodeCopyMachine {
+ public:
+  static std::shared_ptr<ShadowNode> copyShadowSubtree(
+      const std::shared_ptr<const ShadowNode> &sn);
+  static void clearParent(const std::shared_ptr<const ShadowNode> &sn);
+};
+
+}; // namespace Wishlist

package/cpp/MGErrorHandler.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+namespace Wishlist {
+
+class MGErrorHandler {
+ public:
+  virtual void reportError(const std::string &message) = 0;
+};
+
+}; // namespace Wishlist

package/cpp/MGViewportCarer/MGVSyncRequester.hpp

@@ -0,0 +1,18 @@
+//
+//  MGVSyncRequester.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+
+namespace Wishlist {
+
+struct MGVSyncRequester {
+  virtual void requestVSync() = 0;
+};
+
+}; // namespace Wishlist

package/cpp/MGViewportCarer/MGViewportCarer.hpp

@@ -0,0 +1,42 @@
+//
+//  MGViewportCarer.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <stdio.h>
+
+namespace Wishlist {
+
+using namespace facebook::react;
+
+static float MG_NO_OFFSET = std::numeric_limits<float>::min();
+
+struct MGDims {
+  float width;
+  float height;
+};
+
+class MGViewportCarer {
+ public:
+  virtual void initialRenderAsync(
+      MGDims dimensions,
+      float initialContentSize,
+      int originItem,
+      const std::vector<std::shared_ptr<ShadowNode const>> &registeredViews,
+      const std::vector<std::string> &names,
+      const std::string &inflatorId) = 0;
+
+  virtual void didScrollAsync(
+      MGDims dimensions,
+      float contentOffset,
+      const std::string &inflatorId) = 0;
+
+  virtual void didUpdateContentOffset() = 0;
+};
+
+}; // namespace Wishlist