basalt-core 0.0.0-rc5 → 0.1.0

package/native/core/TextShadows.h

@@ -0,0 +1,96 @@
+// `textShadowColor`, `textShadowOffset` and `textShadowRadius`, resolved.
+//
+// Three props that every pre-CSS React Native title sets and that no host read.
+// They are `TextAttributes`, so they arrive per *fragment* -- per `<Text>` inside
+// a `<Text>` -- and neither text engine here can draw a different shadow per run:
+// GTK appends one `PangoLayout` to the snapshot, and AppKit draws lines with
+// `CTLineDraw`, which does not honour an `NSShadow` attribute the way AppKit's
+// own text drawing does. So one shadow is taken for the paragraph.
+//
+// ## Which fragment wins, and why that is written down
+//
+// The first fragment that asks for a shadow. That is the same rule
+// `borderStyle` follows for four sides that can only have one stroke, and it is
+// a limit rather than a reading of the spec: `<Text>` with a shadow holding a
+// `<Text>` with a different one draws the outer one twice. Recorded in
+// backlog/text.md rather than approximated, because the alternative -- drawing
+// each run separately -- costs the single-layout arrangement both hosts are
+// built on.
+//
+// ## The radius is a standard deviation, as iOS means it
+//
+// React Native's iOS half puts `textShadowRadius` into `NSShadow.shadowBlurRadius`,
+// which is the `CALayer.shadowRadius` kind of parameter: a gaussian standard
+// deviation rather than CSS's blur radius, which is twice one. So AppKit passes
+// it to `CGContextSetShadowWithColor` unchanged and GTK doubles it for
+// `GskShadow`, which takes CSS's. That is the same conversion, in the same
+// direction, as `filter: drop-shadow(...)`; see core/Filters.h.
+
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedString.h>
+
+#include <cmath>
+#include <optional>
+
+namespace basalt {
+
+// One text shadow, in the terms both hosts take: an offset, the gaussian's
+// standard deviation, and a straight sRGB colour.
+struct TextShadow {
+  float dx{0.0F};
+  float dy{0.0F};
+  float standardDeviation{0.0F};
+  float red{0.0F};
+  float green{0.0F};
+  float blue{0.0F};
+  float alpha{0.0F};
+};
+
+// The shadow a paragraph draws, or nothing.
+//
+// A shadow needs a colour with some alpha in it: React Native's default is no
+// colour at all, and a transparent one is a shadow an app asked to be invisible.
+// An offset of nothing and a radius of nothing is also nothing -- a shadow
+// exactly behind the glyphs with no blur cannot be seen -- which is worth
+// skipping rather than drawing, because both hosts pay for a shadow pass.
+inline std::optional<TextShadow> textShadow(
+    const facebook::react::AttributedString &attributedString) {
+  for (const auto &fragment : attributedString.getFragments()) {
+    const auto &attributes = fragment.textAttributes;
+    if (!attributes.textShadowColor) {
+      continue;
+    }
+    const auto components =
+        facebook::react::colorComponentsFromColor(attributes.textShadowColor);
+    if (components.alpha <= 0.0F) {
+      continue;
+    }
+
+    TextShadow shadow;
+    if (attributes.textShadowOffset.has_value()) {
+      shadow.dx = static_cast<float>(attributes.textShadowOffset->width);
+      shadow.dy = static_cast<float>(attributes.textShadowOffset->height);
+    }
+    // NaN is how React Native spells "not set" for a Float, so a radius that is
+    // not a number is zero rather than a crash in a blur.
+    if (!std::isnan(attributes.textShadowRadius)) {
+      shadow.standardDeviation = static_cast<float>(attributes.textShadowRadius);
+    }
+    if (shadow.standardDeviation < 0.0F) {
+      shadow.standardDeviation = 0.0F;
+    }
+    if (shadow.dx == 0.0F && shadow.dy == 0.0F && shadow.standardDeviation == 0.0F) {
+      continue;
+    }
+
+    shadow.red = components.red;
+    shadow.green = components.green;
+    shadow.blue = components.blue;
+    shadow.alpha = components.alpha;
+    return shadow;
+  }
+  return std::nullopt;
+}
+
+} // namespace basalt

package/native/core/TextVerticalAlign.h

@@ -0,0 +1,33 @@
+// Where a paragraph sits in a box taller than it is: the arithmetic half.
+//
+// Separate from `core/TextAlignments.h` for one reason, and it is the reason
+// `FocusRing.h` and `ControlMetrics.h` are separate too: this is needed by each
+// host's *widget* layer -- `RnView.cpp`, `RnTextLayout.mm`,
+// `RnWin32TextLayout.cpp` -- and that layer has no React Native in it and
+// cannot include a header that names `TextAlignmentVertical`. Each of those
+// three draws the paragraph, and the box it is drawing into is only known then:
+// a view resized without its props changing has new slack and the same text.
+//
+// So the enum lives in TextAlignments.h with the rest of the alignment
+// decisions, and the one line all three draw with lives here.
+
+#pragma once
+
+namespace basalt {
+
+// How far down to start drawing, given the box and what the text needs.
+//
+// Never negative: a paragraph taller than its box starts at the top, however it
+// was aligned, because the alternative is text pushed out through the top edge
+// where there is nothing to scroll it back. iOS and Android both do this, and a
+// `numberOfLines` paragraph is the case -- the box is the lines that fit and the
+// text is all of them.
+inline double textVerticalOffset(double boxHeight, double textHeight, double flush) {
+  const double slack = boxHeight - textHeight;
+  if (slack <= 0.0 || flush <= 0.0) {
+    return 0.0;
+  }
+  return slack * flush;
+}
+
+} // namespace basalt

package/native/core/UIManagerAccess.cpp

@@ -1,5 +1,9 @@
 #include "UIManagerAccess.h"
 
+#include <glog/logging.h>
+
+#include <mutex>
+
 namespace basalt {
 
 namespace {
@@ -19,6 +23,38 @@ std::shared_ptr<facebook::react::UIManager> sharedUIManager() {
   return held().lock();
 }
 
+bool reportMountedSurface(facebook::react::SurfaceId surfaceId) {
+  const auto uiManager = sharedUIManager();
+  if (!uiManager) {
+    return false;
+  }
+  // `visit` answers false without running the callback when the surface is not
+  // there, and says it is safe from any thread. See the header for why this
+  // question is the one that matters.
+  const bool registered = uiManager->getShadowTreeRegistry().visit(
+      surfaceId, [](const facebook::react::ShadowTree &) {});
+  if (!registered) {
+    // Every time, because this should be rare: it means a transaction was
+    // applied after its surface had gone, which is the race this guards. A run
+    // that logs this in quantity is saying the refusal is not rare, and a
+    // *healthy* run that logs it at all is saying the question is wrong.
+    LOG(WARNING) << "mount report refused: surface " << surfaceId
+                 << " is no longer registered";
+    return false;
+  }
+  // Once per process, so that a suite can tell "the guard is letting mounts
+  // through" from "the guard refuses everything". Refusing everything is the
+  // failure this has no other way of noticing: nothing asserts that a mount
+  // hook ran, so an over-eager refusal would stop Reanimated silently and leave
+  // every test green. See docs/backlog/testing.md.
+  static std::once_flag reported;
+  std::call_once(reported, [surfaceId] {
+    LOG(INFO) << "mount reported to the UIManager, surface " << surfaceId;
+  });
+  uiManager->reportMount(surfaceId);
+  return true;
+}
+
 namespace {
 
 EventListenerInstaller &installer() {

package/native/core/UIManagerAccess.h

@@ -24,6 +24,34 @@ namespace basalt {
 void setSharedUIManager(std::weak_ptr<facebook::react::UIManager> uiManager);
 std::shared_ptr<facebook::react::UIManager> sharedUIManager();
 
+// `reportMount`, but only for a surface the UIManager still has, which is a
+// workaround for an upstream use-after-free and not a tidying-up.
+//
+// `UIManager::mountHooks_` holds raw, non-owning pointers and unregistering is
+// the owner's job. `Scheduler` registers one and `~Scheduler` does not take it
+// out again, so from the moment `destroyReactInstance` writes
+// `scheduler_ = nullptr` the list contains a freed `EventPerformanceLogger` --
+// three statements before it tells a mounting manager anything, so the epoch
+// guard in MountingWalk.h cannot help. A mount draining on the main queue in
+// that gap used to walk the list and call a virtual method on freed memory.
+// See docs/backlog/testing.md.
+//
+// What makes a probe enough: `stopAllSurfaces()` runs *before* the Scheduler is
+// freed and takes the shadow trees out of the registry, so "the hook is
+// dangling" always implies "the surface has gone". Asking whether the surface is
+// still registered therefore refuses exactly the dangerous case, and the healthy
+// case is unaffected because a live surface is still in there. It also skips a
+// call that had nothing to report: with no root shadow node `reportMount` only
+// tells every hook the tree unmounted.
+//
+// Not airtight, and it is worth being clear about that. The surface could in
+// principle be stopped between the question and the call, which is a few
+// instructions rather than three statements of teardown. The fix is one line
+// upstream, in `~Scheduler`.
+//
+// Returns whether it reported.
+bool reportMountedSurface(facebook::react::SurfaceId surfaceId);
+
 // Watching every event Fabric dispatches.
 //
 // `Scheduler::addEventListener` is how a library sees events before the

package/native/core/WindowBoundsCache.cpp

@@ -166,22 +166,79 @@ WindowBounds lastKnownWindowBounds() {
   return cache();
 }
 
+namespace {
+
+std::function<void()> &dimensionsListener() {
+  static std::function<void()> value;
+  return value;
+}
+
+} // namespace
+
+namespace {
+
+// The main surface's size, which is the window minus whatever the desktop drew
+// around it. See the header.
+std::pair<double, double> &surfaceSize() {
+  static std::pair<double, double> value{0.0, 0.0};
+  return value;
+}
+
+} // namespace
+
+void notifySurfaceSize(double width, double height) {
+  std::function<void()> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    if (surfaceSize().first == width && surfaceSize().second == height) {
+      return;
+    }
+    surfaceSize() = {width, height};
+    toCall = dimensionsListener();
+  }
+  // Outside the lock, which emits into the runtime; see
+  // notifyWindowBoundsChanged below.
+  if (toCall) {
+    toCall();
+  }
+}
+
+void lastKnownSurfaceSize(double *outWidth, double *outHeight) {
+  const std::lock_guard<std::mutex> guard(lock());
+  if (outWidth != nullptr) {
+    *outWidth = surfaceSize().first;
+  }
+  if (outHeight != nullptr) {
+    *outHeight = surfaceSize().second;
+  }
+}
+
+void setDimensionsListener(std::function<void()> listener) {
+  const std::lock_guard<std::mutex> guard(lock());
+  dimensionsListener() = std::move(listener);
+}
+
 void notifyWindowBoundsChanged() {
   // Asked on the UI thread, which is where this is called from, and stored
   // where the JavaScript thread can read it.
   const WindowBounds bounds = windowBounds();
 
   std::function<void(const WindowBounds &)> toCall;
+  std::function<void()> toCallForDimensions;
   {
     const std::lock_guard<std::mutex> guard(lock());
     cache() = bounds;
     toCall = listener();
+    toCallForDimensions = dimensionsListener();
   }
-  // Called outside the lock: it emits a device event, and holding a lock across
+  // Called outside the lock: they emit device events, and holding a lock across
   // a call into the runtime is how a deadlock is built.
   if (toCall) {
     toCall(bounds);
   }
+  if (toCallForDimensions) {
+    toCallForDimensions();
+  }
 }
 
 // --- Windows closing themselves ----------------------------------------------

package/native/core/WindowControl.h

@@ -70,6 +70,30 @@ void setWindowFullScreen(bool fullScreen);
 // nothing removes it.
 void setWindowBoundsListener(std::function<void(const WindowBounds &)> listener);
 
+// How big the area React lays out in is, which is not the window's frame: a
+// title bar belongs to the window and not to the app.
+//
+// Reported by each host wherever it starts or re-constrains its *main* surface,
+// which is the one place that already knows this number -- and the number
+// `Dimensions.get('window')` should answer with, since it is what an app can
+// put something in. A second window and the error inspector have surfaces of
+// their own and are deliberately not reported: `Dimensions` is singular, and
+// the app's window is the one it means.
+void notifySurfaceSize(double width, double height);
+
+// The last size reported, or zeroes before the first surface starts. Readable
+// from any thread, like the bounds above and for the same reason.
+void lastKnownSurfaceSize(double *outWidth, double *outHeight);
+
+// A second slot on the same signal, for `Dimensions`.
+//
+// Two rather than one because the two listeners have different lifetimes and
+// neither owns the other: `useWindow()`'s module exists only in an app that
+// imports this package, and React Native's `DeviceInfo` module exists in every
+// app -- `Dimensions.js` requires it at import. A single slot would mean
+// whichever was constructed second silently took the other's events.
+void setDimensionsListener(std::function<void()> listener);
+
 // The host's half of that: called from wherever it already learns the window
 // moved or resized, on the UI thread. Also updates the cache below, so it is
 // worth calling once when the window is first shown even if nothing is

package/native/core/WritingDirections.h

@@ -0,0 +1,52 @@
+// `writingDirection`, as a name both hosts print.
+//
+// The prop decides which edge a paragraph starts from, and the two text engines
+// take it in their own terms: a Pango context's base direction, an
+// `NSParagraphStyle`'s `baseWritingDirection`. What is shared is only the word
+// the tree dump reports, which exists so the two dumps compare line by line.
+//
+// `natural` is printed rather than left out. Asking for the Unicode algorithm's
+// answer is not the same as saying nothing: a nested `<Text>` inherits the
+// enclosing paragraph's direction when nothing is said, and the algorithm's
+// answer when `natural` is.
+
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedString.h>
+
+#include <optional>
+
+namespace basalt {
+
+// The direction the paragraph asked for, from the first fragment that has one.
+// React Native resolves a paragraph's attributes onto every fragment in it, so
+// the first is the paragraph's; a nested `<Text>` with its own direction is a
+// limit this shares with the text shadow, and backlog/text.md records it.
+inline std::optional<facebook::react::WritingDirection> writingDirection(
+    const facebook::react::AttributedString &attributedString) {
+  for (const auto &fragment : attributedString.getFragments()) {
+    if (fragment.textAttributes.baseWritingDirection.has_value()) {
+      return fragment.textAttributes.baseWritingDirection;
+    }
+  }
+  return std::nullopt;
+}
+
+// Its name, or nullptr when the app asked for nothing.
+inline const char *writingDirectionName(
+    std::optional<facebook::react::WritingDirection> direction) {
+  if (!direction.has_value()) {
+    return nullptr;
+  }
+  switch (*direction) {
+    case facebook::react::WritingDirection::Natural:
+      return "natural";
+    case facebook::react::WritingDirection::LeftToRight:
+      return "ltr";
+    case facebook::react::WritingDirection::RightToLeft:
+      return "rtl";
+  }
+  return nullptr;
+}
+
+} // namespace basalt

package/native/core/portability_probe.cpp

@@ -109,6 +109,13 @@ void showMenu(const MenuRequest &, MenuCallback onChosen) {
     onChosen(-1);
   }
 }
+// And its roles. A platform that cannot show a menu performs nothing in one, so
+// every role is unsupported here and `entriesFrom` drops them all -- which is
+// the same answer this file gives everywhere: no, and in the right shape.
+bool menuRoleSupported(const std::string &) {
+  return false;
+}
+void performMenuRole(const std::string &) {}
 // Added when the gesture recognisers arrived: "run this on the UI thread", now
 // and later. A platform with a run loop has both already; this one has neither
 // and says so.

package/native/tests/RenamedFontFile.h

@@ -0,0 +1,161 @@
+// A font file the machine does not have, built from one it does.
+//
+// Shared by both suites' font tests, because both have the same problem. The
+// case `expo-font` exists for is a family the system has never heard of: an app
+// ships Inter, loads it at runtime, and `fontFamily: 'Inter'` has to start
+// working. A test that registers a font already in the system index proves the
+// name mapping and nothing else, because every layer underneath already knew
+// that family -- which is exactly how GTK's Pango-context reload and macOS's
+// real registration path came to have no test.
+//
+// So this takes a real font file and renames the family *inside* it, which is
+// the one thing that makes it new. The rename is done in place, one byte per
+// occurrence, so nothing in the file moves: a name record's length and every
+// offset after it stay valid, and no checksum has to be recomputed. The
+// replacement letter is applied to the family's first character wherever the
+// name table spells it, in ASCII and in the UTF-16BE that Windows-platform
+// name records use.
+//
+// Shipping a fixture font would be the other way to do this, and it would mean
+// a binary in the repository plus its licence, for a file that would still have
+// to be renamed to be sure the machine lacks it.
+
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace basalt::test {
+
+struct RenamedFont {
+  // Empty when the source could not be read or has no name table to patch, so
+  // a test can say so rather than assert on a file that was never written.
+  std::string path;
+  std::string family;
+};
+
+namespace detail {
+
+inline std::uint16_t beU16(const unsigned char *at) {
+  return static_cast<std::uint16_t>((at[0] << 8) | at[1]);
+}
+
+inline std::uint32_t beU32(const unsigned char *at) {
+  return (static_cast<std::uint32_t>(at[0]) << 24) | (static_cast<std::uint32_t>(at[1]) << 16) |
+      (static_cast<std::uint32_t>(at[2]) << 8) | static_cast<std::uint32_t>(at[3]);
+}
+
+// Replaces one byte in every occurrence of `needle` between `from` and `to`.
+// `at` picks which byte of the match, which is 0 for ASCII and 1 for UTF-16BE,
+// where the high byte of a Latin letter is zero.
+inline int patchOccurrences(std::vector<unsigned char> &bytes,
+                            std::size_t from,
+                            std::size_t to,
+                            const std::vector<unsigned char> &needle,
+                            std::size_t at,
+                            unsigned char replacement) {
+  if (needle.empty() || to > bytes.size() || from >= to) {
+    return 0;
+  }
+  int patched = 0;
+  for (std::size_t i = from; i + needle.size() <= to; i++) {
+    bool same = true;
+    for (std::size_t j = 0; j < needle.size(); j++) {
+      if (bytes[i + j] != needle[j]) {
+        same = false;
+        break;
+      }
+    }
+    if (same) {
+      bytes[i + at] = replacement;
+      patched++;
+      i += needle.size() - 1;
+    }
+  }
+  return patched;
+}
+
+} // namespace detail
+
+// Writes `source` to `destination` with `family`'s first letter replaced by
+// `replacement` wherever the name table spells it, and answers with the new
+// family name. `family` is the name the file calls itself, which is what the
+// platform's own registry reads back.
+inline RenamedFont renameFontFile(const std::string &source,
+                                  const std::string &family,
+                                  const std::string &destination,
+                                  char replacement = 'Q') {
+  if (family.empty() || family[0] == replacement) {
+    return {};
+  }
+
+  std::FILE *in = std::fopen(source.c_str(), "rb");
+  if (in == nullptr) {
+    return {};
+  }
+  std::vector<unsigned char> bytes;
+  unsigned char chunk[16384];
+  while (const std::size_t read = std::fread(chunk, 1, sizeof(chunk), in)) {
+    bytes.insert(bytes.end(), chunk, chunk + read);
+  }
+  std::fclose(in);
+
+  // A collection holds several fonts and starts with its own header; the table
+  // directory is not where this expects it, so say no rather than patch bytes
+  // at a guess.
+  if (bytes.size() < 12 || detail::beU32(bytes.data()) == 0x74746366 /* 'ttcf' */) {
+    return {};
+  }
+
+  const std::uint16_t tables = detail::beU16(bytes.data() + 4);
+  std::size_t nameAt = 0;
+  std::size_t nameLength = 0;
+  for (std::uint16_t i = 0; i < tables; i++) {
+    const std::size_t record = 12 + std::size_t{16} * i;
+    if (record + 16 > bytes.size()) {
+      return {};
+    }
+    if (detail::beU32(bytes.data() + record) == 0x6E616D65 /* 'name' */) {
+      nameAt = detail::beU32(bytes.data() + record + 8);
+      nameLength = detail::beU32(bytes.data() + record + 12);
+      break;
+    }
+  }
+  if (nameAt == 0 || nameLength == 0 || nameAt + nameLength > bytes.size()) {
+    return {};
+  }
+
+  const std::vector<unsigned char> ascii(family.begin(), family.end());
+  std::vector<unsigned char> utf16;
+  utf16.reserve(family.size() * 2);
+  for (const char character : family) {
+    utf16.push_back(0);
+    utf16.push_back(static_cast<unsigned char>(character));
+  }
+
+  int patched = detail::patchOccurrences(bytes, nameAt, nameAt + nameLength, ascii, 0,
+                                         static_cast<unsigned char>(replacement));
+  patched += detail::patchOccurrences(bytes, nameAt, nameAt + nameLength, utf16, 1,
+                                      static_cast<unsigned char>(replacement));
+  if (patched == 0) {
+    return {};
+  }
+
+  std::FILE *out = std::fopen(destination.c_str(), "wb");
+  if (out == nullptr) {
+    return {};
+  }
+  const std::size_t written = std::fwrite(bytes.data(), 1, bytes.size(), out);
+  std::fclose(out);
+  if (written != bytes.size()) {
+    return {};
+  }
+
+  std::string renamed = family;
+  renamed[0] = replacement;
+  return RenamedFont{destination, renamed};
+}
+
+} // namespace basalt::test

package/native/tests/TestHarness.cpp

@@ -6,8 +6,11 @@
 
 #include "TestHarness.h"
 
+#include "CrashHandler.h"
+
 #include <algorithm>
 #include <cctype>
+#include <iostream>
 #include <sstream>
 
 namespace basalt::testing {
@@ -47,6 +50,21 @@ std::string lowered(std::string text) {
 } // namespace
 
 int runAllTests(int argc, char **argv) {
+  // Unbuffered, and this is not a style choice. `basalt_appkit_tests`
+  // segfaulted on CI's Mac and the log said only "Segmentation fault: 11": not
+  // one test name, because stdout to a pipe is block-buffered and the buffer
+  // dies with the process. On a developer's machine it is a terminal and
+  // line-buffered, so the same crash would have named the test.
+  //
+  // A unit suite that cannot say where it died is a suite that costs a CI round
+  // trip per guess, which is what this cost.
+  std::cout << std::unitbuf;
+
+  // And the handler from core/CrashHandler.h, for the half a flush cannot give:
+  // which frame faulted. The hosts install it at startup and the suites did
+  // not, so a crash in a *test* said less than a crash in an app.
+  basalt::installCrashHandler();
+
   // Arguments are substrings of test names, and a test runs if it matches any
   // of them. There is a lot of the day in the difference between running one
   // test and running all of them, and this runner used to accept an argument