@leonsilicon/react-native-wishlist 0.0.0

package/ios/MGWishlistManager.mm

@@ -0,0 +1,319 @@
+#import "MGWishlistManager.h"
+
+#import <objc/runtime.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTScheduler.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterStub.h>
+#import <ReactCommon/RCTTurboModule.h>
+#include <jsi/JSIDynamic.h>
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <react/renderer/core/EventListener.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+#include "WKTJsiWorkletContext.h"
+#include "MGContentContainerComponent.h"
+#include "MGObjCJSIUtils.h"
+#include "MGTemplateContainerComponent.h"
+#include "MGTemplateInterceptorComponent.h"
+#include "MGUIManagerHolder.h"
+#import "MGWishListComponent.h"
+#import "MGWishlistQueue.h"
+#include "WishlistJsRuntime.h"
+
+using namespace facebook::react;
+using namespace Wishlist;
+
+@interface MGWishlistManager () <RCTEventDispatcherObserver>
+
+@property (nonatomic, weak) RCTBridge *bridge;
+
+@end
+
+@implementation MGWishlistManager {
+  __weak RCTSurfacePresenter *_surfacePresenter;
+  std::shared_ptr<EventListener> _eventListener;
+  dispatch_queue_t _wishlistQueue;
+}
+
+RCT_EXPORT_MODULE(WishlistManager);
+
++ (void)initialize
+{
+  if (self != [MGWishlistManager class]) {
+    return;
+  }
+  RCTComponentViewFactory *factory = [RCTComponentViewFactory currentComponentViewFactory];
+  [factory registerComponentViewClass:[MGWishListComponent class]];
+  [factory registerComponentViewClass:[MGTemplateContainerComponent class]];
+  [factory registerComponentViewClass:[MGTemplateInterceptorComponent class]];
+  [factory registerComponentViewClass:[MGContentContainerComponent class]];
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  _bridge = bridge;
+  __weak __typeof(self) weakSelf = self;
+  _eventListener = std::make_shared<EventListener>([weakSelf](const RawEvent &event) -> bool {
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf) {
+      return false;
+    }
+    return [strongSelf handleFabricEvent:event];
+  });
+  // In bridgeless mode the real surface presenter arrives via
+  // `setSurfacePresenter:` — the eventListener and UIManager hook-up happen
+  // there. In the legacy bridge path we still see a usable presenter here.
+  RCTSurfacePresenter *presenter = (RCTSurfacePresenter *)_bridge.surfacePresenter;
+  if ([presenter isKindOfClass:[RCTSurfacePresenter class]]) {
+    _surfacePresenter = presenter;
+    [_surfacePresenter.scheduler addEventListener:_eventListener];
+    MGUIManagerHolder::getInstance().setUIManager(_surfacePresenter.scheduler.uiManager);
+  }
+
+  [[bridge.moduleRegistry moduleForName:"EventDispatcher" lazilyLoadIfNecessary:YES] addDispatchObserver:self];
+}
+
+- (void)installWishlistRuntime
+{
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)_bridge;
+  auto callInvoker = cxxBridge.jsCallInvoker;
+  facebook::jsi::Runtime *jsRuntime = (facebook::jsi::Runtime *)cxxBridge.runtime;
+
+  // Install a JSI helper that lets the JS side hand us the
+  // `react-native-worklets-core` context (created via `Worklets.createContext`)
+  // it intends wishlist to run on. We unwrap the C++ `JsiWorkletContext`
+  // shared_ptr from the host object and use its worklet runtime as
+  // `WishlistJsRuntime`, so native and JS share global state. Without this the
+  // registry/handlers installed by the worklet context are invisible to
+  // wishlist's native code.
+  auto setupWishlistRuntime = [callInvoker](
+                                  facebook::jsi::Runtime &rt,
+                                  const facebook::jsi::Value & /*thisVal*/,
+                                  const facebook::jsi::Value *args,
+                                  size_t count) -> facebook::jsi::Value {
+    if (count < 1 || !args[0].isObject()) {
+      throw facebook::jsi::JSError(
+          rt, "MGWishlistManager._setWishlistContext expects a worklet context");
+    }
+    auto hostObject = args[0].asObject(rt).asHostObject(rt);
+    auto context = std::dynamic_pointer_cast<RNWorklet::JsiWorkletContext>(hostObject);
+    if (!context) {
+      throw facebook::jsi::JSError(
+          rt, "MGWishlistManager._setWishlistContext: argument is not a JsiWorkletContext");
+    }
+    facebook::jsi::Runtime &workletRuntime = context->getWorkletRuntime();
+    auto contextWeak = std::weak_ptr<RNWorklet::JsiWorkletContext>(context);
+    Wishlist::WishlistJsRuntime::getInstance().initialize(
+        &workletRuntime,
+        [=](std::function<void()> &&f) { callInvoker->invokeAsync(std::move(f)); },
+        [=](std::function<void()> &&f) {
+          __block auto retainedWork = std::move(f);
+          MGExecuteOnWishlistQueue(^{
+            retainedWork();
+          });
+        },
+        [contextWeak](std::function<void(facebook::jsi::Runtime &)> &&job) {
+          if (auto ctx = contextWeak.lock()) {
+            ctx->invokeOnWorkletThread(
+                [job = std::move(job)](RNWorklet::JsiWorkletContext * /*c*/,
+                                       facebook::jsi::Runtime &rt) { job(rt); });
+          }
+        });
+    return facebook::jsi::Value::undefined();
+  };
+
+  jsRuntime->global().setProperty(
+      *jsRuntime,
+      "__mgWishlistSetContext",
+      facebook::jsi::Function::createFromHostFunction(
+          *jsRuntime,
+          facebook::jsi::PropNameID::forAscii(*jsRuntime, "__mgWishlistSetContext"),
+          1,
+          setupWishlistRuntime));
+
+  // In bridgeless mode RN sets the real surface presenter on us via
+  // `setSurfacePresenter:` (separately from `setBridge:`), which also seeds
+  // `MGUIManagerHolder`. Capture again here as a fallback for the legacy
+  // bridge path — the scheduler's uiManager is finally wired up by the time
+  // JS reaches `install()`.
+  if (_surfacePresenter != nil) {
+    if (MGUIManagerHolder::getInstance().getUIManager() == nullptr) {
+      MGUIManagerHolder::getInstance().setUIManager(_surfacePresenter.scheduler.uiManager);
+    }
+  }
+}
+
+- (void)eventDispatcherWillDispatchEvent:(id<RCTEvent>)event
+{
+  [self handlePaperEvent:event];
+}
+
+- (bool)handleFabricEvent:(const RawEvent &)event
+{
+  std::string type = event.type;
+
+  auto shadowNodeFamily = event.shadowNodeFamily.lock();
+  if (shadowNodeFamily == nullptr) {
+    return event.eventTarget != nullptr;
+  }
+
+  int tag = shadowNodeFamily->getTag();
+  if (tag >= 0) {
+    // Some RN 0.83 Fabric events can have no instance handle. If we let those
+    // continue through the default event queue, RN crashes when retaining the
+    // target or mixing the JS `target` into the payload.
+    return shadowNodeFamily->getInstanceHandle() == nullptr;
+  }
+
+  if (event.eventTarget == nullptr) {
+    return false;
+  }
+
+  auto eventPayload = event.eventPayload;
+  WishlistJsRuntime::getInstance().accessRuntime([=](jsi::Runtime &rt) {
+    jsi::Value payload = eventPayload ? eventPayload->asJSIValue(rt) : jsi::Value::null();
+    [self sendEventWithType:jsi::String::createFromUtf8(rt, type) tag:tag payload:payload];
+  });
+
+  return true;
+}
+
+- (void)handlePaperEvent:(id<RCTEvent>)event
+{
+  NSNumber *tag = event.viewTag;
+  NSString *type = event.eventName;
+
+  WishlistJsRuntime::getInstance().accessRuntime([=](jsi::Runtime &rt) {
+    [self sendEventWithType:jsi::String::createFromUtf8(rt, [type UTF8String])
+                        tag:tag.intValue
+                    payload:convertObjCObjectToJSIValue(rt, event.arguments[2])];
+  });
+}
+
+- (void)sendEventWithType:(const jsi::String &)type tag:(int)tag payload:(const jsi::Value &)payload
+{
+  auto &rt = WishlistJsRuntime::getInstance().getRuntime();
+  try {
+    auto global = rt.global().getPropertyAsObject(rt, "global");
+    if (global.hasProperty(rt, "handleEvent")) {
+      auto f = global.getPropertyAsFunction(rt, "handleEvent");
+      f.call(rt, type, tag, payload);
+    }
+  } catch (std::exception &error) {
+    RCTLogError(@"%@", [NSString stringWithUTF8String:error.what()]);
+  }
+}
+
+- (void)initialize
+{
+}
+
+// In bridgeless mode RN calls this method on the TurboModule with the
+// real surface presenter (the one set on `RCTBridge` is unusable here). We
+// keep this reference and re-attach the wishlist event listener / refresh the
+// cached UIManager.
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  _surfacePresenter = (RCTSurfacePresenter *)surfacePresenter;
+
+  // Ensure the event listener exists (setBridge: may not have set it up under
+  // bridgeless mode).
+  if (_eventListener == nullptr) {
+    __weak __typeof(self) weakSelf = self;
+    _eventListener = std::make_shared<EventListener>([weakSelf](const RawEvent &event) -> bool {
+      __typeof(self) strongSelf = weakSelf;
+      if (!strongSelf) {
+        return false;
+      }
+      return [strongSelf handleFabricEvent:event];
+    });
+  }
+
+  RCTScheduler *scheduler = _surfacePresenter.scheduler;
+  if (scheduler != nil) {
+    [scheduler addEventListener:_eventListener];
+    MGUIManagerHolder::getInstance().setUIManager(scheduler.uiManager);
+  }
+}
+
+- (void)invalidate
+{
+  [_surfacePresenter.scheduler removeEventListener:_eventListener];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+  // Wire up `WishlistJsRuntime` to the worklets UI runtime now that JS has
+  // started (so `globalThis.__workletsModuleProxy` is available). This must
+  // happen before any wishlist component mounts.
+  [self installWishlistRuntime];
+  return @true;
+}
+
+- (std::shared_ptr<TurboModule>)getTurboModule:(const ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<NativeWishlistManagerSpecJSI>(params);
+}
+
+@end
+
+@implementation MGWishlistComponentManager
+
+RCT_EXPORT_MODULE(MGWishlist)
+
+RCT_CUSTOM_VIEW_PROPERTY(inflatorId, NSString *, UIView) {}
+RCT_CUSTOM_VIEW_PROPERTY(initialIndex, double, UIView) {}
+
+RCT_EXPORT_VIEW_PROPERTY(onStartReached, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onEndReached, RCTDirectEventBlock)
+
+- (UIView *)view
+{
+  return [[UIView alloc] init];
+}
+
+@end
+
+@implementation MGTemplateContainerManager
+
+RCT_EXPORT_MODULE(MGTemplateContainer)
+
+RCT_CUSTOM_VIEW_PROPERTY(inflatorId, NSString *, UIView) {}
+
+RCT_CUSTOM_VIEW_PROPERTY(wishlistId, NSString *, UIView) {}
+
+RCT_CUSTOM_VIEW_PROPERTY(names, NSArray<NSString *> *, UIView) {}
+
+- (UIView *)view
+{
+  return [[UIView alloc] init];
+}
+
+@end
+
+@implementation MGTemplateInterceptorManager
+
+RCT_EXPORT_MODULE(MGTemplateInterceptor)
+
+RCT_CUSTOM_VIEW_PROPERTY(inflatorId, NSString *, UIView) {}
+
+- (UIView *)view
+{
+  return [[UIView alloc] init];
+}
+
+@end
+
+@implementation MGContentContainerManager
+
+RCT_EXPORT_MODULE(MGContentContainerManager)
+
+- (UIView *)view
+{
+  return [[UIView alloc] init];
+}
+
+@end

package/ios/MGWishlistQueue.h

@@ -0,0 +1,11 @@
+#import <React/RCTDefines.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+RCT_EXTERN dispatch_queue_t MGGetWishlistQueue(void);
+
+RCT_EXTERN BOOL MGIsWishlistQueue(void);
+
+RCT_EXTERN void MGExecuteOnWishlistQueue(dispatch_block_t block);
+
+NS_ASSUME_NONNULL_END

package/ios/MGWishlistQueue.m

@@ -0,0 +1,34 @@
+#import "MGWishlistQueue.h"
+
+dispatch_queue_t MGGetWishlistQueue(void)
+{
+  static dispatch_queue_t wishlistQueue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    dispatch_queue_attr_t qos =
+        dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INITIATED, -1);
+    wishlistQueue = dispatch_queue_create("wishlistqueue", qos);
+  });
+  return wishlistQueue;
+}
+
+BOOL MGIsWishlistQueue(void)
+{
+  static void *wishlistQueueKey = &wishlistQueueKey;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    dispatch_queue_set_specific(MGGetWishlistQueue(), wishlistQueueKey, wishlistQueueKey, NULL);
+  });
+  return dispatch_get_specific(wishlistQueueKey) == wishlistQueueKey;
+}
+
+void MGExecuteOnWishlistQueue(dispatch_block_t block)
+{
+  if (MGIsWishlistQueue()) {
+    block();
+  } else {
+    dispatch_async(MGGetWishlistQueue(), ^{
+      block();
+    });
+  }
+}

package/ios/Orchestrator/MGOrchestrator.h

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+#import <react/renderer/components/wishlist/Props.h>
+#import <react/renderer/components/wishlist/ShadowNodes.h>
+#import <memory>
+#import <string>
+#import <vector>
+#import "MGDI.hpp"
+#import "MGViewportCarerImpl.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+using namespace Wishlist;
+
+@class MGWishListComponent;
+
+@interface MGOrchestrator : NSObject
+
+- (instancetype)initWith:(MGWishListComponent *)wishlist
+              wishlistId:(std::string)wishlistId
+           viewportCarer:(std::shared_ptr<MGViewportCarerImpl>)viewportCarer;
+
+- (void)renderAsyncWithDimensions:(MGDims)dimensions
+               initialContentSize:(CGFloat)initialContentSize
+                     initialIndex:(NSInteger)initialIndex
+                        templates:(std::vector<std::shared_ptr<facebook::react::ShadowNode const>>)templates
+                            names:(std::vector<std::string>)names
+                       inflatorId:(std::string)inflatorId;
+- (void)didScrollAsyncWithDimensions:(MGDims)dimensions
+                       contentOffset:(float)contentOffset
+                          inflatorId:(std::string)inflatorId;
+- (void)scrollToItem:(int)index;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Orchestrator/MGOrchestrator.mm

@@ -0,0 +1,139 @@
+#import "MGOrchestrator.h"
+
+#include <set>
+#include "MGDIImpl.hpp"
+#include "MGDataBindingImpl.hpp"
+#include "MGErrorHandlerIOS.h"
+#include "MGOrchestratorCppAdapter.hpp"
+#include "MGUIScheduleriOS.hpp"
+#include "MGViewportCarerImpl.h"
+#include "MGWishListComponent.h"
+#include "WishlistJsRuntime.h"
+
+using namespace Wishlist;
+
+@implementation MGOrchestrator {
+  MGWishListComponent *_wishlist;
+  std::shared_ptr<MGDIImpl> _di;
+  std::string _inflatorId;
+  std::string _wishlistId;
+  MGDims _dimensions;
+  BOOL _alreadyRendered;
+  std::shared_ptr<MGOrchestratorCppAdapter> _adapter;
+  std::vector<Item> _items;
+  int _pendingScrollToItem;
+}
+
+- (instancetype)initWith:(MGWishListComponent *)wishlist
+              wishlistId:(std::string)wishlistId
+           viewportCarer:(std::shared_ptr<MGViewportCarerImpl>)viewportCarer
+{
+  if (self = [super init]) {
+    _wishlist = wishlist;
+    _wishlistId = wishlistId;
+    _alreadyRendered = NO;
+    _pendingScrollToItem = -1;
+    _di = std::make_shared<MGDIImpl>();
+    auto weakDI = std::weak_ptr<MGDIImpl>(_di);
+    viewportCarer->setDI(_di);
+    _di->setViewportCarer(viewportCarer);
+
+    __weak __typeof(self) weakSelf = self;
+    _adapter = std::make_shared<MGOrchestratorCppAdapter>(
+        [weakSelf]() { [weakSelf handleVSync]; },
+        [weakSelf](std::vector<Item> items) { [weakSelf didPushChildren:std::move(items)]; });
+    _di->setVSyncRequester(_adapter);
+    _di->setDataBinding(std::make_shared<MGDataBindingImpl>(_wishlistId, weakDI));
+    _di->setUIScheduler(std::make_shared<MGUIScheduleriOS>());
+    _di->setErrorHandler(std::make_shared<MGErrorHandlerIOS>());
+
+    viewportCarer->setListener(std::weak_ptr(_adapter));
+  }
+  return self;
+}
+
+- (void)handleVSync
+{
+  _di->getViewportCarer()->didScrollAsync(_dimensions, MG_NO_OFFSET, _inflatorId);
+}
+
+- (void)renderAsyncWithDimensions:(MGDims)dimensions
+               initialContentSize:(CGFloat)initialContentSize
+                     initialIndex:(NSInteger)initialIndex
+                        templates:(std::vector<std::shared_ptr<facebook::react::ShadowNode const>>)templates
+                            names:(std::vector<std::string>)names
+                       inflatorId:(std::string)inflatorId
+{
+  if (!_alreadyRendered && names.size() > 0 && names.size() == templates.size()) {
+    _alreadyRendered = YES;
+    _dimensions = dimensions;
+    _inflatorId = inflatorId;
+    _di->getViewportCarer()->initialRenderAsync(
+        dimensions, initialContentSize, initialIndex, templates, names, inflatorId);
+  } else {
+    _dimensions = dimensions;
+    _inflatorId = inflatorId;
+    [self handleVSync];
+  }
+}
+
+- (void)didScrollAsyncWithDimensions:(MGDims)dimensions
+                       contentOffset:(float)contentOffset
+                          inflatorId:(std::string)inflatorId
+{
+  _dimensions = dimensions;
+  _inflatorId = inflatorId;
+  _di->getViewportCarer()->didScrollAsync(dimensions, contentOffset, inflatorId);
+}
+- (void)notifyAboutNewTemplates:(std::vector<std::shared_ptr<facebook::react::ShadowNode const>>)templates
+                      withNames:(std::vector<std::string>)names
+                     inflatorId:(std::string)inflatorId
+{
+  _inflatorId = inflatorId;
+  [self handleVSync];
+}
+
+- (void)scrollToItem:(int)index
+{
+  float offset = -1;
+  for (auto &item : _items) {
+    if (item.index == index) {
+      offset = item.offset;
+      break;
+    }
+  }
+
+  if (offset == -1) {
+    _pendingScrollToItem = index;
+    bool isBelow = _items.back().index < index;
+    // TODO: Implement proper animation for items outside the window.
+    if (isBelow) {
+      [self scrollToOffset:_items.back().offset + 10000];
+    } else {
+      [self scrollToOffset:_items.back().offset - 10000];
+    }
+  } else {
+    _pendingScrollToItem = -1;
+    [self scrollToOffset:offset];
+  }
+}
+
+- (void)scrollToOffset:(float)offset
+{
+  [_wishlist.scrollView setContentOffset:{0, offset} animated:YES];
+}
+
+- (void)didPushChildren:(std::vector<Item>)items
+{
+  _items = std::move(items);
+  if (_pendingScrollToItem != -1) {
+    [self scrollToItem:_pendingScrollToItem];
+  }
+}
+
+- (void)dealloc
+{
+  _wishlist = nil;
+}
+
+@end

package/ios/Orchestrator/MGOrchestratorCppAdapter.cpp

@@ -0,0 +1,25 @@
+//
+//  MGOrchestratorCppAdapter.cpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#include "MGOrchestratorCppAdapter.hpp"
+
+namespace Wishlist {
+
+MGOrchestratorCppAdapter::MGOrchestratorCppAdapter(
+    std::function<void()> onRequestVSync,
+    std::function<void(std::vector<Item> items)> didPushChildren)
+    : onRequestVSync_(onRequestVSync), didPushChildren_(didPushChildren) {}
+
+void MGOrchestratorCppAdapter::didPushChildren(std::vector<Item> newWindow) {
+  didPushChildren_(std::move(newWindow));
+}
+
+void MGOrchestratorCppAdapter::requestVSync() {
+  onRequestVSync_();
+}
+
+}; // namespace Wishlist

package/ios/Orchestrator/MGOrchestratorCppAdapter.hpp

@@ -0,0 +1,32 @@
+//
+//  MGOrchestratorCppAdapter.hpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+#include <functional>
+#include "MGVSyncRequester.hpp"
+#include "MGViewportCarerListener.hpp"
+
+namespace Wishlist {
+
+class MGOrchestratorCppAdapter final : public MGVSyncRequester,
+                                       public MGViewportCarerListener {
+ public:
+  MGOrchestratorCppAdapter(
+      std::function<void()> onRequestVSync,
+      std::function<void(std::vector<Item> items)> didPushChildren);
+
+ private:
+  void didPushChildren(std::vector<Item> newWindow) override;
+  void requestVSync() override;
+
+  std::function<void()> onRequestVSync_;
+  std::function<void(std::vector<Item> items)> didPushChildren_;
+};
+
+}; // namespace Wishlist

package/ios/UIScheduleriOS/MGUIScheduleriOS.hpp

@@ -0,0 +1,19 @@
+//
+//  MGUIScheduleriOS.hpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#pragma once
+
+#include <stdio.h>
+#include "MGUIScheduler.hpp"
+
+namespace Wishlist {
+
+struct MGUIScheduleriOS : MGUIScheduler {
+  virtual void scheduleOnUI(std::function<void()> &&f);
+};
+
+}; // namespace Wishlist

package/ios/UIScheduleriOS/MGUIScheduleriOS.mm

@@ -0,0 +1,21 @@
+//
+//  MGUIScheduleriOS.cpp
+//  CocoaAsyncSocket
+//
+//  Created by Szymon on 14/01/2023.
+//
+
+#import "MGUIScheduleriOS.hpp"
+#import <React/RCTUtils.h>
+
+namespace Wishlist {
+
+void MGUIScheduleriOS::scheduleOnUI(std::function<void()> &&f)
+{
+  __block auto retainedWork = std::move(f);
+  RCTExecuteOnMainQueue(^{
+    retainedWork();
+  });
+};
+
+}; // namespace Wishlist