react-native 0.71.0-rc.0 → 0.71.0-rc.1

package/Libraries/Core/ReactNativeVersion.js

@@ -13,5 +13,5 @@ exports.version = {
   major: 0,
   minor: 71,
   patch: 0,
-  prerelease: 'rc.0',
+  prerelease: 'rc.1',
 };

package/Libraries/Text/BaseText/RCTBaseTextViewManager.m

@@ -36,6 +36,7 @@ RCT_REMAP_SHADOW_PROPERTY(fontWeight, textAttributes.fontWeight, NSString)
 RCT_REMAP_SHADOW_PROPERTY(fontStyle, textAttributes.fontStyle, NSString)
 RCT_REMAP_SHADOW_PROPERTY(fontVariant, textAttributes.fontVariant, NSArray)
 RCT_REMAP_SHADOW_PROPERTY(allowFontScaling, textAttributes.allowFontScaling, BOOL)
+RCT_REMAP_SHADOW_PROPERTY(dynamicTypeRamp, textAttributes.dynamicTypeRamp, RCTDynamicTypeRamp)
 RCT_REMAP_SHADOW_PROPERTY(maxFontSizeMultiplier, textAttributes.maxFontSizeMultiplier, CGFloat)
 RCT_REMAP_SHADOW_PROPERTY(letterSpacing, textAttributes.letterSpacing, CGFloat)
 // Paragraph Styles

package/Libraries/Text/RCTTextAttributes.h

@@ -7,6 +7,7 @@
 
 #import <UIKit/UIKit.h>
 
+#import <React/RCTDynamicTypeRamp.h>
 #import <React/RCTTextDecorationLineType.h>
 
 #import "RCTTextTransform.h"
@@ -36,6 +37,7 @@ extern NSString *const RCTTextAttributesTagAttributeName;
 @property (nonatomic, copy, nullable) NSString *fontStyle;
 @property (nonatomic, copy, nullable) NSArray<NSString *> *fontVariant;
 @property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, assign) RCTDynamicTypeRamp dynamicTypeRamp;
 @property (nonatomic, assign) CGFloat letterSpacing;
 // Paragraph Styles
 @property (nonatomic, assign) CGFloat lineHeight;

package/Libraries/Text/RCTTextAttributes.m

@@ -59,6 +59,8 @@ NSString *const RCTTextAttributesTagAttributeName = @"RCTTextAttributesTagAttrib
   _fontStyle = textAttributes->_fontStyle ?: _fontStyle;
   _fontVariant = textAttributes->_fontVariant ?: _fontVariant;
   _allowFontScaling = textAttributes->_allowFontScaling || _allowFontScaling; // *
+  _dynamicTypeRamp = textAttributes->_dynamicTypeRamp != RCTDynamicTypeRampUndefined ? textAttributes->_dynamicTypeRamp
+                                                                                     : _dynamicTypeRamp;
   _letterSpacing = !isnan(textAttributes->_letterSpacing) ? textAttributes->_letterSpacing : _letterSpacing;
 
   // Paragraph Styles
@@ -230,6 +232,12 @@ NSString *const RCTTextAttributesTagAttributeName = @"RCTTextAttributesTagAttrib
 
   if (fontScalingEnabled) {
     CGFloat fontSizeMultiplier = !isnan(_fontSizeMultiplier) ? _fontSizeMultiplier : 1.0;
+    if (_dynamicTypeRamp != RCTDynamicTypeRampUndefined) {
+      UIFontMetrics *fontMetrics = RCTUIFontMetricsForDynamicTypeRamp(_dynamicTypeRamp);
+      // Using a specific font size reduces rounding errors from -scaledValueForValue:
+      CGFloat requestedSize = isnan(_fontSize) ? RCTBaseSizeForDynamicTypeRamp(_dynamicTypeRamp) : _fontSize;
+      fontSizeMultiplier = [fontMetrics scaledValueForValue:requestedSize] / requestedSize;
+    }
     CGFloat maxFontSizeMultiplier = !isnan(_maxFontSizeMultiplier) ? _maxFontSizeMultiplier : 0.0;
     return maxFontSizeMultiplier >= 1.0 ? fminf(maxFontSizeMultiplier, fontSizeMultiplier) : fontSizeMultiplier;
   } else {
@@ -324,7 +332,7 @@ static NSString *capitalizeText(NSString *text)
       RCTTextAttributesCompareFloats(_fontSizeMultiplier) && RCTTextAttributesCompareFloats(_maxFontSizeMultiplier) &&
       RCTTextAttributesCompareStrings(_fontWeight) && RCTTextAttributesCompareObjects(_fontStyle) &&
       RCTTextAttributesCompareObjects(_fontVariant) && RCTTextAttributesCompareOthers(_allowFontScaling) &&
-      RCTTextAttributesCompareFloats(_letterSpacing) &&
+      RCTTextAttributesCompareOthers(_dynamicTypeRamp) && RCTTextAttributesCompareFloats(_letterSpacing) &&
       // Paragraph Styles
       RCTTextAttributesCompareFloats(_lineHeight) && RCTTextAttributesCompareFloats(_alignment) &&
       RCTTextAttributesCompareOthers(_baseWritingDirection) && RCTTextAttributesCompareOthers(_lineBreakStrategy) &&

package/Libraries/Text/Text/RCTDynamicTypeRamp.h

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RCTDynamicTypeRamp) {
+  RCTDynamicTypeRampUndefined,
+  RCTDynamicTypeRampCaption2,
+  RCTDynamicTypeRampCaption1,
+  RCTDynamicTypeRampFootnote,
+  RCTDynamicTypeRampSubheadline,
+  RCTDynamicTypeRampCallout,
+  RCTDynamicTypeRampBody,
+  RCTDynamicTypeRampHeadline,
+  RCTDynamicTypeRampTitle3,
+  RCTDynamicTypeRampTitle2,
+  RCTDynamicTypeRampTitle1,
+  RCTDynamicTypeRampLargeTitle
+};
+
+@interface RCTConvert (DynamicTypeRamp)
+
++ (RCTDynamicTypeRamp)RCTDynamicTypeRamp:(nullable id)json;
+
+@end
+
+/// Generates a `UIFontMetrics` instance representing a particular Dynamic Type ramp.
+UIFontMetrics *_Nonnull RCTUIFontMetricsForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp);
+/// The "reference" size for a particular font scale ramp, equal to a text element's size under default text size
+/// settings.
+CGFloat RCTBaseSizeForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp);

package/Libraries/Text/Text/RCTDynamicTypeRamp.m

@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#import <React/RCTDynamicTypeRamp.h>
+
+@implementation RCTConvert (DynamicTypeRamp)
+
+RCT_ENUM_CONVERTER(
+    RCTDynamicTypeRamp,
+    (@{
+      @"caption2" : @(RCTDynamicTypeRampCaption2),
+      @"caption1" : @(RCTDynamicTypeRampCaption1),
+      @"footnote" : @(RCTDynamicTypeRampFootnote),
+      @"subheadline" : @(RCTDynamicTypeRampSubheadline),
+      @"callout" : @(RCTDynamicTypeRampCallout),
+      @"body" : @(RCTDynamicTypeRampBody),
+      @"headline" : @(RCTDynamicTypeRampHeadline),
+      @"title3" : @(RCTDynamicTypeRampTitle3),
+      @"title2" : @(RCTDynamicTypeRampTitle2),
+      @"title1" : @(RCTDynamicTypeRampTitle1),
+      @"largeTitle" : @(RCTDynamicTypeRampLargeTitle),
+    }),
+    RCTDynamicTypeRampUndefined,
+    integerValue)
+
+@end
+
+UIFontMetrics *RCTUIFontMetricsForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp)
+{
+  static NSDictionary<NSNumber *, UIFontTextStyle> *mapping;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    mapping = @{
+      @(RCTDynamicTypeRampCaption2) : UIFontTextStyleCaption2,
+      @(RCTDynamicTypeRampCaption1) : UIFontTextStyleCaption1,
+      @(RCTDynamicTypeRampFootnote) : UIFontTextStyleFootnote,
+      @(RCTDynamicTypeRampSubheadline) : UIFontTextStyleSubheadline,
+      @(RCTDynamicTypeRampCallout) : UIFontTextStyleCallout,
+      @(RCTDynamicTypeRampBody) : UIFontTextStyleBody,
+      @(RCTDynamicTypeRampHeadline) : UIFontTextStyleHeadline,
+      @(RCTDynamicTypeRampTitle3) : UIFontTextStyleTitle3,
+      @(RCTDynamicTypeRampTitle2) : UIFontTextStyleTitle2,
+      @(RCTDynamicTypeRampTitle1) : UIFontTextStyleTitle1,
+      @(RCTDynamicTypeRampLargeTitle) : UIFontTextStyleLargeTitle,
+    };
+  });
+
+  id textStyle =
+      mapping[@(dynamicTypeRamp)] ?: UIFontTextStyleBody; // Default to body if we don't recognize the specified ramp
+  return [UIFontMetrics metricsForTextStyle:textStyle];
+}
+
+CGFloat RCTBaseSizeForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp)
+{
+  static NSDictionary<NSNumber *, NSNumber *> *mapping;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    // Values taken from
+    // https://developer.apple.com/design/human-interface-guidelines/foundations/typography/#specifications
+    mapping = @{
+      @(RCTDynamicTypeRampCaption2) : @11,
+      @(RCTDynamicTypeRampCaption1) : @12,
+      @(RCTDynamicTypeRampFootnote) : @13,
+      @(RCTDynamicTypeRampSubheadline) : @15,
+      @(RCTDynamicTypeRampCallout) : @16,
+      @(RCTDynamicTypeRampBody) : @17,
+      @(RCTDynamicTypeRampHeadline) : @17,
+      @(RCTDynamicTypeRampTitle3) : @20,
+      @(RCTDynamicTypeRampTitle2) : @22,
+      @(RCTDynamicTypeRampTitle1) : @28,
+      @(RCTDynamicTypeRampLargeTitle) : @34,
+    };
+  });
+
+  NSNumber *baseSize =
+      mapping[@(dynamicTypeRamp)] ?: @17; // Default to body size if we don't recognize the specified ramp
+  return CGFLOAT_IS_DOUBLE ? [baseSize doubleValue] : [baseSize floatValue];
+}

package/Libraries/Text/Text.d.ts

@@ -26,6 +26,23 @@ export interface TextPropsIOS {
    */
   adjustsFontSizeToFit?: boolean | undefined;
 
+  /**
+   * The Dynamic Text scale ramp to apply to this element on iOS.
+   */
+  dynamicTypeRamp?:
+    | 'caption2'
+    | 'caption1'
+    | 'footnote'
+    | 'subheadline'
+    | 'callout'
+    | 'body'
+    | 'headline'
+    | 'title3'
+    | 'title2'
+    | 'title1'
+    | 'largeTitle'
+    | undefined;
+
   /**
    * Specifies smallest possible scale a font can reach when adjustsFontSizeToFit is enabled. (values 0.01-1.0).
    */

package/Libraries/Text/TextNativeComponent.js

@@ -34,6 +34,7 @@ const textViewConfig = {
     numberOfLines: true,
     ellipsizeMode: true,
     allowFontScaling: true,
+    dynamicTypeRamp: true,
     maxFontSizeMultiplier: true,
     disabled: true,
     selectable: true,

package/Libraries/Text/TextProps.js

@@ -229,6 +229,23 @@ export type TextProps = $ReadOnly<{|
    */
   adjustsFontSizeToFit?: ?boolean,
 
+  /**
+   * The Dynamic Text scale ramp to apply to this element on iOS.
+   */
+  dynamicTypeRamp?: ?(
+    | 'caption2'
+    | 'caption1'
+    | 'footnote'
+    | 'subheadline'
+    | 'callout'
+    | 'body'
+    | 'headline'
+    | 'title3'
+    | 'title2'
+    | 'title1'
+    | 'largeTitle'
+  ),
+
   /**
    * Smallest possible scale a font can reach.
    *

package/Libraries/WebPerformance/NativePerformanceObserver.cpp

@@ -0,0 +1,42 @@
+/*
+ * 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 "NativePerformanceObserver.h"
+#include <glog/logging.h>
+
+namespace facebook::react {
+
+NativePerformanceObserver::NativePerformanceObserver(
+    std::shared_ptr<CallInvoker> jsInvoker)
+    : NativePerformanceObserverCxxSpec(std::move(jsInvoker)) {}
+
+void NativePerformanceObserver::startReporting(
+    jsi::Runtime &rt,
+    std::string entryType) {
+  LOG(INFO) << "Started reporting perf entry type: " << entryType;
+}
+
+void NativePerformanceObserver::stopReporting(
+    jsi::Runtime &rt,
+    std::string entryType) {
+  LOG(INFO) << "Stopped reporting perf entry type: " << entryType;
+}
+
+std::vector<RawPerformanceEntry> NativePerformanceObserver::getPendingEntries(
+    jsi::Runtime &rt) {
+  return std::vector<RawPerformanceEntry>{};
+}
+
+void NativePerformanceObserver::setOnPerformanceEntryCallback(
+    jsi::Runtime &rt,
+    std::optional<AsyncCallback<>> callback) {
+  callback_ = callback;
+  LOG(INFO) << "setOnPerformanceEntryCallback: "
+            << (callback ? "non-empty" : "empty");
+}
+
+} // namespace facebook::react

package/Libraries/WebPerformance/NativePerformanceObserver.h

@@ -0,0 +1,64 @@
+/*
+ * 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 <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+#pragma mark - Structs
+
+using RawPerformanceEntry = NativePerformanceObserverCxxBaseRawPerformanceEntry<
+    std::string,
+    int32_t,
+    double,
+    double,
+    // For "event" entries only:
+    std::optional<double>,
+    std::optional<double>,
+    std::optional<double>>;
+
+template <>
+struct Bridging<RawPerformanceEntry>
+    : NativePerformanceObserverCxxBaseRawPerformanceEntryBridging<
+          std::string,
+          int32_t,
+          double,
+          double,
+          std::optional<double>,
+          std::optional<double>,
+          std::optional<double>> {};
+
+#pragma mark - implementation
+
+class NativePerformanceObserver
+    : public NativePerformanceObserverCxxSpec<NativePerformanceObserver>,
+      std::enable_shared_from_this<NativePerformanceObserver> {
+ public:
+  NativePerformanceObserver(std::shared_ptr<CallInvoker> jsInvoker);
+
+  void startReporting(jsi::Runtime &rt, std::string entryType);
+
+  void stopReporting(jsi::Runtime &rt, std::string entryType);
+
+  std::vector<RawPerformanceEntry> getPendingEntries(jsi::Runtime &rt);
+
+  void setOnPerformanceEntryCallback(
+      jsi::Runtime &rt,
+      std::optional<AsyncCallback<>> callback);
+
+ private:
+  std::optional<AsyncCallback<>> callback_;
+};
+
+} // namespace facebook::react

package/Libraries/WebPerformance/NativePerformanceObserver.js

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {TurboModule} from '../TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+export const RawPerformanceEntryTypeValues = {
+  UNDEFINED: 0,
+};
+
+export type RawPerformanceEntryType = number;
+
+export type RawPerformanceEntry = {|
+  name: string,
+  entryType: RawPerformanceEntryType,
+  startTime: number,
+  duration: number,
+  // For "event" entries only:
+  processingStart?: number,
+  processingEnd?: number,
+  interactionId?: number,
+|};
+
+export interface Spec extends TurboModule {
+  +startReporting: (entryType: string) => void;
+  +stopReporting: (entryType: string) => void;
+  +getPendingEntries: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +setOnPerformanceEntryCallback: (callback?: () => void) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>(
+  'NativePerformanceObserverCxx',
+): ?Spec);

package/Libraries/WebPerformance/PerformanceObserver.js

@@ -0,0 +1,223 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict
+ */
+
+import type {
+  RawPerformanceEntry,
+  RawPerformanceEntryType,
+} from './NativePerformanceObserver';
+
+import warnOnce from '../Utilities/warnOnce';
+import NativePerformanceObserver from './NativePerformanceObserver';
+
+export type HighResTimeStamp = number;
+// TODO: Extend once new types (such as event) are supported.
+// TODO: Get rid of the "undefined" once there is at least one type supported.
+export type PerformanceEntryType = 'undefined';
+
+export class PerformanceEntry {
+  name: string;
+  entryType: PerformanceEntryType;
+  startTime: HighResTimeStamp;
+  duration: number;
+
+  constructor(init: {
+    name: string,
+    entryType: PerformanceEntryType,
+    startTime: HighResTimeStamp,
+    duration: number,
+  }) {
+    this.name = init.name;
+    this.entryType = init.entryType;
+    this.startTime = init.startTime;
+    this.duration = init.duration;
+  }
+
+  // $FlowIgnore: Flow(unclear-type)
+  toJSON(): Object {
+    return {
+      name: this.name,
+      entryType: this.entryType,
+      startTime: this.startTime,
+      duration: this.duration,
+    };
+  }
+}
+
+function rawToPerformanceEntryType(
+  type: RawPerformanceEntryType,
+): PerformanceEntryType {
+  return 'undefined';
+}
+
+function rawToPerformanceEntry(entry: RawPerformanceEntry): PerformanceEntry {
+  return new PerformanceEntry({
+    name: entry.name,
+    entryType: rawToPerformanceEntryType(entry.entryType),
+    startTime: entry.startTime,
+    duration: entry.duration,
+  });
+}
+
+export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
+
+export class PerformanceObserverEntryList {
+  _entries: PerformanceEntryList;
+
+  constructor(entries: PerformanceEntryList) {
+    this._entries = entries;
+  }
+
+  getEntries(): PerformanceEntryList {
+    return this._entries;
+  }
+
+  getEntriesByType(type: PerformanceEntryType): PerformanceEntryList {
+    return this._entries.filter(entry => entry.entryType === type);
+  }
+
+  getEntriesByName(
+    name: string,
+    type?: PerformanceEntryType,
+  ): PerformanceEntryList {
+    if (type === undefined) {
+      return this._entries.filter(entry => entry.name === name);
+    } else {
+      return this._entries.filter(
+        entry => entry.name === name && entry.entryType === type,
+      );
+    }
+  }
+}
+
+export type PerformanceObserverCallback = (
+  list: PerformanceObserverEntryList,
+  observer: PerformanceObserver,
+) => void;
+
+export type PerformanceObserverInit =
+  | {
+      entryTypes: Array<PerformanceEntryType>,
+    }
+  | {
+      type: PerformanceEntryType,
+    };
+
+let _observedEntryTypeRefCount: Map<PerformanceEntryType, number> = new Map();
+
+let _observers: Set<PerformanceObserver> = new Set();
+
+let _onPerformanceEntryCallbackIsSet: boolean = false;
+
+function warnNoNativePerformanceObserver() {
+  warnOnce(
+    'missing-native-performance-observer',
+    'Missing native implementation of PerformanceObserver',
+  );
+}
+
+/**
+ * Implementation of the PerformanceObserver interface for RN,
+ * corresponding to the standard in https://www.w3.org/TR/performance-timeline/
+ *
+ * @example
+ * const observer = new PerformanceObserver((list, _observer) => {
+ *   const entries = list.getEntries();
+ *   entries.forEach(entry => {
+ *     reportEvent({
+ *       eventName: entry.name,
+ *       startTime: entry.startTime,
+ *       endTime: entry.startTime + entry.duration,
+ *       processingStart: entry.processingStart,
+ *       processingEnd: entry.processingEnd,
+ *       interactionId: entry.interactionId,
+ *     });
+ *   });
+ * });
+ * observer.observe({ type: "event" });
+ */
+export default class PerformanceObserver {
+  _callback: PerformanceObserverCallback;
+  _entryTypes: $ReadOnlySet<PerformanceEntryType>;
+
+  constructor(callback: PerformanceObserverCallback) {
+    this._callback = callback;
+  }
+
+  observe(options: PerformanceObserverInit) {
+    if (!NativePerformanceObserver) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+    if (!_onPerformanceEntryCallbackIsSet) {
+      NativePerformanceObserver.setOnPerformanceEntryCallback(
+        onPerformanceEntry,
+      );
+      _onPerformanceEntryCallbackIsSet = true;
+    }
+    if (options.entryTypes) {
+      this._entryTypes = new Set(options.entryTypes);
+    } else {
+      this._entryTypes = new Set([options.type]);
+    }
+    this._entryTypes.forEach(type => {
+      if (!_observedEntryTypeRefCount.has(type)) {
+        NativePerformanceObserver.startReporting(type);
+      }
+      _observedEntryTypeRefCount.set(
+        type,
+        (_observedEntryTypeRefCount.get(type) ?? 0) + 1,
+      );
+    });
+    _observers.add(this);
+  }
+
+  disconnect(): void {
+    if (!NativePerformanceObserver) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+    this._entryTypes.forEach(type => {
+      const entryTypeRefCount = _observedEntryTypeRefCount.get(type) ?? 0;
+      if (entryTypeRefCount === 1) {
+        _observedEntryTypeRefCount.delete(type);
+        NativePerformanceObserver.stopReporting(type);
+      } else if (entryTypeRefCount !== 0) {
+        _observedEntryTypeRefCount.set(type, entryTypeRefCount - 1);
+      }
+    });
+    _observers.delete(this);
+    if (_observers.size === 0) {
+      NativePerformanceObserver.setOnPerformanceEntryCallback(undefined);
+      _onPerformanceEntryCallbackIsSet = false;
+    }
+  }
+
+  static supportedEntryTypes: $ReadOnlyArray<PerformanceEntryType> =
+    // TODO: add types once they are fully supported
+    Object.freeze([]);
+}
+
+// This is a callback that gets scheduled and periodically called from the native side
+function onPerformanceEntry() {
+  if (!NativePerformanceObserver) {
+    return;
+  }
+  const rawEntries = NativePerformanceObserver.getPendingEntries();
+  const entries = rawEntries.map(rawToPerformanceEntry);
+  _observers.forEach(observer => {
+    const entriesForObserver: PerformanceEntryList = entries.filter(entry =>
+      observer._entryTypes.has(entry.entryType),
+    );
+    observer._callback(
+      new PerformanceObserverEntryList(entriesForObserver),
+      observer,
+    );
+  });
+}

package/React/Base/RCTVersion.m

@@ -24,7 +24,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(71),
                   RCTVersionPatch: @(0),
-                  RCTVersionPrerelease: @"rc.0",
+                  RCTVersionPrerelease: @"rc.1",
                   };
   });
   return __rnVersion;

package/React/CoreModules/CoreModulesPlugins.h

@@ -53,6 +53,7 @@ Class RCTWebSocketModuleCls(void) __attribute__((used));
 Class RCTDevLoadingViewCls(void) __attribute__((used));
 Class RCTDevSplitBundleLoaderCls(void) __attribute__((used));
 Class RCTEventDispatcherCls(void) __attribute__((used));
+Class RCTBlobManagerCls(void) __attribute__((used));
 
 #ifdef __cplusplus
 }

package/React/CoreModules/CoreModulesPlugins.mm

@@ -43,6 +43,7 @@ Class RCTCoreModulesClassProvider(const char *name) {
     {"DevLoadingView", RCTDevLoadingViewCls},
     {"DevSplitBundleLoader", RCTDevSplitBundleLoaderCls},
     {"EventDispatcher", RCTEventDispatcherCls},
+    {"BlobModule", RCTBlobManagerCls},
   };
 
   auto p = sCoreModuleClassMap->find(name);

package/ReactAndroid/build.gradle

@@ -363,8 +363,8 @@ task installArchives {
 }
 
 android {
-    buildToolsVersion = "31.0.0"
-    compileSdkVersion 31
+    buildToolsVersion = "33.0.0"
+    compileSdkVersion 33
 
     // Used to override the NDK path/version on internal CI or by allowing
     // users to customize the NDK path/version from their root project (e.g. for M1 support)
@@ -377,7 +377,7 @@ android {
 
     defaultConfig {
         minSdkVersion(21)
-        targetSdkVersion(31)
+        targetSdkVersion(33)
         versionCode(1)
         versionName("1.0")
 
@@ -616,11 +616,13 @@ apply plugin: "org.jetbrains.kotlin.android"
 apply from: "./publish.gradle"
 
 // We need to override the artifact ID as this project is called `ReactAndroid` but
-// the maven coordinates are on `react-native`.
+// the maven coordinates are on `react-android`.
+// Please note that the original coordinates, `react-native`, have been voided
+// as they caused https://github.com/facebook/react-native/issues/35210
 publishing {
     publications {
         getByName("release") {
-            artifactId 'react-native'
+            artifactId 'react-android'
         }
     }
 }