basalt-core 0.0.0-rc5

package/native/core/ImageBytes.cpp

@@ -0,0 +1,205 @@
+#include "ImageBytes.h"
+
+#include <curl/curl.h>
+
+#include <array>
+#include <cctype>
+#include <cstdint>
+#include <fstream>
+#include <mutex>
+#include <sstream>
+
+namespace basalt {
+
+namespace {
+
+std::once_flag curlInitFlag;
+
+size_t appendBytes(char *data, size_t size, size_t count, void *userData) {
+  auto *out = static_cast<std::string *>(userData);
+  out->append(data, size * count);
+  return size * count;
+}
+
+bool startsWith(const std::string &value, const char *prefix) {
+  return value.rfind(prefix, 0) == 0;
+}
+
+// Standard base64, ignoring whitespace and tolerating missing padding. Written
+// out rather than taken from glib or Foundation because this file is the half
+// that has neither.
+bool decodeBase64(const std::string &input, std::string *out) {
+  static constexpr std::string_view kAlphabet =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+  std::array<int8_t, 256> reverse{};
+  reverse.fill(-1);
+  for (size_t i = 0; i < kAlphabet.size(); i++) {
+    reverse[static_cast<unsigned char>(kAlphabet[i])] = static_cast<int8_t>(i);
+  }
+
+  uint32_t accumulator = 0;
+  int bits = 0;
+  for (const char c : input) {
+    if (c == '=' ) {
+      break;
+    }
+    if (std::isspace(static_cast<unsigned char>(c)) != 0) {
+      continue;
+    }
+    const int8_t value = reverse[static_cast<unsigned char>(c)];
+    if (value < 0) {
+      return false;
+    }
+    accumulator = (accumulator << 6) | static_cast<uint32_t>(value);
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out->push_back(static_cast<char>((accumulator >> bits) & 0xFF));
+    }
+  }
+  return true;
+}
+
+// Percent-decoding, for the path half of a file: URI. A path with a space in it
+// arrives as %20 and opening it literally fails with "no such file", which is a
+// confusing thing to be told about a file that plainly exists.
+std::string percentDecode(const std::string &input) {
+  std::string out;
+  out.reserve(input.size());
+  for (size_t i = 0; i < input.size(); i++) {
+    if (input[i] == '%' && i + 2 < input.size()) {
+      const auto hex = input.substr(i + 1, 2);
+      char *end = nullptr;
+      const long value = std::strtol(hex.c_str(), &end, 16);
+      if (end != nullptr && *end == '\0') {
+        out.push_back(static_cast<char>(value));
+        i += 2;
+        continue;
+      }
+    }
+    out.push_back(input[i]);
+  }
+  return out;
+}
+
+bool readFile(const std::string &path, std::string *out, std::string *error) {
+  std::ifstream file(path, std::ios::binary);
+  if (!file) {
+    *error = "could not open " + path;
+    return false;
+  }
+  std::ostringstream contents;
+  contents << file.rdbuf();
+  *out = contents.str();
+  if (out->empty()) {
+    *error = "empty file: " + path;
+    return false;
+  }
+  return true;
+}
+
+} // namespace
+
+bool fetchImageBytes(const std::string &uri, std::string *out, std::string *error) {
+  out->clear();
+
+  if (uri.empty()) {
+    *error = "empty source uri";
+    return false;
+  }
+
+  if (startsWith(uri, "data:")) {
+    const auto comma = uri.find(',');
+    if (comma == std::string::npos) {
+      *error = "malformed data: URI";
+      return false;
+    }
+    if (uri.substr(0, comma).find(";base64") == std::string::npos) {
+      // Percent-encoded text payloads are legal but never carry an image.
+      *error = "only base64 data: URIs are supported";
+      return false;
+    }
+    if (!decodeBase64(uri.substr(comma + 1), out)) {
+      out->clear();
+      *error = "malformed base64 in data: URI";
+      return false;
+    }
+    return true;
+  }
+
+  if (startsWith(uri, "http://") || startsWith(uri, "https://")) {
+    std::call_once(curlInitFlag, []() { curl_global_init(CURL_GLOBAL_DEFAULT); });
+
+    CURL *handle = curl_easy_init();
+    if (handle == nullptr) {
+      *error = "could not initialise libcurl";
+      return false;
+    }
+    curl_easy_setopt(handle, CURLOPT_URL, uri.c_str());
+    curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, appendBytes);
+    curl_easy_setopt(handle, CURLOPT_WRITEDATA, out);
+    // Without this, libcurl installs a SIGALRM-based resolver timeout that is
+    // not safe to use off the main thread.
+    curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1L);
+    const CURLcode result = curl_easy_perform(handle);
+    long status = 0;
+    curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &status);
+    curl_easy_cleanup(handle);
+
+    if (result != CURLE_OK) {
+      out->clear();
+      *error = curl_easy_strerror(result);
+      return false;
+    }
+    if (status >= 400) {
+      out->clear();
+      *error = "http " + std::to_string(status);
+      return false;
+    }
+    return true;
+  }
+
+  // Anything else is a path. file:// is the explicit form; a bare path is what
+  // a bundled asset looks like once it has been resolved.
+  std::string path = uri;
+  if (startsWith(uri, "file://")) {
+    path = percentDecode(uri.substr(std::string("file://").size()));
+    // file:///tmp/x has an empty authority; file://host/x has one this cannot
+    // reach, and treating its host as the first path segment would silently
+    // read the wrong file.
+    if (!path.empty() && path.front() != '/') {
+      *error = "remote file: URIs are not supported: " + uri;
+      return false;
+    }
+
+#ifdef _WIN32
+    // On Windows the leading slash is not part of the path.
+    //
+    // `file:///C:/x` has the URI path `/C:/x`, and on a POSIX system that is
+    // also the filesystem path -- which is why this went unnoticed until a
+    // third desktop. Windows has no root above the drive letter, so `/C:/x`
+    // does not open and the slash has to come off. Every browser and every URI
+    // library does the same.
+    //
+    // Guarded rather than written portably, even though a POSIX directory
+    // literally named `C:` is not a thing anyone has: this file is shared, the
+    // other two desktops cannot be tested from here, and a shared behaviour
+    // change is not worth making blind for a case that cannot arise.
+    if (path.size() >= 3 && path[0] == '/' &&
+        ((path[1] >= 'A' && path[1] <= 'Z') || (path[1] >= 'a' && path[1] <= 'z')) &&
+        path[2] == ':') {
+      path.erase(0, 1);
+    }
+#endif
+  }
+
+  if (!readFile(path, out, error)) {
+    out->clear();
+    return false;
+  }
+  return true;
+}
+
+} // namespace basalt

package/native/core/ImageBytes.h

@@ -0,0 +1,29 @@
+// Reading the bytes behind an <Image> source.
+//
+// Not platform-specific, which is why it is here. A URI is a URI: `file://`,
+// a bare path, `data:` and `http(s)` mean the same things on every desktop, and
+// the only part of image loading that differs is decoding the bytes into
+// whatever the toolkit paints -- a GdkTexture on GTK, a CGImage on AppKit.
+//
+// Written second, which is the useful part: this began as private code inside
+// GtkImageLoader, and porting <Image> to macOS was the point at which "the same
+// thing twice" became visible.
+
+#pragma once
+
+#include <string>
+
+namespace basalt {
+
+// Schemes understood:
+//   file://       read from disk, percent-decoded
+//   data:         base64 payloads only
+//   http, https   fetched with libcurl
+//   bare paths    treated as file paths, which is what a `require()`d asset
+//                 looks like once Metro has resolved it in a release bundle
+//
+// Blocking, so call it off the thread that draws. Returns false and fills
+// `error` on failure, in which case `out` is left empty.
+bool fetchImageBytes(const std::string &uri, std::string *out, std::string *error);
+
+} // namespace basalt

package/native/core/ImageCache.cpp

@@ -0,0 +1,51 @@
+#include "ImageCache.h"
+
+namespace basalt {
+
+void ImageCachePolicy::noteUse(const std::string &uri) {
+  const auto it = entries_.find(uri);
+  if (it == entries_.end()) {
+    return;
+  }
+  order_.splice(order_.begin(), order_, it->second);
+}
+
+std::vector<std::string> ImageCachePolicy::insert(const std::string &uri, size_t bytes) {
+  // Replacing what is already there: the same URI decoded again, which happens
+  // when a host reloads an image whose contents changed.
+  remove(uri);
+
+  order_.push_front(Entry{uri, bytes});
+  entries_[uri] = order_.begin();
+  bytes_ += bytes;
+
+  std::vector<std::string> evicted;
+  // Never the entry just inserted, however large it is -- it is on screen, and
+  // dropping it here would decode it again on the next frame, forever.
+  while (bytes_ > budget_ && order_.size() > 1) {
+    const Entry &oldest = order_.back();
+    evicted.push_back(oldest.uri);
+    bytes_ -= oldest.bytes;
+    entries_.erase(oldest.uri);
+    order_.pop_back();
+  }
+  return evicted;
+}
+
+void ImageCachePolicy::remove(const std::string &uri) {
+  const auto it = entries_.find(uri);
+  if (it == entries_.end()) {
+    return;
+  }
+  bytes_ -= it->second->bytes;
+  order_.erase(it->second);
+  entries_.erase(it);
+}
+
+void ImageCachePolicy::clear() {
+  order_.clear();
+  entries_.clear();
+  bytes_ = 0;
+}
+
+} // namespace basalt

package/native/core/ImageCache.h

@@ -0,0 +1,89 @@
+// What a decoded image cache keeps, and what it drops.
+//
+// All three hosts cache decoded images by URI in an `unordered_map` that
+// nothing ever removes from. That is fine for the demo, where a handful of
+// images load once, and wrong for the case the cache exists for: a long list
+// of remote images, scrolled, where every one ever seen stays in memory until
+// the process exits.
+//
+// ## Why the policy is here and the pixels are not
+//
+// The three hosts hold three unrelated things -- a `GdkTexture`, a `CGImage`,
+// an `RnWin32Image` -- and none of them can be described in core without
+// dragging a toolkit in with it. What *can* be shared is the decision: which
+// URI to drop next, and when. So this tracks keys and sizes, answers with the
+// URIs to release, and never sees a pixel.
+//
+// It also means the policy is testable without a display, which is the same
+// reason core/ScrollIndicator.h and core/ScrollBounds.h are shaped this way.
+//
+// ## Least recently used
+//
+// The alternative is least recently *added*, which is cheaper and wrong for
+// exactly the case this exists for: scrolling a list back up should not have
+// to re-decode the rows that are about to be on screen again. A use is a hit
+// or an insert, and both move an entry to the front.
+//
+// Not thread-safe, and not meant to be: every host calls this from the thread
+// that owns its views, which is where the decode is handed back to.
+
+#pragma once
+
+#include <cstddef>
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace basalt {
+
+// Roughly a dozen full-screen images on a 1080p display: 1920 x 1080 x 4 bytes
+// is 8.3MB, so this is about a dozen of them, or a great many thumbnails.
+//
+// A number rather than a fraction of anything, because the three desktops do
+// not agree on how to ask how much memory there is, and a cache whose size
+// depended on the machine would make a leak reproduce on one and not another.
+inline constexpr size_t kImageCacheBudgetBytes = 96u * 1024u * 1024u;
+
+class ImageCachePolicy {
+ public:
+  explicit ImageCachePolicy(size_t budgetBytes = kImageCacheBudgetBytes)
+      : budget_(budgetBytes) {}
+
+  // Records that a cached image was used, moving it to the front. Does nothing
+  // for a URI this does not know, which is what a hit on a host that cached
+  // something before this existed looks like.
+  void noteUse(const std::string &uri);
+
+  // Records a newly decoded image, and answers with the URIs whose images
+  // should now be released -- oldest first, and never the one just inserted.
+  //
+  // An image larger than the whole budget is kept rather than refused: it is
+  // on screen, and a cache that evicted it immediately would decode it again
+  // on the next frame forever.
+  std::vector<std::string> insert(const std::string &uri, size_t bytes);
+
+  // Drops one entry, for a host that released an image for its own reasons.
+  void remove(const std::string &uri);
+
+  void clear();
+
+  size_t bytes() const { return bytes_; }
+  size_t count() const { return entries_.size(); }
+  size_t budget() const { return budget_; }
+
+ private:
+  struct Entry {
+    std::string uri;
+    size_t bytes{0};
+  };
+
+  // Front is most recently used. A list so that moving an entry is a splice
+  // and the iterators the map holds stay valid.
+  std::list<Entry> order_;
+  std::unordered_map<std::string, std::list<Entry>::iterator> entries_;
+  size_t bytes_{0};
+  size_t budget_;
+};
+
+} // namespace basalt

package/native/core/JsRuntimeAccess.cpp

@@ -0,0 +1,70 @@
+#include "JsRuntimeAccess.h"
+
+#include <mutex>
+#include <stdexcept>
+#include <utility>
+
+namespace basalt {
+
+namespace {
+
+// A mutex rather than a bare static, because unlike the UIManager this is read
+// from whatever thread a subprocess reader happens to be on while the main
+// thread may be clearing it on the way to quitting.
+std::mutex &lock() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+RuntimeRunner &runner() {
+  static RuntimeRunner function;
+  return function;
+}
+
+class RunnerCallInvoker : public facebook::react::CallInvoker {
+ public:
+  void invokeAsync(facebook::react::CallFunc &&func) noexcept override {
+    runOnJsRuntime(std::move(func));
+  }
+
+  void invokeSync(facebook::react::CallFunc && /*func*/) override {
+    // See the header: the only door a host leaves open posts. A caller wanting
+    // this wants something this platform cannot give it, and saying so here is
+    // better than a deadlock in whatever it was doing.
+    throw std::logic_error(
+        "basalt: invokeSync on the runtime-runner CallInvoker. This invoker is "
+        "ReactHost::runOnRuntimeScheduler, which posts and cannot run work inline; "
+        "see core/JsRuntimeAccess.h.");
+  }
+};
+
+} // namespace
+
+void setRuntimeRunner(RuntimeRunner function) {
+  std::lock_guard<std::mutex> guard(lock());
+  runner() = std::move(function);
+}
+
+bool runOnJsRuntime(std::function<void(facebook::jsi::Runtime &)> work) {
+  // Copied out under the lock and called outside it: the runner posts to another
+  // thread, and holding a lock across a call into the host is how the drop and
+  // key listeners were careful too.
+  RuntimeRunner function;
+  {
+    std::lock_guard<std::mutex> guard(lock());
+    function = runner();
+  }
+  if (!function) {
+    return false;
+  }
+  function(std::move(work));
+  return true;
+}
+
+std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker() {
+  static std::shared_ptr<facebook::react::CallInvoker> invoker =
+      std::make_shared<RunnerCallInvoker>();
+  return invoker;
+}
+
+} // namespace basalt

package/native/core/JsRuntimeAccess.h

@@ -0,0 +1,60 @@
+// Reaching the JavaScript thread from native code that is not a TurboModule.
+//
+// A TurboModule is handed a CallInvoker when it is constructed, which is how
+// every module here answers asynchronously: the drop listener, the key listener
+// and the file dialogs all capture `jsInvoker_` and call back through it. An
+// Expo module is not a TurboModule -- it is a plain jsi object installed into
+// `globalThis.expo.modules`, built by a function that is given a runtime and
+// nothing else (see ExpoModules.h) -- so it has no invoker to capture and no way
+// to emit an event or settle a promise later.
+//
+// Until now nothing needed one, because every Expo module here was synchronous
+// underneath and JsiPromise.h's already-settled promises were the honest answer.
+// The first module with a subprocess in it breaks that: output arrives on a
+// reader thread minutes after the call that started it returned.
+//
+// What the hosts have is `ReactHost::runOnRuntimeScheduler`, which is the same
+// door the reload path and the dev menu already go through. So each host leaves
+// it here as it starts, the way it leaves the event-listener installer in
+// UIManagerAccess.h, and core code that needs the JavaScript thread asks for it
+// by name rather than by owning a pointer to the host.
+//
+// **Asynchronous only.** `runOnRuntimeScheduler` posts; it cannot run work
+// inline and wait. `jsCallInvoker()` below is a CallInvoker over it, which makes
+// React Native's own AsyncPromise available to an Expo module, and its
+// `invokeSync` throws rather than pretending: a synchronous call from another
+// thread into a runtime that is busy is a deadlock, and the invoker that offers
+// it would be lying about what this door can do.
+
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+
+#include <jsi/jsi.h>
+
+#include <functional>
+#include <memory>
+
+namespace basalt {
+
+// Posts `work` to the JavaScript thread. Anything that touches a runtime from
+// another thread goes through here.
+using RuntimeRunner = std::function<void(std::function<void(facebook::jsi::Runtime &)>)>;
+
+// Called by each host once its ReactHost exists, and again with nullptr as it
+// shuts down -- work posted to a host that is going away must not run.
+void setRuntimeRunner(RuntimeRunner runner);
+
+// False when no host left one, which is every build that is not a host: the
+// tests and the portability probe. The caller's `work` is then never run, and a
+// caller that has something to report is the one that decides whether silence is
+// acceptable.
+bool runOnJsRuntime(std::function<void(facebook::jsi::Runtime &)> work);
+
+// The above as a CallInvoker, for React Native's bridging helpers -- chiefly
+// `AsyncPromise`, which is how a native call that finishes later hands back a
+// promise. One instance, shared; it holds nothing but the call to
+// runOnJsRuntime, so it stays valid across a reload that replaces the runner.
+std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker();
+
+} // namespace basalt

package/native/core/JsiPromise.h

@@ -0,0 +1,51 @@
+// Settled promises, built the only way a jsi host function can build one:
+// through JavaScript's own `Promise`.
+//
+// Every asynchronous native API on this platform is synchronous underneath --
+// reading the clipboard, registering a font, asking whether a URL can be opened
+// are all immediate calls. The JavaScript signatures are async because they are
+// async *somewhere*, usually on a platform where the work crosses a process
+// boundary. So the honest implementation is to do the work and hand back a
+// promise that is already settled, rather than to invent a thread.
+//
+// A header rather than a file because these are three lines each and the
+// alternative -- a fourth copy in the next module -- is how the first three
+// happened.
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <string>
+
+namespace basalt {
+
+// `Promise.resolve(value)`.
+inline facebook::jsi::Value resolved(facebook::jsi::Runtime &runtime,
+                                     facebook::jsi::Value &&value) {
+  return runtime.global()
+      .getPropertyAsObject(runtime, "Promise")
+      .getPropertyAsFunction(runtime, "resolve")
+      .call(runtime, std::move(value));
+}
+
+// `Promise.resolve()`, for a function whose result is that it finished.
+inline facebook::jsi::Value resolved(facebook::jsi::Runtime &runtime) {
+  return resolved(runtime, facebook::jsi::Value::undefined());
+}
+
+// `Promise.reject(new Error(message))`. An Error rather than a string: a
+// rejection reason that is not an Error loses its stack, and every JavaScript
+// caller assumes `error.message`.
+inline facebook::jsi::Value rejected(facebook::jsi::Runtime &runtime,
+                                     const std::string &message) {
+  facebook::jsi::Function error = runtime.global().getPropertyAsFunction(runtime, "Error");
+  facebook::jsi::Value reason =
+      error.callAsConstructor(runtime, facebook::jsi::String::createFromUtf8(runtime, message));
+  return runtime.global()
+      .getPropertyAsObject(runtime, "Promise")
+      .getPropertyAsFunction(runtime, "reject")
+      .call(runtime, std::move(reason));
+}
+
+} // namespace basalt

package/native/core/KeyEvents.cpp

@@ -0,0 +1,116 @@
+#include "KeyEvents.h"
+
+#include <mutex>
+#include <unordered_map>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+struct Registry {
+  std::mutex mutex;
+  std::unordered_map<facebook::react::Tag, std::vector<KeyCombination>> claims;
+  std::function<void(facebook::react::Tag, const KeyCombination &)> listener;
+};
+
+Registry &registry() {
+  static Registry shared;
+  return shared;
+}
+
+} // namespace
+
+void setHandledKeys(facebook::react::Tag tag, std::vector<KeyCombination> combinations) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  // Assigned, not merged. A re-render hands over the whole list, and merging
+  // would keep a shortcut alive after the app stopped declaring it -- which
+  // would look like the shortcut working and be a leak of behaviour.
+  state.claims[tag] = std::move(combinations);
+}
+
+void clearHandledKeys(facebook::react::Tag tag) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  state.claims.erase(tag);
+}
+
+bool handlesKey(facebook::react::Tag tag, const KeyCombination &pressed) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  const auto it = state.claims.find(tag);
+  if (it == state.claims.end()) {
+    return false;
+  }
+  for (const KeyCombination &claimed : it->second) {
+    if (claimed == pressed) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::optional<facebook::react::Tag> handledBy(
+    const std::vector<facebook::react::Tag> &path, const KeyCombination &pressed) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  if (state.claims.empty()) {
+    return std::nullopt;
+  }
+  // In order, which is innermost first: the caller walks outwards from the
+  // focused view, so the first claim found is the most specific one.
+  for (const facebook::react::Tag tag : path) {
+    const auto it = state.claims.find(tag);
+    if (it == state.claims.end()) {
+      continue;
+    }
+    for (const KeyCombination &claimed : it->second) {
+      if (claimed == pressed) {
+        return tag;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<facebook::react::Tag> handledByAny(const KeyCombination &pressed) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  for (const auto &[tag, combinations] : state.claims) {
+    for (const KeyCombination &claimed : combinations) {
+      if (claimed == pressed) {
+        return tag;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+std::size_t handledKeyViewCount() {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  return state.claims.size();
+}
+
+void setKeyListener(std::function<void(facebook::react::Tag, const KeyCombination &)> listener) {
+  Registry &state = registry();
+  const std::lock_guard<std::mutex> lock(state.mutex);
+  state.listener = std::move(listener);
+}
+
+void reportKey(facebook::react::Tag tag, const KeyCombination &pressed) {
+  std::function<void(facebook::react::Tag, const KeyCombination &)> listener;
+  {
+    Registry &state = registry();
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    listener = state.listener;
+  }
+  // Outside the lock, as core/DragAndDrop.cpp does and for the same reason: the
+  // listener reaches JavaScript, and holding a lock across that invites the
+  // deadlock where JavaScript re-enters to change its own claims.
+  if (listener) {
+    listener(tag, pressed);
+  }
+}
+
+} // namespace basalt