@react-native-oh/react-native-harmony 0.72.82 → 0.77.18-1

package/Libraries/LinkingIOS/RCTLinkingManager.mm

@@ -0,0 +1,204 @@
+/*
+ * 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/RCTLinkingManager.h>
+
+#import <FBReactNativeSpec/FBReactNativeSpec.h>
+#import <React/RCTBridge.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTLinkingPlugins.h"
+
+static NSString *const kOpenURLNotification = @"RCTOpenURLNotification";
+
+static void postNotificationWithURL(NSURL *URL, id sender)
+{
+  NSDictionary<NSString *, id> *payload = @{@"url" : URL.absoluteString};
+  [[NSNotificationCenter defaultCenter] postNotificationName:kOpenURLNotification object:sender userInfo:payload];
+}
+
+@interface RCTLinkingManager () <NativeLinkingManagerSpec>
+@end
+
+@implementation RCTLinkingManager
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (void)startObserving
+{
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleOpenURLNotification:)
+                                               name:kOpenURLNotification
+                                             object:nil];
+}
+
+- (void)stopObserving
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ @"url" ];
+}
+
++ (BOOL)application:(UIApplication *)app
+            openURL:(NSURL *)URL
+            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options
+{
+  postNotificationWithURL(URL, self);
+  return YES;
+}
+
+// Corresponding api deprecated in iOS 9
++ (BOOL)application:(UIApplication *)application
+              openURL:(NSURL *)URL
+    sourceApplication:(NSString *)sourceApplication
+           annotation:(id)annotation
+{
+  postNotificationWithURL(URL, self);
+  return YES;
+}
+
++ (BOOL)application:(UIApplication *)application
+    continueUserActivity:(NSUserActivity *)userActivity
+      restorationHandler:(nonnull void (^)(NSArray<id<UIUserActivityRestoring>> *_Nullable))restorationHandler
+{
+  // This can be nullish when launching an App Clip.
+  if ([userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb] && userActivity.webpageURL != nil) {
+    NSDictionary *payload = @{@"url" : userActivity.webpageURL.absoluteString};
+    [[NSNotificationCenter defaultCenter] postNotificationName:kOpenURLNotification object:self userInfo:payload];
+  }
+  return YES;
+}
+
+- (void)handleOpenURLNotification:(NSNotification *)notification
+{
+  [self sendEventWithName:@"url" body:notification.userInfo];
+}
+
+RCT_EXPORT_METHOD(openURL
+                  : (NSURL *)URL resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject)
+{
+  [RCTSharedApplication() openURL:URL
+      options:@{}
+      completionHandler:^(BOOL success) {
+        if (success) {
+          resolve(@YES);
+        } else {
+#if TARGET_OS_SIMULATOR
+          // Simulator-specific code
+          if ([URL.absoluteString hasPrefix:@"tel:"]) {
+            RCTLogWarn(@"Unable to open the Phone app in the simulator for telephone URLs. URL:  %@", URL);
+            resolve(@NO);
+          } else {
+            reject(RCTErrorUnspecified, [NSString stringWithFormat:@"Unable to open URL: %@", URL], nil);
+          }
+#else
+          // Device-specific code
+          reject(RCTErrorUnspecified, [NSString stringWithFormat:@"Unable to open URL: %@", URL], nil);
+#endif
+        }
+      }];
+}
+
+RCT_EXPORT_METHOD(canOpenURL
+                  : (NSURL *)URL resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (__unused RCTPromiseRejectBlock)reject)
+{
+  if (RCTRunningInAppExtension()) {
+    // Technically Today widgets can open urls, but supporting that would require
+    // a reference to the NSExtensionContext
+    resolve(@NO);
+    return;
+  }
+
+  // This can be expensive, so we deliberately don't call on main thread
+  BOOL canOpen = [RCTSharedApplication() canOpenURL:URL];
+  NSString *scheme = [URL scheme];
+  if (canOpen) {
+    resolve(@YES);
+  } else if (![[scheme lowercaseString] hasPrefix:@"http"] && ![[scheme lowercaseString] hasPrefix:@"https"]) {
+    // On iOS 9 and above canOpenURL returns NO without a helpful error.
+    // Check if a custom scheme is being used, and if it exists in LSApplicationQueriesSchemes
+    NSArray *querySchemes = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"LSApplicationQueriesSchemes"];
+    if (querySchemes != nil &&
+        ([querySchemes containsObject:scheme] || [querySchemes containsObject:[scheme lowercaseString]])) {
+      resolve(@NO);
+    } else {
+      reject(
+          RCTErrorUnspecified,
+          [NSString
+              stringWithFormat:@"Unable to open URL: %@. Add %@ to LSApplicationQueriesSchemes in your Info.plist.",
+                               URL,
+                               scheme],
+          nil);
+    }
+  } else {
+    resolve(@NO);
+  }
+}
+
+RCT_EXPORT_METHOD(getInitialURL : (RCTPromiseResolveBlock)resolve reject : (__unused RCTPromiseRejectBlock)reject)
+{
+  NSURL *initialURL = nil;
+  if (self.bridge.launchOptions[UIApplicationLaunchOptionsURLKey]) {
+    initialURL = self.bridge.launchOptions[UIApplicationLaunchOptionsURLKey];
+  } else {
+    NSDictionary *userActivityDictionary =
+        self.bridge.launchOptions[UIApplicationLaunchOptionsUserActivityDictionaryKey];
+    if ([userActivityDictionary[UIApplicationLaunchOptionsUserActivityTypeKey] isEqual:NSUserActivityTypeBrowsingWeb]) {
+      initialURL = ((NSUserActivity *)userActivityDictionary[@"UIApplicationLaunchOptionsUserActivityKey"]).webpageURL;
+    }
+  }
+  resolve(RCTNullIfNil(initialURL.absoluteString));
+}
+
+RCT_EXPORT_METHOD(openSettings : (RCTPromiseResolveBlock)resolve reject : (__unused RCTPromiseRejectBlock)reject)
+{
+  NSURL *url = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
+  [RCTSharedApplication() openURL:url
+      options:@{}
+      completionHandler:^(BOOL success) {
+        if (success) {
+          resolve(nil);
+        } else {
+          reject(RCTErrorUnspecified, @"Unable to open app settings", nil);
+        }
+      }];
+}
+
+RCT_EXPORT_METHOD(sendIntent
+                  : (NSString *)action extras
+                  : (NSArray *_Nullable)extras resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject)
+{
+  RCTLogError(@"Not implemented: %@", NSStringFromSelector(_cmd));
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeLinkingManagerSpecJSI>(params);
+}
+
+@end
+
+Class RCTLinkingManagerCls(void)
+{
+  return RCTLinkingManager.class;
+}

package/Libraries/LinkingIOS/RCTLinkingPlugins.h

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// FB Internal: FBRCTLinkingPlugins.h is autogenerated by the build system.
+#import <React/FBRCTLinkingPlugins.h>
+
+#else
+
+// OSS-compatibility layer
+
+#import <Foundation/Foundation.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// RCTTurboModuleManagerDelegate should call this to resolve module classes.
+Class RCTLinkingClassProvider(const char *name);
+
+// Lookup functions
+Class RCTLinkingManagerCls(void) __attribute__((used));
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/LinkingIOS/RCTLinkingPlugins.mm

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifndef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// OSS-compatibility layer
+
+#import "RCTLinkingPlugins.h"
+
+#import <string>
+#import <unordered_map>
+
+Class RCTLinkingClassProvider(const char *name) {
+  // Intentionally leak to avoid crashing after static destructors are run.
+  static const auto sCoreModuleClassMap = new const std::unordered_map<std::string, Class (*)(void)>{
+    {"LinkingManager", RCTLinkingManagerCls},
+  };
+
+  auto p = sCoreModuleClassMap->find(name);
+  if (p != sCoreModuleClassMap->end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return nil;
+}
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/LinkingIOS/React-RCTLinking.podspec

@@ -0,0 +1,56 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+folly_version = folly_config[:version]
+
+header_search_paths = [
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+  "\"${PODS_ROOT}/Headers/Public/ReactCodegen/react/renderer/components\"",
+]
+
+Pod::Spec.new do |s|
+  s.name                   = "React-RCTLinking"
+  s.version                = version
+  s.summary                = "A general interface to interact with both incoming and outgoing app links."
+  s.homepage               = "https://reactnative.dev/"
+  s.documentation_url      = "https://reactnative.dev/docs/linking"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
+  s.source                 = source
+  s.source_files           = "*.{m,mm}"
+  s.preserve_paths         = "package.json", "LICENSE", "LICENSE-docs"
+  s.header_dir             = "RCTLinking"
+  s.pod_target_xcconfig    = {
+                               "USE_HEADERMAP" => "YES",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' ')
+                             }
+  s.framework = "UIKit"
+
+  s.dependency "React-Core/RCTLinkingHeaders", version
+  s.dependency "ReactCommon/turbomodule/core", version
+  s.dependency "React-jsi", version
+
+  add_dependency(s, "React-RCTFBReactNativeSpec")
+  add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
+  add_dependency(s, "React-NativeModulesApple", :additional_framework_paths => ["build/generated/ios"])
+end

package/Libraries/Lists/FillRateHelper.js

@@ -0,0 +1,19 @@
+/**
+ * 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-local
+ * @format
+ */
+
+'use strict';
+
+import {typeof FillRateHelper as FillRateHelperType} from '@react-native/virtualized-lists';
+
+const FillRateHelper: FillRateHelperType =
+  require('@react-native/virtualized-lists').FillRateHelper;
+
+export type {FillRateInfo} from '@react-native/virtualized-lists';
+module.exports = FillRateHelper;

package/Libraries/Lists/FlatList.d.ts

@@ -0,0 +1,244 @@
+/**
+ * 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
+ */
+
+import type * as React from 'react';
+import type {
+  ListRenderItem,
+  ViewToken,
+  VirtualizedListProps,
+  ViewabilityConfig,
+} from '@react-native/virtualized-lists';
+import type {ScrollViewComponent} from '../Components/ScrollView/ScrollView';
+import type {StyleProp} from '../StyleSheet/StyleSheet';
+import type {ViewStyle} from '../StyleSheet/StyleSheetTypes';
+import type {View} from '../Components/View/View';
+
+export interface FlatListProps<ItemT> extends VirtualizedListProps<ItemT> {
+  /**
+   * Optional custom style for multi-item rows generated when numColumns > 1
+   */
+  columnWrapperStyle?: StyleProp<ViewStyle> | undefined;
+
+  /**
+   * Determines when the keyboard should stay visible after a tap.
+   * - 'never' (the default), tapping outside of the focused text input when the keyboard is up dismisses the keyboard. When this happens, children won't receive the tap.
+   * - 'always', the keyboard will not dismiss automatically, and the scroll view will not catch taps, but children of the scroll view can catch taps.
+   * - 'handled', the keyboard will not dismiss automatically when the tap was handled by a children, (or captured by an ancestor).
+   * - false, deprecated, use 'never' instead
+   * - true, deprecated, use 'always' instead
+   */
+  keyboardShouldPersistTaps?:
+    | boolean
+    | 'always'
+    | 'never'
+    | 'handled'
+    | undefined;
+
+  /**
+   * An array (or array-like list) of items to render. Other data types can be
+   * used by targeting VirtualizedList directly.
+   */
+  data: ArrayLike<ItemT> | null | undefined;
+
+  /**
+   * A marker property for telling the list to re-render (since it implements PureComponent).
+   * If any of your `renderItem`, Header, Footer, etc. functions depend on anything outside of the `data` prop,
+   * stick it here and treat it immutably.
+   */
+  extraData?: any | undefined;
+
+  /**
+   * `getItemLayout` is an optional optimization that lets us skip measurement of dynamic
+   * content if you know the height of items a priori. getItemLayout is the most efficient,
+   * and is easy to use if you have fixed height items, for example:
+   * ```
+   * getItemLayout={(data, index) => (
+   *   {length: ITEM_HEIGHT, offset: ITEM_HEIGHT * index, index}
+   * )}
+   * ```
+   * Remember to include separator length (height or width) in your offset calculation if you specify
+   * `ItemSeparatorComponent`.
+   */
+  getItemLayout?:
+    | ((
+        data: ArrayLike<ItemT> | null | undefined,
+        index: number,
+      ) => {length: number; offset: number; index: number})
+    | undefined;
+
+  /**
+   * If true, renders items next to each other horizontally instead of stacked vertically.
+   */
+  horizontal?: boolean | null | undefined;
+
+  /**
+   * How many items to render in the initial batch
+   */
+  initialNumToRender?: number | undefined;
+
+  /**
+   * Instead of starting at the top with the first item, start at initialScrollIndex
+   */
+  initialScrollIndex?: number | null | undefined;
+
+  /**
+   * Used to extract a unique key for a given item at the specified index. Key is used for caching
+   * and as the react key to track item re-ordering. The default extractor checks `item.key`, then
+   * falls back to using the index, like React does.
+   */
+  keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
+
+  /**
+   * Uses legacy MetroListView instead of default VirtualizedSectionList
+   */
+  legacyImplementation?: boolean | undefined;
+
+  /**
+   * Multiple columns can only be rendered with `horizontal={false}` and will zig-zag like a `flexWrap` layout.
+   * Items should all be the same height - masonry layouts are not supported.
+   */
+  numColumns?: number | undefined;
+
+  /**
+   * If provided, a standard RefreshControl will be added for "Pull to Refresh" functionality.
+   * Make sure to also set the refreshing prop correctly.
+   */
+  onRefresh?: (() => void) | null | undefined;
+
+  /**
+   * Called when the viewability of rows changes, as defined by the `viewablePercentThreshold` prop.
+   */
+  onViewableItemsChanged?:
+    | ((info: {
+        viewableItems: Array<ViewToken<ItemT>>;
+        changed: Array<ViewToken<ItemT>>;
+      }) => void)
+    | null
+    | undefined;
+
+  /**
+   * Set this true while waiting for new data from a refresh.
+   */
+  refreshing?: boolean | null | undefined;
+
+  /**
+   * Takes an item from data and renders it into the list. Typical usage:
+   * ```
+   * _renderItem = ({item}) => (
+   *   <TouchableOpacity onPress={() => this._onPress(item)}>
+   *     <Text>{item.title}</Text>
+   *   </TouchableOpacity>
+   * );
+   * ...
+   * <FlatList data={[{title: 'Title Text', key: 'item1'}]} renderItem={this._renderItem} />
+   * ```
+   * Provides additional metadata like `index` if you need it.
+   */
+  renderItem: ListRenderItem<ItemT> | null | undefined;
+
+  /**
+   * See `ViewabilityHelper` for flow type and further documentation.
+   */
+  viewabilityConfig?: ViewabilityConfig | undefined;
+
+  /**
+   * Note: may have bugs (missing content) in some circumstances - use at your own risk.
+   *
+   * This may improve scroll performance for large lists.
+   */
+  removeClippedSubviews?: boolean | undefined;
+
+  /**
+   * Fades out the edges of the scroll content.
+   *
+   * If the value is greater than 0, the fading edges will be set accordingly
+   * to the current scroll direction and position,
+   * indicating if there is more content to show.
+   *
+   * The default value is 0.
+   * @platform android
+   */
+  fadingEdgeLength?: number | undefined;
+}
+
+export abstract class FlatListComponent<
+  ItemT,
+  Props,
+> extends React.Component<Props> {
+  /**
+   * Scrolls to the end of the content. May be janky without `getItemLayout` prop.
+   */
+  scrollToEnd: (params?: {animated?: boolean | null | undefined}) => void;
+
+  /**
+   * Scrolls to the item at the specified index such that it is positioned in the viewable area
+   * such that viewPosition 0 places it at the top, 1 at the bottom, and 0.5 centered in the middle.
+   * Cannot scroll to locations outside the render window without specifying the getItemLayout prop.
+   */
+  scrollToIndex: (params: {
+    animated?: boolean | null | undefined;
+    index: number;
+    viewOffset?: number | undefined;
+    viewPosition?: number | undefined;
+  }) => void;
+
+  /**
+   * Requires linear scan through data - use `scrollToIndex` instead if possible.
+   * May be janky without `getItemLayout` prop.
+   */
+  scrollToItem: (params: {
+    animated?: boolean | null | undefined;
+    item: ItemT;
+    viewOffset?: number | undefined;
+    viewPosition?: number | undefined;
+  }) => void;
+
+  /**
+   * Scroll to a specific content pixel offset, like a normal `ScrollView`.
+   */
+  scrollToOffset: (params: {
+    animated?: boolean | null | undefined;
+    offset: number;
+  }) => void;
+
+  /**
+   * Tells the list an interaction has occurred, which should trigger viewability calculations,
+   * e.g. if waitForInteractions is true and the user has not scrolled. This is typically called
+   * by taps on items or by navigation actions.
+   */
+  recordInteraction: () => void;
+
+  /**
+   * Displays the scroll indicators momentarily.
+   */
+  flashScrollIndicators: () => void;
+
+  /**
+   * Provides a handle to the underlying scroll responder.
+   */
+  getScrollResponder: () => JSX.Element | null | undefined;
+
+  /**
+   * Provides a reference to the underlying host component
+   */
+  getNativeScrollRef: () =>
+    | React.ElementRef<typeof View>
+    | React.ElementRef<typeof ScrollViewComponent>
+    | null
+    | undefined;
+
+  getScrollableNode: () => any;
+
+  setNativeProps: (props: {[key: string]: unknown}) => void;
+}
+
+export class FlatList<ItemT = any> extends FlatListComponent<
+  ItemT,
+  FlatListProps<ItemT>
+> {}