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

package/Libraries/FBLazyVector/FBLazyVector/FBLazyIterator.h

@@ -0,0 +1,127 @@
+/*
+ * 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
+
+#import <functional>
+#import <iterator>
+
+namespace FB {
+
+template <typename T, typename U>
+class LazyIterator {
+ public:
+  using value_type = T;
+  using pointer = std::unique_ptr<T>;
+  using reference = T;
+  using iterator_category = std::random_access_iterator_tag;
+  using difference_type = std::int32_t;
+  using size_type = std::int32_t;
+  using convert_type = std::function<T(U)>;
+
+ public:
+  LazyIterator() = default;
+
+  LazyIterator(U vector, convert_type convert, size_type i)
+      : _v(vector), _i(i), _convert(std::move(convert)) {}
+
+  bool operator==(const LazyIterator& other) const {
+    return _i == other._i && _v == other._v;
+  }
+
+  bool operator<(const LazyIterator& b) const {
+    return _i < b._i;
+  }
+
+  value_type operator*() const {
+    return _convert(_v[_i]);
+  }
+
+  std::unique_ptr<value_type> operator->() const {
+    return std::make_unique<value_type>(*this);
+  }
+
+  LazyIterator operator+(difference_type n) const {
+    return LazyIterator(_v, _convert, _i + n);
+  }
+
+  LazyIterator& operator+=(difference_type n) {
+    _i += n;
+    return *this;
+  }
+
+  LazyIterator& operator-=(difference_type n) {
+    _i -= n;
+    return *this;
+  }
+
+  LazyIterator operator-(difference_type n) const {
+    return LazyIterator(_v, _i - n);
+  }
+
+  difference_type operator-(const LazyIterator& a) const {
+    return _i - a._i;
+  }
+
+  LazyIterator& operator++() {
+    return *this += 1;
+  }
+
+  LazyIterator operator++(int) {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  LazyIterator& operator--() {
+    return *this -= 1;
+  }
+
+  LazyIterator operator--(int) {
+    auto tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+  value_type operator[](difference_type n) const {
+    return _convert(_v[_i + n]);
+  }
+
+ private:
+  U _v;
+  size_type _i;
+  convert_type _convert;
+};
+
+template <typename T, typename U>
+LazyIterator<T, U> operator+(
+    typename LazyIterator<T, U>::difference_type n,
+    const LazyIterator<T, U>& i) {
+  return i + n;
+}
+
+template <typename T, typename U>
+bool operator!=(const LazyIterator<T, U>& a, const LazyIterator<T, U>& b) {
+  return !(a == b);
+}
+
+template <typename T, typename U>
+bool operator<=(const LazyIterator<T, U>& a, const LazyIterator<T, U>& b) {
+  return a < b || a == b;
+}
+
+template <typename T, typename U>
+bool operator>(const LazyIterator<T, U>& a, const LazyIterator<T, U>& b) {
+  return b < a;
+}
+
+template <typename T, typename U>
+bool operator>=(const LazyIterator<T, U>& a, const LazyIterator<T, U>& b) {
+  return a > b || a == b;
+}
+
+} // namespace FB

package/Libraries/FBLazyVector/FBLazyVector/FBLazyVector.h

@@ -0,0 +1,102 @@
+/*
+ * 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
+
+#import <cassert>
+#import <functional>
+#import <iterator>
+
+#import <FBLazyVector/FBLazyIterator.h>
+
+namespace FB {
+
+/**
+ * Presents a type-safe wrapper around an arbitrary object that represents an
+ * _immutable_ array of objects. Each item is constructed lazily on demand and
+ * reconstructed on each access; there is no caching.
+ */
+template <typename T, typename U>
+class LazyVector {
+ public:
+  using value_type = T;
+  using reference = T;
+  using const_reference = T;
+  using const_iterator = LazyIterator<T, U>;
+  using iterator = const_iterator;
+  using size_type = std::int32_t;
+  using convert_type = std::function<T(U)>;
+
+  static LazyVector<T, U>
+  fromUnsafeRawValue(U v, size_type size, convert_type convert) {
+    return {v, size, convert};
+  }
+
+  U unsafeRawValue() const {
+    return _v;
+  }
+
+  bool empty() const {
+    return _size == 0;
+  }
+
+  size_type size() const {
+    return _size;
+  }
+
+  const_reference at(size_type pos) const {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    if (!(pos < _size))
+      throw std::out_of_range("out of range");
+#else
+    assert(pos < _size || !"out of range");
+#endif
+    return _convert(_v[pos]);
+  }
+
+  const_reference operator[](size_type pos) const {
+    assert(pos < _size);
+    return _convert(_v[pos]);
+  }
+
+  const_reference front() const {
+    assert(_size);
+    return (*this)[0];
+  }
+
+  const_reference back() const {
+    assert(_size);
+    return (*this)[_size - 1];
+  }
+
+  const_iterator begin() const {
+    return const_iterator(_v, _convert, 0);
+  }
+
+  const_iterator cbegin() const {
+    return begin();
+  }
+
+  const_iterator end() const {
+    return const_iterator(_v, _convert, _size);
+  }
+
+  const_iterator cend() const {
+    return end();
+  }
+
+ private:
+  /** Wrapped vector */
+  LazyVector(U vector, size_type size, convert_type convert)
+      : _v(vector), _size(size), _convert(convert) {}
+
+  U _v;
+  size_type _size;
+  convert_type _convert;
+};
+
+} // namespace FB

package/Libraries/FBLazyVector/FBLazyVector.podspec

@@ -0,0 +1,31 @@
+# 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
+
+Pod::Spec.new do |s|
+  s.name                   = "FBLazyVector"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = "**/*.{c,h,m,mm,cpp}"
+  s.header_dir             = "FBLazyVector"
+
+end

package/Libraries/HeapCapture/HeapCapture.js

@@ -0,0 +1,29 @@
+/**
+ * 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 NativeJSCHeapCapture from './NativeJSCHeapCapture';
+
+const HeapCapture = {
+  captureHeap: function (path: string) {
+    let error = null;
+    try {
+      global.nativeCaptureHeap(path);
+      console.log('HeapCapture.captureHeap succeeded: ' + path);
+    } catch (e) {
+      console.log('HeapCapture.captureHeap error: ' + e.toString());
+      error = e.toString();
+    }
+    if (NativeJSCHeapCapture) {
+      NativeJSCHeapCapture.captureComplete(path, error);
+    }
+  },
+};
+
+module.exports = HeapCapture;

package/Libraries/HeapCapture/NativeJSCHeapCapture.js

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+
+export * from '../../src/private/specs/modules/NativeJSCHeapCapture';
+import NativeJSCHeapCapture from '../../src/private/specs/modules/NativeJSCHeapCapture';
+export default NativeJSCHeapCapture;

package/Libraries/Image/AssetRegistry.js

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+module.exports = require('@react-native/assets-registry/registry');

package/Libraries/Image/AssetSourceResolver.harmony.ts

@@ -1,11 +1,64 @@
-import {
-  getAssetDestRelativePath,
-  Asset,
-} from '@react-native-oh/react-native-harmony-cli/src/assetResolver';
-import {
-  getBasePath,
-} from '@react-native/assets-registry/path-support';
-import { Platform } from 'react-native';
+/**
+ * Copyright (c) 2024 Huawei Technologies Co., Ltd.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { AssetData } from 'metro';
+// @ts-ignore
+import { getBasePath } from '@react-native/assets-registry/path-support';
+import { Dimensions, Platform } from 'react-native';
+
+const ALLOWED_SCALES: number[] = [1, 2, 3, 4];
+
+function filterAssetScales(
+  scales: readonly number[],
+): readonly number[] {
+  const result = scales.filter(scale => ALLOWED_SCALES.includes(scale));
+  if (result.length === 0 && scales.length > 0) {
+    // No matching scale found, but there are some available. Ideally we don't
+    // want to be in this situation and should throw, but for now as a fallback
+    // let's just use the closest larger image
+    const maxScale = ALLOWED_SCALES[ALLOWED_SCALES.length - 1];
+    for (const scale of scales) {
+      if (scale > maxScale) {
+        result.push(scale);
+        break;
+      }
+    }
+    // There is no larger scales available, use the largest we have
+    if (result.length === 0) {
+      result.push(scales[scales.length - 1]);
+    }
+  }
+  return result;
+}
+
+function pickScale(scales: Array<number>, deviceScale?: number): number {
+  const validScales = filterAssetScales(scales);
+  if (deviceScale == null) {
+    deviceScale = Dimensions.get('window').scale;
+  }
+  // Packager guarantees that `scales` array is sorted
+  for (let i = 0; i < validScales.length; i++) {
+    if (validScales[i] >= deviceScale) {
+      return validScales[i];
+    }
+  }
+
+  // If nothing matches, device scale is larger than any available
+  // scales, so we return the biggest one. Unless the array is empty,
+  // in which case we default to 1
+  return validScales[validScales.length - 1] || 1;
+}
+
+function getScaledAssetPath(asset: AssetData): string {
+  const scale = pickScale(asset.scales);
+  const scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+  const assetDir = getBasePath(asset);
+  return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+}
 
 type ResolvedAssetSource = {
   readonly __packager_asset: boolean;
@@ -15,40 +68,33 @@ type ResolvedAssetSource = {
   readonly scale: number;
 };
 
-function getAssetPath(asset: Asset): string {
-  const assetDir = getBasePath(asset);
-  return assetDir + '/' + asset.name + '.' + asset.type;
-}
-
 class AssetSourceResolver {
   constructor(
     private serverUrl: string | undefined,
     private jsbundleUrl: string | undefined,
-    private asset: Asset
+    private asset: AssetData
   ) {}
 
   isLoadedFromServer(): boolean {
     return !!this.serverUrl;
   }
 
-  isLoadedFromFileSystem(): boolean {
-    return !!(this.jsbundleUrl && this.jsbundleUrl.startsWith('file://'));
-  }
-
   public defaultAsset(): ResolvedAssetSource {
     if (this.isLoadedFromServer()) {
       return this.assetServerURL();
     }
 
-    const prefix = this.isLoadedFromFileSystem() ? this.jsbundleUrl : 'asset://';
+    const path = 'asset://';
 
-    return {
-      __packager_asset: this.asset.__packager_asset,
-      uri: `${prefix}${getAssetDestRelativePath(this.asset)}`,
-      scale: 1,
-      width: this.asset.width,
-      height: this.asset.height,
-    };
+    // Assets can have relative paths outside of the project root.
+    // Replace `../` with `_` to make sure they don't end up outside of
+    // the expected assets directory.
+    return this.fromSource(
+      path +
+        getScaledAssetPath(this.asset)
+          .replace(/^assets\//, '')
+          .replace(/\.\.\//g, '_')
+    );
   }
 
   /**
@@ -62,11 +108,11 @@ class AssetSourceResolver {
 
     return this.fromSource(
       this.serverUrl +
-      getAssetPath(this.asset) +
+        getScaledAssetPath(this.asset) +
         '?platform=' +
         Platform.OS +
         '&hash=' +
-        this.asset.hash,
+        this.asset.hash
     );
   }
 
@@ -76,7 +122,7 @@ class AssetSourceResolver {
       width: this.asset.width,
       height: this.asset.height,
       uri: source,
-      scale: 1,
+      scale: pickScale(this.asset.scales),
     };
   }
 }

package/Libraries/Image/AssetSourceResolver.js

@@ -0,0 +1,202 @@
+/**
+ * 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';
+
+export type ResolvedAssetSource = {|
+  +__packager_asset: boolean,
+  +width: ?number,
+  +height: ?number,
+  +uri: string,
+  +scale: number,
+|};
+
+import type {
+  AssetDestPathResolver,
+  PackagerAsset,
+} from '@react-native/assets-registry/registry';
+
+const PixelRatio = require('../Utilities/PixelRatio').default;
+const Platform = require('../Utilities/Platform');
+const {pickScale} = require('./AssetUtils');
+const {
+  getAndroidResourceFolderName,
+  getAndroidResourceIdentifier,
+  getBasePath,
+} = require('@react-native/assets-registry/path-support');
+const invariant = require('invariant');
+
+/**
+ * Returns a path like 'assets/AwesomeModule/icon@2x.png'
+ */
+function getScaledAssetPath(asset: PackagerAsset): string {
+  const scale = pickScale(asset.scales, PixelRatio.get());
+  const scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+  const assetDir = getBasePath(asset);
+  return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+}
+
+/**
+ * Returns a path like 'drawable-mdpi/icon.png'
+ */
+function getAssetPathInDrawableFolder(asset: PackagerAsset): string {
+  const scale = pickScale(asset.scales, PixelRatio.get());
+  const drawableFolder = getAndroidResourceFolderName(asset, scale);
+  const fileName = getAndroidResourceIdentifier(asset);
+  return drawableFolder + '/' + fileName + '.' + asset.type;
+}
+
+/**
+ * Returns true if the asset can be loaded over the network.
+ */
+function assetSupportsNetworkLoads(asset: PackagerAsset): boolean {
+  return !(asset.type === 'xml' && Platform.OS === 'android');
+}
+
+class AssetSourceResolver {
+  serverUrl: ?string;
+  // where the jsbundle is being run from
+  jsbundleUrl: ?string;
+  // the asset to resolve
+  asset: PackagerAsset;
+
+  constructor(serverUrl: ?string, jsbundleUrl: ?string, asset: PackagerAsset) {
+    this.serverUrl = serverUrl;
+    this.jsbundleUrl = jsbundleUrl;
+    this.asset = asset;
+  }
+
+  isLoadedFromServer(): boolean {
+    return (
+      this.serverUrl != null &&
+      this.serverUrl !== '' &&
+      assetSupportsNetworkLoads(this.asset)
+    );
+  }
+
+  isLoadedFromFileSystem(): boolean {
+    return this.jsbundleUrl != null && this.jsbundleUrl?.startsWith('file://');
+  }
+
+  defaultAsset(): ResolvedAssetSource {
+    if (this.isLoadedFromServer()) {
+      return this.assetServerURL();
+    }
+
+    if (this.asset.resolver != null) {
+      return this.getAssetUsingResolver(this.asset.resolver);
+    }
+
+    if (Platform.OS === 'android') {
+      return this.isLoadedFromFileSystem()
+        ? this.drawableFolderInBundle()
+        : this.resourceIdentifierWithoutScale();
+    } else {
+      return this.scaledAssetURLNearBundle();
+    }
+  }
+
+  getAssetUsingResolver(resolver: AssetDestPathResolver): ResolvedAssetSource {
+    switch (resolver) {
+      case 'android':
+        return this.isLoadedFromFileSystem()
+          ? this.drawableFolderInBundle()
+          : this.resourceIdentifierWithoutScale();
+      case 'generic':
+        return this.scaledAssetURLNearBundle();
+      default:
+        throw new Error(
+          "Don't know how to get asset via provided resolver: " +
+            resolver +
+            '\nAsset: ' +
+            JSON.stringify(this.asset, null, '\t') +
+            '\nPossible resolvers are:' +
+            JSON.stringify(['android', 'generic'], null, '\t'),
+        );
+    }
+  }
+
+  /**
+   * Returns an absolute URL which can be used to fetch the asset
+   * from the devserver
+   */
+  assetServerURL(): ResolvedAssetSource {
+    invariant(this.serverUrl != null, 'need server to load from');
+    return this.fromSource(
+      this.serverUrl +
+        getScaledAssetPath(this.asset) +
+        '?platform=' +
+        Platform.OS +
+        '&hash=' +
+        this.asset.hash,
+    );
+  }
+
+  /**
+   * Resolves to just the scaled asset filename
+   * E.g. 'assets/AwesomeModule/icon@2x.png'
+   */
+  scaledAssetPath(): ResolvedAssetSource {
+    return this.fromSource(getScaledAssetPath(this.asset));
+  }
+
+  /**
+   * Resolves to where the bundle is running from, with a scaled asset filename
+   * E.g. 'file:///sdcard/bundle/assets/AwesomeModule/icon@2x.png'
+   */
+  scaledAssetURLNearBundle(): ResolvedAssetSource {
+    const path = this.jsbundleUrl ?? 'file://';
+    return this.fromSource(
+      // Assets can have relative paths outside of the project root.
+      // When bundling them we replace `../` with `_` to make sure they
+      // don't end up outside of the expected assets directory.
+      path + getScaledAssetPath(this.asset).replace(/\.\.\//g, '_'),
+    );
+  }
+
+  /**
+   * The default location of assets bundled with the app, located by
+   * resource identifier
+   * The Android resource system picks the correct scale.
+   * E.g. 'assets_awesomemodule_icon'
+   */
+  resourceIdentifierWithoutScale(): ResolvedAssetSource {
+    invariant(
+      Platform.OS === 'android',
+      'resource identifiers work on Android',
+    );
+    return this.fromSource(getAndroidResourceIdentifier(this.asset));
+  }
+
+  /**
+   * If the jsbundle is running from a sideload location, this resolves assets
+   * relative to its location
+   * E.g. 'file:///sdcard/AwesomeModule/drawable-mdpi/icon.png'
+   */
+  drawableFolderInBundle(): ResolvedAssetSource {
+    const path = this.jsbundleUrl ?? 'file://';
+    return this.fromSource(path + getAssetPathInDrawableFolder(this.asset));
+  }
+
+  fromSource(source: string): ResolvedAssetSource {
+    return {
+      __packager_asset: true,
+      width: this.asset.width,
+      height: this.asset.height,
+      uri: source,
+      scale: pickScale(this.asset.scales, PixelRatio.get()),
+    };
+  }
+
+  static pickScale: (scales: Array<number>, deviceScale?: number) => number =
+    pickScale;
+}
+
+module.exports = AssetSourceResolver;