@leonsilicon/react-native-wishlist 0.0.0

package/cpp/DependencyInjection/MGDIImpl.cpp

@@ -0,0 +1,65 @@
+//
+//  MGDIImpl.cpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#include "MGDIImpl.hpp"
+
+#include <iostream>
+
+namespace Wishlist {
+
+std::shared_ptr<MGDataBinding> MGDIImpl::getDataBinding() {
+  return dataBinding_;
+}
+
+std::shared_ptr<MGVSyncRequester> MGDIImpl::getVSyncRequester() {
+  return vSyncRequester_;
+}
+
+std::shared_ptr<MGViewportCarer> MGDIImpl::getViewportCarer() {
+  return viewportCarer_;
+}
+
+std::shared_ptr<MGUIScheduler> MGDIImpl::getUIScheduler() {
+  return uiScheduler_;
+};
+
+std::shared_ptr<MGErrorHandler> MGDIImpl::getErrorHandler() {
+  return errorHandler_;
+}
+
+void MGDIImpl::setDataBinding(const std::shared_ptr<MGDataBinding> &db) {
+  dataBinding_ = db;
+}
+
+void MGDIImpl::setVSyncRequester(const std::shared_ptr<MGVSyncRequester> &vr) {
+  vSyncRequester_ = vr;
+}
+
+void MGDIImpl::setPushChildrenListener(
+    const std::shared_ptr<MGViewportCarerListener> &pcl) {
+  pushChildrenListener_ = pcl;
+}
+
+void MGDIImpl::setViewportCarer(const std::shared_ptr<MGViewportCarer> &vc) {
+  viewportCarer_ = vc;
+}
+
+void MGDIImpl::setUIScheduler(const std::shared_ptr<MGUIScheduler> &us) {
+  uiScheduler_ = us;
+}
+
+void MGDIImpl::setErrorHandler(const std::shared_ptr<MGErrorHandler> &eh) {
+  errorHandler_ = eh;
+}
+
+std::weak_ptr<MGDI> MGDIImpl::getWeak() {
+  return weak_from_this();
+}
+
+MGDIImpl::~MGDIImpl() {}
+
+}; // namespace Wishlist

package/cpp/DependencyInjection/MGDIImpl.hpp

@@ -0,0 +1,45 @@
+//
+//  MGDIImpl.hpp
+//  MGWishList
+//
+//  Created by Szymon on 13/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+#include <memory>
+#include "MGDI.hpp"
+
+namespace Wishlist {
+
+class MGDIImpl : public MGDI, public std::enable_shared_from_this<MGDIImpl> {
+ public:
+  std::shared_ptr<MGDataBinding> getDataBinding() override;
+  std::shared_ptr<MGVSyncRequester> getVSyncRequester() override;
+  std::shared_ptr<MGViewportCarer> getViewportCarer() override;
+  std::shared_ptr<MGUIScheduler> getUIScheduler() override;
+  std::shared_ptr<MGErrorHandler> getErrorHandler() override;
+
+  void setDataBinding(const std::shared_ptr<MGDataBinding> &db);
+  void setVSyncRequester(const std::shared_ptr<MGVSyncRequester> &vr);
+  void setPushChildrenListener(
+      const std::shared_ptr<MGViewportCarerListener> &pcl);
+  void setViewportCarer(const std::shared_ptr<MGViewportCarer> &vc);
+  void setUIScheduler(const std::shared_ptr<MGUIScheduler> &us);
+  void setErrorHandler(const std::shared_ptr<MGErrorHandler> &eh);
+
+  std::weak_ptr<MGDI> getWeak();
+
+  virtual ~MGDIImpl();
+
+ private:
+  std::shared_ptr<MGDataBinding> dataBinding_;
+  std::shared_ptr<MGVSyncRequester> vSyncRequester_;
+  std::shared_ptr<MGViewportCarerListener> pushChildrenListener_;
+  std::shared_ptr<MGViewportCarer> viewportCarer_;
+  std::shared_ptr<MGUIScheduler> uiScheduler_;
+  std::shared_ptr<MGErrorHandler> errorHandler_;
+};
+
+}; // namespace Wishlist

package/cpp/DependencyInjection/MGUIManagerHolder.cpp

@@ -0,0 +1,21 @@
+#include "MGUIManagerHolder.h"
+
+namespace Wishlist {
+
+MGUIManagerHolder &MGUIManagerHolder::getInstance() {
+  static MGUIManagerHolder instance;
+  return instance;
+}
+
+MGUIManagerHolder::MGUIManagerHolder() : uiManager_(nullptr) {}
+
+std::shared_ptr<UIManager> MGUIManagerHolder::getUIManager() const {
+  return uiManager_;
+}
+
+void MGUIManagerHolder::setUIManager(
+    const std::shared_ptr<UIManager> &uiManager) {
+  uiManager_ = uiManager;
+}
+
+}; // namespace Wishlist

package/cpp/DependencyInjection/MGUIManagerHolder.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+
+using namespace facebook::react;
+
+namespace Wishlist {
+
+class MGUIManagerHolder {
+ public:
+  static MGUIManagerHolder &getInstance();
+
+  std::shared_ptr<UIManager> getUIManager() const;
+  void setUIManager(const std::shared_ptr<UIManager> &uiManager);
+
+ private:
+  MGUIManagerHolder();
+  MGUIManagerHolder(const MGUIManagerHolder &) = delete;
+  MGUIManagerHolder &operator=(const MGUIManagerHolder &) = delete;
+
+  std::shared_ptr<UIManager> uiManager_;
+};
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ComponentsPool.cpp

@@ -0,0 +1,91 @@
+#include "ComponentsPool.h"
+
+#include <iostream>
+
+using namespace facebook::react;
+using namespace jsi;
+
+namespace Wishlist {
+
+void ComponentsPool::setNames(const std::vector<std::string> &names) {
+  nameToIndex_.clear();
+  for (int i = 0; i < names.size(); ++i) {
+    nameToIndex_[names[i]] = i;
+  }
+}
+
+void ComponentsPool::setRegisteredViews(
+    std::vector<std::shared_ptr<ShadowNode const>> registeredViews) {
+  registeredViews_ = registeredViews;
+}
+
+void ComponentsPool::returnToPool(std::shared_ptr<ShadowNode const> sn) {
+  if (sn == nullptr) {
+    return;
+  }
+  ShadowNodeCopyMachine::clearParent(sn);
+  std::string type = tagToType_[sn->getTag()];
+  reusable_[type].push_back(sn);
+}
+
+void ComponentsPool::templatesUpdated() {
+  // optimise by reusing some of elements if they are
+  // the same
+  tagToType_.clear();
+  reusable_.clear();
+}
+
+std::shared_ptr<ShadowNode const> ComponentsPool::getNodeForType(const std::string &type) {
+  if (reusable_[type].size() > 0) {
+    auto res = reusable_[type].back();
+    reusable_[type].pop_back();
+    return res;
+  }
+
+  auto templateNode = registeredViews_[nameToIndex_[type]];
+  auto deepCopy = ShadowNodeCopyMachine::copyShadowSubtree(templateNode);
+  tagToType_[deepCopy->getTag()] = type;
+  return deepCopy;
+}
+
+jsi::Object ComponentsPool::prepareProxy(jsi::Runtime &rt) {
+  if (proxy_ == nullptr) {
+    proxy_ = std::static_pointer_cast<jsi::HostObject>(
+        std::make_shared<ComponentsPool::Proxy>(shared_from_this()));
+  }
+  return jsi::Object::createFromHostObject(rt, proxy_);
+}
+
+ComponentsPool::Proxy::Proxy(std::weak_ptr<ComponentsPool> wcp) : wcp(wcp) {}
+
+Value ComponentsPool::Proxy::get(Runtime &rt, const PropNameID &nameProp) {
+  std::string name = nameProp.utf8(rt);
+
+  if (name == "getComponent") {
+    std::weak_ptr<ComponentsPool> blockWcp = this->wcp;
+    return jsi::Function::createFromHostFunction(
+        rt,
+        nameProp,
+        1,
+        [blockWcp](
+            Runtime &rt, const Value &thisVal, const Value *args, size_t count)
+            -> Value {
+          std::string type = args[0].asString(rt).utf8(rt);
+          auto sn = blockWcp.lock()->getNodeForType(type);
+
+          return jsi::Object::createFromHostObject(
+              rt, std::make_shared<ShadowNodeBinding>(sn, blockWcp, type, ""));
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+void ComponentsPool::Proxy::set(
+    Runtime &rt,
+    const PropNameID &name,
+    const Value &value) {
+  throw jsi::JSError(rt, "set hasn't been implemented yet");
+}
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ComponentsPool.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <stdio.h>
+#include <map>
+#include <memory>
+#include <sstream>
+#include "ShadowNodeBinding.h"
+#include "ShadowNodeCopyMachine.h"
+
+using namespace facebook::react;
+using namespace facebook::jsi;
+
+namespace Wishlist {
+
+class ComponentsPool : public std::enable_shared_from_this<ComponentsPool> {
+ public:
+  void setNames(const std::vector<std::string> &names);
+
+  void setRegisteredViews(std::vector<std::shared_ptr<ShadowNode const>> registeredViews);
+
+  void returnToPool(std::shared_ptr<ShadowNode const> sn);
+
+  void templatesUpdated();
+
+  std::shared_ptr<ShadowNode const> getNodeForType(const std::string &type);
+
+  Object prepareProxy(Runtime &rt);
+
+  class Proxy : public HostObject {
+   public:
+    std::weak_ptr<ComponentsPool> wcp;
+
+    Proxy(std::weak_ptr<ComponentsPool> wcp);
+
+    virtual Value get(Runtime &rt, const PropNameID &nameProp);
+
+    virtual void set(Runtime &rt, const PropNameID &name, const Value &value);
+  };
+
+ private:
+  std::map<std::string, int> nameToIndex_;
+  std::map<int, std::string> tagToType_;
+  std::map<std::string, std::vector<std::shared_ptr<ShadowNode const>>> reusable_;
+  std::vector<std::shared_ptr<ShadowNode const>> registeredViews_;
+  std::shared_ptr<HostObject> proxy_;
+};
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ItemProvider.cpp

@@ -0,0 +1,60 @@
+#include "ItemProvider.h"
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/primitives.h>
+#include "WishlistJsRuntime.h"
+
+namespace Wishlist {
+
+WishItem WorkletItemProvider::provide(
+    int index,
+    const std::shared_ptr<ShadowNodeBinding> &prevSn) {
+  WishItem wishItem;
+
+  auto &rt = WishlistJsRuntime::getInstance().getRuntime();
+
+  jsi::Function inflateItem =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getPropertyAsObject(rt, "__wishlistInflatorRegistry")
+          .getPropertyAsFunction(rt, "inflateItem");
+
+  jsi::Value returnedValue;
+  try {
+    returnedValue = inflateItem.call(
+        rt,
+        jsi::String::createFromUtf8(rt, tag),
+        jsi::Value(index),
+        cp->prepareProxy(rt),
+        prevSn ? jsi::Object::createFromHostObject(rt, prevSn)
+               : jsi::Value::null());
+  } catch (std::exception &error) {
+    di.lock()->getErrorHandler()->reportError(error.what());
+    return wishItem;
+  }
+
+  if (returnedValue.isUndefined()) {
+    return wishItem;
+  }
+
+  std::shared_ptr<ShadowNodeBinding> shadowNodeWrapper =
+      returnedValue.asObject(rt).getHostObject<ShadowNodeBinding>(rt);
+
+  auto sn = shadowNodeWrapper->getShadowNode();
+
+  auto affected = std::vector<const LayoutableShadowNode *>();
+  this->lc.affectedNodes = &affected;
+  // better use layoutTree instead of measure (will be persistant)
+  std::shared_ptr<YogaLayoutableShadowNode> ysn =
+      std::static_pointer_cast<YogaLayoutableShadowNode>(sn->clone({}));
+  facebook::react::Size sz = ysn->measure(this->lc, this->lcc);
+
+  wishItem.sn = std::static_pointer_cast<ShadowNode>(ysn);
+  wishItem.height = sz.height;
+  wishItem.index = index;
+  wishItem.key = shadowNodeWrapper->getKey();
+  wishItem.type = shadowNodeWrapper->getType();
+  return wishItem;
+}
+
+}; // namespace Wishlist

package/cpp/ItemProvider/ItemProvider.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <react/renderer/uimanager/primitives.h>
+#include <stdio.h>
+#include <memory>
+#include "ComponentsPool.h"
+#include "MGDI.hpp"
+
+using namespace facebook::react;
+
+namespace Wishlist {
+
+struct WishItem {
+  float offset;
+  int index;
+  std::string key;
+  std::string type;
+  float height;
+  bool dirty = false;
+  std::shared_ptr<ShadowNode> sn;
+};
+
+class ItemProvider {
+ public:
+  float maxWidth = 0;
+  LayoutConstraints lcc;
+  LayoutContext lc;
+
+  ItemProvider(float maxWidth, LayoutContext lc) {
+    this->maxWidth = maxWidth;
+    this->lc = lc;
+    lcc.layoutDirection = facebook::react::LayoutDirection::LeftToRight;
+    lcc.maximumSize.width = maxWidth;
+  }
+
+  virtual void setComponentsPool(std::shared_ptr<ComponentsPool> pool) = 0;
+
+  virtual WishItem provide(
+      int index,
+      const std::shared_ptr<ShadowNodeBinding> &prevSn) = 0;
+
+  virtual ~ItemProvider() {}
+};
+
+struct WorkletItemProvider : ItemProvider {
+  std::shared_ptr<ComponentsPool> cp;
+  std::string tag;
+  std::weak_ptr<MGDI> di;
+
+  WorkletItemProvider(
+      std::weak_ptr<MGDI> di,
+      float maxWidth,
+      LayoutContext lc,
+      std::string tag)
+      : ItemProvider(maxWidth, lc), di(di) {
+    this->tag = tag;
+  }
+
+  void setComponentsPool(std::shared_ptr<ComponentsPool> pool) override {
+    cp = pool;
+  }
+
+  WishItem provide(int index, const std::shared_ptr<ShadowNodeBinding> &prevSn)
+      override;
+};
+
+}; // namespace Wishlist