@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/platform/ios_ui.mm

@@ -0,0 +1,454 @@
+// Lucent runtime — UIKit glue: UIKit's lifecycle notifications into the
+// shared Lifecycle, the presentation context, and showing view controllers.
+#include "ios_ui.h"
+
+#import <objc/runtime.h>
+
+#include <array>
+#include <string>
+
+using namespace lucent;
+
+namespace {
+
+// --- the notifications, as data -----------------------------------------------------------
+
+struct AppNotification {
+  const char* name;
+  AppEvent event;
+  NSNotificationName __unsafe_unretained notification;
+};
+
+struct SceneNotification {
+  const char* name;
+  SceneEvent event;
+  NSNotificationName __unsafe_unretained notification;
+};
+
+const std::array<AppNotification, 6>& appNotifications() {
+  static const std::array<AppNotification, 6> table = {{
+      {"didBecomeActive", AppEvent::DidBecomeActive, UIApplicationDidBecomeActiveNotification},
+      {"willResignActive", AppEvent::WillResignActive, UIApplicationWillResignActiveNotification},
+      {"didEnterBackground", AppEvent::DidEnterBackground, UIApplicationDidEnterBackgroundNotification},
+      {"willEnterForeground", AppEvent::WillEnterForeground, UIApplicationWillEnterForegroundNotification},
+      {"didReceiveMemoryWarning", AppEvent::DidReceiveMemoryWarning, UIApplicationDidReceiveMemoryWarningNotification},
+      {"willTerminate", AppEvent::WillTerminate, UIApplicationWillTerminateNotification},
+  }};
+  return table;
+}
+
+const std::array<SceneNotification, 6>& sceneNotifications() {
+  static const std::array<SceneNotification, 6> table = {{
+      {"willConnect", SceneEvent::WillConnect, UISceneWillConnectNotification},
+      {"didDisconnect", SceneEvent::DidDisconnect, UISceneDidDisconnectNotification},
+      {"didActivate", SceneEvent::DidActivate, UISceneDidActivateNotification},
+      {"willDeactivate", SceneEvent::WillDeactivate, UISceneWillDeactivateNotification},
+      {"willEnterForeground", SceneEvent::WillEnterForeground, UISceneWillEnterForegroundNotification},
+      {"didEnterBackground", SceneEvent::DidEnterBackground, UISceneDidEnterBackgroundNotification},
+  }};
+  return table;
+}
+
+/// The entry of `table` named `name`; TypeError for any other name.
+template <class Table>
+const auto& named(const Table& table, const String& name, const char* what) {
+  std::string wanted = name.toUtf8();
+  for (const auto& entry : table)
+    if (wanted == entry.name) return entry;
+
+  throw Exception(makeError(String::fromLatin1("TypeError"), String::fromUtf8(std::string("Unknown ") + what + ": " + wanted)));
+}
+
+SceneState stateOf(UIScene* scene) {
+  // Only window scenes can present.
+  if (![scene isKindOfClass:[UIWindowScene class]]) return SceneState::Unattached;
+
+  switch (scene.activationState) {
+    case UISceneActivationStateForegroundActive:
+      return SceneState::ForegroundActive;
+    case UISceneActivationStateForegroundInactive:
+      return SceneState::ForegroundInactive;
+    case UISceneActivationStateBackground:
+      return SceneState::Background;
+    default:
+      return SceneState::Unattached;
+  }
+}
+
+void requireMain(const char* what) {
+  if (onMainThread()) return;
+
+  throwError(String::fromLatin1("InvalidStateError"), String::fromUtf8(std::string(what) + " is only available on the main thread"));
+}
+
+}  // namespace
+
+// --- scenes and their ids -------------------------------------------------------------------
+
+/// Tags a scene with its SceneId. It goes with the scene: if UIKit never
+/// said the scene disconnected, its going says so.
+@interface LucentSceneTag : NSObject
+@property(nonatomic, readonly) SceneId sceneId;
+- (instancetype)initWithSceneId:(SceneId)sceneId;
+@end
+
+@implementation LucentSceneTag
+
+- (instancetype)initWithSceneId:(SceneId)sceneId {
+  if ((self = [super init])) _sceneId = sceneId;
+  return self;
+}
+
+- (void)dealloc {
+  SceneId id = _sceneId;
+  lucent::detail::runOn(&ExecutionContext::main(), [id] {
+    if (Lifecycle::shared().sceneScope(id)) Lifecycle::shared().report(id, SceneEvent::DidDisconnect);
+  });
+}
+
+@end
+
+namespace {
+
+char tagKey;
+
+/// Connected scenes by id, held weakly. Main thread.
+NSMapTable<NSNumber*, UIScene*>* scenesById() {
+  static NSMapTable<NSNumber*, UIScene*>* table = [NSMapTable strongToWeakObjectsMapTable];
+  return table;
+}
+
+SceneId taggedId(UIScene* scene) {
+  LucentSceneTag* tag = objc_getAssociatedObject(scene, &tagKey);
+  return tag ? tag.sceneId : 0;
+}
+
+/// The scene's id, connecting it first if it has none.
+SceneId tag(UIScene* scene) {
+  if (SceneId known = taggedId(scene)) return known;
+
+  SceneId id = Lifecycle::shared().connect();
+  objc_setAssociatedObject(scene, &tagKey, [[LucentSceneTag alloc] initWithSceneId:id], OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  [scenesById() setObject:scene forKey:@(id)];
+
+  return id;
+}
+
+/// Scenes connected before Lucent heard of them.
+void adoptConnectedScenes() {
+  UIApplication* app = [UIApplication sharedApplication];
+  if (!app) return;
+
+  for (UIScene* scene in app.connectedScenes) tag(scene);
+}
+
+void sceneNotified(UIScene* scene, SceneEvent event) {
+  if (![scene isKindOfClass:[UIScene class]]) return;
+
+  SceneId id = tag(scene);
+  Lifecycle::shared().report(id, event);
+
+  if (event != SceneEvent::DidDisconnect) return;
+
+  // Should UIKit connect this object again, it is a new scene.
+  [scenesById() removeObjectForKey:@(id)];
+  objc_setAssociatedObject(scene, &tagKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+UIWindow* keyWindowOf(UIWindowScene* scene) {
+  if (scene.keyWindow) return scene.keyWindow;
+
+  // Not key yet (still activating): its first visible window at the normal level.
+  for (UIWindow* window in scene.windows)
+    if (!window.hidden && window.windowLevel == UIWindowLevelNormal) return window;
+
+  return nil;
+}
+
+UIViewController* topOf(UIViewController* root) {
+  UIViewController* top = root;
+
+  while (top.presentedViewController && !top.presentedViewController.isBeingDismissed) top = top.presentedViewController;
+
+  return top;
+}
+
+std::optional<objc::PresentationContext> contextOf(SceneId id) {
+  auto* scene = (UIWindowScene*)[scenesById() objectForKey:@(id)];
+  if (![scene isKindOfClass:[UIWindowScene class]]) return std::nullopt;
+
+  UIWindow* window = keyWindowOf(scene);
+  UIViewController* top = topOf(window.rootViewController);
+  if (!top) return std::nullopt;
+
+  return objc::PresentationContext{id, scene, window, top};
+}
+
+}  // namespace
+
+/// Follows UIKit's lifecycle notifications from the moment the binary loads,
+/// before any scene connects, on the main thread (where UIKit posts them;
+/// one posted elsewhere is passed there). The observers stay for the
+/// process.
+@interface LucentLifecycleObserver : NSObject
+@end
+
+@implementation LucentLifecycleObserver
+
++ (void)load {
+  NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
+
+  for (const auto& n : sceneNotifications()) {
+    SceneEvent event = n.event;
+    [center addObserverForName:n.notification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification* note) {
+                      id scene = note.object;
+                      lucent::detail::runOn(&ExecutionContext::main(), [scene, event] { sceneNotified(scene, event); });
+                    }];
+  }
+
+  for (const auto& n : appNotifications()) {
+    AppEvent event = n.event;
+    [center addObserverForName:n.notification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification*) {
+                      lucent::detail::runOn(&ExecutionContext::main(), [event] { Lifecycle::shared().report(event); });
+                    }];
+  }
+}
+
+@end
+
+// --- presenting ----------------------------------------------------------------------------
+
+/// Watches a presented view controller for the person dismissing it (as its
+/// presentation controller's delegate, if it had none) and for its release
+/// (associated with it), until disarmed.
+@interface LucentPresentationWatch : NSObject <UIAdaptivePresentationControllerDelegate>
+- (instancetype)initWithDismissed:(std::function<void()>)dismissed;
+- (void)disarm;
+@end
+
+@implementation LucentPresentationWatch {
+  std::function<void()> _dismissed;
+}
+
+- (instancetype)initWithDismissed:(std::function<void()>)dismissed {
+  if ((self = [super init])) _dismissed = std::move(dismissed);
+  return self;
+}
+
+- (void)fire {
+  std::function<void()> dismissed = std::move(_dismissed);
+  _dismissed = nullptr;
+  if (dismissed) dismissed();
+}
+
+- (void)disarm {
+  _dismissed = nullptr;
+}
+
+- (void)presentationControllerDidDismiss:(UIPresentationController*)presentationController {
+  // Settling may unwatch, releasing this object: keep it until it returns.
+  LucentPresentationWatch* watch = self;
+  [watch fire];
+}
+
+- (void)dealloc {
+  [self fire];
+}
+
+@end
+
+namespace {
+
+char watchKey;
+
+/// A popover needs an anchor (UIActivityViewController on iPad): the middle
+/// of the presenting view, unless the view controller has its own.
+void anchorPopover(UIViewController* viewController, UIViewController* from) {
+  if (viewController.modalPresentationStyle != UIModalPresentationPopover) return;
+
+  UIPopoverPresentationController* popover = viewController.popoverPresentationController;
+  if (!popover || popover.sourceView || popover.barButtonItem) return;
+  if (@available(iOS 16.0, *)) {
+    if (popover.sourceItem) return;
+  }
+
+  CGRect bounds = from.view.bounds;
+  popover.sourceView = from.view;
+  popover.sourceRect = CGRectMake(CGRectGetMidX(bounds), CGRectGetMidY(bounds), 0, 0);
+  popover.permittedArrowDirections = 0;
+}
+
+void unwatch(UIViewController* viewController, LucentPresentationWatch* watch) {
+  [watch disarm];
+
+  if (viewController.presentationController.delegate == watch) viewController.presentationController.delegate = nil;
+  if (objc_getAssociatedObject(viewController, &watchKey) == watch)
+    objc_setAssociatedObject(viewController, &watchKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+[[noreturn]] void refuse(const std::string& why) {
+  throwError(String::fromLatin1("InvalidStateError"), String::fromUtf8(why));
+}
+
+}  // namespace
+
+namespace lucent::objc {
+
+std::optional<PresentationContext> presentationContext() {
+  requireMain("The presentation context");
+  adoptConnectedScenes();
+
+  std::optional<SceneId> picked = presentingScene(Lifecycle::shared().scenes(), [](SceneId id) {
+    return stateOf([scenesById() objectForKey:@(id)]);
+  });
+
+  return picked ? contextOf(*picked) : std::nullopt;
+}
+
+SceneId sceneIdOf(UIScene* scene) {
+  requireMain("A scene's id");
+  return scene ? tag(scene) : 0;
+}
+
+UIScene* sceneOf(SceneId id) {
+  requireMain("A scene");
+  return [scenesById() objectForKey:@(id)];
+}
+
+std::function<void()> detail::show(SceneId scene, UIViewController* viewController, bool animated, std::function<void()> dismissed) {
+  requireMain("Presenting");
+
+  std::optional<PresentationContext> context = contextOf(scene);
+  if (!context) refuse("The scene has no window to present from");
+
+  if (viewController.presentingViewController || viewController.isBeingPresented || viewController.parentViewController ||
+      viewController.viewIfLoaded.window)
+    refuse("The view controller is already shown");
+
+  // UIKit logs, rather than throws, when it refuses to present during
+  // another presentation or dismissal: refuse first.
+  UIViewController* top = context->top;
+  if (top.presentedViewController || top.isBeingPresented || top.isBeingDismissed) refuse("Another presentation is under way");
+
+  anchorPopover(viewController, top);
+
+  LucentPresentationWatch* watch = [[LucentPresentationWatch alloc] initWithDismissed:std::move(dismissed)];
+  objc_setAssociatedObject(viewController, &watchKey, watch, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+  UIPresentationController* controller = viewController.presentationController;
+  if (controller && !controller.delegate) controller.delegate = watch;
+
+  // Some view controllers (UIActivityViewController) are shown later than
+  // the call, once their content is ready: a dismissal asked for before
+  // then waits for it. Main thread only.
+  struct Presenting {
+    bool shown = false;
+    bool withdrawn = false;
+  };
+  auto presenting = std::make_shared<Presenting>();
+
+  __weak UIViewController* weakViewController = viewController;
+  void (^dismiss)(void) = ^{
+    UIViewController* shown = weakViewController;
+    UIViewController* presenter = shown.presentingViewController;
+    if (presenter && !shown.isBeingDismissed) [presenter dismissViewControllerAnimated:animated completion:nil];
+  };
+
+  NSString* failure = nil;
+  @try {
+    [top presentViewController:viewController
+                      animated:animated
+                    completion:^{
+                      presenting->shown = true;
+                      if (presenting->withdrawn) dismiss();
+                    }];
+  } @catch (NSException* e) {
+    failure = e.reason ?: e.name;
+  }
+
+  if (failure) {
+    unwatch(viewController, watch);
+    refuse(failure.UTF8String);
+  }
+
+  __weak LucentPresentationWatch* weakWatch = watch;
+  return [weakViewController, weakWatch, presenting, dismiss] {
+    presenting->withdrawn = true;
+
+    UIViewController* shown = weakViewController;
+    LucentPresentationWatch* watching = weakWatch;
+    if (shown && watching) unwatch(shown, watching);
+
+    if (presenting->shown) dismiss();
+  };
+}
+
+Error detail::dismissedError() {
+  return makeError(String::fromLatin1("AbortError"), String::fromLatin1("The view controller was dismissed"));
+}
+
+std::shared_ptr<Scope> detail::callerScope() { return ExecutionContext::of(ExecutionContext::currentRef()).root(); }
+
+namespace {
+
+/// A subscription as the function that ends it, also ended by `signal`.
+Fn<void()> stopper(std::shared_ptr<Resource> subscription, Opt<AbortSignal> signal) {
+  AbortSignal abort = signal.has() ? signal.get() : nullptr;
+  uint64_t listener = 0;
+
+  if (abort) {
+    std::weak_ptr<Resource> weak = subscription;
+    listener = abort->add([weak] {
+      if (auto s = weak.lock()) s->close();
+    });
+  }
+
+  std::weak_ptr<AbortSignalObject> weakSignal = abort;
+  return Fn<void()>([subscription, weakSignal, listener] {
+    subscription->close();
+    if (auto s = weakSignal.lock(); s && listener) s->remove(listener);
+  });
+}
+
+bool abortedAlready(const Opt<AbortSignal>& signal) { return signal.has() && signal.get() && signal.get()->aborted.load(); }
+
+/// The session's persistent identifier of a connected scene, else "".
+String identifierOf(SceneId id) {
+  NSString* identifier = [scenesById() objectForKey:@(id)].session.persistentIdentifier;
+  return identifier ? fromNSString(identifier, "persistentIdentifier") : String();
+}
+
+}  // namespace
+
+Fn<void()> onAppEvent(const String& event, Fn<void()> listener, Opt<AbortSignal> signal) {
+  AppEvent e = named(appNotifications(), event, "app event").event;
+  if (abortedAlready(signal)) return Fn<void()>([] {});
+
+  auto subscription = Lifecycle::shared().subscribe(
+      e, [listener] { callNow([&] { listener(); }); }, detail::callerScope());
+
+  return stopper(std::move(subscription), signal);
+}
+
+Fn<void()> onSceneEvent(const String& event, Fn<void(String)> listener, Opt<AbortSignal> signal) {
+  SceneEvent e = named(sceneNotifications(), event, "scene event").event;
+  if (abortedAlready(signal)) return Fn<void()>([] {});
+
+  auto subscription = Lifecycle::shared().subscribe(
+      e,
+      [listener](SceneId scene) {
+        String identifier = identifierOf(scene);
+        callNow([&] { listener(identifier); });
+      },
+      detail::callerScope());
+
+  return stopper(std::move(subscription), signal);
+}
+
+}  // namespace lucent::objc

package/runtime/cpp/lucent/platform/swiftui.h

@@ -0,0 +1,190 @@
+// Lucent runtime — what the glue of SwiftUI components shares (iOS,
+// Objective-C++ with ARC).
+//
+// A SwiftUI component's body is Swift, generated from the JSX its setup
+// returns; the rest of the setup is Lucent code. The
+// generated Swift calls back into it through C functions: the body's
+// actions (the setup's functions a tap… calls) by index, with the
+// arguments the Swift gives them, the Lucent code `withAnimation`
+// animates, and a change of the body's size. All run on the main thread;
+// actions and animations in Lucent's main context.
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "../array.h"
+#include "../function.h"
+#include "../items.h"
+#include "../native.h"
+#include "../view.h"
+#include "ios.h"
+
+namespace lucent::swiftui {
+
+/// How the Swift side runs action `action` of `context`, with `args`: a
+/// retained NSArray of its arguments, which the call takes.
+using Invoke = void (*)(void* context, int32_t action, void* args);
+/// How it lets `context` go, when its view goes.
+using Release = void (*)(void* context);
+/// How it reports that the body's size changed.
+using Resized = void (*)(void* context);
+/// The Lucent code withAnimation runs.
+using Body = void (*)(void* context);
+
+/**
+ * The actions a body calls, by index, and the content of their mount. The
+ * Swift side holds them through a context (context()) until its view
+ * goes; the mount clears them when it ends, so what they captured goes
+ * with it.
+ */
+struct Actions {
+  explicit Actions(std::weak_ptr<ui::Content> content) : content(std::move(content)) {}
+
+  std::vector<std::function<void(NSArray* args)>> list;
+  /// The mount's content, which a change of the body's size marks.
+  std::weak_ptr<ui::Content> content;
+};
+
+/// A context the Swift side owns (release() lets it go), holding `actions`.
+inline void* context(const std::shared_ptr<Actions>& actions) {
+  return new std::shared_ptr<Actions>(actions);
+}
+
+/// Runs an action, which Swift calls on the main thread, in the main context.
+inline void invoke(void* context, int32_t action, void* args) {
+  NSArray* given = (__bridge_transfer NSArray*)args;
+  auto actions = *static_cast<std::shared_ptr<Actions>*>(context);
+
+  if (action < 0 || static_cast<std::size_t>(action) >= actions->list.size()) return;
+
+  // A copy: the action may end the mount, which clears the list.
+  auto run = actions->list[static_cast<std::size_t>(action)];
+
+  if (run) callNowIn(ExecutionContext::main(), [&] { run(given); });
+}
+
+namespace detail {
+
+/// An action's argument `i`, as the Lucent function takes it; missing, or NSNull, is none.
+template <class T>
+struct Arg;
+
+template <>
+struct Arg<double> {
+  static double from(id v) { return [(NSNumber*)v doubleValue]; }
+};
+
+template <>
+struct Arg<bool> {
+  static bool from(id v) { return [(NSNumber*)v boolValue]; }
+};
+
+template <>
+struct Arg<String> {
+  static String from(id v) { return objc::fromNSString((NSString*)v, "a SwiftUI argument"); }
+};
+
+template <class T>
+struct Arg<Opt<T>> {
+  static Opt<T> from(id v) { return v && v != [NSNull null] ? Opt<T>(Arg<T>::from(v)) : Opt<T>(null); }
+};
+
+template <class T>
+T arg(NSArray* args, std::size_t i) {
+  return Arg<T>::from(i < args.count ? args[i] : nil);
+}
+
+template <class... A, std::size_t... I>
+void call(const Fn<void(A...)>& f, NSArray* args, std::index_sequence<I...>) {
+  f(arg<A>(args, I)...);
+}
+
+}  // namespace detail
+
+/// The setup function `f` as an action: the Swift side's arguments, in order, are its parameters.
+template <class... A>
+std::function<void(NSArray*)> action(Fn<void(A...)> f) {
+  return [f = std::move(f)](NSArray* args) { detail::call(f, args, std::index_sequence_for<A...>{}); };
+}
+
+inline void release(void* context) { delete static_cast<std::shared_ptr<Actions>*>(context); }
+
+/**
+ * The body's size changed, SwiftUI's own layout too (no Lucent code ran):
+ * its mount's content is marked, so the host measures it again on a later
+ * turn of the main thread. Swift calls it on the main thread.
+ */
+inline void resized(void* context) {
+  ui::invalidateSize((*static_cast<std::shared_ptr<Actions>*>(context))->content);
+}
+
+// --- plain data, encoded for the Swift side (emit/toolkit-values.ts) ----------------------
+
+inline id value(double v) { return @(v); }
+inline id value(bool v) { return @(v); }
+inline id value(const String& v) { return objc::toNSString(v); }
+
+/// NSNull when `v` is null or undefined, else `each` of its value.
+template <class T, class F>
+id optional(const Opt<T>& v, F each) {
+  return v.has() ? each(v.get()) : [NSNull null];
+}
+
+template <class T, class F>
+id array(const Array<T>& a, F each) {
+  NSMutableArray* out = [NSMutableArray arrayWithCapacity:a.size()];
+
+  for (std::size_t i = 0; i < a.size(); i++) [out addObject:each(a.at(i))];
+
+  return out;
+}
+
+/// An object's fields, in order.
+inline id record(std::initializer_list<id> fields) {
+  return [NSArray arrayWithObjects:fields.begin() count:fields.size()];
+}
+
+/// A retained object the Swift side returns (a hosting controller), as Lucent's reference.
+inline NativeRef adopt(void* retained, const char* what) {
+  return objc::wrap((__bridge_transfer id)retained, what);
+}
+
+/**
+ * withAnimation: `shim` runs SwiftUI's withAnimation around a call of
+ * `body`, now, with the animation's Lucent values (`args`, as its C
+ * types). Its writes are one transaction, whose effects (the values the
+ * body shows) run before withAnimation returns, so SwiftUI animates what
+ * they change. What `body` throws is thrown here, once Swift is done.
+ */
+template <class F, class... A>
+void animate(void (*shim)(void* context, Body body, A...), F body, std::type_identity_t<A>... args) {
+  struct Call {
+    F* body;
+    std::exception_ptr error;
+  } call{&body, nullptr};
+
+  shim(&call, [](void* context) {
+    auto* c = static_cast<Call*>(context);
+
+    // Nothing may unwind through Swift's frames.
+    try {
+      ui::mainGraph()->transaction([&] { (*c->body)(); });
+    } catch (...) {
+      c->error = std::current_exception();
+    }
+  }, args...);
+
+  if (call.error) std::rethrow_exception(call.error);
+}
+
+}  // namespace lucent::swiftui

package/runtime/cpp/lucent/presentation.cpp

@@ -0,0 +1,11 @@
+#include "presentation.h"
+
+namespace lucent {
+
+Error sceneGoneError() { return makeError(String::fromLatin1("AbortError"), String::fromLatin1("The scene disconnected")); }
+
+Error noSceneError() {
+  return makeError(String::fromLatin1("InvalidStateError"), String::fromLatin1("No scene is in the foreground to present from"));
+}
+
+}  // namespace lucent