@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/scripts/deploy.js

@@ -0,0 +1,191 @@
+// @ts-check
+const { execSync } = require('child_process');
+const fs = require('node:fs');
+const readline = require('readline');
+
+const RNOH_REPO_TOKEN = process.env.RNOH_REPO_TOKEN ?? '';
+
+if (!RNOH_REPO_TOKEN) {
+  console.log('RNOH_REPO_TOKEN not found');
+  process.exit(1);
+}
+
+const EXPECTED_EXECUTION_DIRECTORY_NAME =
+  'react-native-harmony-reanimated';
+const GITLAB_URL = 'https://gl.swmansion.com';
+const GITLAB_PROJECT_ID = 522;
+const MODULE_NAME = 'reanimated';
+const HAR_FILE_OUTPUT_PATH = `tester/harmony/${MODULE_NAME}/build/default/outputs/default/${MODULE_NAME}.har`;
+const UNSCOPED_NPM_PACKAGE_NAME = 'react-native-harmony-reanimated';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function runDeployment() {
+  if (!process.cwd().endsWith(EXPECTED_EXECUTION_DIRECTORY_NAME)) {
+    console.log(
+      `This script should be executed from ${EXPECTED_EXECUTION_DIRECTORY_NAME} directory`
+    );
+    process.exit(1);
+  }
+
+  if (!isRepositoryClean()) {
+    console.log(
+      'Repository should be clean, on main branch and up to date with upstream.'
+    );
+    process.exit(1);
+  }
+
+  let version = '';
+
+  const currentVersion = JSON.parse(
+    fs.readFileSync('./package.json').toString()
+  )['version'];
+  rl.question(
+    `Current version: ${currentVersion}. Enter new version: `,
+    (newVersion) => {
+      version = newVersion;
+
+      execSync(`npm run update_version  -- --new-version ${version}`, {
+        stdio: 'inherit',
+      });
+
+      rl.question(
+        `Please generate ${HAR_FILE_OUTPUT_PATH} file. Open DevEco Studio, select any file in '${MODULE_NAME}' module, and run Build > Make Module '${MODULE_NAME}'.\nOnce you finish type 'done': `,
+        (answer) => {
+          if (answer !== 'done') {
+            console.log('Deployment aborted');
+            process.exit(1);
+          }
+          console.log(
+            `Copying ${`../${HAR_FILE_OUTPUT_PATH}`} to ./harmony dir`
+          );
+          if (!fs.existsSync(`../${HAR_FILE_OUTPUT_PATH}`)) {
+            console.log(`Couldn't find ${HAR_FILE_OUTPUT_PATH}.`);
+            process.exit(1);
+          }
+          fs.rmSync('./harmony', { recursive: true, force: true });
+          fs.mkdirSync('./harmony');
+          fs.renameSync(
+            `../${HAR_FILE_OUTPUT_PATH}`,
+            `./harmony/${MODULE_NAME}.har`
+          );
+
+          // const changelogForCurrentVersion = execSync(
+          //   `npm run -s gen:changelog`
+          // ).toString();
+          // updateChangelog(version, changelogForCurrentVersion);
+
+          execSync(`npm publish --dry-run`, { stdio: 'inherit' });
+
+          rl.question(
+            'Are changes good to be published and pushed to the upstream? (yes/no): ',
+            async (answer) => {
+              if (answer.toLowerCase() === 'yes') {
+                execSync(`npm publish`, { stdio: 'inherit' });
+                console.log('NPM Package was published successfully.');
+                execSync(
+                  `git checkout -b release-${UNSCOPED_NPM_PACKAGE_NAME}-${version}`
+                );
+                execSync('git add -A');
+                execSync(
+                  `git commit -m "release: ${UNSCOPED_NPM_PACKAGE_NAME}@${version}"`,
+                  {
+                    stdio: 'inherit',
+                  }
+                );
+                execSync(`git push -u origin HEAD --no-verify`, {
+                  stdio: 'inherit',
+                });
+
+                execSync(`git tag v${version}`);
+                execSync(`git push -u origin v${version} --no-verify`, {
+                  stdio: 'inherit',
+                });
+                const mergeRequestId = await createMergeRequest(
+                  `release-${UNSCOPED_NPM_PACKAGE_NAME}-${version}`,
+                  `release: ${UNSCOPED_NPM_PACKAGE_NAME}@${version}`
+                );
+                console.log(`Please merge the following Merge Request:\n
+                https://gl.swmansion.com/rnoh/${UNSCOPED_NPM_PACKAGE_NAME}/-/merge_requests/${mergeRequestId}`);
+                rl.close();
+              } else {
+                console.log('Deployment aborted.');
+                rl.close();
+              }
+            }
+          );
+        }
+      );
+    }
+  );
+}
+
+/**
+ * @returns {boolean}
+ */
+function isRepositoryClean() {
+  const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+  const branch = execSync('git branch --show-current', {
+    encoding: 'utf-8',
+  }).trim();
+  const isUpdated =
+    execSync('git rev-list HEAD...origin/main --count', {
+      encoding: 'utf-8',
+    }).trim() === '0';
+  return !status && branch === 'main' && isUpdated;
+}
+
+/**
+ * @param {string} version
+ *  @param {string} changelogForCurrentVersion
+ */
+function updateChangelog(version, changelogForCurrentVersion) {
+  let data = fs.readFileSync('../CHANGELOG.md').toString();
+  data = data.replace(
+    '# Changelog',
+    `# Changelog\n\n## v${version}\n ${changelogForCurrentVersion}`
+  );
+  fs.writeFileSync('../CHANGELOG.md', data);
+}
+
+/**
+ * @param {string} sourceBranch
+ * @param {string} title
+ * @returns {Promise<number>}
+ */
+async function createMergeRequest(sourceBranch, title) {
+  try {
+    const response = await fetch(
+      `${GITLAB_URL}/api/v4/projects/${GITLAB_PROJECT_ID}/merge_requests`,
+      {
+        method: 'POST',
+        headers: {
+          'PRIVATE-TOKEN': RNOH_REPO_TOKEN,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          source_branch: sourceBranch,
+          target_branch: 'main',
+          title: title,
+          squash: false,
+          remove_source_branch: true,
+        }),
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create merge request: ${response.statusText} ${response.status}`
+      );
+    }
+    const responseData = await response.json();
+    return responseData.iid;
+  } catch (error) {
+    console.error('Error creating merge request:', error);
+    throw error;
+  }
+}
+
+runDeployment();

package/scripts/set-reanimated-version.js

@@ -0,0 +1,37 @@
+const path = require('path');
+const { getFlags, getVersion } = require('../../../scripts/releasing');
+const {
+  updateVersion,
+  updatePeerDependency,
+} = require('../../../scripts/version-utils');
+
+const packageJsonPath = path.resolve(__dirname, '../package.json');
+const jsVersionPath = path.resolve(
+  __dirname,
+  '../src/platform-specific/jsVersion.ts'
+);
+
+const { argv } = process;
+const { currentVersion, newVersion } = getVersion(argv, packageJsonPath);
+
+updateVersion(packageJsonPath, jsVersionPath, newVersion);
+
+if (getFlags(argv).flags.nightly) {
+  const workletsPackageJsonPath = path.resolve(
+    __dirname,
+    '../../react-native-worklets/package.json'
+  );
+  const { newVersion: newWorkletsVersion } = getVersion(
+    argv,
+    workletsPackageJsonPath
+  );
+
+  updatePeerDependency(
+    packageJsonPath,
+    'react-native-worklets',
+    newWorkletsVersion
+  );
+}
+
+// Log the current version so it can be restored if needed.
+console.log(currentVersion);

package/scripts/update-version.js

@@ -0,0 +1,119 @@
+//@ts-check
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync } = require('node:child_process');
+const JSON5 = require('json5');
+
+const PACKAGE_DIR_NAME = 'react-native-harmony-reanimated';
+const MODULE_NAME = 'reanimated';
+const PACKAGE_TGZ_STEM_NAME_WITHOUT_VERSION =
+  'rnoh-react-native-harmony-reanimated';
+
+(async function main() {
+  const newVersionIndex = process.argv.findIndex(
+    (arg) => arg === '--new-version'
+  );
+  let version;
+
+  if (newVersionIndex !== -1 && process.argv[newVersionIndex + 1]) {
+    version = process.argv[newVersionIndex + 1];
+  } else {
+    const currentVersion = readPackage('.').version;
+    version = await askUserForVersion(currentVersion);
+  }
+
+  updatePackageVersion('.', version);
+  console.log(`Updated ${PACKAGE_DIR_NAME}/package.json`);
+  updatePackageScript('../tester', version);
+  console.log('Updated tester/package.json');
+  updateOHPackageVersion(
+    `../tester/harmony/${MODULE_NAME}/oh-package.json5`,
+    version
+  );
+  console.log(`Updated ${MODULE_NAME}/oh-package.json5`);
+  execSync('npm i && cd ../tester', { stdio: 'inherit' });
+})();
+
+/**
+ * @param {string} currentVersion
+ * @returns {Promise<string>}
+ */
+function askUserForVersion(currentVersion) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(
+      `Current version: ${currentVersion}. Enter new version: `,
+      (userInput) => {
+        rl.close();
+        resolve(userInput);
+      }
+    );
+  });
+}
+
+/**
+ * @param {string} packageDir
+ * @returns {{version: string, scripts?: Record<string, string>}} - parsed content of package.json
+ */
+function readPackage(packageDir) {
+  const packageJsonPath = path.join(packageDir, 'package.json');
+  const packageContent = fs.readFileSync(packageJsonPath, 'utf-8');
+  return JSON.parse(packageContent);
+}
+
+/**
+ * @param {string} packageDir
+ * @param {string} version
+ */
+function updatePackageVersion(packageDir, version) {
+  const packageData = readPackage(packageDir);
+  packageData.version = version;
+
+  const packageJsonPath = path.join(packageDir, 'package.json');
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageData, null, 2),
+    'utf-8'
+  );
+}
+
+/**
+ * @param {string} packageDir
+ * @param {string} version
+ */
+function updatePackageScript(packageDir, version) {
+  const packageData = readPackage(packageDir);
+
+  for (let script in packageData.scripts) {
+    const regex = new RegExp(
+      `${PACKAGE_TGZ_STEM_NAME_WITHOUT_VERSION}-\\d*\\.\\d*\\.\\d*`,
+      'g'
+    );
+    packageData.scripts[script] = packageData.scripts[script].replace(
+      regex,
+      `${PACKAGE_TGZ_STEM_NAME_WITHOUT_VERSION}-${version}`
+    );
+  }
+  const packageJsonPath = path.join(packageDir, 'package.json');
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageData, null, 2),
+    'utf-8'
+  );
+}
+/**
+ * @param {string} ohPackagePath
+ * @param {string} version
+ */
+function updateOHPackageVersion(ohPackagePath, version) {
+  const ohPackageContent = JSON5.parse(
+    fs.readFileSync(ohPackagePath).toString()
+  );
+  ohPackageContent.version = version;
+  fs.writeFileSync(ohPackagePath, JSON5.stringify(ohPackageContent, null, 2));
+}

package/scripts/validate-react-native-version.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const semverSatisfies = require('semver/functions/satisfies');
+const semverPrerelease = require('semver/functions/prerelease');
+const path = require('path');
+
+const packageJsonPath = path.resolve(__dirname, '../package.json');
+const packageJson = require(packageJsonPath);
+const reanimatedVersion = packageJson.version;
+const compatibilityFile = require('../compatibility.json');
+
+const reactNativeVersion = process.argv[2];
+const architecture = 'fabric';
+const supportedRNVersions = [];
+
+if (semverPrerelease(reactNativeVersion)) {
+  // Don't perform any checks for pre-release versions, like nightlies or
+  // feature previews. The user knows what they're doing.
+  process.exit(0);
+}
+
+for (const key in compatibilityFile[architecture]) {
+  if (semverSatisfies(reanimatedVersion, key)) {
+    supportedRNVersions.push(
+      // @ts-ignore
+      ...compatibilityFile[architecture][key]['react-native']
+    );
+  }
+}
+
+// If user uses a version of Reanimated that is not listed in the compatibility file, we skip the check
+if (supportedRNVersions.length === 0) {
+  process.exit(0);
+}
+
+for (const version of supportedRNVersions) {
+  if (semverSatisfies(reactNativeVersion, `${version}.x`)) {
+    process.exit(0);
+  }
+}
+
+// eslint-disable-next-line reanimated/use-logger
+console.error(
+  `[Reanimated] Your installed version of React Native (${reactNativeVersion}) is not compatible with installed version of Reanimated (${reanimatedVersion}). See the documentation for the list of supported versions: https://docs.swmansion.com/react-native-reanimated/docs/guides/compatibility/`
+);
+process.exit(1);

package/scripts/validate-worklets-build.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// We don't use this script in runtime since `process` might not be available.
+
+const path = require('path');
+const packageJsonPath = path.resolve(__dirname, '../package.json');
+const packageJson = require(packageJsonPath);
+const reanimatedVersion = packageJson.version;
+
+const validateVersion = require('./validate-worklets-version');
+
+const result = validateVersion(reanimatedVersion);
+if (!result.ok) {
+  // eslint-disable-next-line reanimated/use-logger
+  console.error('[Reanimated] ' + result.message);
+  process.exit(1);
+}

package/scripts/validate-worklets-version.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const semverSatisfies = require('semver/functions/satisfies');
+const semverPrerelease = require('semver/functions/prerelease');
+const semverOutside = require('semver/ranges/outside');
+const expectedVersion = require('./worklets-version.json');
+const compatibilityFile = require('../compatibility.json');
+
+const architecture = 'fabric';
+
+/**
+ * @param {string} reanimatedVersion
+ * @returns {{ ok: boolean; message?: string }}
+ */
+function validateVersion(reanimatedVersion) {
+  let workletsVersion;
+  try {
+    const { version } = require('react-native-worklets/package.json');
+    workletsVersion = version;
+  } catch (_e) {
+    return {
+      ok: false,
+      message:
+        "react-native-worklets package isn't installed. Please install a version between " +
+        expectedVersion.min +
+        ' and ' +
+        expectedVersion.max +
+        ' to use Reanimated ' +
+        reanimatedVersion +
+        '.',
+    };
+  }
+
+  if (semverPrerelease(workletsVersion)) {
+    /**
+     * Don't perform any checks for pre-release versions, like nightlies or
+     * feature previews. The user knows what they're doing.
+     */
+    return { ok: true };
+  }
+
+  const supportedWorkletsVersions = [];
+
+  for (const key in compatibilityFile[architecture]) {
+    if (semverSatisfies(reanimatedVersion, key)) {
+      supportedWorkletsVersions.push(
+        // @ts-ignore
+        ...compatibilityFile[architecture][key]['react-native-worklets']
+      );
+    }
+  }
+
+  if (supportedWorkletsVersions.length === 0) {
+    return { ok: true };
+  }
+
+  for (const version of supportedWorkletsVersions) {
+    if (semverSatisfies(workletsVersion, version)) {
+      return { ok: true };
+    }
+  }
+
+  const earliestSupportedVersion = supportedWorkletsVersions[0];
+  const latestSupportedVersion =
+    supportedWorkletsVersions[supportedWorkletsVersions.length - 1];
+
+  const isHigher = semverOutside(workletsVersion, latestSupportedVersion, '>');
+
+  const installMessage = isHigher
+    ? `Please install the latest supported version of Worklets ${latestSupportedVersion} or older`
+    : `Please install Worklets ${earliestSupportedVersion} or newer`;
+
+  return {
+    ok: false,
+    message: `Your installed version of Worklets (${workletsVersion}) is not compatible with installed version of Reanimated (${reanimatedVersion}). ${installMessage}. See the documentation for the list of supported versions: https://docs.swmansion.com/react-native-reanimated/docs/guides/compatibility/#supported-react-native-worklets-versions`,
+  };
+}
+
+module.exports = validateVersion;

package/scripts/worklets-version.json

@@ -0,0 +1,4 @@
+{
+  "min": "0.7.0",
+  "max": "0.7"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Software Mansion <swmansion.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.OpenSource

@@ -1,11 +0,0 @@
-[
-    {
-        "Name": "react-native-reanimated",
-        "License": "MIT License",
-        "License File": "LICENSE",
-        "Version Number": "3.18.0",
-        "Owner" : "xiafeng@huawei.com",
-        "Upstream URL": "https://github.com/software-mansion/react-native-reanimated",
-        "Description": "React Native's Animated library reimplemented"
-    }
-]

package/README.md

@@ -1,10 +0,0 @@
-# @react-native-ohos/react-native-reanimated
-This project is based on [react-native-reanimated@v3.18.0](https://github.com/software-mansion/react-native-reanimated/tree/3.18.0)
-
-## Documentation
-[中文](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-cn/react-native-reanimated.md)
-
-[English](https://gitee.com/react-native-oh-library/usage-docs/blob/master/en/react-native-reanimated.md)
-
-## License
-This library is licensed under [The MIT License (MIT)](https://github.com/react-native-oh-library/react-native-harmony-reanimated/blob/sig/LICENSE).

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.cpp

@@ -1,68 +0,0 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-
-namespace reanimated {
-
-std::lock_guard<std::mutex> PropsRegistry::createLock() const {
-  return std::lock_guard<std::mutex>(mutex_);
-}
-
-void PropsRegistry::update(
-    const ShadowNode::Shared &shadowNode,
-    folly::dynamic &&props) {
-  const auto tag = shadowNode->getTag();
-  const auto it = map_.find(tag);
-  if (it == map_.cend()) {
-    // we need to store ShadowNode because `ShadowNode::getFamily`
-    // returns `ShadowNodeFamily const &` which is non-owning
-    map_[tag] = std::make_pair(shadowNode, props);
-  } else {
-    // no need to update `.first` because ShadowNode's family never changes
-    // merge new props with old props
-    it->second.second.update(props);
-  }
-}
-
-void PropsRegistry::for_each(std::function<void(
-                                 const ShadowNodeFamily &family,
-                                 const folly::dynamic &props)> callback) const {
-  for (const auto &[_, value] : map_) {
-    callback(value.first->getFamily(), value.second);
-  }
-}
-
-void PropsRegistry::markNodeAsRemovable(const ShadowNode::Shared &shadowNode) {
-  removableShadowNodes_[shadowNode->getTag()] = shadowNode;
-}
-
-void PropsRegistry::unmarkNodeAsRemovable(Tag viewTag) {
-  removableShadowNodes_.erase(viewTag);
-}
-
-void PropsRegistry::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
-  for (auto it = removableShadowNodes_.begin();
-       it != removableShadowNodes_.end();) {
-    const auto &shadowNode = it->second;
-    const auto &family = shadowNode->getFamily();
-    const auto &ancestors = family.getAncestors(rootShadowNode);
-
-    // Skip if the node hasn't been removed
-    if (!ancestors.empty()) {
-      ++it;
-      continue;
-    }
-
-    const auto tag = shadowNode->getTag();
-    map_.erase(tag);
-    it = removableShadowNodes_.erase(it);
-  }
-}
-
-void PropsRegistry::remove(const Tag tag) {
-  map_.erase(tag);
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.h

@@ -1,68 +0,0 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/components/root/RootShadowNode.h>
-#include <react/renderer/core/ShadowNode.h>
-
-#include <unordered_map>
-#include <utility>
-
-using namespace facebook;
-using namespace react;
-
-namespace reanimated {
-
-class PropsRegistry {
- public:
-  std::lock_guard<std::mutex> createLock() const;
-  // returns a lock you need to hold when calling any of the methods below
-
-  void update(const ShadowNode::Shared &shadowNode, folly::dynamic &&props);
-
-  void for_each(std::function<void(
-                    const ShadowNodeFamily &family,
-                    const folly::dynamic &props)> callback) const;
-
-  void remove(const Tag tag);
-
-  void pauseReanimatedCommits() {
-    isPaused_ = true;
-  }
-
-  bool shouldReanimatedSkipCommit() {
-    return isPaused_;
-  }
-
-  void unpauseReanimatedCommits() {
-    isPaused_ = false;
-  }
-
-  void pleaseCommitAfterPause() {
-    shouldCommitAfterPause_ = true;
-  }
-
-  bool shouldCommitAfterPause() {
-    return shouldCommitAfterPause_.exchange(false);
-  }
-
-  bool isEmpty() {
-    return map_.empty();
-  }
-
-  void markNodeAsRemovable(const ShadowNode::Shared &shadowNode);
-  void unmarkNodeAsRemovable(Tag viewTag);
-  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
-
- private:
-  std::unordered_map<Tag, std::pair<ShadowNode::Shared, folly::dynamic>> map_;
-  std::unordered_map<Tag, ShadowNode::Shared> removableShadowNodes_;
-
-  mutable std::mutex mutex_; // Protects `map_`.
-
-  std::atomic<bool> isPaused_;
-  std::atomic<bool> shouldCommitAfterPause_;
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED