react-native-windows 0.84.0 → 0.85.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/webperformance/NativePerformance.cpp

@@ -1,414 +0,0 @@
-/*
- * 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.
- */
-
-
-#if _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996) // deprecated APIs
-#endif
-#include "NativePerformance.h"
-
-#include <memory>
-#include <unordered_map>
-#include <variant>
-
-#include <cxxreact/JSExecutor.h>
-#include <cxxreact/ReactMarker.h>
-#include <jsi/JSIDynamic.h>
-#include <jsi/instrumentation.h>
-#include <react/performance/timeline/PerformanceEntryReporter.h>
-#include <react/performance/timeline/PerformanceObserver.h>
-
-#include "NativePerformance.h"
-
-#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
-#include "Plugins.h"
-#endif
-
-std::shared_ptr<facebook::react::TurboModule> NativePerformanceModuleProvider(
-    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
-  return std::make_shared<facebook::react::NativePerformance>(
-      std::move(jsInvoker));
-}
-
-namespace facebook::react {
-
-namespace {
-
-class PerformanceObserverWrapper : public jsi::NativeState {
- public:
-  explicit PerformanceObserverWrapper(
-      const std::shared_ptr<PerformanceObserver> observer)
-      : observer(observer) {}
-
-  const std::shared_ptr<PerformanceObserver> observer;
-};
-
-void sortEntries(std::vector<PerformanceEntry>& entries) {
-  return std::stable_sort(
-      entries.begin(), entries.end(), PerformanceEntrySorter{});
-}
-
-NativePerformanceEntry toNativePerformanceEntry(const PerformanceEntry& entry) {
-  auto nativeEntry = std::visit(
-      [](const auto& entryData) -> NativePerformanceEntry {
-        return {
-            .name = entryData.name,
-            .entryType = entryData.entryType,
-            .startTime = entryData.startTime,
-            .duration = entryData.duration,
-        };
-      },
-      entry);
-
-  if (std::holds_alternative<PerformanceEventTiming>(entry)) {
-    auto eventEntry = std::get<PerformanceEventTiming>(entry);
-    nativeEntry.processingStart = eventEntry.processingStart;
-    nativeEntry.processingEnd = eventEntry.processingEnd;
-    nativeEntry.interactionId = eventEntry.interactionId;
-  }
-  if (std::holds_alternative<PerformanceResourceTiming>(entry)) {
-    auto resourceEntry = std::get<PerformanceResourceTiming>(entry);
-    nativeEntry.fetchStart = resourceEntry.fetchStart;
-    nativeEntry.requestStart = resourceEntry.requestStart;
-    nativeEntry.connectStart = resourceEntry.connectStart;
-    nativeEntry.connectEnd = resourceEntry.connectEnd;
-    nativeEntry.responseStart = resourceEntry.responseStart;
-    nativeEntry.responseEnd = resourceEntry.responseEnd;
-    nativeEntry.responseStatus = resourceEntry.responseStatus;
-    nativeEntry.contentType = resourceEntry.contentType;
-    nativeEntry.encodedBodySize = resourceEntry.encodedBodySize;
-    nativeEntry.decodedBodySize = resourceEntry.decodedBodySize;
-  }
-
-  return nativeEntry;
-}
-
-std::vector<NativePerformanceEntry> toNativePerformanceEntries(
-    std::vector<PerformanceEntry>& entries) {
-  std::vector<NativePerformanceEntry> result;
-  result.reserve(entries.size());
-
-  for (auto& entry : entries) {
-    result.emplace_back(toNativePerformanceEntry(entry));
-  }
-
-  return result;
-}
-
-const std::array<PerformanceEntryType, 2> ENTRY_TYPES_AVAILABLE_FROM_TIMELINE{
-    {PerformanceEntryType::MARK, PerformanceEntryType::MEASURE}};
-
-bool isAvailableFromTimeline(PerformanceEntryType entryType) {
-  return entryType == PerformanceEntryType::MARK ||
-      entryType == PerformanceEntryType::MEASURE;
-}
-
-std::shared_ptr<PerformanceObserver> tryGetObserver(
-    jsi::Runtime& rt,
-    jsi::Object& observerObj) {
-  if (!observerObj.hasNativeState(rt)) {
-    return nullptr;
-  }
-
-  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
-      observerObj.getNativeState(rt));
-  return observerWrapper ? observerWrapper->observer : nullptr;
-}
-
-PerformanceEntryReporter::UserTimingDetailProvider getDetailProviderFromEntry(
-    jsi::Runtime& rt,
-    jsi::Value& entry) {
-  return [&rt, &entry]() -> folly::dynamic {
-    try {
-      auto detail = entry.asObject(rt).getProperty(rt, "detail");
-      return jsi::dynamicFromValue(rt, detail);
-    } catch (jsi::JSIException&) {
-      return nullptr;
-    }
-  };
-}
-
-} // namespace
-
-NativePerformance::NativePerformance(std::shared_ptr<CallInvoker> jsInvoker)
-    : NativePerformanceCxxSpec(std::move(jsInvoker)) {}
-
-HighResTimeStamp NativePerformance::now(jsi::Runtime& /*rt*/) {
-  // This is not spec-compliant, as this is the duration from system boot to
-  // now, instead of from app startup to now.
-  // This should be carefully changed eventually.
-  return HighResTimeStamp::now();
-}
-
-HighResDuration NativePerformance::timeOrigin(jsi::Runtime& /*rt*/) {
-  // This is not spec-compliant, as this is an approximation from Unix epoch to
-  // system boot, instead of a precise duration from Unix epoch to app startup.
-  return HighResTimeStamp::unsafeOriginFromUnixTimeStamp();
-}
-
-void NativePerformance::reportMark(
-    jsi::Runtime& rt,
-    const std::string& name,
-    HighResTimeStamp startTime,
-    jsi::Value entry) {
-  PerformanceEntryReporter::getInstance()->reportMark(
-      name, startTime, getDetailProviderFromEntry(rt, entry));
-}
-
-void NativePerformance::reportMeasure(
-    jsi::Runtime& rt,
-    const std::string& name,
-    HighResTimeStamp startTime,
-    HighResDuration duration,
-    jsi::Value entry) {
-  PerformanceEntryReporter::getInstance()->reportMeasure(
-      name, startTime, duration, getDetailProviderFromEntry(rt, entry));
-}
-
-std::optional<double> NativePerformance::getMarkTime(
-    jsi::Runtime& /*rt*/,
-    const std::string& name) {
-  auto markTime = PerformanceEntryReporter::getInstance()->getMarkTime(name);
-  return markTime ? std::optional{(*markTime).toDOMHighResTimeStamp()}
-                  : std::nullopt;
-}
-
-void NativePerformance::clearMarks(
-    jsi::Runtime& /*rt*/,
-    std::optional<std::string> entryName) {
-  if (entryName) {
-    PerformanceEntryReporter::getInstance()->clearEntries(
-        PerformanceEntryType::MARK, *entryName);
-  } else {
-    PerformanceEntryReporter::getInstance()->clearEntries(
-        PerformanceEntryType::MARK);
-  }
-}
-
-void NativePerformance::clearMeasures(
-    jsi::Runtime& /*rt*/,
-    std::optional<std::string> entryName) {
-  if (entryName) {
-    PerformanceEntryReporter::getInstance()->clearEntries(
-        PerformanceEntryType::MEASURE, *entryName);
-  } else {
-    PerformanceEntryReporter::getInstance()->clearEntries(
-        PerformanceEntryType::MEASURE);
-  }
-}
-
-std::vector<NativePerformanceEntry> NativePerformance::getEntries(
-    jsi::Runtime& /*rt*/) {
-  std::vector<PerformanceEntry> entries;
-
-  for (auto entryType : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
-    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
-  }
-
-  sortEntries(entries);
-
-  return toNativePerformanceEntries(entries);
-}
-
-std::vector<NativePerformanceEntry> NativePerformance::getEntriesByName(
-    jsi::Runtime& /*rt*/,
-    const std::string& entryName,
-    std::optional<PerformanceEntryType> entryType) {
-  std::vector<PerformanceEntry> entries;
-
-  if (entryType) {
-    if (isAvailableFromTimeline(*entryType)) {
-      PerformanceEntryReporter::getInstance()->getEntries(
-          entries, *entryType, entryName);
-    }
-  } else {
-    for (auto type : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
-      PerformanceEntryReporter::getInstance()->getEntries(
-          entries, type, entryName);
-    }
-  }
-
-  sortEntries(entries);
-
-  return toNativePerformanceEntries(entries);
-}
-
-std::vector<NativePerformanceEntry> NativePerformance::getEntriesByType(
-    jsi::Runtime& /*rt*/,
-    PerformanceEntryType entryType) {
-  std::vector<PerformanceEntry> entries;
-
-  if (isAvailableFromTimeline(entryType)) {
-    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
-  }
-
-  sortEntries(entries);
-
-  return toNativePerformanceEntries(entries);
-}
-
-std::vector<std::pair<std::string, uint32_t>> NativePerformance::getEventCounts(
-    jsi::Runtime& /*rt*/) {
-  const auto& eventCounts =
-      PerformanceEntryReporter::getInstance()->getEventCounts();
-  return {eventCounts.begin(), eventCounts.end()};
-}
-
-std::unordered_map<std::string, double> NativePerformance::getSimpleMemoryInfo(
-    jsi::Runtime& rt) {
-  auto heapInfo = rt.instrumentation().getHeapInfo(false);
-  std::unordered_map<std::string, double> heapInfoToJs;
-  for (auto& entry : heapInfo) {
-    heapInfoToJs[entry.first] = static_cast<double>(entry.second);
-  }
-  return heapInfoToJs;
-}
-
-std::unordered_map<std::string, double>
-NativePerformance::getReactNativeStartupTiming(jsi::Runtime& /*rt*/) {
-  std::unordered_map<std::string, double> result;
-
-  ReactMarker::StartupLogger& startupLogger =
-      ReactMarker::StartupLogger::getInstance();
-  if (!std::isnan(startupLogger.getAppStartupStartTime())) {
-    result["startTime"] = startupLogger.getAppStartupStartTime();
-  } else if (!std::isnan(startupLogger.getInitReactRuntimeStartTime())) {
-    result["startTime"] = startupLogger.getInitReactRuntimeStartTime();
-  }
-
-  if (!std::isnan(startupLogger.getInitReactRuntimeStartTime())) {
-    result["initializeRuntimeStart"] =
-        startupLogger.getInitReactRuntimeStartTime();
-  }
-
-  if (!std::isnan(startupLogger.getRunJSBundleStartTime())) {
-    result["executeJavaScriptBundleEntryPointStart"] =
-        startupLogger.getRunJSBundleStartTime();
-  }
-
-  if (!std::isnan(startupLogger.getAppStartupEndTime())) {
-    result["endTime"] = startupLogger.getAppStartupEndTime();
-  }
-
-  return result;
-}
-
-jsi::Object NativePerformance::createObserver(
-    jsi::Runtime& rt,
-    NativePerformancePerformanceObserverCallback callback) {
-  // The way we dispatch performance observer callbacks is a bit different from
-  // the spec. The specification requires us to queue a single task that
-  // dispatches observer callbacks. Instead, we are queuing all callbacks as
-  // separate tasks in the scheduler.
-  PerformanceObserverCallback cb = [callback = std::move(callback)]() {
-    callback.callWithPriority(SchedulerPriority::IdlePriority);
-  };
-
-  auto& registry =
-      PerformanceEntryReporter::getInstance()->getObserverRegistry();
-
-  auto observer = PerformanceObserver::create(registry, std::move(cb));
-  auto observerWrapper = std::make_shared<PerformanceObserverWrapper>(observer);
-  jsi::Object observerObj{rt};
-  observerObj.setNativeState(rt, observerWrapper);
-  return observerObj;
-}
-
-double NativePerformance::getDroppedEntriesCount(
-    jsi::Runtime& rt,
-    jsi::Object observerObj) {
-  auto observer = tryGetObserver(rt, observerObj);
-
-  if (!observer) {
-    return 0;
-  }
-
-  return observer->getDroppedEntriesCount();
-}
-
-void NativePerformance::observe(
-    jsi::Runtime& rt,
-    jsi::Object observerObj,
-    NativePerformancePerformanceObserverObserveOptions options) {
-  auto observer = tryGetObserver(rt, observerObj);
-
-  if (!observer) {
-    return;
-  }
-
-  auto durationThreshold =
-      options.durationThreshold.value_or(HighResDuration::zero());
-
-  // observer of type multiple
-  if (options.entryTypes.has_value()) {
-    std::unordered_set<PerformanceEntryType> entryTypes;
-    auto rawTypes = options.entryTypes.value();
-
-    for (auto rawType : rawTypes) {
-      entryTypes.insert(Bridging<PerformanceEntryType>::fromJs(rt, rawType));
-    }
-
-    observer->observe(entryTypes);
-  } else { // single
-    auto buffered = options.buffered.value_or(false);
-    if (options.type.has_value()) {
-      observer->observe(
-          static_cast<PerformanceEntryType>(options.type.value()),
-          {.buffered = buffered, .durationThreshold = durationThreshold});
-    }
-  }
-}
-
-void NativePerformance::disconnect(jsi::Runtime& rt, jsi::Object observerObj) {
-  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
-      observerObj.getNativeState(rt));
-
-  if (!observerWrapper) {
-    return;
-  }
-
-  auto observer = observerWrapper->observer;
-  observer->disconnect();
-}
-
-std::vector<NativePerformanceEntry> NativePerformance::takeRecords(
-    jsi::Runtime& rt,
-    jsi::Object observerObj,
-    bool sort) {
-  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
-      observerObj.getNativeState(rt));
-
-  if (!observerWrapper) {
-    return {};
-  }
-
-  auto observer = observerWrapper->observer;
-  auto records = observer->takeRecords();
-  if (sort) {
-    sortEntries(records);
-  }
-  return toNativePerformanceEntries(records);
-}
-
-std::vector<PerformanceEntryType>
-NativePerformance::getSupportedPerformanceEntryTypes(jsi::Runtime& /*rt*/) {
-  auto supportedEntryTypes = PerformanceEntryReporter::getSupportedEntryTypes();
-  return {supportedEntryTypes.begin(), supportedEntryTypes.end()};
-}
-
-#pragma mark - Testing
-
-void NativePerformance::clearEventCountsForTesting(jsi::Runtime& /*rt*/) {
-  PerformanceEntryReporter::getInstance()->clearEventCounts();
-}
-
-} // namespace facebook::react
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/platform/android/react/renderer/components/text/ParagraphState.h

@@ -1,91 +0,0 @@
-/*
- * 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 <react/debug/react_native_assert.h>
-#include <react/renderer/attributedstring/AttributedString.h>
-#include <react/renderer/attributedstring/ParagraphAttributes.h>
-#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
-#include <react/renderer/textlayoutmanager/TextLayoutManagerExtended.h>
-
-//#include <fbjni/fbjni.h> // [windows #15020] 
-#include <folly/dynamic.h>
-#include <react/renderer/mapbuffer/MapBuffer.h>
-
-#include <utility>
-
-namespace facebook::react {
-
-// constants for Text State serialization
-constexpr static MapBuffer::Key TX_STATE_KEY_ATTRIBUTED_STRING = 0;
-constexpr static MapBuffer::Key TX_STATE_KEY_PARAGRAPH_ATTRIBUTES = 1;
-// Used for TextInput only
-constexpr static MapBuffer::Key TX_STATE_KEY_HASH = 2;
-constexpr static MapBuffer::Key TX_STATE_KEY_MOST_RECENT_EVENT_COUNT = 3;
-
-/*
- * State for <Paragraph> component.
- * Represents what to render and how to render.
- */
-class ParagraphState final {
- public:
-  /*
-   * All content of <Paragraph> component represented as an `AttributedString`.
-   */
-  AttributedString attributedString;
-
-  /*
-   * Represents all visual attributes of a paragraph of text represented as
-   * a ParagraphAttributes.
-   */
-  ParagraphAttributes paragraphAttributes;
-
-  /*
-   * `TextLayoutManager` provides a connection to platform-specific
-   * text rendering infrastructure which is capable to render the
-   * `AttributedString`.
-   */
-  std::weak_ptr<const TextLayoutManager> layoutManager;
-
-  /**
-   * A fully prepared representation of a text layout to mount
-   */
-  MeasuredPreparedLayout measuredLayout;
-
-  ParagraphState(
-      AttributedString attributedString,
-      ParagraphAttributes paragraphAttributes,
-      std::weak_ptr<const TextLayoutManager> layoutManager,
-      MeasuredPreparedLayout measuredLayout)
-      : attributedString(std::move(attributedString)),
-        paragraphAttributes(std::move(paragraphAttributes)),
-        layoutManager(std::move(layoutManager)),
-        measuredLayout(std::move(measuredLayout))
-  {
-  }
-
-  ParagraphState(
-      AttributedString attributedString,
-      ParagraphAttributes paragraphAttributes,
-      std::weak_ptr<const TextLayoutManager> layoutManager)
-      : ParagraphState(std::move(attributedString), std::move(paragraphAttributes), std::move(layoutManager), {})
-  {
-  }
-
-  ParagraphState() = default;
-  ParagraphState(const ParagraphState & /*previousState*/, const folly::dynamic & /*data*/)
-  {
-    react_native_assert(false && "Not supported");
-  };
-
-  folly::dynamic getDynamic() const;
-  MapBuffer getMapBuffer() const;
-  //jni::local_ref<jobject> getJNIReference() const; // [windows #15020]
-};
-
-} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/EventDispatcher.cpp

@@ -1,80 +0,0 @@
-/*
- * 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.
- */
-
-
-#if _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996) // deprecated APIs
-#endif
-#include "EventDispatcher.h"
-#include <react/renderer/core/StateUpdate.h>
-
-#include "EventQueue.h"
-#include "RawEvent.h"
-
-namespace facebook::react {
-
-EventDispatcher::EventDispatcher(
-    const EventQueueProcessor& eventProcessor,
-    std::unique_ptr<EventBeat> eventBeat,
-    StatePipe statePipe,
-    std::weak_ptr<EventLogger> eventLogger)
-    : eventQueue_(EventQueue(eventProcessor, std::move(eventBeat))),
-      statePipe_(std::move(statePipe)),
-      eventLogger_(std::move(eventLogger)) {}
-
-void EventDispatcher::dispatchEvent(RawEvent&& rawEvent) const {
-  // Allows the event listener to interrupt default event dispatch
-  if (eventListeners_.willDispatchEvent(rawEvent)) {
-    return;
-  }
-
-  auto eventLogger = eventLogger_.lock();
-  if (eventLogger != nullptr) {
-    rawEvent.loggingTag = eventLogger->onEventStart(
-        rawEvent.type, rawEvent.eventTarget, rawEvent.eventStartTimeStamp);
-  }
-  eventQueue_.enqueueEvent(std::move(rawEvent));
-}
-
-void EventDispatcher::experimental_flushSync() const {
-  eventQueue_.experimental_flushSync();
-}
-
-void EventDispatcher::dispatchStateUpdate(
-    StateUpdate&& stateUpdate,
-    EventQueue::UpdateMode updateMode) const {
-  eventQueue_.enqueueStateUpdate(std::move(stateUpdate), updateMode);
-}
-
-void EventDispatcher::dispatchUniqueEvent(RawEvent&& rawEvent) const {
-  // Allows the event listener to interrupt default event dispatch
-  if (eventListeners_.willDispatchEvent(rawEvent)) {
-    return;
-  }
-
-  eventQueue_.enqueueUniqueEvent(std::move(rawEvent));
-}
-
-void EventDispatcher::addListener(
-    std::shared_ptr<const EventListener> listener) const {
-  eventListeners_.addListener(std::move(listener));
-}
-
-/*
- * Removes provided event listener to the event dispatcher.
- */
-void EventDispatcher::removeListener(
-    const std::shared_ptr<const EventListener>& listener) const {
-  eventListeners_.removeListener(listener);
-}
-
-} // namespace facebook::react
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif