react-native-update-cli 2.8.5 → 2.9.0

package/src/bundle-pack.ts

@@ -0,0 +1,51 @@
+import path from 'path';
+import * as fs from 'fs-extra';
+import { ZipFile as YazlZipFile } from 'yazl';
+import { t } from './utils/i18n';
+
+const ignorePackingFileNames = [
+  '.',
+  '..',
+  'index.bundlejs.map',
+  'bundle.harmony.js.map',
+];
+const ignorePackingExtensions = ['DS_Store', 'txt.map'];
+
+export async function packBundle(dir: string, output: string): Promise<void> {
+  console.log(t('packing'));
+  fs.ensureDirSync(path.dirname(output));
+  await new Promise<void>((resolve, reject) => {
+    const zipfile = new YazlZipFile();
+
+    function addDirectory(root: string, rel: string) {
+      if (rel) {
+        zipfile.addEmptyDirectory(rel);
+      }
+      const children = fs.readdirSync(root);
+      for (const name of children) {
+        if (
+          ignorePackingFileNames.includes(name) ||
+          ignorePackingExtensions.some((ext) => name.endsWith(`.${ext}`))
+        ) {
+          continue;
+        }
+        const fullPath = path.join(root, name);
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          zipfile.addFile(fullPath, rel + name);
+        } else if (stat.isDirectory()) {
+          addDirectory(fullPath, `${rel}${name}/`);
+        }
+      }
+    }
+
+    addDirectory(dir, '');
+
+    zipfile.outputStream.on('error', (err: unknown) => reject(err));
+    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
+      resolve();
+    });
+    zipfile.end();
+  });
+  console.log(t('fileGenerated', { file: output }));
+}

package/src/bundle-runner.ts

@@ -0,0 +1,463 @@
+import { spawn, spawnSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { satisfies } from 'compare-versions';
+import * as fs from 'fs-extra';
+import { t } from './utils/i18n';
+
+const g2js = require('gradle-to-js/lib/parser');
+const properties = require('properties');
+
+export interface BundleCliOptions {
+  taro?: boolean;
+  expo?: boolean;
+  rncli?: boolean;
+}
+
+export interface RunBundleCommandOptions {
+  bundleName: string;
+  dev: string;
+  entryFile: string;
+  outputFolder: string;
+  platform: string;
+  sourcemapOutput: string;
+  config?: string;
+  forceHermes?: boolean;
+  cli: BundleCliOptions;
+  isSentry: boolean;
+}
+
+interface GradleConfig {
+  crunchPngs?: boolean;
+  enableHermes?: boolean;
+}
+
+export async function runReactNativeBundleCommand({
+  bundleName,
+  dev,
+  entryFile,
+  outputFolder,
+  platform,
+  sourcemapOutput,
+  config,
+  forceHermes,
+  cli,
+  isSentry,
+}: RunBundleCommandOptions): Promise<void> {
+  let gradleConfig: GradleConfig = {};
+  if (platform === 'android') {
+    gradleConfig = await checkGradleConfig();
+    if (gradleConfig.crunchPngs !== false) {
+      console.warn(t('androidCrunchPngsWarning'));
+    }
+  }
+
+  const reactNativeBundleArgs: string[] = [];
+  const envArgs = process.env.PUSHY_ENV_ARGS;
+
+  if (envArgs) {
+    reactNativeBundleArgs.push(...envArgs.trim().split(/\s+/));
+  }
+
+  fs.emptyDirSync(outputFolder);
+
+  let cliPath = '';
+  let usingExpo = false;
+
+  const getExpoCli = () => {
+    try {
+      const searchPaths = [process.cwd()];
+
+      try {
+        const expoPath = require.resolve('expo/package.json', {
+          paths: [process.cwd()],
+        });
+        const expoDir = expoPath.replace(/\/package\.json$/, '');
+        searchPaths.push(expoDir);
+      } catch {
+        // expo 包不存在，忽略
+      }
+
+      cliPath = require.resolve('@expo/cli', {
+        paths: searchPaths,
+      });
+
+      const expoCliVersion = JSON.parse(
+        fs
+          .readFileSync(
+            require.resolve('@expo/cli/package.json', {
+              paths: searchPaths,
+            }),
+          )
+          .toString(),
+      ).version;
+      if (satisfies(expoCliVersion, '>= 0.10.17')) {
+        usingExpo = true;
+      } else {
+        cliPath = '';
+      }
+    } catch {
+      // fallback 到 RN CLI
+    }
+  };
+
+  const getRnCli = () => {
+    try {
+      cliPath = require.resolve('react-native/local-cli/cli.js', {
+        paths: [process.cwd()],
+      });
+    } catch {
+      cliPath = require.resolve('@react-native-community/cli/build/bin.js', {
+        paths: [process.cwd()],
+      });
+    }
+  };
+
+  const getTaroCli = () => {
+    try {
+      cliPath = require.resolve('@tarojs/cli/bin/taro', {
+        paths: [process.cwd()],
+      });
+    } catch {
+      // fallback 到 RN CLI
+    }
+  };
+
+  if (cli.expo) {
+    getExpoCli();
+  } else if (cli.taro) {
+    getTaroCli();
+  } else if (cli.rncli) {
+    getRnCli();
+  }
+
+  if (!cliPath) {
+    getExpoCli();
+    if (!usingExpo) {
+      getRnCli();
+    }
+  }
+
+  if (isSentry) {
+    if (platform === 'ios') {
+      process.env.SENTRY_PROPERTIES = 'ios/sentry.properties';
+    } else if (platform === 'android') {
+      process.env.SENTRY_PROPERTIES = 'android/sentry.properties';
+    }
+  }
+
+  let bundleCommand = 'bundle';
+  if (usingExpo) {
+    bundleCommand = 'export:embed';
+  } else if (platform === 'harmony') {
+    bundleCommand = 'bundle-harmony';
+  } else if (cli.taro) {
+    bundleCommand = 'build';
+  }
+
+  if (platform === 'harmony') {
+    bundleName = 'bundle.harmony.js';
+    if (forceHermes === undefined) {
+      forceHermes = true;
+    }
+  }
+
+  reactNativeBundleArgs.push(
+    cliPath,
+    bundleCommand,
+    '--assets-dest',
+    outputFolder,
+    '--bundle-output',
+    path.join(outputFolder, bundleName),
+  );
+
+  if (platform !== 'harmony') {
+    reactNativeBundleArgs.push('--platform', platform, '--reset-cache');
+  }
+
+  if (cli.taro) {
+    reactNativeBundleArgs.push('--type', 'rn');
+  } else {
+    reactNativeBundleArgs.push('--dev', dev, '--entry-file', entryFile);
+  }
+
+  if (sourcemapOutput) {
+    reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
+  }
+
+  if (config) {
+    reactNativeBundleArgs.push('--config', config);
+  }
+
+  const reactNativeBundleProcess = spawn('node', reactNativeBundleArgs);
+  console.log(
+    `Running bundle command: node ${reactNativeBundleArgs.join(' ')}`,
+  );
+
+  await new Promise<void>((resolve, reject) => {
+    reactNativeBundleProcess.stdout.on('data', (data) => {
+      console.log(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.stderr.on('data', (data) => {
+      console.error(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.on('close', async (exitCode) => {
+      if (exitCode) {
+        reject(new Error(t('bundleCommandError', { code: exitCode })));
+        return;
+      }
+
+      let hermesEnabled: boolean | undefined = false;
+
+      if (forceHermes) {
+        hermesEnabled = true;
+        console.log(t('forceHermes'));
+      } else if (platform === 'android') {
+        const gradleProperties = await new Promise<{ hermesEnabled?: boolean }>(
+          (resolve) => {
+            properties.parse(
+              './android/gradle.properties',
+              { path: true },
+              (
+                error: Error | null,
+                props: { hermesEnabled?: boolean } = {},
+              ) => {
+                if (error) {
+                  console.error(error);
+                  resolve({});
+                  return;
+                }
+                resolve(props);
+              },
+            );
+          },
+        );
+        hermesEnabled = gradleProperties.hermesEnabled;
+
+        if (typeof hermesEnabled !== 'boolean') {
+          hermesEnabled = gradleConfig.enableHermes;
+        }
+      } else if (
+        platform === 'ios' &&
+        fs.existsSync('ios/Pods/hermes-engine')
+      ) {
+        hermesEnabled = true;
+      }
+
+      if (hermesEnabled) {
+        await compileHermesByteCode(
+          bundleName,
+          outputFolder,
+          sourcemapOutput,
+          !isSentry,
+        );
+      }
+
+      if (platform === 'harmony') {
+        const harmonyRawAssetsPath =
+          'harmony/entry/src/main/resources/rawfile/assets';
+        fs.ensureDirSync(harmonyRawAssetsPath);
+        fs.copySync(outputFolder, harmonyRawAssetsPath, { overwrite: true });
+        fs.moveSync(
+          `${harmonyRawAssetsPath}/bundle.harmony.js`,
+          `${harmonyRawAssetsPath}/../bundle.harmony.js`,
+          { overwrite: true },
+        );
+      }
+
+      resolve();
+    });
+  });
+}
+
+function getHermesOSBin() {
+  if (os.platform() === 'win32') return 'win64-bin';
+  if (os.platform() === 'darwin') return 'osx-bin';
+  if (os.platform() === 'linux') return 'linux64-bin';
+}
+
+async function checkGradleConfig(): Promise<GradleConfig> {
+  let enableHermes = false;
+  let crunchPngs: boolean | undefined;
+  try {
+    const gradleConfig = await g2js.parseFile('android/app/build.gradle');
+    crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
+    const projectConfig = gradleConfig['project.ext.react'];
+    if (projectConfig) {
+      for (const packagerConfig of projectConfig) {
+        if (
+          packagerConfig.includes('enableHermes') &&
+          packagerConfig.includes('true')
+        ) {
+          enableHermes = true;
+          break;
+        }
+      }
+    }
+  } catch {
+    // ignore parsing failures
+  }
+  return {
+    enableHermes,
+    crunchPngs,
+  };
+}
+
+async function compileHermesByteCode(
+  bundleName: string,
+  outputFolder: string,
+  sourcemapOutput: string,
+  shouldCleanSourcemap: boolean,
+) {
+  console.log(t('hermesEnabledCompiling'));
+  const rnDir = path.dirname(
+    require.resolve('react-native', {
+      paths: [process.cwd()],
+    }),
+  );
+  let hermesPath = path.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
+
+  if (!fs.existsSync(hermesPath)) {
+    hermesPath = `node_modules/hermes-engine/${getHermesOSBin()}`;
+  }
+
+  const hermesCommand = `${hermesPath}/hermesc`;
+
+  const args = [
+    '-emit-binary',
+    '-out',
+    path.join(outputFolder, bundleName),
+    path.join(outputFolder, bundleName),
+    '-O',
+  ];
+  if (sourcemapOutput) {
+    fs.copyFileSync(
+      sourcemapOutput,
+      path.join(outputFolder, `${bundleName}.txt.map`),
+    );
+    args.push('-output-source-map');
+  }
+  console.log(
+    t('runningHermesc', { command: hermesCommand, args: args.join(' ') }),
+  );
+  spawnSync(hermesCommand, args, {
+    stdio: 'ignore',
+  });
+  if (sourcemapOutput) {
+    const composerPath =
+      'node_modules/react-native/scripts/compose-source-maps.js';
+    if (!fs.existsSync(composerPath)) {
+      return;
+    }
+    console.log(t('composingSourceMap'));
+    spawnSync(
+      'node',
+      [
+        composerPath,
+        path.join(outputFolder, `${bundleName}.txt.map`),
+        path.join(outputFolder, `${bundleName}.map`),
+        '-o',
+        sourcemapOutput,
+      ],
+      {
+        stdio: 'ignore',
+      },
+    );
+  }
+  if (shouldCleanSourcemap) {
+    fs.removeSync(path.join(outputFolder, `${bundleName}.txt.map`));
+  }
+}
+
+export async function copyDebugidForSentry(
+  bundleName: string,
+  outputFolder: string,
+  sourcemapOutput: string,
+): Promise<void> {
+  if (sourcemapOutput) {
+    let copyDebugidPath: string | undefined;
+    try {
+      copyDebugidPath = require.resolve(
+        '@sentry/react-native/scripts/copy-debugid.js',
+        {
+          paths: [process.cwd()],
+        },
+      );
+    } catch {
+      console.error(t('sentryCliNotFound'));
+      return;
+    }
+
+    if (!fs.existsSync(copyDebugidPath)) {
+      return;
+    }
+    console.log(t('copyingDebugId'));
+    spawnSync(
+      'node',
+      [
+        copyDebugidPath,
+        path.join(outputFolder, `${bundleName}.txt.map`),
+        path.join(outputFolder, `${bundleName}.map`),
+      ],
+      {
+        stdio: 'ignore',
+      },
+    );
+  }
+  fs.removeSync(path.join(outputFolder, `${bundleName}.txt.map`));
+}
+
+export async function uploadSourcemapForSentry(
+  bundleName: string,
+  outputFolder: string,
+  sourcemapOutput: string,
+  version: string,
+): Promise<void> {
+  if (!sourcemapOutput) {
+    return;
+  }
+
+  let sentryCliPath: string | undefined;
+  try {
+    sentryCliPath = require.resolve('@sentry/cli/bin/sentry-cli', {
+      paths: [process.cwd()],
+    });
+  } catch {
+    console.error(t('sentryCliNotFound'));
+    return;
+  }
+
+  if (!fs.existsSync(sentryCliPath)) {
+    return;
+  }
+
+  spawnSync(
+    'node',
+    [sentryCliPath, 'releases', 'set-commits', version, '--auto'],
+    {
+      stdio: 'inherit',
+    },
+  );
+  console.log(t('sentryReleaseCreated', { version }));
+
+  console.log(t('uploadingSourcemap'));
+  spawnSync(
+    'node',
+    [
+      sentryCliPath,
+      'releases',
+      'files',
+      version,
+      'upload-sourcemaps',
+      '--strip-prefix',
+      path.join(process.cwd(), outputFolder),
+      path.join(outputFolder, bundleName),
+      path.join(outputFolder, `${bundleName}.map`),
+    ],
+    {
+      stdio: 'inherit',
+    },
+  );
+}