react-native-windows 0.68.1 → 0.69.0-preview.1

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputProps.cpp

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "WindowsTextInputProps.h"
+
+namespace facebook::react {
+
+static bool
+hasValue(const RawProps &rawProps, bool defaultValue, const char *name, const char *prefix, const char *suffix) {
+  auto rawValue = rawProps.at(name, prefix, suffix);
+
+  // No change to prop - use default
+  if (rawValue == nullptr) {
+    return defaultValue;
+  }
+
+  // Value passed from JS
+  if (rawValue->hasValue()) {
+    return true;
+  }
+
+  // Null/undefined passed in, indicating that we should use the default
+  // platform value - thereby resetting this
+  return false;
+}
+
+WindowsTextInputProps::WindowsTextInputProps(
+    const PropsParserContext &context,
+    const WindowsTextInputProps &sourceProps,
+    const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      BaseTextProps(context, sourceProps, rawProps),
+
+      /*
+      traits(convertRawProp(context, rawProps, sourceProps.traits, {})),
+      paragraphAttributes(convertRawProp(
+          context,
+          rawProps,
+          sourceProps.paragraphAttributes,
+          {})),
+          */
+
+      allowFontScaling(convertRawProp(context, rawProps, "allowFontScaling", sourceProps.allowFontScaling, {true})),
+      clearTextOnFocus(convertRawProp(context, rawProps, "clearTextOnFocus", sourceProps.clearTextOnFocus, {false})),
+      editable(convertRawProp(context, rawProps, "editable", sourceProps.editable, {true})),
+      maxLength(convertRawProp(context, rawProps, "maxLength", sourceProps.maxLength, {0})),
+      multiline(convertRawProp(context, rawProps, "multiline", sourceProps.multiline, {false})),
+      placeholder(convertRawProp(context, rawProps, "placeholder", sourceProps.placeholder, {})),
+      placeholderTextColor(
+          convertRawProp(context, rawProps, "placeholderTextColor", sourceProps.placeholderTextColor, {})),
+      scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {true})),
+      selection(convertRawProp(context, rawProps, "selection", sourceProps.selection, {})),
+      selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
+      selectTextOnFocus(convertRawProp(context, rawProps, "selectTextOnFocus", sourceProps.selectTextOnFocus, {false})),
+      spellCheck(convertRawProp(context, rawProps, "spellCheck", sourceProps.spellCheck, {false})),
+      text(convertRawProp(context, rawProps, "text", sourceProps.text, {})),
+      mostRecentEventCount(
+          convertRawProp(context, rawProps, "mostRecentEventCount", sourceProps.mostRecentEventCount, {0})),
+      secureTextEntry(convertRawProp(context, rawProps, "secureTextEntry", sourceProps.secureTextEntry, {false})),
+      keyboardType(convertRawProp(context, rawProps, "keyboardType", sourceProps.keyboardType, {})),
+      contextMenuHidden(convertRawProp(context, rawProps, "contextMenuHidden", sourceProps.contextMenuHidden, {false})),
+      caretHidden(convertRawProp(context, rawProps, "caretHidden", sourceProps.caretHidden, {false})),
+      autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
+      clearTextOnSubmit(convertRawProp(context, rawProps, "clearTextOnSubmit", sourceProps.clearTextOnSubmit, {false})),
+      submitKeyEvents(convertRawProp(context, rawProps, "submitKeyEvents", sourceProps.submitKeyEvents, {})),
+      autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})),
+      // See AndroidTextInputComponentDescriptor for usage
+      // TODO T63008435: can these, and this feature, be removed entirely?
+      hasPadding(hasValue(rawProps, sourceProps.hasPadding, "", "padding", "")),
+      hasPaddingHorizontal(hasValue(rawProps, sourceProps.hasPaddingHorizontal, "Horizontal", "padding", "")),
+      hasPaddingVertical(hasValue(rawProps, sourceProps.hasPaddingVertical, "Vertical", "padding", "")),
+      hasPaddingLeft(hasValue(rawProps, sourceProps.hasPaddingLeft, "Left", "padding", "")),
+      hasPaddingTop(hasValue(rawProps, sourceProps.hasPaddingTop, "Top", "padding", "")),
+      hasPaddingRight(hasValue(rawProps, sourceProps.hasPaddingRight, "Right", "padding", "")),
+      hasPaddingBottom(hasValue(rawProps, sourceProps.hasPaddingBottom, "Bottom", "padding", "")),
+      hasPaddingStart(hasValue(rawProps, sourceProps.hasPaddingStart, "Start", "padding", "")),
+      hasPaddingEnd(hasValue(rawProps, sourceProps.hasPaddingEnd, "End", "padding", "")) {}
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputProps.h

@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/rnwcore/Props.h>
+#include <react/renderer/components/text/BaseTextProps.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+struct WindowsTextInputSelectionStruct {
+  int start;
+  int end;
+};
+
+static inline void
+fromRawValue(const PropsParserContext &context, const RawValue &value, WindowsTextInputSelectionStruct &result) {
+  auto map = (butter::map<std::string, RawValue>)value;
+
+  auto tmp_start = map.find("start");
+  if (tmp_start != map.end()) {
+    fromRawValue(context, tmp_start->second, result.start);
+  }
+  auto tmp_end = map.find("end");
+  if (tmp_end != map.end()) {
+    fromRawValue(context, tmp_end->second, result.end);
+  }
+}
+
+static inline std::string toString(const WindowsTextInputSelectionStruct &value) {
+  return "[Object WindowsTextInputSelectionStruct]";
+}
+
+struct WindowsTextInputSubmitKeyEventsStruct {
+  bool altKey;
+  bool ctrlKey;
+  bool metaKey;
+  bool shiftKey;
+  std::string code;
+};
+
+static inline void
+fromRawValue(const PropsParserContext &context, const RawValue &value, WindowsTextInputSubmitKeyEventsStruct &result) {
+  auto map = (butter::map<std::string, RawValue>)value;
+
+  auto tmp_altKey = map.find("altKey");
+  if (tmp_altKey != map.end()) {
+    fromRawValue(context, tmp_altKey->second, result.altKey);
+  }
+  auto tmp_ctrlKey = map.find("ctrlKey");
+  if (tmp_ctrlKey != map.end()) {
+    fromRawValue(context, tmp_ctrlKey->second, result.ctrlKey);
+  }
+  auto tmp_metaKey = map.find("metaKey");
+  if (tmp_metaKey != map.end()) {
+    fromRawValue(context, tmp_metaKey->second, result.metaKey);
+  }
+  auto tmp_shiftKey = map.find("shiftKey");
+  if (tmp_shiftKey != map.end()) {
+    fromRawValue(context, tmp_shiftKey->second, result.shiftKey);
+  }
+  auto tmp_code = map.find("code");
+  if (tmp_code != map.end()) {
+    fromRawValue(context, tmp_code->second, result.code);
+  }
+}
+
+static inline std::string toString(const WindowsTextInputSubmitKeyEventsStruct &value) {
+  return "[Object WindowsTextInputSubmitKeyEventsStruct]";
+}
+
+static inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    std::vector<WindowsTextInputSubmitKeyEventsStruct> &result) {
+  auto items = (std::vector<RawValue>)value;
+  for (const auto &item : items) {
+    WindowsTextInputSubmitKeyEventsStruct newItem;
+    fromRawValue(context, item, newItem);
+    result.emplace_back(newItem);
+  }
+}
+
+class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
+ public:
+  WindowsTextInputProps() = default;
+  WindowsTextInputProps(
+      const PropsParserContext &context,
+      const WindowsTextInputProps &sourceProps,
+      const RawProps &rawProps);
+
+  bool allowFontScaling{true};
+  bool clearTextOnFocus{false};
+  bool editable{true};
+  int maxLength{0};
+  bool multiline{false};
+  std::string placeholder{};
+  SharedColor placeholderTextColor{};
+  bool scrollEnabled{true};
+  WindowsTextInputSelectionStruct selection{};
+  SharedColor selectionColor{};
+  bool selectTextOnFocus{false};
+  bool spellCheck{false};
+  std::string text{};
+  int mostRecentEventCount{0};
+  bool secureTextEntry{false};
+  std::string keyboardType{};
+  bool contextMenuHidden{false};
+  bool caretHidden{false};
+  std::string autoCapitalize{};
+  bool clearTextOnSubmit{false};
+  std::vector<WindowsTextInputSubmitKeyEventsStruct> submitKeyEvents{};
+  bool autoFocus{false};
+
+  /**
+   * Auxiliary information to detect if these props are set or not.
+   * See AndroidTextInputComponentDescriptor for usage.
+   * TODO T63008435: can these, and this feature, be removed entirely?
+   */
+  const bool hasPadding{};
+  const bool hasPaddingHorizontal{};
+  const bool hasPaddingVertical{};
+  const bool hasPaddingLeft{};
+  const bool hasPaddingTop{};
+  const bool hasPaddingRight{};
+  const bool hasPaddingBottom{};
+  const bool hasPaddingStart{};
+  const bool hasPaddingEnd{};
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputShadowNode.cpp

@@ -0,0 +1,193 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "WindowsTextInputShadowNode.h"
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/attributedstring/TextAttributes.h>
+#include <react/renderer/components/text/BaseTextShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+
+#include <utility>
+
+namespace facebook {
+namespace react {
+
+extern const char WindowsTextInputComponentName[] = "WindowsTextInput";
+
+void WindowsTextInputShadowNode::setContextContainer(ContextContainer *contextContainer) {
+  ensureUnsealed();
+  contextContainer_ = contextContainer;
+}
+
+AttributedString WindowsTextInputShadowNode::getAttributedString() const {
+  // Use BaseTextShadowNode to get attributed string from children
+  auto childTextAttributes = TextAttributes::defaultTextAttributes();
+  childTextAttributes.apply(getConcreteProps().textAttributes);
+
+  auto attributedString = AttributedString{};
+  auto attachments = BaseTextShadowNode::Attachments{};
+  BaseTextShadowNode::buildAttributedString(childTextAttributes, *this, attributedString, attachments);
+
+  // BaseTextShadowNode only gets children. We must detect and prepend text
+  // value attributes manually.
+  if (!getConcreteProps().text.empty()) {
+    auto textAttributes = TextAttributes::defaultTextAttributes();
+    textAttributes.apply(getConcreteProps().textAttributes);
+    auto fragment = AttributedString::Fragment{};
+    fragment.string = getConcreteProps().text;
+    fragment.textAttributes = textAttributes;
+    // If the TextInput opacity is 0 < n < 1, the opacity of the TextInput and
+    // text value's background will stack. This is a hack/workaround to prevent
+    // that effect.
+    fragment.textAttributes.backgroundColor = clearColor();
+    fragment.parentShadowView = ShadowView(*this);
+    attributedString.prependFragment(fragment);
+  }
+
+  return attributedString;
+}
+
+// For measurement purposes, we want to make sure that there's at least a
+// single character in the string so that the measured height is greater
+// than zero. Otherwise, empty TextInputs with no placeholder don't
+// display at all.
+// TODO T67606511: We will redefine the measurement of empty strings as part
+// of T67606511
+AttributedString WindowsTextInputShadowNode::getPlaceholderAttributedString() const {
+  // Return placeholder text, since text and children are empty.
+  auto textAttributedString = AttributedString{};
+  auto fragment = AttributedString::Fragment{};
+  fragment.string = getConcreteProps().placeholder;
+
+  if (fragment.string.empty()) {
+    fragment.string = BaseTextShadowNode::getEmptyPlaceholder();
+  }
+
+  auto textAttributes = TextAttributes::defaultTextAttributes();
+  textAttributes.apply(getConcreteProps().textAttributes);
+
+  // If there's no text, it's possible that this Fragment isn't actually
+  // appended to the AttributedString (see implementation of appendFragment)
+  fragment.textAttributes = textAttributes;
+  fragment.parentShadowView = ShadowView(*this);
+  textAttributedString.appendFragment(fragment);
+
+  return textAttributedString;
+}
+
+void WindowsTextInputShadowNode::setTextLayoutManager(SharedTextLayoutManager textLayoutManager) {
+  ensureUnsealed();
+  textLayoutManager_ = std::move(textLayoutManager);
+}
+
+AttributedString WindowsTextInputShadowNode::getMostRecentAttributedString() const {
+  auto const &state = getStateData();
+
+  auto reactTreeAttributedString = getAttributedString();
+
+  // Sometimes the treeAttributedString will only differ from the state
+  // not by inherent properties (string or prop attributes), but by the frame of
+  // the parent which has changed Thus, we can't directly compare the entire
+  // AttributedString
+  bool treeAttributedStringChanged =
+      !state.reactTreeAttributedString.compareTextAttributesWithoutFrame(reactTreeAttributedString);
+
+  return (!treeAttributedStringChanged ? state.attributedString : reactTreeAttributedString);
+}
+
+void WindowsTextInputShadowNode::updateStateIfNeeded() {
+  ensureUnsealed();
+
+  auto reactTreeAttributedString = getAttributedString();
+  auto const &state = getStateData();
+
+  // Tree is often out of sync with the value of the TextInput.
+  // This is by design - don't change the value of the TextInput in the State,
+  // and therefore in Java, unless the tree itself changes.
+  if (state.reactTreeAttributedString == reactTreeAttributedString) {
+    return;
+  }
+
+  // If props event counter is less than what we already have in state, skip it
+  if (getConcreteProps().mostRecentEventCount < state.mostRecentEventCount) {
+    return;
+  }
+
+  // Store default TextAttributes in state.
+  // In the case where the TextInput is completely empty (no value, no
+  // defaultValue, no placeholder, no children) there are therefore no fragments
+  // in the AttributedString, and when State is updated, it needs some way to
+  // reconstruct a Fragment with default TextAttributes.
+  auto defaultTextAttributes = TextAttributes::defaultTextAttributes();
+  defaultTextAttributes.apply(getConcreteProps().textAttributes);
+
+  auto newEventCount =
+      (state.reactTreeAttributedString == reactTreeAttributedString ? 0 : getConcreteProps().mostRecentEventCount);
+  auto newAttributedString = getMostRecentAttributedString();
+
+  // Even if we're here and updating state, it may be only to update the layout
+  // manager If that is the case, make sure we don't update text: pass in the
+  // current attributedString unchanged, and pass in zero for the "event count"
+  // so no changes are applied There's no way to prevent a state update from
+  // flowing to Java, so we just ensure it's a noop in those cases.
+  setStateData(WindowsTextInputState{
+      newEventCount,
+      newAttributedString,
+      reactTreeAttributedString,
+      {}, // [Windows] getConcreteProps().paragraphAttributes,
+      defaultTextAttributes,
+      ShadowView(*this),
+      state.defaultThemePaddingStart,
+      state.defaultThemePaddingEnd,
+      state.defaultThemePaddingTop,
+      state.defaultThemePaddingBottom});
+}
+
+#pragma mark - LayoutableShadowNode
+
+Size WindowsTextInputShadowNode::measureContent(
+    LayoutContext const &layoutContext,
+    LayoutConstraints const &layoutConstraints) const {
+  if (getStateData().cachedAttributedStringId != 0) {
+    return textLayoutManager_
+        ->measureCachedSpannableById(
+            getStateData().cachedAttributedStringId,
+            {}, // [Windows] getConcreteProps().paragraphAttributes,
+            layoutConstraints)
+        .size;
+  }
+
+  // Layout is called right after measure.
+  // Measure is marked as `const`, and `layout` is not; so State can be updated
+  // during layout, but not during `measure`. If State is out-of-date in layout,
+  // it's too late: measure will have already operated on old State. Thus, we
+  // use the same value here that we *will* use in layout to update the state.
+  AttributedString attributedString = getMostRecentAttributedString();
+
+  if (attributedString.isEmpty()) {
+    attributedString = getPlaceholderAttributedString();
+  }
+
+  if (attributedString.isEmpty() && getStateData().mostRecentEventCount != 0) {
+    return {0, 0};
+  }
+
+  return textLayoutManager_
+      ->measure(
+          AttributedStringBox{attributedString},
+          {}, // TODO getConcreteProps().paragraphAttributes,
+          layoutConstraints)
+      .size;
+}
+
+void WindowsTextInputShadowNode::layout(LayoutContext layoutContext) {
+  updateStateIfNeeded();
+  ConcreteViewShadowNode::layout(layoutContext);
+}
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputShadowNode.h

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <butter/map.h>
+#include <react/renderer/components/rnwcore/EventEmitters.h>
+#include "WindowsTextInputEventEmitter.h"
+#include "WindowsTextInputProps.h"
+#include "WindowsTextInputState.h"
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/utils/ContextContainer.h>
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+
+namespace facebook {
+namespace react {
+
+extern const char WindowsTextInputComponentName[];
+
+/*
+ * `ShadowNode` for <WindowsTextInput> component.
+ */
+class WindowsTextInputShadowNode final : public ConcreteViewShadowNode<
+                                             WindowsTextInputComponentName,
+                                             WindowsTextInputProps,
+                                             WindowsTextInputEventEmitter,
+                                             WindowsTextInputState> {
+ public:
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::TextKind);
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    return traits;
+  }
+
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  void setContextContainer(ContextContainer *contextContainer);
+
+  /*
+   * Returns a `AttributedString` which represents text content of the node.
+   */
+  AttributedString getAttributedString() const;
+  AttributedString getPlaceholderAttributedString() const;
+
+  /*
+   * Associates a shared TextLayoutManager with the node.
+   * `ParagraphShadowNode` uses the manager to measure text content
+   * and construct `ParagraphState` objects.
+   */
+  void setTextLayoutManager(SharedTextLayoutManager textLayoutManager);
+
+#pragma mark - LayoutableShadowNode
+
+  Size measureContent(LayoutContext const &layoutContext, LayoutConstraints const &layoutConstraints) const override;
+  void layout(LayoutContext layoutContext) override;
+
+ private:
+  ContextContainer *contextContainer_{};
+
+  /**
+   * Get the most up-to-date attributed string for measurement and State.
+   */
+  AttributedString getMostRecentAttributedString() const;
+
+  /*
+   * Creates a `State` object (with `AttributedText` and
+   * `TextLayoutManager`) if needed.
+   */
+  void updateStateIfNeeded();
+
+  SharedTextLayoutManager textLayoutManager_;
+
+  /*
+   * Cached attributed string that represents the content of the subtree started
+   * from the node.
+   */
+  mutable std::optional<AttributedString> cachedAttributedString_{};
+};
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputState.cpp

@@ -0,0 +1,76 @@
+/*
+ * 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 "WindowsTextInputState.h"
+
+#include <react/renderer/components/text/conversions.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
+
+#include <utility>
+
+namespace facebook {
+namespace react {
+
+WindowsTextInputState::WindowsTextInputState(
+    int64_t mostRecentEventCount,
+    AttributedString attributedString,
+    AttributedString reactTreeAttributedString,
+    ParagraphAttributes paragraphAttributes,
+    TextAttributes defaultTextAttributes,
+    ShadowView defaultParentShadowView,
+    float defaultThemePaddingStart,
+    float defaultThemePaddingEnd,
+    float defaultThemePaddingTop,
+    float defaultThemePaddingBottom)
+    : mostRecentEventCount(mostRecentEventCount),
+      attributedString(std::move(attributedString)),
+      reactTreeAttributedString(std::move(reactTreeAttributedString)),
+      paragraphAttributes(std::move(paragraphAttributes)),
+      defaultTextAttributes(std::move(defaultTextAttributes)),
+      defaultParentShadowView(std::move(defaultParentShadowView)),
+      defaultThemePaddingStart(defaultThemePaddingStart),
+      defaultThemePaddingEnd(defaultThemePaddingEnd),
+      defaultThemePaddingTop(defaultThemePaddingTop),
+      defaultThemePaddingBottom(defaultThemePaddingBottom) {}
+
+WindowsTextInputState::WindowsTextInputState(WindowsTextInputState const &previousState, folly::dynamic const &data)
+    : mostRecentEventCount(data.getDefault("mostRecentEventCount", previousState.mostRecentEventCount).getInt()),
+      cachedAttributedStringId(data.getDefault("opaqueCacheId", previousState.cachedAttributedStringId).getInt()),
+      attributedString(previousState.attributedString),
+      reactTreeAttributedString(previousState.reactTreeAttributedString),
+      paragraphAttributes(previousState.paragraphAttributes),
+      defaultTextAttributes(previousState.defaultTextAttributes),
+      defaultParentShadowView(previousState.defaultParentShadowView),
+      defaultThemePaddingStart(
+          data.getDefault("themePaddingStart", previousState.defaultThemePaddingStart).getDouble()),
+      defaultThemePaddingEnd(data.getDefault("themePaddingEnd", previousState.defaultThemePaddingEnd).getDouble()),
+      defaultThemePaddingTop(data.getDefault("themePaddingTop", previousState.defaultThemePaddingTop).getDouble()),
+      defaultThemePaddingBottom(
+          data.getDefault("themePaddingBottom", previousState.defaultThemePaddingBottom).getDouble()){};
+
+#ifdef ANDROID
+folly::dynamic AndroidTextInputState::getDynamic() const {
+  // Java doesn't need all fields, so we don't pass them all along.
+  folly::dynamic newState = folly::dynamic::object();
+
+  // If we have a `cachedAttributedStringId` we know that we're (1) not trying
+  // to set a new string, so we don't need to pass it along; (2) setState was
+  // called from Java to trigger a relayout with a `cachedAttributedStringId`,
+  // so Java has all up-to-date information and we should pass an empty map
+  // through.
+  if (cachedAttributedStringId == 0) {
+    newState["mostRecentEventCount"] = mostRecentEventCount;
+    newState["attributedString"] = toDynamic(attributedString);
+    newState["hash"] = newState["attributedString"]["hash"];
+    newState["paragraphAttributes"] = toDynamic(paragraphAttributes); // TODO: can we memoize this in Java?
+  }
+  return newState;
+}
+#endif
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/TextInput/WindowsTextInputState.h

@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+/*
+ * State for <WindowsTextInput> component.
+ */
+class WindowsTextInputState final {
+ public:
+  int64_t mostRecentEventCount{0};
+
+  /**
+   * Stores an opaque cache ID used on the Java side to refer to a specific
+   * AttributedString for measurement purposes only.
+   */
+  int64_t cachedAttributedStringId{0};
+
+  /*
+   * All content of <TextInput> component represented as an `AttributedString`.
+   * Only set if changed from the React tree's perspective.
+   */
+  AttributedString attributedString{};
+
+  /*
+   * All content of <TextInput> component represented as an `AttributedString`.
+   * This stores the previous computed *from the React tree*. This usually
+   * doesn't change as the TextInput contents are being updated. If it does
+   * change, we need to wipe out current contents of the TextInput and replace
+   * with the new value from the tree.
+   */
+  AttributedString reactTreeAttributedString{};
+
+  /*
+   * Represents all visual attributes of a paragraph of text represented as
+   * a ParagraphAttributes.
+   */
+  ParagraphAttributes paragraphAttributes{};
+
+  /**
+   * Default TextAttributes used if we need to construct a new Fragment.
+   * Only used if text is inserted into an AttributedString with no existing
+   * Fragments.
+   */
+  TextAttributes defaultTextAttributes;
+
+  /**
+   * Default parent ShadowView used if we need to construct a new Fragment.
+   * Only used if text is inserted into an AttributedString with no existing
+   * Fragments.
+   */
+  ShadowView defaultParentShadowView;
+
+  /**
+   * Communicates Android theme padding back to the ShadowNode / Component
+   * Descriptor for layout.
+   */
+  float defaultThemePaddingStart{NAN};
+  float defaultThemePaddingEnd{NAN};
+  float defaultThemePaddingTop{NAN};
+  float defaultThemePaddingBottom{NAN};
+
+  WindowsTextInputState(
+      int64_t mostRecentEventCount,
+      AttributedString attributedString,
+      AttributedString reactTreeAttributedString,
+      ParagraphAttributes paragraphAttributes,
+      TextAttributes defaultTextAttributes,
+      ShadowView defaultParentShadowView,
+      float defaultThemePaddingStart,
+      float defaultThemePaddingEnd,
+      float defaultThemePaddingTop,
+      float defaultThemePaddingBottom);
+
+  WindowsTextInputState() = default;
+  WindowsTextInputState(WindowsTextInputState const &previousState, folly::dynamic const &data);
+  folly::dynamic getDynamic() const;
+  /* [Windows
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  };
+     Windows] */
+};
+
+} // namespace react
+} // namespace facebook