react-native-windows 0.78.6 → 0.79.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/css/CSSHexColor.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <optional>
+ #include <string_view>
+ 
+ #include <react/utils/toLower.h>
+ 
+ namespace facebook::react {
+ 
+ namespace detail {
+ enum class HexColorType {
+   Long,
+   Short,
+ };
+ 
+ constexpr uint8_t hexToNumeric(std::string_view hex, HexColorType hexType) {
+   int result = 0;
+   for (char c : hex) {
+     int value = 0;
+     if (c >= '0' && c <= '9') {
+       value = c - '0';
+     } else {
+       value = toLower(c) - 'a' + 10;
+     }
+     result *= 16;
+     result += value;
+   }
+ 
+   if (hexType == HexColorType::Short) {
+     return static_cast<uint8_t>(result * 16 + result); // Windows #14666
+   } else {
+     return static_cast<uint8_t>(result); // Windows #14666
+   }
+ }
+ 
+ constexpr bool isHexDigit(char c) {
+   return (c >= '0' && c <= '9') || (toLower(c) >= 'a' && toLower(c) <= 'f');
+ }
+ 
+ constexpr bool isValidHexColor(std::string_view hex) {
+   // The syntax of a <hex-color> is a <hash-token> token whose value consists
+   // of 3, 4, 6, or 8 hexadecimal digits.
+   if (hex.size() != 3 && hex.size() != 4 && hex.size() != 6 &&
+       hex.size() != 8) {
+     return false;
+   }
+ 
+   for (auto c : hex) {
+     if (!isHexDigit(c)) {
+       return false;
+     }
+   }
+ 
+   return true;
+ }
+ } // namespace detail
+ 
+ /**
+  * Parses a CSS <hex-color> value from hash token string value and returns a
+  * CSSColor if it is valid.
+  * https://www.w3.org/TR/css-color-4/#hex-color
+  */
+ template <typename CSSColor>
+ constexpr std::optional<CSSColor> parseCSSHexColor(
+     std::string_view hexColorValue) {
+   if (detail::isValidHexColor(hexColorValue)) {
+     if (hexColorValue.length() == 3) {
+       return CSSColor{
+           hexToNumeric(hexColorValue.substr(0, 1), detail::HexColorType::Short),
+           hexToNumeric(hexColorValue.substr(1, 1), detail::HexColorType::Short),
+           hexToNumeric(hexColorValue.substr(2, 1), detail::HexColorType::Short),
+           255u};
+     } else if (hexColorValue.length() == 4) {
+       return CSSColor{
+           hexToNumeric(hexColorValue.substr(0, 1), detail::HexColorType::Short),
+           hexToNumeric(hexColorValue.substr(1, 1), detail::HexColorType::Short),
+           hexToNumeric(hexColorValue.substr(2, 1), detail::HexColorType::Short),
+           hexToNumeric(
+               hexColorValue.substr(3, 1), detail::HexColorType::Short)};
+     } else if (hexColorValue.length() == 6) {
+       return CSSColor{
+           hexToNumeric(hexColorValue.substr(0, 2), detail::HexColorType::Long),
+           hexToNumeric(hexColorValue.substr(2, 2), detail::HexColorType::Long),
+           hexToNumeric(hexColorValue.substr(4, 2), detail::HexColorType::Long),
+           255u};
+     } else if (hexColorValue.length() == 8) {
+       return CSSColor{
+           hexToNumeric(hexColorValue.substr(0, 2), detail::HexColorType::Long),
+           hexToNumeric(hexColorValue.substr(2, 2), detail::HexColorType::Long),
+           hexToNumeric(hexColorValue.substr(4, 2), detail::HexColorType::Long),
+           hexToNumeric(hexColorValue.substr(6, 2), detail::HexColorType::Long)};
+     }
+   }
+   return {};
+ }
+ 
+ } // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/css/CSSTokenizer.h

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <cmath>
+#include <string_view>
+
+#include <react/renderer/css/CSSToken.h>
+
+namespace facebook::react {
+
+/**
+ * A minimal tokenizer for a subset of CSS syntax.
+ * `auto`).
+ *
+ * This is based on the W3C CSS Syntax specification, with simplifications made
+ * for syntax which React Native does not attempt to support.
+ * https://www.w3.org/TR/css-syntax-3/#tokenizing-and-parsing
+ */
+class CSSTokenizer {
+ public:
+  explicit constexpr CSSTokenizer(std::string_view characters)
+      : remainingCharacters_{characters} {}
+
+  /**
+   * Returns the next token according to the algorithm described in
+   * https://www.w3.org/TR/css-syntax-3/#consume-token
+   */
+  constexpr CSSToken next() {
+    char nextChar = peek();
+
+    if (isWhitespace(nextChar)) {
+      return consumeWhitespace();
+    }
+
+    switch (nextChar) {
+      case '(':
+        return consumeCharacter(CSSTokenType::OpenParen);
+      case ')':
+        return consumeCharacter(CSSTokenType::CloseParen);
+      case '[':
+        return consumeCharacter(CSSTokenType::OpenSquare);
+      case ']':
+        return consumeCharacter(CSSTokenType::CloseSquare);
+      case '{':
+        return consumeCharacter(CSSTokenType::OpenCurly);
+      case '}':
+        return consumeCharacter(CSSTokenType::CloseCurly);
+      case ',':
+        return consumeCharacter(CSSTokenType::Comma);
+      case '+':
+      case '-':
+      case '.':
+        if (wouldStartNumber()) {
+          return consumeNumeric();
+        } else {
+          return consumeDelim();
+        }
+      case '#':
+        if (isIdent(peek(1))) {
+          return consumeHash();
+        } else {
+          return consumeDelim();
+        }
+    }
+
+    if (isDigit(nextChar)) {
+      return consumeNumeric();
+    }
+
+    if (isIdentStart(nextChar)) {
+      return consumeIdentlikeToken();
+    }
+
+    if (nextChar == '\0') {
+      return CSSToken{CSSTokenType::EndOfFile};
+    }
+
+    return consumeDelim();
+  }
+
+ private:
+  constexpr char peek(size_t i = 0) const {
+    auto index = position_ + i;
+    return index >= remainingCharacters_.size() ? '\0'
+                                                : remainingCharacters_[index];
+  }
+
+  constexpr void advance() {
+    position_ += 1;
+  }
+
+  constexpr CSSToken consumeDelim() {
+    advance();
+    return {CSSTokenType::Delim, consumeRunningValue()};
+  }
+
+  constexpr CSSToken consumeCharacter(CSSTokenType tokenType) {
+    advance();
+    consumeRunningValue();
+    return CSSToken{tokenType};
+  }
+
+  constexpr CSSToken consumeWhitespace() {
+    while (isWhitespace(peek())) {
+      advance();
+    }
+
+    consumeRunningValue();
+    return CSSToken{CSSTokenType::WhiteSpace};
+  }
+
+  constexpr bool wouldStartNumber() const {
+    // https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+    if (peek() == '+' || peek() == '-') {
+      if (isDigit(peek(1))) {
+        return true;
+      }
+      if (peek(1) == '.' && isDigit(peek(2))) {
+        return true;
+      }
+    } else if (peek() == '.' && isDigit(peek(1))) {
+      return true;
+    } else if (isDigit(peek())) {
+      return true;
+    }
+
+    return false;
+  }
+
+  constexpr CSSToken consumeNumber() {
+    // https://www.w3.org/TR/css-syntax-3/#consume-number
+    // https://www.w3.org/TR/css-syntax-3/#convert-a-string-to-a-number
+    int32_t signPart = 1; // [Windows]
+    if (peek() == '+' || peek() == '-') {
+      if (peek() == '-') {
+        signPart = -1; // [Windows]
+      }
+      advance();
+    }
+
+    double intPart = 0;
+    while (isDigit(peek())) {
+      intPart = intPart * 10 + (peek() - '0');
+      advance();
+    }
+
+    double fractionalPart = 0;
+    int32_t fractionDigits = 0;
+    if (peek() == '.') {
+      advance();
+      while (isDigit(peek())) {
+        fractionalPart = fractionalPart * 10 + (peek() - '0');
+        fractionDigits++;
+        advance();
+      }
+    }
+
+    int32_t exponentSign = 1; // [Windows]
+    double exponentPart = 0;
+    if ((peek() == 'e' || peek() == 'E') &&
+        (isDigit(peek(1)) ||
+         ((peek(1) == '+' || peek(1) == '-') && isDigit(peek(2))))) {
+      advance();
+      if (peek() == '+' || peek() == '-') {
+        if (peek() == '-') {
+          exponentSign = -1; // [Windows]
+        }
+        advance();
+      }
+
+      while (isDigit(peek())) {
+        exponentPart = exponentPart * 10 + (peek() - '0');
+        advance();
+      }
+    }
+    float value;
+    if (exponentPart == 0 && fractionalPart == 0) {
+      value = static_cast<float>(signPart * intPart);
+    } else {
+      value = static_cast<float>(
+          signPart *
+          (intPart + (fractionalPart * std::pow(10, -fractionDigits))) *
+          std::pow(10, exponentSign * exponentPart));
+    }
+
+    consumeRunningValue();
+    return {CSSTokenType::Number, value};
+  }
+
+  constexpr CSSToken consumeNumeric() {
+    // https://www.w3.org/TR/css-syntax-3/#consume-numeric-token
+    auto numberToken = consumeNumber();
+
+    if (isIdent(peek())) {
+      auto ident = consumeIdentSequence();
+      return {
+          CSSTokenType::Dimension,
+          numberToken.numericValue(),
+          ident.stringValue()};
+    } else if (peek() == '%') {
+      advance();
+      consumeRunningValue();
+      return {CSSTokenType::Percentage, numberToken.numericValue()};
+    } else {
+      return numberToken;
+    }
+  }
+
+  constexpr CSSToken consumeIdentlikeToken() {
+    // https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
+    auto ident = consumeIdentSequence();
+    if (peek() == '(') {
+      advance();
+      consumeRunningValue();
+      return {CSSTokenType::Function, ident.stringValue()};
+    }
+
+    return ident;
+  }
+
+  constexpr CSSToken consumeIdentSequence() {
+    // https://www.w3.org/TR/css-syntax-3/#consume-an-ident-sequence
+    while (isIdent(peek())) {
+      advance();
+    }
+
+    return {CSSTokenType::Ident, consumeRunningValue()};
+  }
+
+  constexpr CSSToken consumeHash() {
+    // https://www.w3.org/TR/css-syntax-3/#consume-token (U+0023 NUMBER SIGN)
+    advance();
+    consumeRunningValue();
+
+    return {CSSTokenType::Hash, consumeIdentSequence().stringValue()};
+  }
+
+  constexpr std::string_view consumeRunningValue() {
+    auto next = remainingCharacters_.substr(0, position_);
+    remainingCharacters_ = remainingCharacters_.substr(next.size());
+    position_ = 0;
+    return next;
+  }
+
+  static constexpr bool isDigit(char c) {
+    // https://www.w3.org/TR/css-syntax-3/#digit
+    return c >= '0' && c <= '9';
+  }
+
+  static constexpr bool isIdentStart(char c) {
+    // https://www.w3.org/TR/css-syntax-3/#ident-start-code-point
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' ||
+        static_cast<unsigned char>(c) > 0x80;
+  }
+
+  static constexpr bool isIdent(char c) {
+    {
+      // https://www.w3.org/TR/css-syntax-3/#ident-code-point
+      return isIdentStart(c) || isDigit(c) || c == '-';
+    }
+  }
+
+  static constexpr bool isWhitespace(char c) {
+    // https://www.w3.org/TR/css-syntax-3/#whitespace
+    return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+  }
+
+  std::string_view remainingCharacters_;
+  size_t position_{0};
+};
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mounting/internal/CullingContext.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+ #include "CullingContext.h"
+ #include <react/featureflags/ReactNativeFeatureFlags.h>
+ #include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+ #include <react/renderer/core/LayoutableShadowNode.h>
+ #include "ShadowViewNodePair.h"
+ 
+ namespace facebook::react {
+ 
+ bool CullingContext::shouldConsiderCulling() const {
+   return frame.size.width > 0 && frame.size.height > 0;
+ }
+ 
+ CullingContext CullingContext::adjustCullingContextIfNeeded(
+     const ShadowViewNodePair& pair) const {
+   auto cullingContext = *this;
+   if (ReactNativeFeatureFlags::enableViewCulling()) {
+     if (auto scrollViewShadowNode =
+             static_cast<const ScrollViewShadowNode*>(pair.shadowNode)) { // Windows
+       cullingContext.frame.origin =
+           -scrollViewShadowNode->getContentOriginOffset(
+               /* includeTransform */ true);
+       cullingContext.frame.size =
+           scrollViewShadowNode->getLayoutMetrics().frame.size;
+       cullingContext.transform = Transform::Identity();
+     } else if (pair.shadowView.traits.check(
+                    ShadowNodeTraits::Trait::RootNodeKind)) {
+       cullingContext = {};
+     } else {
+       cullingContext.frame.origin -= pair.shadowView.layoutMetrics.frame.origin;
+ 
+       if (auto layoutableShadowNode =
+               static_cast<const LayoutableShadowNode*>(pair.shadowNode)) { // Windows
+         cullingContext.transform =
+             cullingContext.transform * layoutableShadowNode->getTransform();
+       }
+     }
+   }
+ 
+   return cullingContext;
+ }
+ } // namespace facebook::react
+ 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mounting/internal/sliceChildShadowNodeViewPairs.cpp

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+ #include "sliceChildShadowNodeViewPairs.h"
+ #include <react/featureflags/ReactNativeFeatureFlags.h>
+ #include <react/renderer/core/LayoutableShadowNode.h>
+ 
+ #include "ShadowViewNodePair.h"
+ 
+ namespace facebook::react {
+ 
+ /*
+  * Sorting comparator for `reorderInPlaceIfNeeded`.
+  */
+ static bool shouldFirstPairComesBeforeSecondOne(
+     const ShadowViewNodePair* lhs,
+     const ShadowViewNodePair* rhs) noexcept {
+   return lhs->shadowNode->getOrderIndex() < rhs->shadowNode->getOrderIndex();
+ }
+ 
+ /*
+  * Reorders pairs in-place based on `orderIndex` using a stable sort algorithm.
+  */
+ static void reorderInPlaceIfNeeded(
+     std::vector<ShadowViewNodePair*>& pairs) noexcept {
+   if (pairs.size() < 2) {
+     return;
+   }
+ 
+   auto isReorderNeeded = false;
+   for (const auto& pair : pairs) {
+     if (pair->shadowNode->getOrderIndex() != 0) {
+       isReorderNeeded = true;
+       break;
+     }
+   }
+ 
+   if (!isReorderNeeded) {
+     return;
+   }
+ 
+   std::stable_sort(
+       pairs.begin(), pairs.end(), &shouldFirstPairComesBeforeSecondOne);
+ }
+ 
+ static void sliceChildShadowNodeViewPairsRecursively(
+     std::vector<ShadowViewNodePair*>& pairList,
+     size_t& startOfStaticIndex,
+     ViewNodePairScope& scope,
+     Point layoutOffset,
+     const ShadowNode& shadowNode,
+     const CullingContext& cullingContext) {
+   for (const auto& sharedChildShadowNode : shadowNode.getChildren()) {
+     auto& childShadowNode = *sharedChildShadowNode;
+ #ifndef ANDROID
+     // T153547836: Disabled on Android because the mounting infrastructure
+     // is not fully ready yet.
+     if (childShadowNode.getTraits().check(ShadowNodeTraits::Trait::Hidden)) {
+       continue;
+     }
+ #endif
+     auto shadowView = ShadowView(childShadowNode);
+ 
+     if (ReactNativeFeatureFlags::enableViewCulling()) {
+       if (cullingContext.shouldConsiderCulling() &&
+           shadowView.layoutMetrics != EmptyLayoutMetrics) {
+         auto overflowInsetFrame =
+             shadowView.layoutMetrics.getOverflowInsetFrame() *
+             cullingContext.transform;
+         if (auto layoutableShadowNode =
+                 static_cast<const LayoutableShadowNode*>(&childShadowNode)) { // Windows
+           overflowInsetFrame =
+               overflowInsetFrame * layoutableShadowNode->getTransform();
+         }
+         auto doesIntersect =
+             Rect::intersect(cullingContext.frame, overflowInsetFrame) != Rect{};
+         if (!doesIntersect) {
+           continue; // Culling.
+         }
+       }
+     }
+ 
+     auto origin = layoutOffset;
+     auto cullingContextCopy = cullingContext.adjustCullingContextIfNeeded(
+         {.shadowView = shadowView, .shadowNode = &childShadowNode});
+ 
+     if (shadowView.layoutMetrics != EmptyLayoutMetrics) {
+       origin += shadowView.layoutMetrics.frame.origin;
+       shadowView.layoutMetrics.frame.origin += layoutOffset;
+     }
+ 
+     // This might not be a FormsView, or a FormsStackingContext. We let the
+     // differ handle removal of flattened views from the Mounting layer and
+     // shuffling their children around.
+     bool childrenFormStackingContexts = shadowNode.getTraits().check(
+         ShadowNodeTraits::Trait::ChildrenFormStackingContext);
+     bool isConcreteView = (childShadowNode.getTraits().check(
+                                ShadowNodeTraits::Trait::FormsView) ||
+                            childrenFormStackingContexts) &&
+         !childShadowNode.getTraits().check(
+             ShadowNodeTraits::Trait::ForceFlattenView);
+     bool areChildrenFlattened =
+         (!childShadowNode.getTraits().check(
+              ShadowNodeTraits::Trait::FormsStackingContext) &&
+          !childrenFormStackingContexts) ||
+         childShadowNode.getTraits().check(
+             ShadowNodeTraits::Trait::ForceFlattenView);
+ 
+     Point storedOrigin = {};
+     if (areChildrenFlattened) {
+       storedOrigin = origin;
+     }
+     scope.push_back(
+         {shadowView,
+          &childShadowNode,
+          areChildrenFlattened,
+          isConcreteView,
+          storedOrigin});
+ 
+     if (shadowView.layoutMetrics.positionType == PositionType::Static) {
+       auto it = pairList.begin();
+       std::advance(it, startOfStaticIndex);
+       pairList.insert(it, &scope.back());
+       startOfStaticIndex++;
+       if (areChildrenFlattened) {
+         sliceChildShadowNodeViewPairsRecursively(
+             pairList,
+             startOfStaticIndex,
+             scope,
+             origin,
+             childShadowNode,
+             cullingContextCopy);
+       }
+     } else {
+       pairList.push_back(&scope.back());
+       if (areChildrenFlattened) {
+         size_t pairListSize = pairList.size();
+         sliceChildShadowNodeViewPairsRecursively(
+             pairList,
+             pairListSize,
+             scope,
+             origin,
+             childShadowNode,
+             cullingContextCopy);
+       }
+     }
+   }
+ }
+ 
+ std::vector<ShadowViewNodePair*> sliceChildShadowNodeViewPairs(
+     const ShadowViewNodePair& shadowNodePair,
+     ViewNodePairScope& scope,
+     bool allowFlattened,
+     Point layoutOffset,
+     const CullingContext& cullingContext) {
+   const auto& shadowNode = *shadowNodePair.shadowNode;
+   auto pairList = std::vector<ShadowViewNodePair*>{};
+ 
+   if (shadowNodePair.flattened && shadowNodePair.isConcreteView &&
+       !allowFlattened) {
+     return pairList;
+   }
+ 
+   size_t startOfStaticIndex = 0;
+ 
+   sliceChildShadowNodeViewPairsRecursively(
+       pairList,
+       startOfStaticIndex,
+       scope,
+       layoutOffset,
+       shadowNode,
+       cullingContext);
+ 
+   // Sorting pairs based on `orderIndex` if needed.
+   reorderInPlaceIfNeeded(pairList);
+ 
+   // Set list and mountIndex for each after reordering
+   size_t mountIndex = 0;
+   for (auto child : pairList) {
+     child->mountIndex =
+         (child->isConcreteView ? mountIndex++ : static_cast<unsigned long>(-1));
+   }
+ 
+   return pairList;
+ }
+ 
+ } // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/ReactInstance.cpp

@@ -81,14 +81,6 @@ ReactInstance::ReactInstance(
             try {
               ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(true);
               callback(jsiRuntime);
-
-              // If we have first-class support for microtasks,
-              // they would've been called as part of the previous callback.
-              if (ReactNativeFeatureFlags::disableEventLoopOnBridgeless()) {
-                if (auto timerManager = weakTimerManager.lock()) {
-                  timerManager->callReactNativeMicrotasks(jsiRuntime);
-                }
-              }
             } catch (jsi::JSError& originalError) {
               jsErrorHandler->handleError(jsiRuntime, originalError, true);
             } catch (std::exception& ex) {