react-native 0.0.0-16bb2ae4f → 0.0.0-18697adec

package/ReactCommon/react/renderer/animations/primitives.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/animations/LayoutAnimationCallbackWrapper.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+#include <vector>
+
+namespace facebook {
+namespace react {
+
+// This corresponds exactly with JS.
+enum class AnimationType {
+  None = 0,
+  Spring = 1,
+  Linear = 2,
+  EaseInEaseOut = 4,
+  EaseIn = 8,
+  EaseOut = 16,
+  Keyboard = 32
+};
+
+enum class AnimationProperty {
+  NotApplicable = 0,
+  Opacity = 1,
+  ScaleX = 2,
+  ScaleY = 4,
+  ScaleXY = 8
+};
+
+// This corresponds exactly with JS.
+struct AnimationConfig {
+  AnimationType animationType = AnimationType::None;
+  AnimationProperty animationProperty = AnimationProperty::NotApplicable;
+  double duration =
+      0; // these are perhaps better represented as uint64_t, but they
+  // come from JS as doubles
+  double delay = 0;
+  double springDamping = 0;
+  double initialVelocity = 0;
+};
+
+// This corresponds exactly with JS.
+struct LayoutAnimationConfig {
+  double duration; // ms
+  AnimationConfig createConfig;
+  AnimationConfig updateConfig;
+  AnimationConfig deleteConfig;
+};
+
+enum class AnimationConfigurationType { Create = 1, Update = 2, Delete = 4 };
+
+struct AnimationKeyFrame {
+  // The mutation(s) that should be executed once the animation completes.
+  // This maybe empty.
+  // For CREATE/INSERT this will contain CREATE, INSERT in that order.
+  // For REMOVE/DELETE, same.
+  std::vector<ShadowViewMutation> finalMutationsForKeyFrame;
+
+  // The type of animation this is (for configuration purposes)
+  AnimationConfigurationType type;
+
+  // Tag representing the node being animated.
+  Tag tag;
+
+  ShadowView parentView;
+
+  // ShadowView representing the start and end points of this animation.
+  ShadowView viewStart;
+  ShadowView viewEnd;
+
+  // ShadowView representing the previous frame of the animation.
+  ShadowView viewPrev;
+
+  // If an animation interrupts an existing one, the starting state may actually
+  // be halfway through the intended transition.
+  double initialProgress;
+
+  bool invalidated{false};
+
+  // In the case where some mutation conflicts with this keyframe,
+  // should we generate final synthetic UPDATE mutations for this keyframe?
+  bool generateFinalSyntheticMutations{true};
+};
+
+struct LayoutAnimation {
+  SurfaceId surfaceId;
+  uint64_t startTime;
+  bool completed = false;
+  LayoutAnimationConfig layoutAnimationConfig;
+  LayoutAnimationCallbackWrapper successCallback;
+  LayoutAnimationCallbackWrapper failureCallback;
+  std::vector<AnimationKeyFrame> keyFrames;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/animations/tests/LayoutAnimationTest.cpp

@@ -10,17 +10,17 @@
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
+#include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProvider.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
-
-#include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
-#include <react/renderer/mounting/stubs.h>
 
+#include <react/renderer/mounting/stubs.h>
 #include <react/test_utils/Entropy.h>
 #include <react/test_utils/MockClock.h>
 #include <react/test_utils/shadowTreeGeneration.h>
@@ -51,7 +51,7 @@ static void testShadowNodeTreeLifeCycleLayoutAnimations(
   auto entropy = seed == 0 ? Entropy() : Entropy(seed);
 
   auto eventDispatcher = EventDispatcher::Shared{};
-  auto contextContainer = std::make_shared<ContextContainer>();
+  auto contextContainer = std::make_shared<ContextContainer const>();
   auto componentDescriptorParameters =
       ComponentDescriptorParameters{eventDispatcher, contextContainer, nullptr};
   auto viewComponentDescriptor =
@@ -61,6 +61,8 @@ static void testShadowNodeTreeLifeCycleLayoutAnimations(
   auto noopEventEmitter =
       std::make_shared<ViewEventEmitter const>(nullptr, -1, eventDispatcher);
 
+  PropsParserContext parserContext{-1, *contextContainer};
+
   // Create a RuntimeExecutor
   RuntimeExecutor runtimeExecutor =
       [](std::function<void(jsi::Runtime & runtime)> fn) {};
@@ -75,8 +77,8 @@ static void testShadowNodeTreeLifeCycleLayoutAnimations(
       concreteComponentDescriptorProvider<ViewComponentDescriptor>());
 
   // Create Animation Driver
-  auto animationDriver =
-      std::make_shared<LayoutAnimationDriver>(runtimeExecutor, nullptr);
+  auto animationDriver = std::make_shared<LayoutAnimationDriver>(
+      runtimeExecutor, contextContainer, nullptr);
   animationDriver->setComponentDescriptorRegistry(componentDescriptorRegistry);
 
   // Mock animation timers
@@ -106,6 +108,7 @@ static void testShadowNodeTreeLifeCycleLayoutAnimations(
 
     // Applying size constraints.
     emptyRootNode = emptyRootNode->clone(
+        parserContext,
         LayoutConstraints{
             Size{512, 0}, Size{512, std::numeric_limits<Float>::infinity()}},
         LayoutContext{});

package/ReactCommon/react/renderer/animations/utils.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "utils.h"
+#include <math.h>
+
+namespace facebook {
+namespace react {
+
+std::pair<double, double> calculateAnimationProgress(
+    uint64_t now,
+    LayoutAnimation const &animation,
+    AnimationConfig const &mutationConfig) {
+  if (mutationConfig.animationType == AnimationType::None) {
+    return {1, 1};
+  }
+
+  uint64_t startTime = animation.startTime;
+  uint64_t delay = mutationConfig.delay;
+  uint64_t endTime = startTime + delay + mutationConfig.duration;
+
+  if (now >= endTime) {
+    return {1, 1};
+  }
+  if (now < startTime + delay) {
+    return {0, 0};
+  }
+
+  double linearTimeProgression = 1 -
+      (double)(endTime - delay - now) / (double)(endTime - animation.startTime);
+
+  if (mutationConfig.animationType == AnimationType::Linear) {
+    return {linearTimeProgression, linearTimeProgression};
+  } else if (mutationConfig.animationType == AnimationType::EaseIn) {
+    // This is an accelerator-style interpolator.
+    // In the future, this parameter (2.0) could be adjusted. This has been the
+    // default for Classic RN forever.
+    return {linearTimeProgression, pow(linearTimeProgression, 2.0)};
+  } else if (mutationConfig.animationType == AnimationType::EaseOut) {
+    // This is an decelerator-style interpolator.
+    // In the future, this parameter (2.0) could be adjusted. This has been the
+    // default for Classic RN forever.
+    return {linearTimeProgression, 1.0 - pow(1 - linearTimeProgression, 2.0)};
+  } else if (mutationConfig.animationType == AnimationType::EaseInEaseOut) {
+    // This is a combination of accelerate+decelerate.
+    // The animation starts and ends slowly, and speeds up in the middle.
+    return {
+        linearTimeProgression,
+        cos((linearTimeProgression + 1.0) * M_PI) / 2 + 0.5};
+  } else if (mutationConfig.animationType == AnimationType::Spring) {
+    // Using mSpringDamping in this equation is not really the exact
+    // mathematical springDamping, but a good approximation We need to replace
+    // this equation with the right Factor that accounts for damping and
+    // friction
+    double damping = mutationConfig.springDamping;
+    return {
+        linearTimeProgression,
+        (1 +
+         pow(2, -10 * linearTimeProgression) *
+             sin((linearTimeProgression - damping / 4) * M_PI * 2 / damping))};
+  } else {
+    return {linearTimeProgression, linearTimeProgression};
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/animations/utils.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/animations/primitives.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+
+namespace facebook {
+namespace react {
+
+static inline bool shouldFirstComeBeforeSecondRemovesOnly(
+    ShadowViewMutation const &lhs,
+    ShadowViewMutation const &rhs) noexcept {
+  // Make sure that removes on the same level are sorted - highest indices must
+  // come first.
+  return (lhs.type == ShadowViewMutation::Type::Remove &&
+          lhs.type == rhs.type) &&
+      (lhs.parentShadowView.tag == rhs.parentShadowView.tag) &&
+      (lhs.index > rhs.index);
+}
+
+static inline bool shouldFirstComeBeforeSecondMutation(
+    ShadowViewMutation const &lhs,
+    ShadowViewMutation const &rhs) noexcept {
+  if (lhs.type != rhs.type) {
+    // Deletes always come last
+    if (lhs.type == ShadowViewMutation::Type::Delete) {
+      return false;
+    }
+    if (rhs.type == ShadowViewMutation::Type::Delete) {
+      return true;
+    }
+
+    // Remove comes before insert
+    if (lhs.type == ShadowViewMutation::Type::Remove &&
+        rhs.type == ShadowViewMutation::Type::Insert) {
+      return true;
+    }
+    if (rhs.type == ShadowViewMutation::Type::Remove &&
+        lhs.type == ShadowViewMutation::Type::Insert) {
+      return false;
+    }
+
+    // Create comes before insert
+    if (lhs.type == ShadowViewMutation::Type::Create &&
+        rhs.type == ShadowViewMutation::Type::Insert) {
+      return true;
+    }
+    if (rhs.type == ShadowViewMutation::Type::Create &&
+        lhs.type == ShadowViewMutation::Type::Insert) {
+      return false;
+    }
+  } else {
+    // Make sure that removes on the same level are sorted - highest indices
+    // must come first.
+    if (lhs.type == ShadowViewMutation::Type::Remove &&
+        lhs.parentShadowView.tag == rhs.parentShadowView.tag) {
+      if (lhs.index > rhs.index) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  return false;
+}
+
+std::pair<double, double> calculateAnimationProgress(
+    uint64_t now,
+    LayoutAnimation const &animation,
+    AnimationConfig const &mutationConfig);
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/attributedstring/AttributedString.h

@@ -11,7 +11,6 @@
 #include <memory>
 
 #include <folly/Hash.h>
-#include <folly/Optional.h>
 #include <react/renderer/attributedstring/TextAttributes.h>
 #include <react/renderer/core/Sealable.h>
 #include <react/renderer/core/ShadowNode.h>

package/ReactCommon/react/renderer/attributedstring/ParagraphAttributes.cpp

@@ -21,13 +21,15 @@ bool ParagraphAttributes::operator==(const ParagraphAttributes &rhs) const {
              ellipsizeMode,
              textBreakStrategy,
              adjustsFontSizeToFit,
-             includeFontPadding) ==
+             includeFontPadding,
+             android_hyphenationFrequency) ==
       std::tie(
              rhs.maximumNumberOfLines,
              rhs.ellipsizeMode,
              rhs.textBreakStrategy,
              rhs.adjustsFontSizeToFit,
-             rhs.includeFontPadding) &&
+             rhs.includeFontPadding,
+             rhs.android_hyphenationFrequency) &&
       floatEquality(minimumFontSize, rhs.minimumFontSize) &&
       floatEquality(maximumFontSize, rhs.maximumFontSize);
 }
@@ -47,7 +49,9 @@ SharedDebugStringConvertibleList ParagraphAttributes::getDebugProps() const {
       debugStringConvertibleItem("adjustsFontSizeToFit", adjustsFontSizeToFit),
       debugStringConvertibleItem("minimumFontSize", minimumFontSize),
       debugStringConvertibleItem("maximumFontSize", maximumFontSize),
-      debugStringConvertibleItem("includeFontPadding", includeFontPadding)};
+      debugStringConvertibleItem("includeFontPadding", includeFontPadding),
+      debugStringConvertibleItem(
+          "android_hyphenationFrequency", android_hyphenationFrequency)};
 }
 #endif
 

package/ReactCommon/react/renderer/attributedstring/ParagraphAttributes.h

@@ -42,7 +42,10 @@ class ParagraphAttributes : public DebugStringConvertible {
    */
   EllipsizeMode ellipsizeMode{};
 
-  TextBreakStrategy textBreakStrategy{};
+  /*
+   * (Android only) Break strategy for breaking paragraphs into lines.
+   */
+  TextBreakStrategy textBreakStrategy{TextBreakStrategy::HighQuality};
 
   /*
    * Enables font size adjustment to fit constrained boundaries.
@@ -55,6 +58,12 @@ class ParagraphAttributes : public DebugStringConvertible {
    */
   bool includeFontPadding{true};
 
+  /*
+   * (Android only) Frequency of automatic hyphenation to use when determining
+   * word breaks.
+   */
+  HyphenationFrequency android_hyphenationFrequency{};
+
   /*
    * In case of font size adjustment enabled, defines minimum and maximum
    * font sizes.
@@ -89,7 +98,8 @@ struct hash<facebook::react::ParagraphAttributes> {
         attributes.adjustsFontSizeToFit,
         attributes.minimumFontSize,
         attributes.maximumFontSize,
-        attributes.includeFontPadding);
+        attributes.includeFontPadding,
+        attributes.android_hyphenationFrequency);
   }
 };
 } // namespace std

package/ReactCommon/react/renderer/attributedstring/TextAttributes.cpp

@@ -50,6 +50,9 @@ void TextAttributes::apply(TextAttributes textAttributes) {
   letterSpacing = !std::isnan(textAttributes.letterSpacing)
       ? textAttributes.letterSpacing
       : letterSpacing;
+  textTransform = textAttributes.textTransform.hasValue()
+      ? textAttributes.textTransform
+      : textTransform;
 
   // Paragraph Styles
   lineHeight = !std::isnan(textAttributes.lineHeight)
@@ -120,7 +123,8 @@ bool TextAttributes::operator==(const TextAttributes &rhs) const {
              textShadowColor,
              isHighlighted,
              layoutDirection,
-             accessibilityRole) ==
+             accessibilityRole,
+             textTransform) ==
       std::tie(
              rhs.foregroundColor,
              rhs.backgroundColor,
@@ -139,7 +143,8 @@ bool TextAttributes::operator==(const TextAttributes &rhs) const {
              rhs.textShadowColor,
              rhs.isHighlighted,
              rhs.layoutDirection,
-             rhs.accessibilityRole) &&
+             rhs.accessibilityRole,
+             rhs.textTransform) &&
       floatEquality(opacity, rhs.opacity) &&
       floatEquality(fontSize, rhs.fontSize) &&
       floatEquality(fontSizeMultiplier, rhs.fontSizeMultiplier) &&

package/ReactCommon/react/renderer/attributedstring/TextAttributes.h

@@ -10,8 +10,8 @@
 #include <functional>
 #include <limits>
 
+#include <better/optional.h>
 #include <folly/Hash.h>
-#include <folly/Optional.h>
 #include <react/renderer/attributedstring/primitives.h>
 #include <react/renderer/core/LayoutPrimitives.h>
 #include <react/renderer/core/ReactPrimitives.h>
@@ -51,6 +51,7 @@ class TextAttributes : public DebugStringConvertible {
   better::optional<FontVariant> fontVariant{};
   better::optional<bool> allowFontScaling{};
   Float letterSpacing{std::numeric_limits<Float>::quiet_NaN()};
+  better::optional<TextTransform> textTransform{};
 
   // Paragraph Styles
   Float lineHeight{std::numeric_limits<Float>::quiet_NaN()};
@@ -117,6 +118,7 @@ struct hash<facebook::react::TextAttributes> {
         textAttributes.fontVariant,
         textAttributes.allowFontScaling,
         textAttributes.letterSpacing,
+        textAttributes.textTransform,
         textAttributes.lineHeight,
         textAttributes.alignment,
         textAttributes.baseWritingDirection,