basalt-core 0.0.0-rc5

package/native/core/DevMenu.h

@@ -0,0 +1,75 @@
+// React Native's developer menu, for a desktop.
+//
+// On a phone this is a shake or a hardware key, and on a simulator it is
+// Cmd+D. A desktop has neither a shake nor a simulator, so it is a keyboard
+// shortcut into a native popup menu -- which is also the first thing in this
+// project to use `showMenu`, and the reason that seam exists.
+//
+// What each item does, and where it goes, is the interesting part, because the
+// three actions take three different routes out of here:
+//
+//   Reload                    React Native's own `DevSettings.reload()`, which
+//                             ReactCxxPlatform wires to ReactHost's private
+//                             `reloadReactInstance`. There is no public way in
+//                             from C++, so this asks JavaScript to make the
+//                             call -- through a device event that
+//                             `src/overrides/setUpDeveloperTools.js` listens
+//                             for. That override is React Native's own file
+//                             plus the listener, and it runs from
+//                             InitializeCore in every development bundle, so
+//                             it needs nothing of the app.
+//
+//   Toggle Element Inspector  `toggleElementInspector`, which is React Native's
+//                             own device event and needs no help from this
+//                             package at all: `AppContainer-dev.js` listens for
+//                             it and renders the inspector out of ordinary
+//                             views, which these hosts already mount.
+//
+//   Open Debugger             Straight through `ReactHost::openDebugger`, which
+//                             is public and asks the dev server to open one.
+//
+// Nothing here is compiled out of a release build, and it does not need to be:
+// the menu is only ever shown by a host running in dev mode, and the actions
+// fail quietly without one. What decides is `enableDevMode`, in one place.
+
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+class ReactHost;
+}
+
+namespace basalt {
+
+// What the menu offers, in order. Separate from showing it so that a host can
+// put the same list somewhere else -- an application menu bar, when there is
+// one -- without this file knowing about menus at all.
+struct DevMenuItem {
+  std::string label;
+  // Shown beside the label. Decoration: the host binds the key that opens the
+  // menu, and nothing binds these.
+  std::string shortcut;
+  // What choosing it does. Called on the main thread.
+  std::function<void()> action;
+};
+
+// The dev menu for this host. `reactHost` is borrowed and must outlive the
+// items; hosts hold both for the life of the process.
+std::vector<DevMenuItem> devMenuItems(facebook::react::ReactHost *reactHost);
+
+// Builds the menu, shows it, and runs whichever item was chosen. A no-op
+// without a ReactHost, so a host may call it before one exists.
+//
+// `x` and `y` are in the window's coordinates; negative means "at the pointer",
+// which is what a menu opened from the keyboard wants.
+void showDevMenu(facebook::react::ReactHost *reactHost, double x = -1.0, double y = -1.0);
+
+// The device event `src/overrides/setUpDeveloperTools.js` listens for, and the
+// one action sent through it. Named here so the two sides cannot drift.
+inline constexpr const char *kDevMenuEvent = "basaltDevMenu";
+inline constexpr const char *kDevMenuReload = "reload";
+
+} // namespace basalt

package/native/core/DialogModule.cpp

@@ -0,0 +1,150 @@
+#include "DialogModule.h"
+
+#include "PlatformServices.h"
+#include "TestDialog.h"
+
+#include <ReactCommon/TurboModuleUtils.h>
+#include <react/bridging/Bridging.h>
+#include <react/bridging/Promise.h>
+
+#include <folly/dynamic.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+std::string stringProperty(Runtime &runtime, const Object &options, const char *name) {
+  const Value value = options.getProperty(runtime, name);
+  return value.isString() ? value.asString(runtime).utf8(runtime) : std::string{};
+}
+
+bool boolProperty(Runtime &runtime, const Object &options, const char *name) {
+  const Value value = options.getProperty(runtime, name);
+  return value.isBool() && value.asBool();
+}
+
+// `filters: [{name, extensions: ['png', 'jpg']}]`, which is Electron's shape
+// and the one every desktop's own API is a rearrangement of.
+std::vector<FileFilter> filtersFrom(Runtime &runtime, const Object &options) {
+  std::vector<FileFilter> filters;
+  const Value value = options.getProperty(runtime, "filters");
+  if (!value.isObject() || !value.asObject(runtime).isArray(runtime)) {
+    return filters;
+  }
+  const auto array = value.asObject(runtime).asArray(runtime);
+  const size_t length = array.size(runtime);
+  for (size_t i = 0; i < length; i++) {
+    const Value entry = array.getValueAtIndex(runtime, i);
+    if (!entry.isObject()) {
+      continue;
+    }
+    const Object filter = entry.asObject(runtime);
+    FileFilter parsed;
+    parsed.name = stringProperty(runtime, filter, "name");
+
+    const Value extensions = filter.getProperty(runtime, "extensions");
+    if (extensions.isObject() && extensions.asObject(runtime).isArray(runtime)) {
+      const auto list = extensions.asObject(runtime).asArray(runtime);
+      const size_t count = list.size(runtime);
+      for (size_t j = 0; j < count; j++) {
+        const Value extension = list.getValueAtIndex(runtime, j);
+        if (extension.isString()) {
+          parsed.extensions.push_back(extension.asString(runtime).utf8(runtime));
+        }
+      }
+    }
+    // A filter with no extensions matches nothing and would be a trap on a
+    // desktop that shows it anyway. Dropped rather than shown.
+    if (!parsed.extensions.empty()) {
+      filters.push_back(std::move(parsed));
+    }
+  }
+  return filters;
+}
+
+FileDialogRequest requestFrom(Runtime &runtime,
+                              FileDialogRequest::Kind kind,
+                              const Value *args,
+                              size_t count) {
+  FileDialogRequest request;
+  request.kind = kind;
+  if (count == 0 || !args[0].isObject()) {
+    return request;
+  }
+  const Object options = args[0].asObject(runtime);
+  request.title = stringProperty(runtime, options, "title");
+  request.defaultPath = stringProperty(runtime, options, "defaultPath");
+  request.confirmLabel = stringProperty(runtime, options, "confirmLabel");
+  request.multiple = kind == FileDialogRequest::Kind::OpenFile &&
+      boolProperty(runtime, options, "multiple");
+  request.filters = filtersFrom(runtime, options);
+  return request;
+}
+
+// The one shape all three answer with. `paths` is a list even for a save, so
+// that an app moving between them is not also moving between result types; see
+// the header.
+Value present(Runtime &runtime,
+              const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
+              FileDialogRequest request) {
+  auto promise =
+      std::make_shared<facebook::react::AsyncPromise<folly::dynamic>>(runtime, jsInvoker);
+
+  presentFileDialog(request, [promise](bool canceled, const std::vector<std::string> &paths) {
+    folly::dynamic list = folly::dynamic::array;
+    for (const std::string &path : paths) {
+      list.push_back(path);
+    }
+    promise->resolve(folly::dynamic::object("canceled", canceled)("paths", std::move(list)));
+  });
+
+  return Value(runtime, facebook::react::bridging::toJs(runtime, *promise, jsInvoker));
+}
+
+} // namespace
+
+DesktopDialogModule::DesktopDialogModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["openFile"] = MethodMetadata{1, openFile};
+  methodMap_["saveFile"] = MethodMetadata{1, saveFile};
+  methodMap_["openFolder"] = MethodMetadata{1, openFolder};
+}
+
+Value DesktopDialogModule::openFile(Runtime &runtime,
+                                    TurboModule &module,
+                                    const Value *args,
+                                    size_t count) {
+  return present(runtime,
+                 static_cast<DesktopDialogModule &>(module).jsInvoker_,
+                 requestFrom(runtime, FileDialogRequest::Kind::OpenFile, args, count));
+}
+
+Value DesktopDialogModule::saveFile(Runtime &runtime,
+                                    TurboModule &module,
+                                    const Value *args,
+                                    size_t count) {
+  return present(runtime,
+                 static_cast<DesktopDialogModule &>(module).jsInvoker_,
+                 requestFrom(runtime, FileDialogRequest::Kind::SaveFile, args, count));
+}
+
+Value DesktopDialogModule::openFolder(Runtime &runtime,
+                                      TurboModule &module,
+                                      const Value *args,
+                                      size_t count) {
+  return present(runtime,
+                 static_cast<DesktopDialogModule &>(module).jsInvoker_,
+                 requestFrom(runtime, FileDialogRequest::Kind::OpenFolder, args, count));
+}
+
+} // namespace basalt

package/native/core/DialogModule.h

@@ -0,0 +1,51 @@
+// `BasaltDialog`: the native file dialogs, which React Native has no API for.
+//
+// React Native was built for phones, and a phone has no file dialog -- so there
+// is nothing here to be compatible with and the shape is this project's own.
+// It follows Electron's semantics, because that is the vocabulary a desktop
+// developer already has, with React Native's naming: `openFile`, `saveFile` and
+// `openFolder`, each answering a promise with `{canceled, paths}`.
+//
+// `canceled` rather than an empty list, and `paths` rather than `path` even for
+// a save: telling "the person pressed Cancel" from "the person chose nothing"
+// is the distinction every one of these APIs gets wrong at least once, and a
+// single shape for all three means an app that switches between them does not
+// switch between result types.
+//
+// A plain TurboModule rather than a codegen spec, like `BasaltWindow` beside
+// it: codegen specs exist for React Native's own modules, and this is not one.
+//
+// The dialog itself is `showFileDialog` in PlatformServices.h. Everything here
+// is the JavaScript boundary: reading the options, and settling the promise on
+// the JavaScript thread when the person is done -- which may be a long time.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+class DesktopDialogModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "BasaltDialog";
+
+  explicit DesktopDialogModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+
+ private:
+  static facebook::jsi::Value openFile(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value saveFile(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value openFolder(facebook::jsi::Runtime &runtime,
+                                         facebook::react::TurboModule &module,
+                                         const facebook::jsi::Value *args,
+                                         size_t count);
+};
+
+} // namespace basalt

package/native/core/DragAndDrop.cpp

@@ -0,0 +1,45 @@
+// The listener half of core/DragAndDrop.h.
+//
+// Here rather than in the header because the header is included by the view
+// libraries, which link no core -- so anything with state has to live in the
+// half the hosts link. See the CMakeLists comment about FocusRing.h and
+// Backface.h for the same rule stated where it bites.
+
+#include "DragAndDrop.h"
+
+#include <mutex>
+
+namespace basalt {
+namespace {
+
+std::mutex &lock() {
+  static std::mutex value;
+  return value;
+}
+
+std::function<void(const DropEvent &)> &listener() {
+  static std::function<void(const DropEvent &)> value;
+  return value;
+}
+
+} // namespace
+
+void setDropListener(std::function<void(const DropEvent &)> value) {
+  const std::lock_guard<std::mutex> guard(lock());
+  listener() = std::move(value);
+}
+
+void reportDrop(const DropEvent &event) {
+  std::function<void(const DropEvent &)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    toCall = listener();
+  }
+  // Outside the lock: it emits a device event, and holding a lock across a
+  // call into the runtime is how a deadlock is built.
+  if (toCall) {
+    toCall(event);
+  }
+}
+
+} // namespace basalt

package/native/core/DragAndDrop.h

@@ -0,0 +1,225 @@
+// Dragging something into the application, and out of it.
+//
+// A desktop application is expected to accept a file dropped on it. React
+// Native has no API for that, because a phone has no pointer to drag with, so
+// there is nothing here to be compatible with -- which makes the shape this
+// takes a decision rather than a port.
+//
+// ## Marked by nativeID, like the title bar's drag regions
+//
+// A view says it accepts a drop by setting `nativeID`, the one prop a plain
+// `<View>` carries to the host on every platform. The alternative is a
+// registration call keyed on a tag from `findNodeHandle`, which means a
+// module method, a ref, and a lifetime to get wrong -- for a fact about a
+// view that React already sends down on every commit.
+//
+// See core/TitleBarRegions.h, which marks views the same way and for the same
+// reason. The strings live here rather than in a host because every host that
+// reads them must read the same ones, and JavaScript writes them from a
+// fourth place.
+//
+// ## What a drop target accepts
+//
+// Files and text, which are the two kinds every desktop agrees on. The marker
+// carries them so that a view accepting only files is not told about dragged
+// text at all -- the desktop asks "will you take this?" before the drop, and
+// answering honestly is what makes the cursor say no rather than the app
+// rejecting it afterwards.
+//
+// ## Which view is told
+//
+// The deepest accepting view under the pointer, found by walking up from the
+// view the hit test returned. Exactly the rule the title bar applies, and for
+// the same reason: a label inside a drop target should not have to be marked,
+// and a drop target inside another should win.
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include <react/renderer/core/ReactPrimitives.h>
+
+namespace basalt {
+
+// What a drop carries. Both may be present: a file manager commonly offers a
+// dragged file as a path *and* as its name in text, and which one an app wants
+// is the app's business.
+struct DragPayload {
+  // Absolute paths. Not URIs: every host is asked for a file list and hands
+  // back something path-shaped, and an app that wanted a URI can make one.
+  std::vector<std::string> files;
+  std::string text;
+
+  bool hasFiles() const { return !files.empty(); }
+  bool hasText() const { return !text.empty(); }
+  bool empty() const { return files.empty() && text.empty(); }
+};
+
+// What a view will take. A mask rather than an enum: a view may accept both,
+// and "either" is the common case.
+enum DropAccepts : std::uint16_t {
+  DropAcceptsNone = 0,
+  DropAcceptsFiles = 1 << 0,
+  DropAcceptsText = 1 << 1,
+};
+
+// The prefix a marked view's nativeID starts with. What follows is the
+// accepted kinds, comma separated: `basalt-drop:files`, `basalt-drop:text`,
+// `basalt-drop:files,text`.
+//
+// A prefix rather than three fixed strings, because this one has a payload and
+// the title bar's does not.
+inline constexpr const char *kDropTargetIdPrefix = "basalt-drop:";
+
+// What a nativeID says this view accepts, or DropAcceptsNone when it is not a
+// drop marker at all -- which is every other nativeID an app sets, including
+// the title bar's and its own.
+//
+// Unknown kinds are ignored rather than refused: a marker written by a newer
+// JavaScript than the host should degrade to the kinds this host knows, not to
+// nothing.
+inline std::uint16_t dropAcceptsFrom(const std::string &nativeId) {
+  const std::string prefix(kDropTargetIdPrefix);
+  if (nativeId.rfind(prefix, 0) != 0) {
+    return DropAcceptsNone;
+  }
+  std::uint16_t accepts = DropAcceptsNone;
+  std::string kind;
+  // One pass, splitting on commas, with the last kind flushed at the end.
+  for (size_t i = prefix.size(); i <= nativeId.size(); i++) {
+    if (i == nativeId.size() || nativeId[i] == ',') {
+      if (kind == "files") {
+        accepts |= DropAcceptsFiles;
+      } else if (kind == "text") {
+        accepts |= DropAcceptsText;
+      }
+      kind.clear();
+    } else {
+      kind += nativeId[i];
+    }
+  }
+  return accepts;
+}
+
+// Whether a view accepting `accepts` would take this payload.
+//
+// The question the desktop asks before the drop, which is why it is answered
+// from what is being dragged rather than from what was dropped: a target that
+// said yes and then refused is a cursor that lied.
+inline bool wouldAccept(std::uint16_t accepts, const DragPayload &payload) {
+  if (accepts == DropAcceptsNone || payload.empty()) {
+    return false;
+  }
+  if ((accepts & DropAcceptsFiles) != 0 && payload.hasFiles()) {
+    return true;
+  }
+  return (accepts & DropAcceptsText) != 0 && payload.hasText();
+}
+
+// The nativeID a view would carry to accept these kinds -- the inverse of
+// dropAcceptsFrom, here so that a test can round-trip the two and JavaScript
+// has one authority to match.
+inline std::string dropTargetIdFor(std::uint16_t accepts) {
+  std::string id(kDropTargetIdPrefix);
+  if ((accepts & DropAcceptsFiles) != 0) {
+    id += "files";
+  }
+  if ((accepts & DropAcceptsText) != 0) {
+    if (id.size() > std::string(kDropTargetIdPrefix).size()) {
+      id += ",";
+    }
+    id += "text";
+  }
+  return id;
+}
+
+// --- Dragging out -----------------------------------------------------------
+//
+// The other direction, and marked the same way -- except that a drag source
+// declares *what it is*, not what it takes, so the marker carries a value:
+// `basalt-drag:text:hello`, `basalt-drag:files:/tmp/one.txt`.
+//
+// Declared in advance rather than produced on demand, because every toolkit
+// owns the gesture: GtkDragSource, `beginDraggingSessionWithItems:` and
+// `DoDragDrop` all start the drag themselves and ask what is being dragged
+// synchronously, on the UI thread. An app asked at that moment would have to
+// answer from JavaScript on another thread, which is the same problem
+// refusing to close has, and it is solved the same way -- say it beforehand.
+inline constexpr const char *kDragSourceIdPrefix = "basalt-drag:";
+
+// What a marked view represents, or an empty payload for any other nativeID.
+//
+// Everything after the second colon is the value, so a path or a line of text
+// containing a colon survives: only the first two are structure.
+inline DragPayload dragPayloadFrom(const std::string &nativeId) {
+  DragPayload payload;
+  const std::string prefix(kDragSourceIdPrefix);
+  if (nativeId.rfind(prefix, 0) != 0) {
+    return payload;
+  }
+  const size_t kindEnd = nativeId.find(':', prefix.size());
+  if (kindEnd == std::string::npos) {
+    return payload;
+  }
+  const std::string kind = nativeId.substr(prefix.size(), kindEnd - prefix.size());
+  const std::string value = nativeId.substr(kindEnd + 1);
+  if (value.empty()) {
+    return payload;
+  }
+  if (kind == "files") {
+    payload.files.push_back(value);
+  } else if (kind == "text") {
+    payload.text = value;
+  }
+  return payload;
+}
+
+// The inverse, so a test can round-trip it and JavaScript has one authority
+// to match. Files win where a payload somehow carries both: a desktop
+// dragging a file offers its name as text anyway.
+inline std::string dragSourceIdFor(const DragPayload &payload) {
+  std::string id(kDragSourceIdPrefix);
+  if (payload.hasFiles()) {
+    return id + "files:" + payload.files.front();
+  }
+  if (payload.hasText()) {
+    return id + "text:" + payload.text;
+  }
+  return id;
+}
+
+// What happened over a drop target.
+//
+// One struct and a kind rather than three callbacks, because the host reports
+// all three from the same place and JavaScript wants them on one event.
+enum class DropPhase {
+  // The pointer moved over an accepting view, which is what draws the "you
+  // may drop here" state. Sent on entering and while moving within it.
+  Over,
+  // It left, or the drag ended somewhere else. The app clears that state.
+  Leave,
+  // It was dropped. The only phase carrying the payload: the desktops do not
+  // all reveal what is being dragged until it lands, and one that does should
+  // not tempt an app into reading it early.
+  Drop,
+};
+
+struct DropEvent {
+  facebook::react::Tag tag{0};
+  DropPhase phase{DropPhase::Over};
+  // In the surface root's coordinates, like a touch.
+  double x{0.0};
+  double y{0.0};
+  DragPayload payload;
+};
+
+// Set by the module; called by whichever host is running.
+void setDropListener(std::function<void(const DropEvent &)> listener);
+
+// The host's half: called on the UI thread.
+void reportDrop(const DropEvent &event);
+
+} // namespace basalt

package/native/core/ExpoImageComponent.cpp

@@ -0,0 +1,79 @@
+#include "ExpoImageComponent.h"
+
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/components/image/conversions.h>
+
+namespace facebook::react {
+
+// The name React Native registers for it, from `requireNativeViewManager`:
+// `ViewManagerAdapter_` plus the Expo module's name. There is no app-identifier
+// suffix because nothing here sets `__expo_app_identifier__`, which exists so
+// that two copies of a library in one app do not collide.
+extern const char ExpoImageComponentName[] = "ViewManagerAdapter_ExpoImage";
+
+namespace {
+
+ImageResizeMode resizeModeFrom(const std::string &contentFit) {
+  // CSS object-fit, which is what expo-image's contentFit is.
+  if (contentFit == "contain") {
+    return ImageResizeMode::Contain;
+  }
+  if (contentFit == "fill") {
+    return ImageResizeMode::Stretch;
+  }
+  if (contentFit == "none") {
+    return ImageResizeMode::None;
+  }
+  // `scale-down` is `contain` that never scales up. Nothing here can express
+  // the second half, and contain is the half that matters for an image larger
+  // than its box, which is the case scale-down exists for.
+  if (contentFit == "scale-down") {
+    return ImageResizeMode::Contain;
+  }
+  return ImageResizeMode::Cover;
+}
+
+} // namespace
+
+ExpoImageProps::ExpoImageProps(const PropsParserContext &context,
+                               const ExpoImageProps &sourceProps,
+                               const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      sources(convertRawProp(context, rawProps, "source", sourceProps.sources, {})),
+      tintColor(convertRawProp(context, rawProps, "tintColor", sourceProps.tintColor, {})) {
+  const std::string fit =
+      convertRawProp(context, rawProps, "contentFit", std::string{}, std::string{});
+  contentFit = fit.empty() ? sourceProps.contentFit : resizeModeFrom(fit);
+}
+
+void ExpoImageEventEmitter::onLoadStart() const {
+  dispatchEvent("loadStart");
+}
+
+// expo-image's payload, not React Native's: `{source: {url, width, height,
+// mediaType}}`. An app reads `event.source.width`, so the names matter.
+void ExpoImageEventEmitter::onLoad(const ImageSource &source, double width, double height) const {
+  dispatchEvent("load", [uri = source.uri, width, height](jsi::Runtime &runtime) {
+    auto loaded = jsi::Object(runtime);
+    loaded.setProperty(runtime, "url", uri);
+    loaded.setProperty(runtime, "width", width);
+    loaded.setProperty(runtime, "height", height);
+    loaded.setProperty(runtime, "mediaType", jsi::Value::null());
+    loaded.setProperty(runtime, "isAnimated", false);
+
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "source", std::move(loaded));
+    return payload;
+  });
+}
+
+void ExpoImageEventEmitter::onError(const std::string &message) const {
+  dispatchEvent("error", [message](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "error", message);
+    return payload;
+  });
+}
+
+} // namespace facebook::react