@leonsilicon/react-native-wishlist 0.0.0

package/cpp/TemplateContainer/MGTemplateContainerState.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+#include <vector>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+class JSI_EXPORT MGTemplateContainerState final {
+ public:
+  MGTemplateContainerState(){};
+  MGTemplateContainerState(
+      std::vector<std::shared_ptr<ShadowNode const>> const &templates)
+      : templates_(templates){};
+
+  const std::vector<std::shared_ptr<ShadowNode const>> &getTemplates() const;
+
+#ifdef ANDROID
+  MGTemplateContainerState(
+      MGTemplateContainerState const &previousState,
+      folly::dynamic data){};
+
+  folly::dynamic getDynamic() const;
+
+  MapBuffer getMapBuffer() const;
+#endif
+
+ private:
+  std::vector<std::shared_ptr<ShadowNode const>> templates_;
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/UIScheduler/MGUIScheduler.cpp

@@ -0,0 +1,8 @@
+//
+//  MGUIScheduler.cpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#include "MGUIScheduler.hpp"

package/cpp/UIScheduler/MGUIScheduler.hpp

@@ -0,0 +1,18 @@
+//
+//  MGUIScheduler.hpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#ifndef MGUIScheduler_hpp
+#define MGUIScheduler_hpp
+
+#include <stdio.h>
+#include <functional>
+
+struct MGUIScheduler {
+  virtual void scheduleOnUI(std::function<void()> &&f) = 0;
+};
+
+#endif /* MGUIScheduler_hpp */

package/cpp/Wishlist/MGWishlistComponentDescriptor.h

@@ -0,0 +1,14 @@
+
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "MGWishlistShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+using MGWishlistComponentDescriptor =
+    ConcreteComponentDescriptor<MGWishlistShadowNode>;
+
+} // namespace react
+} // namespace facebook

package/cpp/Wishlist/MGWishlistShadowNode.cpp

@@ -0,0 +1,49 @@
+#include "MGWishlistShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+extern const char MGWishlistComponentName[] = "MGWishlist";
+
+void MGWishlistShadowNode::layout(LayoutContext layoutContext) {
+  auto state = getStateData();
+  if (!state.initialised) {
+    state.initialised = true;
+    state.viewportCarer->setInitialValues(shared_from_this(), layoutContext);
+
+    setStateData(std::move(state));
+  }
+
+  ConcreteViewShadowNode::layout(layoutContext);
+
+  // TODO update viewportObserver if needed
+
+  updateStateIfNeeded();
+}
+
+void MGWishlistShadowNode::updateStateIfNeeded() {
+  ensureUnsealed();
+
+  auto contentBoundingRect = Rect{};
+  for (const auto &childNode : getLayoutableChildNodes()) {
+    contentBoundingRect.unionInPlace(childNode->getLayoutMetrics().frame);
+  }
+
+  auto state = getStateData();
+
+  if (state.contentBoundingRect != contentBoundingRect) {
+    state.contentBoundingRect = contentBoundingRect;
+    setStateData(std::move(state));
+  }
+}
+
+void MGWishlistShadowNode::updateContentOffset(float contentOffset) {
+  ensureUnsealed();
+
+  auto state = getStateData();
+  state.contentOffset = contentOffset;
+  setStateData(std::move(state));
+}
+
+} // namespace react
+} // namespace facebook

package/cpp/Wishlist/MGWishlistShadowNode.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/wishlist/EventEmitters.h>
+#include <react/renderer/components/wishlist/Props.h>
+#include <react/renderer/core/LayoutContext.h>
+#include "MGWishlistState.h"
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char MGWishlistComponentName[];
+
+/*
+ * `ShadowNode` for <Wishlist> component.
+ */
+class JSI_EXPORT MGWishlistShadowNode
+    : public ConcreteViewShadowNode<
+          MGWishlistComponentName,
+          MGWishlistProps,
+          MGWishlistEventEmitter,
+          MGWishlistState>,
+      public std::enable_shared_from_this<MGWishlistShadowNode> {
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+ public:
+  void layout(LayoutContext layoutContext) override;
+
+  void updateContentOffset(float contentOffset);
+
+ private:
+  void updateStateIfNeeded();
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/Wishlist/MGWishlistState.cpp

@@ -0,0 +1,57 @@
+#include "MGWishlistState.h"
+
+#ifdef ANDROID
+#include "JNIStateRegistry.h"
+#endif
+
+namespace facebook {
+namespace react {
+#ifdef ANDROID
+namespace {
+constexpr MapBuffer::Key ViewportCarerKey = 1;
+constexpr MapBuffer::Key ContentOffsetKey = 2;
+} // namespace
+#endif
+
+MGWishlistState::MGWishlistState()
+    : initialised(false),
+      viewportCarer(std::make_shared<MGViewportCarerImpl>()),
+      contentBoundingRect({}),
+      contentOffset(MG_NO_OFFSET){};
+
+#ifdef ANDROID
+
+MGWishlistState::MGWishlistState(
+    MGWishlistState const &previousState,
+    folly::dynamic data)
+    : initialised(previousState.initialised),
+      viewportCarer(previousState.viewportCarer),
+      contentBoundingRect(previousState.contentBoundingRect),
+      contentOffset(MG_NO_OFFSET){};
+
+folly::dynamic MGWishlistState::getDynamic() const {
+  auto viewportCarerRef = Wishlist::JNIStateRegistry::getInstance().addValue(
+      (void *)&viewportCarer);
+  folly::dynamic result = folly::dynamic::object();
+  result["viewportCarer"] = viewportCarerRef;
+  if (contentOffset != MG_NO_OFFSET) {
+    result["contentOffset"] = contentOffset;
+  }
+  return result;
+};
+
+MapBuffer MGWishlistState::getMapBuffer() const {
+  auto viewportCarerRef = Wishlist::JNIStateRegistry::getInstance().addValue(
+      (void *)&viewportCarer);
+  MapBufferBuilder builder;
+  builder.putInt(ViewportCarerKey, viewportCarerRef);
+  if (contentOffset != MG_NO_OFFSET) {
+    builder.putDouble(ContentOffsetKey, contentOffset);
+  }
+  return builder.build();
+};
+
+#endif
+
+} // namespace react
+} // namespace facebook

package/cpp/Wishlist/MGWishlistState.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/graphics/Rect.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+#include "ComponentsPool.h"
+#include "MGViewportCarerImpl.h"
+
+using namespace Wishlist;
+
+namespace facebook {
+namespace react {
+
+// class WishlistShadowNode;
+
+/*
+ * State for <ScrollView> component.
+ */
+class JSI_EXPORT MGWishlistState final {
+ public:
+  bool initialised;
+  std::shared_ptr<MGViewportCarerImpl> viewportCarer;
+  Rect contentBoundingRect;
+  float contentOffset;
+
+  MGWishlistState();
+
+#ifdef ANDROID
+  MGWishlistState(MGWishlistState const &previousState, folly::dynamic data);
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const;
+#endif
+};
+
+} // namespace react
+} // namespace facebook

package/cpp/WishlistDefine.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define MG_WISHLIST_DEBUG 0

package/cpp/WishlistJsRuntime.cpp

@@ -0,0 +1,139 @@
+#include "WishlistJsRuntime.h"
+
+#include <chrono>
+#include <iostream>
+#include <mutex>
+
+namespace Wishlist {
+
+WishlistDispatchQueue::WishlistDispatchQueue() {
+  thread_ = std::thread([this]() {
+    while (true) {
+      std::function<void()> work;
+      {
+        std::unique_lock<std::mutex> lock(mutex_);
+        cv_.wait(lock, [this] { return quit_ || !queue_.empty(); });
+        if (quit_ && queue_.empty()) {
+          return;
+        }
+        work = std::move(queue_.front());
+        queue_.pop();
+      }
+      work();
+    }
+  });
+}
+
+WishlistDispatchQueue::~WishlistDispatchQueue() {
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    quit_ = true;
+  }
+  cv_.notify_all();
+  if (thread_.joinable()) {
+    thread_.join();
+  }
+}
+
+void WishlistDispatchQueue::dispatch(std::function<void()> work) {
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    queue_.push(std::move(work));
+  }
+  cv_.notify_one();
+}
+
+WishlistJsRuntime &WishlistJsRuntime::getInstance() {
+  static WishlistJsRuntime instance;
+  return instance;
+}
+
+WishlistJsRuntime::WishlistJsRuntime() : runtime_(nullptr) {}
+
+void WishlistJsRuntime::initialize(
+    jsi::Runtime *runtime,
+    std::function<void(std::function<void()> &&)> jsCallInvoker,
+    std::function<void(std::function<void()> &&)> workletCallInvoker,
+    std::function<void(std::function<void(jsi::Runtime &)> &&)>
+        runtimeAccessor) {
+  runtime_ = runtime;
+  jsCallInvoker_ = std::move(jsCallInvoker);
+  workletCallInvoker_ = std::move(workletCallInvoker);
+  runtimeAccessor_ = std::move(runtimeAccessor);
+
+  decorateRuntime(*runtime_);
+}
+
+jsi::Runtime &WishlistJsRuntime::getRuntime() const {
+  return *runtime_;
+}
+
+void WishlistJsRuntime::accessRuntime(
+    std::function<void(jsi::Runtime &)> &&f) const {
+  if (runtimeAccessor_) {
+    runtimeAccessor_(std::move(f));
+    return;
+  }
+  auto runtime = runtime_;
+  auto ff = std::move(f);
+  jsCallInvoker_([runtime, ff = std::move(ff)]() mutable {
+    if (runtime) {
+      ff(*runtime);
+    }
+  });
+}
+
+void WishlistJsRuntime::accessRuntimeSync(
+    std::function<void(jsi::Runtime &)> &&f) const {
+  static std::mutex mutex;
+  mutex.lock();
+  auto runtime = runtime_;
+  auto ff = std::move(f);
+  jsCallInvoker_([runtime, ff = std::move(ff)]() mutable {
+    if (runtime) {
+      ff(*runtime);
+    }
+    mutex.unlock();
+  });
+  mutex.lock();
+  mutex.unlock();
+}
+
+void WishlistJsRuntime::decorateRuntime(jsi::Runtime &rt) {
+  auto callback = [](jsi::Runtime &rt,
+                     const jsi::Value & /*thisValue*/,
+                     const jsi::Value *args,
+                     size_t /*count*/) -> jsi::Value {
+    const jsi::Value *value = &args[0];
+    if (value->isString()) {
+      std::cout << value->getString(rt).utf8(rt).c_str() << std::endl;
+    } else if (value->isNumber()) {
+      std::cout << value->getNumber() << std::endl;
+    } else if (value->isUndefined()) {
+      std::cout << "undefined" << std::endl;
+    } else {
+      std::cout << "unsupported value type" << std::endl;
+    }
+    return jsi::Value::undefined();
+  };
+  jsi::Value log = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_log"), 1, callback);
+  rt.global().setProperty(rt, "_log", log);
+
+  auto chronoNow = [](jsi::Runtime & /*rt*/,
+                      const jsi::Value & /*thisValue*/,
+                      const jsi::Value * /*args*/,
+                      size_t /*count*/) -> jsi::Value {
+    double now = std::chrono::system_clock::now().time_since_epoch() /
+        std::chrono::milliseconds(1);
+    return jsi::Value(now);
+  };
+
+  rt.global().setProperty(
+      rt,
+      "_chronoNow",
+      jsi::Function::createFromHostFunction(
+          rt, jsi::PropNameID::forAscii(rt, "_chronoNow"), 0, chronoNow));
+}
+
+}; // namespace Wishlist

package/cpp/WishlistJsRuntime.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <stdio.h>
+#include <thread>
+
+using namespace facebook;
+
+namespace Wishlist {
+
+class WishlistDispatchQueue {
+ public:
+  WishlistDispatchQueue();
+  ~WishlistDispatchQueue();
+
+  void dispatch(std::function<void()> work);
+
+ private:
+  std::mutex mutex_;
+  std::condition_variable cv_;
+  std::queue<std::function<void()>> queue_;
+  bool quit_ = false;
+  std::thread thread_;
+};
+
+class WishlistJsRuntime {
+ public:
+  static WishlistJsRuntime &getInstance();
+
+  void initialize(
+      jsi::Runtime *runtime,
+      std::function<void(std::function<void()> &&)> jsCallInvoker,
+      std::function<void(std::function<void()> &&)> workletCallInvoker,
+      std::function<void(std::function<void(jsi::Runtime &)> &&)>
+          runtimeAccessor = nullptr);
+
+  jsi::Runtime &getRuntime() const;
+  void accessRuntime(std::function<void(jsi::Runtime &rt)> &&f) const;
+  void accessRuntimeSync(std::function<void(jsi::Runtime &rt)> &&f) const;
+
+ private:
+  WishlistJsRuntime();
+  WishlistJsRuntime(const WishlistJsRuntime &) = delete;
+  WishlistJsRuntime &operator=(const WishlistJsRuntime &) = delete;
+
+  void decorateRuntime(jsi::Runtime &runtime);
+
+  jsi::Runtime *runtime_;
+  std::function<void(std::function<void()> &&)> jsCallInvoker_;
+  std::function<void(std::function<void()> &&)> workletCallInvoker_;
+  std::function<void(std::function<void(jsi::Runtime &)> &&)> runtimeAccessor_;
+};
+
+}; // namespace Wishlist

package/ios/MGContentContainerComponent.h

@@ -0,0 +1,9 @@
+#import <React-RCTFabric/React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MGContentContainerComponent : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/MGContentContainerComponent.mm

@@ -0,0 +1,34 @@
+#import "MGContentContainerComponent.h"
+
+#import <react/renderer/components/wishlist/ComponentDescriptors.h>
+#import <react/renderer/components/wishlist/Props.h>
+#import "MGContentContainerComponentDescriptor.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@implementation MGContentContainerComponent
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MGContentContainerProps>();
+    _props = defaultProps;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (facebook::react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return facebook::react::concreteComponentDescriptorProvider<facebook::react::MGContentContainerComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> MGContentContainerCls(void)
+{
+  return MGContentContainerComponent.class;
+}

package/ios/MGErrorHandlerIOS.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+#include "MGErrorHandler.h"
+
+namespace Wishlist {
+
+class MGErrorHandlerIOS final : public MGErrorHandler {
+ public:
+  void reportError(const std::string &message) override;
+};
+
+} // namespace Wishlist

package/ios/MGErrorHandlerIOS.mm

@@ -0,0 +1,12 @@
+#import "MGErrorHandlerIOS.h"
+
+#import <React/RCTLog.h>
+
+namespace Wishlist {
+
+void MGErrorHandlerIOS::reportError(const std::string &message)
+{
+  RCTLogError(@"%@", @(message.c_str()));
+}
+
+}; // namespace Wishlist

package/ios/MGObjCJSIUtils.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+using namespace facebook;
+
+// Copied from RCTTurboModule.mm
+
+/**
+ * All static helper functions are ObjC++ specific.
+ */
+static jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value((bool)[value boolValue]);
+}
+
+static jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value([value doubleValue]);
+}
+
+static jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value)
+{
+  return jsi::String::createFromUtf8(runtime, [value UTF8String] ?: "");
+}
+
+static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+static jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value)
+{
+  jsi::Object result = jsi::Object(runtime);
+  for (NSString *k in value) {
+    result.setProperty(runtime, [k UTF8String], convertObjCObjectToJSIValue(runtime, value[k]));
+  }
+  return result;
+}
+
+static jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value)
+{
+  jsi::Array result = jsi::Array(runtime, value.count);
+  for (size_t i = 0; i < value.count; i++) {
+    result.setValueAtIndex(runtime, i, convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
+{
+  if ([value isKindOfClass:[NSString class]]) {
+    return convertNSStringToJSIString(runtime, (NSString *)value);
+  } else if ([value isKindOfClass:[NSNumber class]]) {
+    if ([value isKindOfClass:[@YES class]]) {
+      return convertNSNumberToJSIBoolean(runtime, (NSNumber *)value);
+    }
+    return convertNSNumberToJSINumber(runtime, (NSNumber *)value);
+  } else if ([value isKindOfClass:[NSDictionary class]]) {
+    return convertNSDictionaryToJSIObject(runtime, (NSDictionary *)value);
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    return convertNSArrayToJSIArray(runtime, (NSArray *)value);
+  } else if (value == (id)kCFNull) {
+    return jsi::Value::null();
+  }
+  return jsi::Value::undefined();
+}

package/ios/MGTemplateContainerComponent.h

@@ -0,0 +1,12 @@
+#import <React-RCTFabric/React/RCTViewComponentView.h>
+#import "MGWishListComponent.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MGTemplateContainerComponent : RCTViewComponentView
+
+- (void)setWishlist:(MGWishListComponent *)wishList;
+
+@end
+
+NS_ASSUME_NONNULL_END