basalt-core 0.0.0-rc5 → 0.2.0

package/native/tests/test_text_selection.cpp

@@ -0,0 +1,168 @@
+// What a press and a drag mean inside selectable text.
+//
+// The selection itself is two integers and an ordering; what is worth asserting
+// is the arbitration, because that is where a wrong answer breaks something
+// else. A press that claimed immediately would stop a `<Pressable>` wrapping
+// the text from ever firing, and a press that never claimed would scroll the
+// list instead of selecting. Both are invisible in a screenshot.
+
+#include "TestHarness.h"
+
+#include "TextSelection.h"
+
+#include <sstream>
+#include <string>
+
+using basalt::TextSelection;
+using facebook::react::Point;
+
+namespace {
+
+// A paragraph's tag, for readability: the number itself means nothing.
+constexpr facebook::react::Tag kParagraph = 7;
+constexpr facebook::react::Tag kOtherParagraph = 9;
+
+} // namespace
+
+TEST(selection_a_press_selects_nothing) {
+  // The whole arbitration rests on this: a press is a tap until it moves, so
+  // nothing is selected and nothing is claimed.
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(!selection.dragging());
+  EXPECT(!selection.active());
+  EXPECT(selection.range().empty());
+  EXPECT_EQ((long)selection.tag(), 0L);
+}
+
+TEST(selection_a_small_move_is_still_a_tap) {
+  // A cursor delivers sub-pixel motion and a hand shakes. Claiming here would
+  // cancel a touch sequence that is still a press.
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(!selection.moveTo(5, Point{11, 10}));
+  EXPECT(!selection.moveTo(5, Point{10, 11.5}));
+  EXPECT(!selection.active());
+  EXPECT(selection.range().empty());
+}
+
+TEST(selection_a_move_past_the_threshold_claims_the_gesture_once) {
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+
+  // True the once: the caller cancels the touch sequence on this edge, and
+  // cancelling twice would be a second touchcancel for one gesture.
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  EXPECT(!selection.moveTo(12, Point{60, 10}));
+  EXPECT(!selection.moveTo(14, Point{80, 10}));
+
+  EXPECT(selection.dragging());
+  EXPECT(selection.active());
+  EXPECT_EQ((long)selection.tag(), (long)kParagraph);
+  EXPECT_EQ(selection.range().start, 4);
+  EXPECT_EQ(selection.range().length, 10);
+}
+
+TEST(selection_a_drag_backwards_selects_the_same_text) {
+  // Anchor and focus are where the gesture started and where it is now, in that
+  // order; a range is the two of them sorted. Reporting a negative length to a
+  // highlight would draw nothing and look like the feature was off.
+  TextSelection selection;
+  selection.press(kParagraph, 12, Point{80, 10});
+  EXPECT(selection.moveTo(4, Point{40, 10}));
+  EXPECT_EQ(selection.range().start, 4);
+  EXPECT_EQ(selection.range().length, 8);
+}
+
+TEST(selection_a_release_keeps_the_selection_and_ends_the_drag) {
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  selection.release();
+
+  // The highlight stays: a person lets go of the mouse and expects the text to
+  // stay selected until they click somewhere.
+  EXPECT(selection.active());
+  EXPECT_EQ(selection.range().length, 5);
+  // And moving afterwards does not extend it, the button being up.
+  EXPECT(!selection.dragging());
+  EXPECT(!selection.moveTo(20, Point{200, 10}));
+  EXPECT_EQ(selection.range().length, 5);
+}
+
+TEST(selection_a_tap_clears_what_was_selected) {
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  selection.release();
+  EXPECT(selection.active());
+
+  // On the press rather than the release: a highlight that survived the click
+  // meant to dismiss it until the button came up again would flicker.
+  selection.press(kParagraph, 2, Point{20, 10});
+  EXPECT(!selection.active());
+  EXPECT(selection.range().empty());
+}
+
+TEST(selection_a_press_outside_selectable_text_cannot_become_one) {
+  // Tag 0 is "nothing selectable here", which is what a host passes for a press
+  // on a view that is not a selectable paragraph. Every later move has to stay
+  // a touch, or dragging over a plain view would cancel its own press.
+  TextSelection selection;
+  selection.press(0, 0, Point{10, 10});
+  EXPECT(!selection.moveTo(5, Point{80, 10}));
+  EXPECT(!selection.dragging());
+  EXPECT(!selection.active());
+}
+
+TEST(selection_a_press_in_another_paragraph_moves_it) {
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  selection.release();
+
+  selection.press(kOtherParagraph, 1, Point{10, 100});
+  EXPECT(selection.moveTo(6, Point{50, 100}));
+  EXPECT_EQ((long)selection.tag(), (long)kOtherParagraph);
+  EXPECT_EQ(selection.range().start, 1);
+  EXPECT_EQ(selection.range().length, 5);
+}
+
+TEST(selection_a_drag_that_comes_back_to_where_it_started_selects_nothing) {
+  // Claimed and empty, which is a real state: the gesture is a selection -- the
+  // touch sequence was cancelled and cannot be un-cancelled -- and there is
+  // nothing to draw. A host asking `active()` gets false and draws nothing,
+  // which is what matters.
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  EXPECT(!selection.moveTo(4, Point{10, 10}));
+  EXPECT(selection.dragging());
+  EXPECT(!selection.active());
+  EXPECT(selection.range().empty());
+}
+
+TEST(selection_clearing_forgets_the_paragraph_as_well) {
+  // What a mutation calls when the text it was selecting is gone: an index into
+  // a paragraph that has been re-laid-out means nothing, and a highlight drawn
+  // from it would be in the wrong place rather than absent.
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(9, Point{40, 10}));
+  selection.clear();
+  EXPECT(!selection.active());
+  EXPECT(!selection.dragging());
+  EXPECT_EQ((long)selection.tag(), 0L);
+  EXPECT(selection.range().empty());
+}
+
+TEST(selection_a_vertical_drag_claims_too) {
+  // The threshold is a distance rather than a horizontal one: selecting from
+  // one line to the next is mostly vertical motion, and a sweep down a
+  // paragraph has to claim as readily as a sweep across one.
+  TextSelection selection;
+  selection.press(kParagraph, 4, Point{10, 10});
+  EXPECT(selection.moveTo(40, Point{10, 40}));
+  EXPECT(selection.active());
+  EXPECT_EQ(selection.range().length, 36);
+}

package/native/tests/test_text_shadows.cpp

@@ -0,0 +1,132 @@
+// The text shadow a paragraph draws. See core/TextShadows.h.
+//
+// The resolution is shared because the rule is a decision rather than a
+// reading: the props are per fragment and neither text engine can draw a
+// different shadow per run, so the first fragment that asks for one wins. A
+// host deciding that for itself would be a host deciding it differently.
+
+#include "TestHarness.h"
+
+#include "TextShadows.h"
+
+#include <sstream>
+#include <utility>
+#include <vector>
+
+using basalt::TextShadow;
+using basalt::textShadow;
+using facebook::react::AttributedString;
+using facebook::react::ColorComponents;
+using Fragment = facebook::react::AttributedString::Fragment;
+using facebook::react::TextAttributes;
+
+namespace {
+
+Fragment fragmentWith(const TextAttributes &attributes, const std::string &text = "x") {
+  Fragment fragment;
+  fragment.string = text;
+  fragment.textAttributes = attributes;
+  return fragment;
+}
+
+TextAttributes shadowed(float dx, float dy, float radius, float alpha) {
+  TextAttributes attributes;
+  attributes.textShadowOffset = facebook::react::Size{dx, dy};
+  attributes.textShadowRadius = radius;
+  attributes.textShadowColor =
+      facebook::react::colorFromComponents(ColorComponents{1.0F, 0.0F, 0.0F, alpha});
+  return attributes;
+}
+
+AttributedString stringOf(std::vector<Fragment> fragments) {
+  AttributedString string;
+  for (auto &fragment : fragments) {
+    // appendFragment takes an rvalue, which is how React Native's own callers
+    // build one.
+    string.appendFragment(std::move(fragment));
+  }
+  return string;
+}
+
+// Not `near`: that is a legacy macro from <minwindef.h>, which arrives
+// through AttributedString.h on Windows and turns the declaration below into
+// `bool (float, float)`. Every other core test that spells it `near` gets away
+// with it by not including that header.
+bool closeTo(float a, float b) { return std::fabs(a - b) < 0.001F; }
+
+} // namespace
+
+TEST(text_shadow_carries_its_offset_sigma_and_colour) {
+  const auto shadow = textShadow(stringOf({fragmentWith(shadowed(2.0F, 3.0F, 4.0F, 0.5F))}));
+  EXPECT(shadow.has_value());
+  if (!shadow.has_value()) {
+    return;
+  }
+  EXPECT(closeTo(shadow->dx, 2.0F));
+  EXPECT(closeTo(shadow->dy, 3.0F));
+  // The standard deviation as React Native gave it: iOS puts this straight into
+  // NSShadow's blur radius, so it is not CSS's radius and must not be halved or
+  // doubled here. Each host converts for its own call.
+  EXPECT(closeTo(shadow->standardDeviation, 4.0F));
+  EXPECT(closeTo(shadow->red, 1.0F));
+  // Within a byte: a colour is packed to eight bits a channel on the way in, so
+  // half alpha comes back as 128/255 rather than as 0.5 exactly.
+  EXPECT(std::fabs(shadow->alpha - 0.5F) < 0.01F);
+}
+
+// The first fragment that asks for one, which is the rule and the limit.
+TEST(text_shadow_is_the_first_fragments) {
+  TextAttributes plain;
+  const auto shadow = textShadow(stringOf({
+      fragmentWith(plain, "no shadow here"),
+      fragmentWith(shadowed(1.0F, 1.0F, 1.0F, 1.0F), "this one"),
+      fragmentWith(shadowed(9.0F, 9.0F, 9.0F, 1.0F), "not this one"),
+  }));
+  EXPECT(shadow.has_value());
+  EXPECT(shadow.has_value() && closeTo(shadow->dx, 1.0F));
+}
+
+// No colour is no shadow, which is React Native's default for every `<Text>`:
+// the props are three and the colour is the one that turns it on.
+TEST(text_shadow_needs_a_colour) {
+  TextAttributes noColour;
+  noColour.textShadowOffset = facebook::react::Size{2.0F, 2.0F};
+  noColour.textShadowRadius = 3.0F;
+  EXPECT(!textShadow(stringOf({fragmentWith(noColour)})).has_value());
+
+  // And a transparent colour is a shadow an app asked to be invisible.
+  EXPECT(!textShadow(stringOf({fragmentWith(shadowed(2.0F, 2.0F, 3.0F, 0.0F))})).has_value());
+}
+
+// A shadow with no offset and no blur is behind the glyphs and cannot be seen,
+// so it is skipped rather than drawn: both hosts pay for a shadow pass.
+TEST(text_shadow_with_no_offset_and_no_blur_is_nothing) {
+  EXPECT(!textShadow(stringOf({fragmentWith(shadowed(0.0F, 0.0F, 0.0F, 1.0F))})).has_value());
+  // A blur on its own is visible, though, and so is an offset on its own.
+  EXPECT(textShadow(stringOf({fragmentWith(shadowed(0.0F, 0.0F, 2.0F, 1.0F))})).has_value());
+  EXPECT(textShadow(stringOf({fragmentWith(shadowed(1.0F, 0.0F, 0.0F, 1.0F))})).has_value());
+}
+
+// `textShadowRadius` arrives as NaN when the style does not set it, which is how
+// React Native spells "not set" for a Float -- and NaN in a blur is a crash or a
+// blank paragraph depending on the renderer.
+TEST(text_shadow_an_unset_radius_is_zero_rather_than_nan) {
+  TextAttributes attributes;
+  attributes.textShadowOffset = facebook::react::Size{2.0F, 0.0F};
+  attributes.textShadowColor =
+      facebook::react::colorFromComponents(ColorComponents{0.0F, 0.0F, 0.0F, 1.0F});
+  // textShadowRadius is left at its default, which is quiet NaN.
+  const auto shadow = textShadow(stringOf({fragmentWith(attributes)}));
+  EXPECT(shadow.has_value());
+  EXPECT(shadow.has_value() && closeTo(shadow->standardDeviation, 0.0F));
+
+  // And a negative radius is clamped, which a stylesheet can ask for and a
+  // gaussian cannot take.
+  TextAttributes negative = shadowed(1.0F, 1.0F, -8.0F, 1.0F);
+  const auto clamped = textShadow(stringOf({fragmentWith(negative)}));
+  EXPECT(clamped.has_value() && closeTo(clamped->standardDeviation, 0.0F));
+}
+
+TEST(text_shadow_an_empty_string_has_none) {
+  EXPECT(!textShadow(AttributedString{}).has_value());
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "basalt-core",
-  "version": "0.0.0-rc5",
+  "version": "0.2.0",
   "description": "React Native on the desktop, over React Native's own C++ core rather than a fork. The shared half: the platform module, the Metro configuration that resolves it, the bundler, and the C++ that is not about a toolkit.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vincentvella/basalt-core.git",
+    "url": "git+https://github.com/vincentvella/basalt.git",
     "directory": "packages/basalt-core"
   },
+  "homepage": "https://basaltjs.dev",
   "main": "dist/src/index.js",
   "exports": {
     ".": "./dist/src/index.js",
@@ -33,6 +34,7 @@
   },
   "bin": {
     "basalt": "dist/cli/basalt.js",
+    "basalt-core": "dist/cli/basalt.js",
     "basalt-bundle": "dist/cli/bundle-cli.js"
   },
   "types": "dist/src/index.d.ts",