react-native-update-cli 2.8.4 → 2.9.0

package/src/bundle.ts

@@ -1,555 +1,177 @@
-import { spawn, spawnSync } from 'child_process';
 import path from 'path';
-import { satisfies } from 'compare-versions';
-import * as fs from 'fs-extra';
-import { ZipFile as YazlZipFile } from 'yazl';
 import { getPlatform } from './app';
-import { translateOptions } from './utils';
-import { checkPlugins, question } from './utils';
-const g2js = require('gradle-to-js/lib/parser');
-const properties = require('properties');
+import { packBundle } from './bundle-pack';
+import {
+  copyDebugidForSentry,
+  runReactNativeBundleCommand,
+  uploadSourcemapForSentry,
+} from './bundle-runner';
+import type { Platform } from './types';
+import { checkPlugins, question, translateOptions } from './utils';
 import { addGitIgnore } from './utils/add-gitignore';
 import { checkLockFiles } from './utils/check-lockfile';
 import { tempDir } from './utils/constants';
 import { depVersions } from './utils/dep-versions';
 import { t } from './utils/i18n';
+import {
+  getBooleanOption,
+  getOptionalStringOption,
+  getStringOption,
+} from './utils/options';
 import { versionCommands } from './versions';
-import os from 'os';
 
-async function runReactNativeBundleCommand({
-  bundleName,
-  dev,
-  entryFile,
-  outputFolder,
-  platform,
-  sourcemapOutput,
-  config,
-  forceHermes,
-  cli,
-}: {
+type NormalizedBundleOptions = {
   bundleName: string;
-  dev: string;
   entryFile: string;
-  outputFolder: string;
-  platform: string;
-  sourcemapOutput: string;
-  config?: string;
-  forceHermes?: boolean;
-  cli: {
-    taro?: boolean;
-    expo?: boolean;
-    rncli?: boolean;
-  };
-}) {
-  let gradleConfig: {
-    crunchPngs?: boolean;
-    enableHermes?: boolean;
-  } = {};
-  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()];
-
-      // 尝试添加 expo 包的路径作为额外的搜索路径
-      try {
-        const expoPath = require.resolve('expo/package.json', {
-          paths: [process.cwd()],
-        });
-        // 获取 expo 包的目录路径
-        const expoDir = expoPath.replace(/\/package\.json$/, '');
-        searchPaths.push(expoDir);
-      } catch {
-        // expo 包不存在，忽略
-      }
-
-      // 尝试从搜索路径中解析 @expo/cli
-      cliPath = require.resolve('@expo/cli', {
-        paths: searchPaths,
-      });
-
-      const expoCliVersion = JSON.parse(
-        fs
-          .readFileSync(
-            require.resolve('@expo/cli/package.json', {
-              paths: searchPaths,
-            }),
-          )
-          .toString(),
-      ).version;
-      // expo cli 0.10.17 (expo 49) 开始支持 bundle:embed
-      if (satisfies(expoCliVersion, '>= 0.10.17')) {
-        usingExpo = true;
-      } else {
-        cliPath = '';
-      }
-    } catch (e) {}
-  };
-
-  const getRnCli = () => {
-    try {
-      // rn < 0.75
-      cliPath = require.resolve('react-native/local-cli/cli.js', {
-        paths: [process.cwd()],
-      });
-    } catch (e) {
-      // rn >= 0.75
-      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 (e) {}
-  };
-
-  if (cli.expo) {
-    getExpoCli();
-  } else if (cli.taro) {
-    getTaroCli();
-  } else if (cli.rncli) {
-    getRnCli();
-  }
-
-  if (!cliPath) {
-    getExpoCli();
-    if (!usingExpo) {
-      getRnCli();
-    }
-  }
-
-  const bundleParams = await checkPlugins();
-  const isSentry = bundleParams.sentry;
-
-  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) {
-      // enable hermes by default for harmony
-      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(' ')}`,
-  );
-
-  return new Promise((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 })));
-      } else {
-        let hermesEnabled: boolean | undefined = false;
-
-        if (forceHermes) {
-          hermesEnabled = true;
-          console.log(t('forceHermes'));
-        } else if (platform === 'android') {
-          const gradlePropeties = await new Promise<{
-            hermesEnabled?: boolean;
-          }>((resolve) => {
-            properties.parse(
-              './android/gradle.properties',
-              { path: true },
-              (error: any, props: { hermesEnabled?: boolean }) => {
-                if (error) {
-                  console.error(error);
-                  resolve({});
-                }
-
-                resolve(props);
-              },
-            );
-          });
-          hermesEnabled = gradlePropeties.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';
-          // copy all files in outputFolder to harmonyRawPath
-          // assets should be in rawfile/assets
-          fs.ensureDirSync(harmonyRawAssetsPath);
-          fs.copySync(outputFolder, harmonyRawAssetsPath, { overwrite: true });
-          fs.moveSync(
-            `${harmonyRawAssetsPath}/bundle.harmony.js`,
-            `${harmonyRawAssetsPath}/../bundle.harmony.js`,
-            { overwrite: true },
-          );
-        }
-        resolve(null);
-      }
-    });
-  });
-}
+  intermediaDir: string;
+  output: string;
+  dev: string;
+  sourcemap: boolean;
+  taro: boolean;
+  expo: boolean;
+  rncli: boolean;
+  hermes: boolean;
+  name?: string;
+  description?: string;
+  metaInfo?: string;
+  packageId?: string;
+  packageVersion?: string;
+  minPackageVersion?: string;
+  maxPackageVersion?: string;
+  packageVersionRange?: string;
+  rollout?: string;
+  dryRun: boolean;
+};
 
-function getHermesOSBin() {
-  if (os.platform() === 'win32') return 'win64-bin';
-  if (os.platform() === 'darwin') return 'osx-bin';
-  if (os.platform() === 'linux') return 'linux64-bin';
-}
+type PublishBundlePayload = {
+  name?: string;
+  description?: string;
+  metaInfo?: string;
+  packageId?: string;
+  packageVersion?: string;
+  minPackageVersion?: string;
+  maxPackageVersion?: string;
+  packageVersionRange?: string;
+  rollout?: string;
+  dryRun?: boolean;
+};
 
-async function checkGradleConfig() {
-  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 (e) {}
+function normalizeBundleOptions(
+  translatedOptions: Record<string, unknown>,
+  platform: string,
+): NormalizedBundleOptions {
   return {
-    enableHermes,
-    crunchPngs,
+    bundleName: getStringOption(
+      translatedOptions,
+      'bundleName',
+      'index.bundlejs',
+    ),
+    entryFile: getStringOption(translatedOptions, 'entryFile', 'index.js'),
+    intermediaDir: getStringOption(
+      translatedOptions,
+      'intermediaDir',
+      `${tempDir}/intermedia/${platform}`,
+    ),
+    output: getStringOption(
+      translatedOptions,
+      'output',
+      `${tempDir}/output/${platform}.\${time}.ppk`,
+    ),
+    dev: getBooleanOption(translatedOptions, 'dev', false) ? 'true' : 'false',
+    sourcemap: getBooleanOption(translatedOptions, 'sourcemap', false),
+    taro: getBooleanOption(translatedOptions, 'taro', false),
+    expo: getBooleanOption(translatedOptions, 'expo', false),
+    rncli: getBooleanOption(translatedOptions, 'rncli', false),
+    hermes: getBooleanOption(translatedOptions, 'hermes', false),
+    name: getOptionalStringOption(translatedOptions, 'name'),
+    description: getOptionalStringOption(translatedOptions, 'description'),
+    metaInfo: getOptionalStringOption(translatedOptions, 'metaInfo'),
+    packageId: getOptionalStringOption(translatedOptions, 'packageId'),
+    packageVersion: getOptionalStringOption(
+      translatedOptions,
+      'packageVersion',
+    ),
+    minPackageVersion: getOptionalStringOption(
+      translatedOptions,
+      'minPackageVersion',
+    ),
+    maxPackageVersion: getOptionalStringOption(
+      translatedOptions,
+      'maxPackageVersion',
+    ),
+    packageVersionRange: getOptionalStringOption(
+      translatedOptions,
+      'packageVersionRange',
+    ),
+    rollout: getOptionalStringOption(translatedOptions, 'rollout'),
+    dryRun: getBooleanOption(translatedOptions, 'dryRun', false),
   };
 }
 
-async function compileHermesByteCode(
+async function uploadSentryArtifactsIfNeeded(
+  shouldUpload: boolean,
   bundleName: string,
-  outputFolder: string,
+  intermediaDir: string,
   sourcemapOutput: string,
-  shouldCleanSourcemap: boolean,
-) {
-  console.log(t('hermesEnabledCompiling'));
-  // >= rn 0.69
-  const rnDir = path.dirname(
-    require.resolve('react-native', {
-      paths: [process.cwd()],
-    }),
+  versionName: string,
+): Promise<void> {
+  if (!shouldUpload) {
+    return;
+  }
+
+  await copyDebugidForSentry(bundleName, intermediaDir, sourcemapOutput);
+  await uploadSourcemapForSentry(
+    bundleName,
+    intermediaDir,
+    sourcemapOutput,
+    versionName,
   );
-  let hermesPath = path.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
-
-  // < rn 0.69
-  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`));
-  }
-}
-
-async function copyDebugidForSentry(
-  bundleName: string,
-  outputFolder: string,
-  sourcemapOutput: string,
-) {
-  if (sourcemapOutput) {
-    let copyDebugidPath: string | undefined;
-    try {
-      copyDebugidPath = require.resolve(
-        '@sentry/react-native/scripts/copy-debugid.js',
-        {
-          paths: [process.cwd()],
-        },
-      );
-    } catch (error) {
-      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`));
-}
-
-async function uploadSourcemapForSentry(
-  bundleName: string,
-  outputFolder: string,
-  sourcemapOutput: string,
-  version: string,
-) {
-  if (sourcemapOutput) {
-    let sentryCliPath: string | undefined;
-    try {
-      sentryCliPath = require.resolve('@sentry/cli/bin/sentry-cli', {
-        paths: [process.cwd()],
-      });
-    } catch (error) {
-      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',
-      },
-    );
-  }
 }
 
-const ignorePackingFileNames = [
-  '.',
-  '..',
-  'index.bundlejs.map',
-  'bundle.harmony.js.map',
-];
-const ignorePackingExtensions = ['DS_Store', 'txt.map'];
-async function pack(dir: string, output: string) {
-  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 childs = fs.readdirSync(root);
-      for (const name of childs) {
-        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()) {
-          //console.log('adding: ' + rel+name);
-          zipfile.addFile(fullPath, rel + name);
-        } else if (stat.isDirectory()) {
-          //console.log('adding: ' + rel+name+'/');
-          addDirectory(fullPath, `${rel}${name}/`);
-        }
-      }
-    }
-
-    addDirectory(dir, '');
-
-    zipfile.outputStream.on('error', (err: any) => reject(err));
-    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
-      resolve(void 0);
-    });
-    zipfile.end();
+async function publishBundleVersion(
+  outputPath: string,
+  platform: Platform,
+  payload: PublishBundlePayload,
+): Promise<string> {
+  return versionCommands.publish({
+    args: [outputPath],
+    options: {
+      platform,
+      ...payload,
+    },
   });
-  console.log(t('fileGenerated', { file: output }));
 }
 
 export const bundleCommands = {
-  bundle: async ({ options }) => {
-    const platform = await getPlatform(options.platform);
+  bundle: async ({
+    options,
+  }: {
+    args?: string[];
+    options: Record<string, unknown>;
+  }) => {
+    const platform = await getPlatform(
+      typeof options.platform === 'string' ? options.platform : undefined,
+    );
 
-    const {
-      bundleName,
-      entryFile,
-      intermediaDir,
-      output,
-      dev,
-      sourcemap,
-      taro,
-      expo,
-      rncli,
-      hermes,
-      name,
-      description,
-      metaInfo,
-      packageId,
-      packageVersion,
-      minPackageVersion,
-      maxPackageVersion,
-      packageVersionRange,
-      rollout,
-      dryRun,
-    } = translateOptions({
+    const translatedOptions = translateOptions({
       ...options,
       tempDir,
       platform,
     });
+    const normalized = normalizeBundleOptions(translatedOptions, platform);
 
     checkLockFiles();
     addGitIgnore();
 
     const bundleParams = await checkPlugins();
-    const sourcemapPlugin = bundleParams.sourcemap;
-    const isSentry = bundleParams.sentry;
-
-    const sourcemapOutput = path.join(intermediaDir, `${bundleName}.map`);
-
-    const realOutput = output.replace(/\$\{time\}/g, `${Date.now()}`);
+    const sourcemapOutput = path.join(
+      normalized.intermediaDir,
+      `${normalized.bundleName}.map`,
+    );
+    const realOutput = normalized.output.replace(
+      /\$\{time\}/g,
+      `${Date.now()}`,
+    );
 
     if (!platform) {
       throw new Error(t('platformRequired'));
@@ -558,72 +180,63 @@ export const bundleCommands = {
     console.log(`Bundling with react-native: ${depVersions['react-native']}`);
 
     await runReactNativeBundleCommand({
-      bundleName,
-      dev,
-      entryFile,
-      outputFolder: intermediaDir,
+      bundleName: normalized.bundleName,
+      dev: normalized.dev,
+      entryFile: normalized.entryFile,
+      outputFolder: normalized.intermediaDir,
       platform,
-      sourcemapOutput: sourcemap || sourcemapPlugin ? sourcemapOutput : '',
-      forceHermes: hermes as unknown as boolean,
+      sourcemapOutput:
+        normalized.sourcemap || bundleParams.sourcemap ? sourcemapOutput : '',
+      forceHermes: normalized.hermes,
       cli: {
-        taro: !!taro,
-        expo: !!expo,
-        rncli: !!rncli,
+        taro: normalized.taro,
+        expo: normalized.expo,
+        rncli: normalized.rncli,
       },
+      isSentry: bundleParams.sentry,
     });
 
-    await pack(path.resolve(intermediaDir), realOutput);
-
-    if (name) {
-      const versionName = await versionCommands.publish({
-        args: [realOutput],
-        options: {
-          platform,
-          name,
-          description,
-          metaInfo,
-          packageId,
-          packageVersion,
-          minPackageVersion,
-          maxPackageVersion,
-          packageVersionRange,
-          rollout,
-          dryRun: Boolean(dryRun),
-        },
+    await packBundle(path.resolve(normalized.intermediaDir), realOutput);
+
+    if (normalized.name) {
+      const versionName = await publishBundleVersion(realOutput, platform, {
+        name: normalized.name,
+        description: normalized.description,
+        metaInfo: normalized.metaInfo,
+        packageId: normalized.packageId,
+        packageVersion: normalized.packageVersion,
+        minPackageVersion: normalized.minPackageVersion,
+        maxPackageVersion: normalized.maxPackageVersion,
+        packageVersionRange: normalized.packageVersionRange,
+        rollout: normalized.rollout,
+        dryRun: normalized.dryRun,
       });
+      await uploadSentryArtifactsIfNeeded(
+        bundleParams.sentry,
+        normalized.bundleName,
+        normalized.intermediaDir,
+        sourcemapOutput,
+        versionName,
+      );
+      return;
+    }
 
-      if (isSentry) {
-        await copyDebugidForSentry(bundleName, intermediaDir, sourcemapOutput);
-        await uploadSourcemapForSentry(
-          bundleName,
-          intermediaDir,
+    if (!getBooleanOption(options, 'no-interactive', false)) {
+      const v = await question(t('uploadBundlePrompt'));
+      if (v.toLowerCase() === 'y') {
+        const versionName = await publishBundleVersion(
+          realOutput,
+          platform,
+          {},
+        );
+        await uploadSentryArtifactsIfNeeded(
+          bundleParams.sentry,
+          normalized.bundleName,
+          normalized.intermediaDir,
           sourcemapOutput,
           versionName,
         );
       }
-    } else if (!options['no-interactive']) {
-      const v = await question(t('uploadBundlePrompt'));
-      if (v.toLowerCase() === 'y') {
-        const versionName = await versionCommands.publish({
-          args: [realOutput],
-          options: {
-            platform,
-          },
-        });
-        if (isSentry) {
-          await copyDebugidForSentry(
-            bundleName,
-            intermediaDir,
-            sourcemapOutput,
-          );
-          await uploadSourcemapForSentry(
-            bundleName,
-            intermediaDir,
-            sourcemapOutput,
-            versionName,
-          );
-        }
-      }
     }
   },
 };