basalt-core 0.0.0-rc5 → 0.1.0

package/native/CMakeLists.txt

@@ -38,6 +38,14 @@ get_filename_component(BASALT_THIRD_PARTY "${BASALT_THIRD_PARTY}" ABSOLUTE)
 # it alongside its own tests and brings its own `main`; see docs/TESTING.md.
 set(BASALT_TEST_HARNESS ${CMAKE_CURRENT_SOURCE_DIR}/tests/TestHarness.cpp
     CACHE INTERNAL "the toolkit-free test runner")
+# What the harness calls and cannot define: a crashing test prints a stack
+# rather than a silent non-zero exit. It lives in basalt_core, which a suite
+# linking that target gets for free -- and the Windows view layer builds with
+# no React Native and therefore no basalt_core, so that build has to compile
+# this one file itself. Named here, beside the harness that needs it, rather
+# than spelled as a path in the package that happens to hit the problem.
+set(BASALT_CRASH_HANDLER ${CMAKE_CURRENT_SOURCE_DIR}/core/CrashHandler.cpp
+    CACHE INTERNAL "the crash handler the test harness installs")
 set(BASALT_TEST_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/tests
     CACHE INTERNAL "where TestHarness.h lives")
 
@@ -52,13 +60,35 @@ set(BASALT_CORE_TESTS
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_app_paths.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_animation.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_backface.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_gradients.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_label_registry.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_live_regions.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_filters.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_blend_modes.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_legacy_shadow.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_shadow_shape.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_background_layers.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_shadows.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_scaling.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_decorations.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_colors.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_variants.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_checking.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_drag_and_drop.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_quit_file.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_menu_entries.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_settle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_key_events.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_js_runtime_access.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_cache.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_animation.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_progress.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_device_metrics.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_app_state.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_system_locale.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_fitting.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_bounds.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_visible_position.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_indicator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_snap.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_window_close.cpp
@@ -71,6 +101,10 @@ set(BASALT_CORE_TESTS
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_hover.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_momentum.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_share.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_settings_store.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_action_sheet.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_alignment.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_selection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_sourcecode.cpp
     CACHE INTERNAL "core's own tests")
 
@@ -203,7 +237,12 @@ if(DEFINED RN_DIR)
     core/ImageCache.cpp
     core/ScrollBounds.cpp
     core/ScrollIndicator.cpp
+    core/AppStateHost.cpp
+    core/SystemLocale.cpp
+    core/DeviceMetrics.cpp
     core/ScrollSnap.cpp
+    # Keeping the content still while items are inserted above it.
+    core/ScrollVisiblePosition.cpp
     # `Appearance`, and the portable half of light-vs-dark.
     core/AppearanceModule.cpp
     # Blob, File and FileReader -- portable in full.
@@ -212,6 +251,8 @@ if(DEFINED RN_DIR)
     core/ColorScheme.cpp
     # Clipboard, Vibration, Alert, Linking, I18nManager, AccessibilityInfo --
     # the core modules ReactCxxPlatform does not provide.
+    # `ActionSheetIOS`, which is a popup menu here; see the header.
+    core/ActionSheet.cpp
     core/CoreModules.cpp
     # <ActivityIndicator>, <Switch>, <RefreshControl> and <Modal>: the props
     # three view layers have to read identically, plus the two shadow-node
@@ -229,6 +270,8 @@ if(DEFINED RN_DIR)
     core/DebuggingOverlay.cpp
     core/DevBundle.cpp
     core/ExpoImageComponent.cpp
+    core/SafeAreaComponent.cpp
+    core/ScreensComponent.cpp
     core/GestureHandlerModule.cpp
     core/Gestures.cpp
     # Hover: the pointer-event path React Native only has on Android.
@@ -251,9 +294,17 @@ if(DEFINED RN_DIR)
     core/ScrollMomentum.cpp
     # A share sheet for the desktops that have none; see the header.
     core/ShareFallback.cpp
+    # `Settings`, which is a file here rather than NSUserDefaults; see the header.
+    core/SettingsStore.cpp
+    # Which way a paragraph runs when the app did not say; see the header.
+    core/TextDirection.cpp
+    # What a press and a drag mean inside selectable text; see the header.
+    core/TextSelection.cpp
     core/SourceCodeModule.cpp
     # Answering a modal dialog without showing one; see the header.
     core/TestDialog.cpp
+    # What the host says when it dies, which was nothing; see the header.
+    core/CrashHandler.cpp
     # Quitting gracefully when the harness says so, rather than on a budget
     # fixed before launch; see the header.
     core/TestQuitFile.cpp

package/native/core/ActionSheet.cpp

@@ -0,0 +1,75 @@
+#include "ActionSheet.h"
+
+#include <algorithm>
+
+namespace basalt {
+
+namespace {
+
+MenuEntry disabledEntry(const std::string &label) {
+  // Assigned rather than a designated initializer, for the reason
+  // MenuEntry::separator() gives: a partial initializer list is an error under
+  // the -Werror the GTK build turns on.
+  MenuEntry entry;
+  entry.label = label;
+  entry.enabled = false;
+  return entry;
+}
+
+bool contains(const std::vector<int> &values, int value) {
+  return std::find(values.begin(), values.end(), value) != values.end();
+}
+
+} // namespace
+
+ActionSheetMenu actionSheetMenu(const ActionSheetRequest &request) {
+  ActionSheetMenu built;
+  built.menu.x = request.x;
+  built.menu.y = request.y;
+
+  if (!request.title.empty()) {
+    built.menu.entries.push_back(disabledEntry(request.title));
+  }
+  if (!request.message.empty()) {
+    built.menu.entries.push_back(disabledEntry(request.message));
+  }
+  if (!built.menu.entries.empty()) {
+    built.menu.entries.push_back(MenuEntry::separator());
+  }
+  built.offset = static_cast<int>(built.menu.entries.size());
+
+  for (size_t index = 0; index < request.options.size(); ++index) {
+    MenuEntry entry;
+    entry.label = request.options[index];
+    entry.enabled = !contains(request.disabledIndices, static_cast<int>(index));
+    built.menu.entries.push_back(entry);
+  }
+
+  return built;
+}
+
+std::optional<int> actionSheetChoice(const ActionSheetRequest &request,
+                                     const ActionSheetMenu &menu,
+                                     int chosen) {
+  const int count = static_cast<int>(request.options.size());
+
+  if (chosen < 0) {
+    // Dismissed. The cancel choice when the app named one, and otherwise
+    // nothing at all; see the header.
+    if (request.cancelIndex >= 0 && request.cancelIndex < count) {
+      return request.cancelIndex;
+    }
+    return std::nullopt;
+  }
+
+  const int option = chosen - menu.offset;
+  if (option < 0 || option >= count) {
+    // A header, or an index no entry of this menu has. Not reported: the app's
+    // callback takes an index into the array it passed, and there is nothing
+    // here to pass it.
+    return std::nullopt;
+  }
+  return option;
+}
+
+} // namespace basalt

package/native/core/ActionSheet.h

@@ -0,0 +1,90 @@
+// `ActionSheetIOS`, which on a desktop is a popup menu.
+//
+// `ActionSheetManager` is a `get` lookup, so its absence was not a crash: the
+// module came back null and `ActionSheetIOS.showActionSheetWithOptions` died on
+// `invariant(RCTActionSheetManager, "ActionSheetManager doesn't exist")` at the
+// first call. Unlike `Settings`, `Share` and `Alert`, there is no JavaScript to
+// replace -- `ActionSheetIOS.js` has no `Platform.OS` branch at all and calls
+// the module directly, which is why this is a module and nothing else. Worth
+// knowing that the two shapes exist: an iOS-named API is not automatically one
+// whose JavaScript refuses to run off iOS.
+//
+// ## A menu rather than a dialog
+//
+// An action sheet is a list of choices, one of which usually cancels, shown
+// because of something the person just did. On a desktop that is a popup menu,
+// and the alternative -- `presentAlert`, which this project already has -- loses
+// more than it gains: a dialog can show the sheet's `title` and `message`, and
+// it cannot show eight choices without looking like a mistake, cannot grey one
+// out, and cannot be dismissed with Escape the way a menu can.
+//
+// So it is `presentMenu`, and the title and message go in as disabled entries
+// at the top. That is a real desktop pattern and it moves the options down the
+// list, which is why `offset` below exists: JavaScript numbers the array it
+// passed, and a menu index counts every entry.
+//
+// ## What a desktop cannot do with it
+//
+// `destructiveButtonIndex` is accepted and ignored. None of the three can style
+// one item of a popup menu as dangerous: GTK's `destructive-action` is a button
+// class, `NSMenuItem` has no such style, and a Win32 menu item has no colour of
+// its own. `tintColor`, `cancelButtonTintColor`, `disabledButtonTintColor` and
+// `userInterfaceStyle` are iOS's own and are likewise ignored rather than
+// refused, so code written for iOS runs unchanged. `disabledButtonIndices` is
+// the one that *does* work, because a menu entry can be greyed.
+
+#pragma once
+
+#include "PlatformServices.h"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace basalt {
+
+// What the app asked for, read off the options object once.
+struct ActionSheetRequest {
+  std::string title;
+  std::string message;
+  std::vector<std::string> options;
+  // Indices into `options`, as `disabledButtonIndices` names them.
+  std::vector<int> disabledIndices;
+  // `cancelButtonIndex`, or -1 when the app named none. It is what a dismissal
+  // reports; see actionSheetChoice.
+  int cancelIndex{-1};
+  // Where the menu goes, in the window's coordinates. Negative means "wherever
+  // the pointer is", which is what MenuRequest means by it and what a sheet with
+  // no `anchor` wants.
+  double x{-1.0};
+  double y{-1.0};
+};
+
+// The popup menu an action sheet becomes, and how to read an answer back out.
+struct ActionSheetMenu {
+  MenuRequest menu;
+  // How many entries the title, the message and their separator took, which is
+  // the difference between a menu index and the option index an app knows.
+  int offset{0};
+};
+
+ActionSheetMenu actionSheetMenu(const ActionSheetRequest &request);
+
+// Which option to report for the menu index `chosen`, or nothing when the app's
+// callback should not be called at all.
+//
+// Nothing, rather than -1, because that is iOS's behaviour and it is load
+// bearing: `UIAlertController` invokes the callback from a button's handler, so
+// a sheet that goes away without a button being pressed calls nothing, and an
+// app that would otherwise act on "index -1" never has to.
+//
+// A dismissal is the one case where this platform answers something iOS does
+// not. Escape closing a menu is far more ordinary than an iPad popover being
+// tapped away, and an app that offered a cancel choice has already said what to
+// do with it -- so a dismissal reports `cancelIndex` when there is one, and
+// nothing when there is not.
+std::optional<int> actionSheetChoice(const ActionSheetRequest &request,
+                                    const ActionSheetMenu &menu,
+                                    int chosen);
+
+} // namespace basalt

package/native/core/AppStateHost.cpp

@@ -0,0 +1,76 @@
+#include "AppStateHost.h"
+
+#include <atomic>
+#include <mutex>
+
+namespace basalt {
+
+namespace {
+
+std::mutex &lock() {
+  static std::mutex value;
+  return value;
+}
+
+std::atomic<AppStateKind> &state() {
+  // Active, not unknown: a host that never reports has still put a window on
+  // the screen, and `AppState.currentState` is read before any event can
+  // arrive. React Native has an `unknown` for a platform that cannot tell, and
+  // all three of these can.
+  static std::atomic<AppStateKind> value{AppStateKind::Active};
+  return value;
+}
+
+std::function<void(AppStateKind)> &listener() {
+  static std::function<void(AppStateKind)> value;
+  return value;
+}
+
+} // namespace
+
+const char *appStateName(AppStateKind state) {
+  switch (state) {
+    case AppStateKind::Active:
+      return "active";
+    case AppStateKind::Inactive:
+      return "inactive";
+    case AppStateKind::Background:
+      return "background";
+  }
+  return "active";
+}
+
+AppStateKind appStateFor(bool focused, bool visible) {
+  if (!visible) {
+    return AppStateKind::Background;
+  }
+  return focused ? AppStateKind::Active : AppStateKind::Inactive;
+}
+
+void notifyAppState(AppStateKind next) {
+  std::function<void(AppStateKind)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    if (state().load(std::memory_order_relaxed) == next) {
+      return;
+    }
+    state().store(next, std::memory_order_relaxed);
+    toCall = listener();
+  }
+  // Outside the lock: it emits into the JavaScript runtime, and holding a lock
+  // across that is how a deadlock is built.
+  if (toCall) {
+    toCall(next);
+  }
+}
+
+AppStateKind currentAppState() {
+  return state().load(std::memory_order_relaxed);
+}
+
+void setAppStateListener(std::function<void(AppStateKind)> next) {
+  const std::lock_guard<std::mutex> guard(lock());
+  listener() = std::move(next);
+}
+
+} // namespace basalt

package/native/core/AppStateHost.h

@@ -0,0 +1,68 @@
+// `AppState`, which told every desktop app nothing at all.
+//
+// ReactCxxPlatform provides an `AppState` module and every method of it is
+// empty: `getConstants` answers `initialAppState: ""`, `getCurrentAppState`
+// calls neither of its callbacks, and `addListener` does nothing. There is a
+// `// TODO: T160890586 Wire up AppState implementation to use real data` where
+// the work would go. So `AppState.currentState` was the empty string -- not
+// `'active'`, not `'unknown'` -- and `AppState.addEventListener('change')`
+// never fired, on all three hosts.
+//
+// That is an API apps use for real work: pausing a poll while the app is not
+// in front, refetching when it comes back, saving a draft on the way out.
+//
+// ## What the three states mean on a desktop
+//
+// React Native's own are iOS's: `active`, `inactive` and `background`. A phone
+// has no focus and no windows, so the mapping has to be chosen, and it is the
+// one react-native-macos uses:
+//
+//   active      the application is frontmost
+//   inactive    it is running and visible, and something else has focus
+//   background  nothing of it is on screen: hidden, or every window minimised
+//
+// `inactive` on iOS is a transition -- a phone call arriving over the app --
+// and the desktop analogue is "another window is in front", which is the same
+// thing an app wants it for: do less, but stay ready.
+//
+// The mapping is here rather than in each host because all three decide it
+// from the same two facts, and only *how they learn them* differs: an
+// `is-active` notification on GTK, `NSApplicationDidBecomeActive` and its
+// siblings on AppKit, `WM_ACTIVATEAPP` on Windows.
+
+#pragma once
+
+#include <functional>
+
+namespace basalt {
+
+enum class AppStateKind {
+  Active,
+  Inactive,
+  Background,
+};
+
+// React Native's own spelling, which is what crosses into JavaScript.
+const char *appStateName(AppStateKind state);
+
+// The state those two facts mean. Invisible wins over focused: a minimised
+// window that somehow still holds focus is not something an app should treat
+// as frontmost.
+AppStateKind appStateFor(bool focused, bool visible);
+
+// Told by the host whenever either fact changes, on the UI thread. Stores the
+// result and calls the listener below, but only when it is different: React
+// Native's `AppState` re-emits whatever it is handed, and an app that refetches
+// on every `active` should not refetch because a window moved.
+void notifyAppState(AppStateKind state);
+
+// What was last reported, readable from any thread -- a TurboModule method runs
+// on the JavaScript thread. `Active` before a host has said anything, which is
+// what an application that has just started and drawn a window is.
+AppStateKind currentAppState();
+
+// The module's half. Replacing a listener drops the previous one; passing
+// nothing removes it, which is what the module's destructor does.
+void setAppStateListener(std::function<void(AppStateKind)> listener);
+
+} // namespace basalt