@react-native/core-cli-utils/dist/private/app.js

React Native CLI library for Frameworks to build on

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true,
});
exports.tasks = void 0;
var _utils = require("./utils");
var _debug = _interopRequireDefault(require("debug"));
var _execa = _interopRequireDefault(require("execa"));
var _fs = _interopRequireDefault(require("fs"));
var _path = _interopRequireDefault(require("path"));
function _interopRequireDefault(e) {
  return e && e.__esModule ? e : { default: e };
}
const log = (0, _debug.default)("core-cli-utils");
const FIRST = 1,
  SECOND = 2,
  THIRD = 3,
  FOURTH = 4;
function getNodePackagePath(packageName) {
  return require.resolve(packageName, {
    cwd: [process.cwd(), ...module.paths],
  });
}
function metro(...args) {
  log(`🚇 metro ${args.join(" ")} `);
  return (0, _execa.default)("npx", ["--offline", "metro", ...args]);
}
const tasks = (exports.tasks = {
  bundle: (options, ...args) => {
    const steps = {
      validate: (0, _utils.task)(FIRST, "Check if Metro is available", () => {
        try {
          require("metro");
        } catch {
          throw new Error("Metro is not available");
        }
      }),
      javascript: (0, _utils.task)(SECOND, "Metro watching for changes", () =>
        metro("serve", ...args)
      ),
    };
    return options.mode === "bundle"
      ? Object.assign(steps, bundleApp(options, ...args))
      : steps;
  },
});
const bundleApp = (options, ...metroArgs) => {
  if (options.outputJsBundle === options.outputBundle) {
    throw new Error("outputJsBundle and outputBundle cannot be the same.");
  }
  let output =
    options.jsvm === "hermes" ? options.outputJsBundle : options.outputBundle;
  if (output === options.outputJsBundle && !output.endsWith(".js")) {
    log(
      `Appending .js to outputBundle (because metro cli does it if it's missing): ${output}`
    );
    output += ".js";
  }
  const isSourceMaps = options.outputSourceMap != null;
  const bundle = {
    javascript: (0, _utils.task)(
      SECOND,
      "Metro generating an .jsbundle",
      () => {
        const args = [
          "--platform",
          options.platform,
          "--dev",
          options.dev ? "true" : "false",
          "--reset-cache",
          "--out",
          output,
        ];
        if (options.jsvm === "hermes" && !options.dev) {
          args.push("--minify", "false");
        } else {
          args.push("--minify", options.minify ? "true" : "false");
        }
        if (isSourceMaps) {
          args.push("--source-map");
        }
        return metro("build", options.entryFile, ...args, ...metroArgs);
      }
    ),
  };
  if (options.jsvm === "jsc") {
    return bundle;
  }
  if (options.hermes?.path == null || options.hermes?.hermesc == null) {
    throw new Error('If jsvm == "hermes", hermes config must be provided.');
  }
  const hermes = options.hermes;
  const isHermesInstalled = _fs.default.existsSync(hermes.path);
  if (!isHermesInstalled) {
    throw new Error(
      "Hermes Pod must be installed before bundling.\n" +
        "Did you forget to bootstrap?"
    );
  }
  const hermesc = _path.default.join(hermes.path, hermes.hermesc);
  let composeSourceMaps;
  if (isSourceMaps) {
    bundle.sourcemap = (0, _utils.task)(
      FIRST,
      "Check if SourceMap script available",
      () => {
        composeSourceMaps = getNodePackagePath(
          "react-native/scripts/compose-source-maps.js"
        );
      }
    );
  }
  bundle.validateHermesc = (0, _utils.task)(
    FIRST,
    "Check if Hermesc is available",
    () => (0, _execa.default)(hermesc, ["--version"])
  );
  bundle.convert = (0, _utils.task)(
    THIRD,
    "Hermesc converting .jsbundle → bytecode",
    () => {
      const args = [
        "-emit-binary",
        "-max-diagnostic-width=80",
        options.dev === true ? "-Og" : "-O",
      ];
      if (isSourceMaps) {
        args.push("-output-source-map");
      }
      args.push(`-out=${options.outputBundle}`, output);
      return (0, _execa.default)(hermesc, args, {
        cwd: options.cwd,
      });
    }
  );
  bundle.compose = (0, _utils.task)(
    FOURTH,
    "Compose Hermes and Metro source maps",
    () => {
      if (composeSourceMaps == null) {
        throw new Error(
          "Unable to find the compose-source-map.js script in react-native"
        );
      }
      const metroSourceMap = output.replace(/(\.js)?$/, ".map");
      const hermesSourceMap = options.outputBundle + ".map";
      const compose = (0, _execa.default)(
        "node",
        [
          composeSourceMaps,
          metroSourceMap,
          hermesSourceMap,
          `-o ${options.outputSourceMap}`,
        ],
        {
          cwd: options.cwd,
        }
      );
      compose.finally(() => {
        _fs.default.rmSync(metroSourceMap, {
          force: true,
        });
        _fs.default.rmSync(hermesSourceMap, {
          force: true,
        });
      });
      return compose;
    }
  );
  return bundle;
};