@react-native/core-cli-utils 0.76.0-nightly-20240715-2eb7bcb8d → 0.76.0-nightly-20240720-3a5eb1973

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import { tasks as _android } from "./private/android.js";
+import { tasks as _app } from "./private/app.js";
+import { tasks as _apple } from "./private/apple.js";
+import { tasks as _clean } from "./private/clean.js";
+import * as _version from "./public/version.js";
+export declare const android: typeof _android;
+export declare const app: typeof _app;
+export declare const apple: typeof _apple;
+export declare const clean: typeof _clean;
+export declare const version: typeof _version;
+export type { Task } from "./private/types";

package/dist/index.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.version =
+  exports.clean =
+  exports.apple =
+  exports.app =
+  exports.android =
+    void 0;
+var _android2 = require("./private/android.js");
+var _app2 = require("./private/app.js");
+var _apple2 = require("./private/apple.js");
+var _clean2 = require("./private/clean.js");
+var _version = _interopRequireWildcard(require("./public/version.js"));
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+const android = _android2.tasks;
+exports.android = android;
+const app = _app2.tasks;
+exports.app = app;
+const apple = _apple2.tasks;
+exports.apple = apple;
+const clean = _clean2.tasks;
+exports.clean = clean;
+const version = _version;
+exports.version = version;

package/dist/index.js.flow

@@ -0,0 +1,26 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+// @babel/register doesn't like export {foo} from './bar'; statements,
+// so we have to jump through hoops here.
+import { tasks as _android } from "./private/android.js";
+import { tasks as _app } from "./private/app.js";
+import { tasks as _apple } from "./private/apple.js";
+import { tasks as _clean } from "./private/clean.js";
+import * as _version from "./public/version.js";
+
+declare export const android: typeof _android;
+declare export const app: typeof _app;
+declare export const apple: typeof _apple;
+declare export const clean: typeof _clean;
+declare export const version: typeof _version;
+
+export type { Task } from "./private/types";

package/dist/private/android.d.ts

@@ -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
+ * @oncall react_native
+ */
+
+import type { Task } from "./types";
+import type { ExecaPromise } from "execa";
+type AndroidBuildMode = "Debug" | "Release";
+type Path = string;
+type Args = ReadonlyArray<string>;
+type Config = {
+  cwd: Path;
+  hermes?: boolean;
+  mode: AndroidBuildMode;
+  name: string;
+  newArchitecture?: boolean;
+  sdk?: Path;
+};
+export declare const tasks: (config: Config) => {
+  assemble: (...gradleArgs: Args) => { run: Task<ExecaPromise> };
+  build: (...gradleArgs: Args) => { run: Task<ExecaPromise> };
+  install: (...gradleArgs: Args) => { run: Task<ExecaPromise> };
+};

package/dist/private/android.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.tasks = void 0;
+var _utils = require("./utils");
+var _execa = _interopRequireDefault(require("execa"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function gradle(taskName, args, options) {
+  const gradlew = _utils.isWindows ? "gradlew.bat" : "./gradlew";
+  return (0, _execa.default)(gradlew, [taskName, ...args], {
+    cwd: options.cwd,
+    env: options.env,
+  });
+}
+function androidSdkPath(sdk) {
+  return sdk ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK ?? "";
+}
+function boolToStr(value) {
+  return value ? "true" : "false";
+}
+const FIRST = 1;
+const tasks = (config) => ({
+  assemble: (...gradleArgs) => ({
+    run: (0, _utils.task)(FIRST, "Assemble Android App", () => {
+      const args = [];
+      if (config.hermes != null) {
+        args.push(`-PhermesEnabled=${boolToStr(config.hermes)}`);
+      }
+      if (config.newArchitecture != null) {
+        args.push(`-PnewArchEnabled=${boolToStr(config.newArchitecture)}`);
+      }
+      args.push(...gradleArgs);
+      return gradle(`${config.name}:assemble${config.mode}`, gradleArgs, {
+        cwd: config.cwd,
+        env: {
+          ANDROID_HOME: androidSdkPath(config.sdk),
+        },
+      });
+    }),
+  }),
+  build: (...gradleArgs) => ({
+    run: (0, _utils.task)(FIRST, "Assembles and tests Android App", () => {
+      const args = [];
+      if (config.hermes != null) {
+        args.push(`-PhermesEnabled=${boolToStr(config.hermes)}`);
+      }
+      if (config.newArchitecture != null) {
+        args.push(`-PnewArchEnabled=${boolToStr(config.newArchitecture)}`);
+      }
+      args.push(...gradleArgs);
+      return gradle(`${config.name}:bundle${config.mode}`, args, {
+        cwd: config.cwd,
+        env: {
+          ANDROID_HOME: androidSdkPath(config.sdk),
+        },
+      });
+    }),
+  }),
+  install: (...gradleArgs) => ({
+    run: (0, _utils.task)(FIRST, "Installs the assembled Android App", () =>
+      gradle(`${config.name}:install${config.mode}`, gradleArgs, {
+        cwd: config.cwd,
+        env: {
+          ANDROID_HOME: androidSdkPath(config.sdk),
+        },
+      })
+    ),
+  }),
+});
+exports.tasks = tasks;

package/dist/private/android.js.flow

@@ -0,0 +1,42 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type { Task } from "./types";
+import type { ExecaPromise } from "execa";
+
+type AndroidBuildMode = "Debug" | "Release";
+
+type Path = string;
+type Args = $ReadOnlyArray<string>;
+
+type Config = {
+  cwd: Path,
+  hermes?: boolean,
+  mode: AndroidBuildMode,
+  name: string,
+  newArchitecture?: boolean,
+  sdk?: Path,
+};
+
+//
+// Android Tasks
+//
+declare export const tasks: (config: Config) => {
+  assemble: (...gradleArgs: Args) => {
+    run: Task<ExecaPromise>,
+  },
+  build: (...gradleArgs: Args) => {
+    run: Task<ExecaPromise>,
+  },
+  install: (...gradleArgs: Args) => {
+    run: Task<ExecaPromise>,
+  },
+};

package/dist/private/app.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type { Task } from "./types";
+import type { ExecaPromise } from "execa";
+type BundlerOptions =
+  /**
+   * > 39 |   ...Bundler,
+   *      |   ^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type HermesConfig = { path: string; hermesc: string };
+type BundlerWatch = {
+  readonly mode: "watch";
+  callback?: (metro: ExecaPromise) => void;
+};
+type BundlerBuild = { readonly mode: "bundle" };
+type Bundler = BundlerWatch | BundlerBuild;
+export declare const tasks: {
+  bundle: (options: BundlerOptions, ...args: ReadonlyArray<string>) => Bundle;
+};
+type Bundle = {
+  validate?: Task<void>;
+  javascript: Task<ExecaPromise>;
+  sourcemap?: Task<void>;
+  validateHermesc?: Task<ExecaPromise>;
+  convert?: Task<ExecaPromise>;
+  compose?: Task<ExecaPromise>;
+};

package/dist/private/app.js

@@ -0,0 +1,176 @@
+"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(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+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) {
+  const metroPath = getNodePackagePath(
+    _path.default.join("metro", "src", "cli.js")
+  );
+  log(`🚇 ${metroPath} ${args.join(" ")} `);
+  return (0, _execa.default)("node", [metroPath, ...args]);
+}
+const 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;
+  },
+};
+exports.tasks = tasks;
+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;
+};

package/dist/private/app.js.flow

@@ -0,0 +1,72 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type { Task } from "./types";
+import type { ExecaPromise } from "execa";
+
+type BundlerOptions = {
+  // Metro's config: https://metrobundler.dev/docs/configuration/
+  config?: string,
+  // Typically index.{ios,android}.js
+  entryFile: string,
+  +platform: "ios" | "android" | string,
+  dev: boolean,
+  // Metro built main bundle
+  outputJsBundle: string,
+  minify: boolean,
+  optimize: boolean,
+  // Generate a source map file
+  outputSourceMap: string,
+  // Where to pass the final bundle. Typically this is the App's resource
+  // folder, however this is app specific. React Native will need to know where
+  // this is to bootstrap your application.  See:
+  // - Android: https://reactnative.dev/docs/integration-with-existing-apps?language=kotlin#creating-a-release-build-in-android-studio
+  // - iOS: https://reactnative.dev/docs/integration-with-existing-apps?language=swift#2-event-handler
+  outputBundle: string,
+  cwd: string,
+
+  jsvm: "hermes" | "jsc",
+  hermes?: HermesConfig,
+
+  ...Bundler,
+};
+
+type HermesConfig = {
+  // Path where hermes is is installed
+  // iOS: Pods/hermes-engine
+  path: string,
+  // iOS: <hermes.path>/destroot/bin/hermesc
+  hermesc: string,
+};
+
+type BundlerWatch = {
+  +mode: "watch",
+  callback?: (metro: ExecaPromise) => void,
+};
+
+type BundlerBuild = {
+  +mode: "bundle",
+};
+
+type Bundler = BundlerWatch | BundlerBuild;
+
+declare export const tasks: {
+  bundle: (options: BundlerOptions, ...args: $ReadOnlyArray<string>) => Bundle,
+};
+
+type Bundle = {
+  validate?: Task<void>,
+  javascript: Task<ExecaPromise>,
+  sourcemap?: Task<void>,
+  validateHermesc?: Task<ExecaPromise>,
+  convert?: Task<ExecaPromise>,
+  compose?: Task<ExecaPromise>,
+};

package/dist/private/apple.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type { Task } from "./types";
+import type { ExecaPromise } from "execa";
+type AppleBuildMode = "Debug" | "Release";
+type AppleBuildOptions =
+  /**
+   * > 23 |   ...AppleOptions,
+   *      |   ^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type AppleBootstrapOption =
+  /**
+   * > 31 |   ...AppleOptions,
+   *      |   ^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type AppleInstallApp =
+  /**
+   * > 40 |   ...AppleOptions,
+   *      |   ^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type AppleOptions = { cwd: string; env?: { [key: string]: string | void } };
+export declare const tasks: {
+  bootstrap: (options: AppleBootstrapOption) => {
+    validate: Task<void>;
+    installRubyGems: Task<ExecaPromise>;
+    installDependencies: Task<ExecaPromise>;
+  };
+  build: (
+    options: AppleBuildOptions,
+    ...args: ReadonlyArray<string>
+  ) => {
+    validate: Task<void>;
+    hasPodsInstalled: Task<void>;
+    build: Task<ExecaPromise>;
+  };
+  ios: {
+    install: (options: AppleInstallApp) => {
+      validate: Task<void>;
+      install: Task<ExecaPromise>;
+    };
+  };
+};