@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/view.cpp

@@ -0,0 +1,123 @@
+#include "view.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "execution.h"
+#include "report.h"
+
+namespace lucent::ui {
+
+std::shared_ptr<Graph> mainGraph() {
+  // Never destroyed, as the main context is not: nothing disposes at exit.
+  static auto* graph = new std::shared_ptr<Graph>(Graph::create(ExecutionContext::main()));
+
+  return *graph;
+}
+
+void reportViewError(std::exception_ptr error, const char* component, const char* what, const char* source) {
+  std::string where = std::string(component) + " " + what + " (" + source + ")";
+
+  reportUncaught(error, where.c_str());
+}
+
+namespace {
+
+/// Where the main thread is in its mounts' code. Main thread only.
+struct Entries {
+  std::weak_ptr<Content> active;
+  int depth = 0;
+  std::vector<std::weak_ptr<Content>> marked;
+  bool flushPosted = false;
+};
+
+Entries& entries() {
+  // Never destroyed: contents may outlive static destruction.
+  static auto* state = new Entries();
+
+  return *state;
+}
+
+/// Hosts call their mounts from the main thread, in the main context or not.
+bool onMainExecutor() { return ExecutionContext::main().onExecutor(); }
+
+}  // namespace
+
+std::shared_ptr<Content> Content::create(std::function<void()> changed) {
+  return std::make_shared<Content>(Token{}, std::move(changed));
+}
+
+void Content::invalidate() {
+  if (marked_ || measuring_ || !onMainExecutor()) return;
+
+  auto& e = entries();
+
+  marked_ = true;
+  // Held weakly: a mount that goes before the flush is not measured.
+  e.marked.push_back(weak_from_this());
+
+  if (e.depth > 0 || e.flushPosted) return;
+
+  e.flushPosted = true;
+  ExecutionContext::main().post([] {
+    entries().flushPosted = false;
+    flush();
+  });
+}
+
+void Content::flush() {
+  auto& e = entries();
+
+  // Marks made while hosts measure wait for the next flush.
+  auto marked = std::move(e.marked);
+
+  e.marked.clear();
+
+  for (auto& weak : marked) {
+    auto content = weak.lock();
+
+    if (!content) continue;
+
+    content->marked_ = false;
+    content->measuring_ = true;
+
+    try {
+      content->changed_();
+    } catch (...) {
+      reportUncaught(std::current_exception(), "a component's measurement");
+    }
+
+    content->measuring_ = false;
+  }
+}
+
+std::weak_ptr<Content> activeContent() { return onMainExecutor() ? entries().active : std::weak_ptr<Content>(); }
+
+ContentEntry::ContentEntry(const std::weak_ptr<Content>& content) {
+  if (!onMainExecutor()) return;
+
+  auto& e = entries();
+
+  entered_ = true;
+  outer_ = std::exchange(e.active, content);
+  ++e.depth;
+
+  if (auto entered = content.lock()) entered->invalidate();
+}
+
+ContentEntry::~ContentEntry() {
+  if (!entered_) return;
+
+  auto& e = entries();
+
+  e.active = std::move(outer_);
+
+  if (--e.depth == 0) Content::flush();
+}
+
+void invalidateSize(const std::weak_ptr<Content>& content) {
+  if (auto target = content.lock()) target->invalidate();
+}
+
+}  // namespace lucent::ui

package/runtime/cpp/lucent/view.h

@@ -0,0 +1,157 @@
+// Lucent runtime — what compiled views share: the main context's reactive
+// graph, their events' routes, where their errors go, and how a mount's
+// host hears that the mount's code ran.
+//
+// A component's setup runs once per mount, on the main context, inside the
+// mount's scope (reactive.h). Its props are signals of that graph; its
+// events are routes its host points at the mount's current event emitter.
+// Nothing here knows React Native: the generated mount glue does.
+//
+// A host sizing a component by its content must measure it again after
+// the mount's code changed its views. It cannot see those changes, so it
+// hears of every entry into the mount instead (Content): its own calls
+// (setup, commits, commands) and every function the setup made (native
+// callbacks, effects, handlers), which enter the mount whenever they run.
+// The host hears once, when the outermost entry on the main thread ends.
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "json.h"
+#include "reactive.h"
+
+namespace lucent::ui {
+
+/// The main context's graph, which every view's props, signals and effects
+/// share. Made on first use; used only on the main context.
+std::shared_ptr<Graph> mainGraph();
+
+/// A component's event, as its setup sees it: calling it sends the
+/// arguments along the route its host installed, or nowhere without one.
+/// Copies share the route, so the host redirects events (a new emitter,
+/// JavaScript no longer listening) without the setup, or the native
+/// subscriptions it made, running again. Used on the main context.
+template <class... Args>
+class Event {
+ public:
+  using Route = std::function<void(Args...)>;
+
+  Event() : route_(std::make_shared<Route>()) {}
+
+  void route(Route route) const { *route_ = std::move(route); }
+
+  void operator()(Args... args) const {
+    // A copy: the route may replace itself while it runs.
+    if (Route r = *route_) r(std::move(args)...);
+  }
+
+ private:
+  std::shared_ptr<Route> route_;
+};
+
+}  // namespace lucent::ui
+
+namespace lucent {
+
+// A signal as a JavaScript value: an object compared by identity, whose
+// JSON is an object with no own properties.
+template <class T>
+bool strictEquals(const ui::Signal<T>& a, const ui::Signal<T>& b) {
+  return a.identity() == b.identity();
+}
+
+template <class T>
+String toJsString(const ui::Signal<T>&) {
+  return String::fromLatin1("[object Object]");
+}
+
+template <class T>
+void jsonWrite(JsonWriter& w, const ui::Signal<T>&) {
+  w.raw("{}");
+}
+
+}  // namespace lucent
+
+namespace lucent::ui {
+
+/// Reports a view's error nobody can catch (its setup's, a command's) with
+/// the component's identity, what failed and the source line it maps to.
+void reportViewError(std::exception_ptr error, const char* component, const char* what, const char* source);
+
+/**
+ * A mount's native content, as its host sizes it. Marked whenever the
+ * mount's code runs, or by invalidateSize(); the host's `changed` runs
+ * once for any number of marks: when the outermost entry into a mount
+ * ends, or in a later turn of the main context for a mark made outside
+ * any. Marks made while `changed` runs (measuring may run the mount's
+ * code) are not changes. Main thread only.
+ */
+class Content : public std::enable_shared_from_this<Content> {
+  struct Token {};
+
+ public:
+  static std::shared_ptr<Content> create(std::function<void()> changed);
+
+  Content(Token, std::function<void()> changed) : changed_(std::move(changed)) {}
+
+  Content(const Content&) = delete;
+  Content& operator=(const Content&) = delete;
+
+  /// Marks the content changed.
+  void invalidate();
+
+ private:
+  friend class ContentEntry;
+
+  /// Runs `changed` for what is marked.
+  static void flush();
+
+  std::function<void()> changed_;
+  bool marked_ = false;
+  bool measuring_ = false;
+};
+
+/// The content of the mount whose code runs now on the main thread (empty
+/// outside any, and off the main thread).
+std::weak_ptr<Content> activeContent();
+
+/**
+ * While one lives, `content`'s mount runs (on the main thread, in the main
+ * context or not, as hosts call their mounts; elsewhere, or for a mount
+ * that has gone, it does nothing): the content is marked, and ending the
+ * outermost entry reports every content marked meanwhile.
+ */
+class ContentEntry {
+ public:
+  explicit ContentEntry(const std::weak_ptr<Content>& content);
+  ~ContentEntry();
+
+  ContentEntry(const ContentEntry&) = delete;
+  ContentEntry& operator=(const ContentEntry&) = delete;
+
+ private:
+  bool entered_ = false;
+  std::weak_ptr<Content> outer_;
+};
+
+/// `f`, entering `content`'s mount whenever it runs: a function a setup made.
+template <class F>
+auto inContent(std::weak_ptr<Content> content, F f) {
+  return [content = std::move(content), f = std::move(f)](auto&&... args) mutable
+         -> std::invoke_result_t<F&, decltype(args)...> {
+    ContentEntry entry(content);
+
+    return f(std::forward<decltype(args)>(args)...);
+  };
+}
+
+/// lucent:ui's invalidateSize(): marks `content` (the mount of the setup
+/// the call is written in) changed; nothing once the mount has gone.
+void invalidateSize(const std::weak_ptr<Content>& content);
+
+}  // namespace lucent::ui

package/runtime/cpp/rn/LucentComponentView.h

@@ -0,0 +1,121 @@
+// Lucent runtime — the iOS host of Lucent components in React Native's
+// Fabric renderer.
+//
+// Each component's generated `<registration>ComponentView` derives from
+// LucentComponentView, which does what every component's host does: it
+// mounts the component when a commit reaches the view on the main thread
+// (never while React renders or the renderer builds shadow trees), gives the
+// mount a token, hands later commits and commands to it, and ends it when
+// the view is recycled. The setup's view fills the host's content box, and
+// the host measures it for a component with no size of its own
+// (LucentViewSizing.h). The React children React Native mounts in the view
+// go in the slot the host makes for each mount of a component taking them,
+// never beside the content (LucentViewChildren.h), and the host reports
+// where that slot is, for Yoga to lay them out in it (LucentViewSlots.h). A
+// view that comes with its controller (a SwiftUI component's) has the
+// controller contained in the nearest view controller above the host, as
+// soon as there is one, until the mount ends, and laid out in the host's
+// direction. The generated subclass provides the renderer's descriptor and
+// the component's Lucent side (a Mounted).
+//
+// Everything runs on the main thread, in Lucent's main context.
+#pragma once
+
+#import <React/RCTViewComponentView.h>
+
+#include <folly/dynamic.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/Props.h>
+
+#include <lucent/native.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "LucentViewRequests.h"
+#include "LucentViews.h"
+
+@class LucentComponentView;
+
+namespace lucent::views {
+
+/**
+ * One mount of a component on its host view: the component's Mount (its
+ * compiled setup, run once), as generated code adapts it for each
+ * component. Destroying it disposes the mount.
+ */
+class Mounted {
+ public:
+  virtual ~Mounted() = default;
+
+  /// The view the component's setup returned.
+  virtual UIView* view() const = 0;
+
+  /// The controller whose view view() is, which the host contains in the
+  /// nearest view controller above it (a SwiftUI component's hosting
+  /// controller); nil for a plain view.
+  virtual UIViewController* controller() const { return nil; }
+
+  /// Applies a later commit's props (the component's own Props type): what
+  /// changed reaches setup's signals; setup does not run again.
+  virtual void update(const facebook::react::Props& props, const facebook::react::Props& previous) = 0;
+
+  /// Runs command `name`; a request answers through `requester`.
+  virtual void command(const std::string& name, const folly::dynamic& args, const Requester& requester) = 0;
+};
+
+/** What a mount knows of its host view. Main thread. */
+class HostView {
+ public:
+  HostView() = default;
+  HostView(LucentComponentView* view, MountToken token) : view_(view), token_(token) {}
+
+  const MountToken& token() const { return token_; }
+
+  /// Whether the view still holds this mount (not recycled or remounted).
+  bool current() const;
+
+  /// The event emitter of the view's current commit while the view holds
+  /// this mount; else null, and events are dropped.
+  std::shared_ptr<const facebook::react::EventEmitter> emitter() const;
+
+  /// The view the host made for this mount's React children (a component
+  /// taking them), while the view holds this mount; else empty.
+  lucent::NativeRef slot() const;
+
+ private:
+  __weak LucentComponentView* view_;
+  MountToken token_;
+};
+
+}  // namespace lucent::views
+
+@interface LucentComponentView : RCTViewComponentView
+
+/// The token of the mount the view holds, or a zero generation.
+@property (nonatomic, readonly) lucent::views::MountToken lucentToken;
+
+/// The event emitter of the view's current commit.
+@property (nonatomic, readonly) std::shared_ptr<const facebook::react::EventEmitter> lucentEventEmitter;
+
+/// Registers a component's view class with React Native's component view
+/// factory: generated classes call it as they load.
++ (void)lucentRegister:(Class)componentViewClass;
+
+/// Whether the component takes React children: its host then makes a slot
+/// for them with each mount (implemented by each component taking them).
++ (BOOL)lucentTakesChildren;
+
+/// The slot of the mount the view holds, or nil.
+@property (nonatomic, readonly) UIView *lucentSlot;
+
+/// The request id a command carries, if it is a request (implemented by
+/// each component with commands).
+- (std::optional<double>)lucentRequestId:(const std::string &)name args:(const folly::dynamic &)args;
+
+/// Implemented by each component: sets it up for `props` on this view.
+- (std::unique_ptr<lucent::views::Mounted>)lucentMount:(const facebook::react::Props &)props
+                                                   host:(lucent::views::HostView)host;
+
+@end