@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/rn/LucentViewChildren.mm

@@ -0,0 +1,211 @@
+// Lucent runtime — a component's React children and slot on iOS (see
+// LucentViewChildren.h). Built only when the app's Lucent code has
+// components, as their host is.
+#if __has_include(<views/lucent_views.h>)
+
+#import "LucentViewChildren.h"
+
+#include <lucent/report.h>
+
+#include <string>
+
+namespace {
+
+/** Reports what went wrong with a component's children: nothing throws into UIKit. */
+void report(NSString *message)
+{
+  lucent::logError((std::string("[lucent] ") + message.UTF8String).c_str());
+}
+
+}  // namespace
+
+@implementation LucentSlotView {
+  __weak UIView *_host;
+  void (^_placed)(void);
+}
+
+- (instancetype)initWithHost:(UIView *)host placed:(void (^)(void))placed
+{
+  if ((self = [super initWithFrame:CGRectZero])) {
+    _host = host;
+    _placed = [placed copy];
+    self.clipsToBounds = YES;
+    // Follows the view it fills as that view resizes.
+    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  }
+
+  return self;
+}
+
+// Unsized when setup adds it: it fills the view it is added to.
+- (void)didMoveToSuperview
+{
+  [super didMoveToSuperview];
+
+  UIView *parent = self.superview;
+
+  if (parent && CGRectIsEmpty(self.frame)) self.frame = parent.bounds;
+
+  [self setNeedsLayout];
+}
+
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+  [self setNeedsLayout];
+}
+
+- (void)setCenter:(CGPoint)center
+{
+  [super setCenter:center];
+  [self setNeedsLayout];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  [self lucentAlign];
+
+  if (_placed) _placed();
+}
+
+- (void)lucentAlign
+{
+  UIView *host = _host;
+  UIView *parent = self.superview;
+
+  if (!host || !parent || ![self isDescendantOfView:host]) return;
+
+  CGPoint origin = [parent convertPoint:self.frame.origin toView:host];
+  CGRect bounds = self.bounds;
+
+  if (CGPointEqualToPoint(bounds.origin, origin)) return;
+
+  bounds.origin = origin;
+  self.bounds = bounds;
+}
+
+@end
+
+@implementation LucentChildren {
+  __weak UIView *_host;
+  NSString *_name;
+  BOOL _takesChildren;
+  void (^_placed)(void);
+  /// React Native's children of the component, in its order.
+  NSMutableArray<UIView *> *_children;
+  /// Whether children given to a component taking none were reported.
+  BOOL _refused;
+}
+
+- (instancetype)initWithHost:(UIView *)host
+                        name:(NSString *)name
+               takesChildren:(BOOL)takesChildren
+                      placed:(void (^)(void))placed
+{
+  if ((self = [super init])) {
+    _host = host;
+    _name = [name copy];
+    _takesChildren = takesChildren;
+    _placed = [placed copy];
+    _children = [NSMutableArray new];
+  }
+
+  return self;
+}
+
+- (void)mount:(UIView *)child index:(NSInteger)index
+{
+  NSInteger count = static_cast<NSInteger>(_children.count);
+
+  if (index < 0 || index > count) {
+    report([NSString stringWithFormat:@"%@: React Native mounted a child at %ld of %ld", _name, (long)index, (long)count]);
+    index = index < 0 ? 0 : count;
+  }
+
+  [_children insertObject:child atIndex:static_cast<NSUInteger>(index)];
+
+  if (!_takesChildren && !_refused) {
+    _refused = YES;
+    report([NSString stringWithFormat:@"%@ takes no React children: React Native gave it %lu, which it does not show",
+                                      _name,
+                                      (unsigned long)_children.count]);
+  }
+
+  [self place:child];
+}
+
+- (void)unmount:(UIView *)child index:(NSInteger)index
+{
+  NSUInteger at = index >= 0 && static_cast<NSUInteger>(index) < _children.count && _children[index] == child
+      ? static_cast<NSUInteger>(index)
+      : [_children indexOfObjectIdenticalTo:child];
+
+  if (at == NSNotFound) {
+    report([NSString stringWithFormat:@"%@: React Native unmounted a child it never mounted here", _name]);
+    return;
+  }
+
+  [_children removeObjectAtIndex:at];
+
+  // Out of the slot it was put in (an earlier mount's, if React Native kept it past a recycle).
+  if ([child.superview isKindOfClass:[LucentSlotView class]]) [child removeFromSuperview];
+}
+
+- (void)startMount
+{
+  _slot = _takesChildren ? [[LucentSlotView alloc] initWithHost:_host placed:_placed] : nil;
+
+  for (UIView *child in _children) [self place:child];
+}
+
+- (void)mountedContent:(UIView *)content
+{
+  if (_slot && content && ![_slot isDescendantOfView:content])
+    report([NSString stringWithFormat:@"%@'s setup did not put its slot in the view it returned: its React children do not show",
+                                      _name]);
+}
+
+- (void)contentChanged
+{
+  [_slot setNeedsLayout];
+}
+
+- (void)endMount
+{
+  // React Native unmounts a view's children before it recycles the view: any left stay where they are.
+  if (_children.count)
+    report([NSString stringWithFormat:@"%@ was recycled holding %lu React children: they stay where React Native left them",
+                                      _name,
+                                      (unsigned long)_children.count]);
+
+  [_children removeAllObjects];
+  _slot = nil;
+  _refused = NO;
+}
+
+/** Puts `child` in the slot, below the next child there: React Native's order. */
+- (void)place:(UIView *)child
+{
+  if (!_slot || child.superview == _slot) return;
+
+  if (child.superview) {
+    report([NSString stringWithFormat:@"%@: a React child is in another view: React Native keeps it there", _name]);
+    return;
+  }
+
+  NSUInteger at = [_children indexOfObjectIdenticalTo:child];
+
+  for (NSUInteger i = at + 1; i < _children.count; i++) {
+    if (_children[i].superview == _slot) {
+      [_slot insertSubview:child belowSubview:_children[i]];
+      return;
+    }
+  }
+
+  [_slot addSubview:child];
+}
+
+@end
+
+#endif

package/runtime/cpp/rn/LucentViewRegistry.h

@@ -0,0 +1,62 @@
+// Lucent runtime — what the renderer made for each view, found again by
+// the view's surface and tag.
+//
+// The Android host never gets a view's event emitter from Java: its
+// descriptor records each one as the renderer makes it (HostDescriptor),
+// and the host finds it when the view mounts. A tag alone does not name a
+// view: each JavaScript runtime numbers its views again, so across a reload
+// an old surface's view and a new one's share tags. Surfaces are numbered
+// for the process, so the two together do.
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+namespace lucent::views {
+
+/** Per view, by surface and tag, what the renderer made: held weakly. Any thread. */
+template <class T>
+class ViewRegistry {
+ public:
+  /// `value` is what the renderer made for view `tag` of `surface`, from now on.
+  void record(int32_t surface, int32_t tag, const std::shared_ptr<T>& value) {
+    std::lock_guard<std::mutex> g(mutex_);
+
+    // Views gone since leave expired entries: dropped whenever the registry has doubled.
+    if (entries_.size() > limit_) {
+      std::erase_if(entries_, [](const auto& entry) { return entry.second.expired(); });
+      limit_ = std::max(kFloor, 2 * entries_.size());
+    }
+
+    entries_[{surface, tag}] = value;
+  }
+
+  /// What the renderer made for view `tag` of `surface`, or null (none, or gone).
+  std::shared_ptr<T> find(int32_t surface, int32_t tag) const {
+    std::lock_guard<std::mutex> g(mutex_);
+    auto found = entries_.find({surface, tag});
+
+    return found == entries_.end() ? nullptr : found->second.lock();
+  }
+
+  /// How many entries it holds, gone ones included until pruned.
+  std::size_t size() const {
+    std::lock_guard<std::mutex> g(mutex_);
+
+    return entries_.size();
+  }
+
+ private:
+  static constexpr std::size_t kFloor = 256;
+
+  mutable std::mutex mutex_;
+  std::map<std::pair<int32_t, int32_t>, std::weak_ptr<T>> entries_;
+  std::size_t limit_ = kFloor;
+};
+
+}  // namespace lucent::views

package/runtime/cpp/rn/LucentViewRequests.cpp

@@ -0,0 +1,91 @@
+#include "LucentViewRequests.h"
+
+#include <lucent/jsi/host.h>
+#include <lucent/report.h>
+
+#include <mutex>
+#include <utility>
+
+namespace lucent::views {
+
+namespace jsi = facebook::jsi;
+
+namespace {
+
+struct Connection {
+  std::weak_ptr<js::Host> host;
+  uint64_t settle = 0;
+};
+
+std::mutex& connectionMutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+Connection& connection() {
+  static Connection current;
+  return current;
+}
+
+}  // namespace
+
+Requester Requester::current() {
+  std::lock_guard<std::mutex> lock(connectionMutex());
+
+  return Requester(connection().host, connection().settle);
+}
+
+Requester::operator bool() const {
+  auto host = host_.lock();
+
+  return host && host->alive();
+}
+
+void Requester::settle(double id, std::function<void(jsi::Runtime&, jsi::Function&)> call) const {
+  auto host = host_.lock();
+
+  if (!host) return;
+
+  host->postToJs([weak = host_, settle = settle_, id, call = std::move(call)](jsi::Runtime& runtime) {
+    auto host = weak.lock();
+    jsi::Function* fn = host ? host->retained(settle) : nullptr;
+
+    if (!fn) return;
+
+    try {
+      call(runtime, *fn);
+    } catch (const std::exception& e) {
+      logError((std::string("[lucent] answering view request ") + std::to_string(id) + ": " + e.what()).c_str());
+    }
+  });
+}
+
+void Requester::resolve(double id, AnswerValue value) const {
+  settle(id, [id, value = std::move(value)](jsi::Runtime& runtime, jsi::Function& fn) {
+    fn.call(runtime, jsi::Value(id), jsi::Value::null(), value(runtime));
+  });
+}
+
+void Requester::reject(double id, std::string message) const {
+  settle(id, [id, message = std::move(message)](jsi::Runtime& runtime, jsi::Function& fn) {
+    fn.call(runtime, jsi::Value(id), jsi::String::createFromUtf8(runtime, message));
+  });
+}
+
+void connectRequests(const std::shared_ptr<js::Host>& host, jsi::Runtime& runtime, jsi::Function settle) {
+  if (!host->alive()) throw jsi::JSError(runtime, "Lucent: this JavaScript runtime's Lucent host is torn down");
+
+  uint64_t id = host->retain(runtime, std::move(settle));
+  Connection previous;
+
+  {
+    std::lock_guard<std::mutex> lock(connectionMutex());
+
+    previous = std::exchange(connection(), Connection{host, id});
+  }
+
+  // The same runtime connecting again (a second views runtime): its old function goes.
+  if (auto old = previous.host.lock(); old == host && previous.settle != id) host->release(previous.settle);
+}
+
+}  // namespace lucent::views

package/runtime/cpp/rn/LucentViewRequests.h

@@ -0,0 +1,104 @@
+// Lucent runtime — answers to the commands of Lucent components that return
+// a value: requests, settled in the JavaScript runtime that sent them.
+//
+// A component's proxy numbers each request and hands the views runtime's
+// settle function to the Lucent module once (its __lucentViewRequests
+// property, connectRequests below). A host view captures the Requester
+// current when a command arrives, and answers through it from any thread.
+// The answer runs on that runtime's JavaScript thread, or not at all once
+// that runtime is torn down (a reload): request ids start again in each
+// runtime, so an answer never reaches another one.
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace lucent::js {
+class Host;
+}
+
+namespace lucent::views {
+
+/// A request's answer, built on the JavaScript thread.
+using AnswerValue = std::function<facebook::jsi::Value(facebook::jsi::Runtime&)>;
+
+/** The runtime a request came from. Copyable; any thread. */
+class Requester {
+ public:
+  Requester() = default;
+
+  /// The runtime connected now: a command's, when it arrives. Empty when no
+  /// runtime has connected (its answers are dropped).
+  static Requester current();
+
+  /// Settles request `id` with `value`. Dropped when the runtime is gone.
+  void resolve(double id, AnswerValue value) const;
+
+  /// Rejects request `id` with an Error whose message is `message`.
+  void reject(double id, std::string message) const;
+
+  /// Whether its runtime is still there (not torn down).
+  explicit operator bool() const;
+
+ private:
+  Requester(std::weak_ptr<js::Host> host, uint64_t settle) : host_(std::move(host)), settle_(settle) {}
+
+  void settle(double id, std::function<void(facebook::jsi::Runtime&, facebook::jsi::Function&)> call) const;
+
+  std::weak_ptr<js::Host> host_;
+  /// The settle function, retained by the host.
+  uint64_t settle_ = 0;
+};
+
+/// Makes `host`'s runtime the one requests come from, settled through
+/// `settle(id, error, value)`. On the JavaScript thread.
+void connectRequests(const std::shared_ptr<js::Host>& host, facebook::jsi::Runtime& runtime, facebook::jsi::Function settle);
+
+/// The name the Lucent module gives the function JavaScript connects with.
+inline constexpr const char* kRequestsName = "__lucentViewRequests";
+
+/**
+ * A request command's answer. The host settles JavaScript's promise with it
+ * on the JS thread (`settle(request, error, value)`): rejected with an
+ * Error of `error`'s message when set, else resolved with `value()`.
+ */
+struct Answer {
+  double request{0};
+  std::optional<std::string> error{};
+  AnswerValue value{};
+};
+
+/**
+ * Where a mount sends its answers. A mount answers each request once:
+ * with its result or error, or, still unanswered when the mount ends,
+ * with a rejection then.
+ */
+using Respond = std::function<void(Answer)>;
+
+/**
+ * A mount's answers, to `requester`'s runtime while `host` (the platform's
+ * HostView: `current()`, whether its view still holds that mount) says so.
+ * Once the view holds another mount, or none (recycled, remounted: a view
+ * or a tag reused), an answer is dropped with what it carries: JavaScript
+ * rejected the request when React unmounted its view. On the thread the
+ * host reads its view on (the main thread).
+ */
+template <class Host>
+Respond answerTo(Host host, Requester requester) {
+  return [host = std::move(host), requester = std::move(requester)](Answer answer) {
+    if (!host.current()) return;
+
+    if (answer.error)
+      requester.reject(answer.request, std::move(*answer.error));
+    else
+      requester.resolve(answer.request, std::move(answer.value));
+  };
+}
+
+}  // namespace lucent::views