@rnx-kit/cli 0.12.6 → 0.14.1

package/src/bundle/kit-config.ts

@@ -1,49 +1,11 @@
-import type { BundleDefinitionWithRequiredParameters } from "@rnx-kit/config";
 import {
-  getBundleDefinition,
-  getBundlePlatformDefinition,
+  getBundleConfig,
+  getPlatformBundleConfig,
   getKitConfig,
 } from "@rnx-kit/config";
-import { warn } from "@rnx-kit/console";
 import type { AllPlatforms } from "@rnx-kit/tools-react-native/platform";
-import chalk from "chalk";
-import type { KitBundleConfig } from "./types";
-
-/**
- * Get a bundle definition from the kit configuration.
- *
- * @param id Optional bundle definition id. Only needed when the kit config has more than one definition.
- * @returns Bundle definition matching the id (if given), or the first bundle definition found. `undefined` if bundling is disabled or not supported for the kit.
- */
-export function getKitBundleDefinition(
-  id?: string
-): BundleDefinitionWithRequiredParameters | undefined {
-  const kitConfig = getKitConfig();
-  if (!kitConfig) {
-    throw new Error(
-      "No kit configuration found for this react-native experience"
-    );
-  }
-
-  if (kitConfig.bundle === null || kitConfig.bundle === undefined) {
-    warn(
-      chalk.yellow(
-        "No bundle configuration found for this react-native experience -- skipping bundling"
-      )
-    );
-    return undefined;
-  } else if (!kitConfig.bundle) {
-    warn(
-      chalk.yellow(
-        "Bundling is disabled for this react-native experience -- skipping"
-      )
-    );
-    return undefined;
-  }
-
-  // get the bundle definition
-  return getBundleDefinition(kitConfig.bundle, id);
-}
+import type { CliPlatformBundleConfig } from "./types";
+import { getDefaultBundlerPlugins } from "../bundler-plugin-defaults";
 
 /**
  * Get the list of target platforms for bundling.
@@ -63,36 +25,56 @@ export function getTargetPlatforms(
     return targetPlatforms;
   }
   throw new Error(
-    "No target platforms given. Update the kit configuration to include a target platform, or provide a target platform on the command-line."
+    "No target platforms given. Update the rnx-kit configuration to include a target platform, or provide a target platform on the command-line."
   );
 }
 
+function getDefaultBundleParameters(platform: string) {
+  const extension =
+    platform === "ios" || platform === "macos" ? "jsbundle" : "bundle";
+
+  return {
+    entryFile: "index.js",
+    bundleOutput: `index.${platform}.${extension}`,
+    sourcemapUseAbsolutePath: false,
+  };
+}
+
 /**
- * Get bundle configuration and target platform(s) from kit config. Create
- * one config per platform, applying any platform-specific customizations in
- * the kit config.
+ * Get the bundle configuration and target platform(s) from the rnx-kit
+ * configuration. Use them to create an array of platform-specific
+ * bundle configurations.
+ *
+ * If an id is given, search for the matching bundle definition. Otherwise, use the first bundle definition.
  *
- * @param id Optional bundle definition id. Only needed when the kit config has more than one definition.
+ * @param id Optional identity of the target bundle definition to return
  * @param overridePlatform Override platform, typically from the command-line. When given, this overrides the list of target platforms.
- * @returns Arrary of kit bundle configurations, one per target platform, or `undefined` if bundling is disabled
+ * @returns Arrary of platform-specific bundle configurations
  */
-export function getKitBundleConfigs(
+export function getCliPlatformBundleConfigs(
   id?: string,
   overridePlatform?: AllPlatforms
-): KitBundleConfig[] | undefined {
-  const bundleDefinition = getKitBundleDefinition(id);
-  if (!bundleDefinition) {
-    return undefined;
-  }
+): CliPlatformBundleConfig[] {
+  const kitConfig = getKitConfig();
+  const maybeBundleConfig = kitConfig
+    ? getBundleConfig(kitConfig, id)
+    : undefined;
+  const bundleConfig = maybeBundleConfig ?? {};
 
-  const platforms = getTargetPlatforms(
-    overridePlatform,
-    bundleDefinition.targets
-  );
+  const platforms = getTargetPlatforms(overridePlatform, bundleConfig.targets);
+
+  return platforms.map<CliPlatformBundleConfig>((platform) => {
+    const platformBundleConfig = getPlatformBundleConfig(
+      bundleConfig,
+      platform
+    );
+
+    // apply defaults to fill in any required props that are missing
 
-  return platforms.map<KitBundleConfig>((platform) => {
     return {
-      ...getBundlePlatformDefinition(bundleDefinition, platform),
+      ...getDefaultBundlerPlugins(),
+      ...getDefaultBundleParameters(platform),
+      ...platformBundleConfig,
       platform,
     };
   });

package/src/bundle/metro.ts

@@ -4,81 +4,40 @@ import { createDirectory } from "@rnx-kit/tools-node/fs";
 import type { ConfigT } from "metro-config";
 import path from "path";
 import { customizeMetroConfig } from "../metro-config";
-import type { BundleConfig } from "./types";
-import type { TypeScriptValidationOptions } from "../types";
-
-/**
- * Create Metro bundler arguments from a bundle configuration.
- *
- * @param bundleConfig Bundle configuration
- * @returns Metro bundle arguments
- */
-export function createMetroBundleArgs({
-  entryPath: entryFile,
-  distPath,
-  assetsPath: assetsDest,
-  bundlePrefix,
-  bundleEncoding,
-  sourceMapPath: sourcemapOutput,
-  sourceMapSourceRootPath: sourcemapSourcesRoot,
-  platform,
-  dev,
-  minify,
-}: BundleConfig): MetroBundleArgs {
-  //  assemble the full path to the bundle file
-  const bundleExtension =
-    platform === "ios" || platform === "macos" ? "jsbundle" : "bundle";
-  const bundleFile = `${bundlePrefix}.${platform}.${bundleExtension}`;
-  const bundlePath = path.join(distPath, bundleFile);
-
-  //  always create a source-map in dev mode
-  if (dev) {
-    sourcemapOutput = sourcemapOutput ?? bundleFile + ".map";
-  }
-
-  //  use an absolute path for the source map file
-  if (sourcemapOutput) {
-    sourcemapOutput = path.join(distPath, sourcemapOutput);
-  }
-
-  return {
-    assetsDest,
-    entryFile,
-    minify,
-    platform,
-    dev,
-    bundleOutput: bundlePath,
-    bundleEncoding,
-    sourcemapOutput,
-    sourcemapSourcesRoot,
-  };
-}
+import type { CliPlatformBundleConfig } from "./types";
 
 /**
  * Run the Metro bundler.
  *
- * @param tsservice TypeScript service to use for type-checking (when enabled)
  * @param metroConfig Metro configuration
  * @param bundleConfig Bundle configuration
+ * @param dev Choose whether or not this will be a "developer" bundle. The alternative is a "production" bundle.
+ *            When `true`, warnings are enabled, and the bundle is not minified by default.
+ *            Further, optimizations like constant folding are disabled.
+ *            When `false`, warnings are disabled and the bundle is minified by default.
+ * @param minify Optionally choose whether or not the bundle is minified. When not set, minification is controlled by the `dev` property.
  */
 export async function metroBundle(
   metroConfig: ConfigT,
-  bundleConfig: BundleConfig
+  bundleConfig: CliPlatformBundleConfig,
+  dev: boolean,
+  minify?: boolean
 ): Promise<void> {
   info(`Bundling ${bundleConfig.platform}...`);
 
-  const typescriptValidationOptions: TypeScriptValidationOptions = {
-    throwOnError: true,
-  };
   customizeMetroConfig(
     metroConfig,
     bundleConfig.detectCyclicDependencies,
     bundleConfig.detectDuplicateDependencies,
-    bundleConfig.typescriptValidation ? typescriptValidationOptions : false,
+    bundleConfig.typescriptValidation,
     bundleConfig.treeShake
   );
 
-  const metroBundleArgs = createMetroBundleArgs(bundleConfig);
+  const metroBundleArgs: MetroBundleArgs = {
+    ...bundleConfig,
+    dev,
+    minify,
+  };
 
   // ensure all output directories exist
   createDirectory(path.dirname(metroBundleArgs.bundleOutput));

package/src/bundle/overrides.ts

@@ -1,51 +1,41 @@
+import type { TransformProfile } from "metro-babel-transformer";
 import type { BundleArgs } from "@rnx-kit/metro-service";
 import { pickValues } from "@rnx-kit/tools-language/properties";
-import type { KitBundleConfig } from "./types";
+import type { CliPlatformBundleConfig } from "./types";
 
-export type KitBundleConfigOverrides = {
-  entryPath?: string;
-  distPath?: string;
-  assetsPath?: string;
-  bundlePrefix?: string;
+export type BundleConfigOverrides = {
+  entryFile?: string;
+  bundleOutput?: string;
   bundleEncoding?: BundleArgs["bundleEncoding"];
   sourcemapOutput?: string;
   sourcemapSourcesRoot?: string;
+  sourcemapUseAbsolutePath?: boolean;
+  assetsDest?: string;
   treeShake?: boolean;
+  unstableTransformProfile?: TransformProfile;
 };
 
 /**
- * Apply overrides, if any, to each kit bundle config. Overrides are applied in-place.
+ * Apply overrides, if any, to each rnx-kit bundle configuration. Overrides are applied in-place.
  *
  * @param overrides Optional overrides to apply
- * @param configs Array of kit bundle configurations to override. This is modified if any overrides are applied.
+ * @param configs Array of platform-specific bundle configurations. This is modified if any overrides are applied.
  */
-export function applyKitBundleConfigOverrides(
-  overrides: KitBundleConfigOverrides,
-  configs: KitBundleConfig[]
+export function applyBundleConfigOverrides(
+  overrides: BundleConfigOverrides,
+  configs: CliPlatformBundleConfig[]
 ): void {
-  const overridesToApply = pickValues(
-    overrides,
-    [
-      "entryPath",
-      "distPath",
-      "assetsPath",
-      "bundlePrefix",
-      "bundleEncoding",
-      "sourcemapOutput",
-      "sourcemapSourcesRoot",
-      "treeShake",
-    ],
-    [
-      "entryPath",
-      "distPath",
-      "assetsPath",
-      "bundlePrefix",
-      "bundleEncoding",
-      "sourcemapOutput",
-      "sourcemapSourcesRoot",
-      "treeShake",
-    ]
-  );
+  const overridesToApply = pickValues(overrides, [
+    "entryFile",
+    "bundleOutput",
+    "bundleEncoding",
+    "sourcemapOutput",
+    "sourcemapSourcesRoot",
+    "sourcemapUseAbsolutePath",
+    "assetsDest",
+    "treeShake",
+    "unstableTransformProfile",
+  ]);
   if (overridesToApply) {
     for (const config of configs) {
       Object.assign(config, overridesToApply);

package/src/bundle/types.ts

@@ -1,30 +1,24 @@
-import type {
-  BundleParameters,
-  BundleRequiredParameters,
-} from "@rnx-kit/config";
+import type { TransformProfile } from "metro-babel-transformer";
+import type { BundleParameters } from "@rnx-kit/config";
 import type { AllPlatforms } from "@rnx-kit/tools-react-native/platform";
 
-export type KitBundleConfig = BundleParameters &
-  BundleRequiredParameters & {
+export type CliPlatformBundleConfig = BundleParameters &
+  Required<
+    Pick<
+      BundleParameters,
+      | "entryFile"
+      | "bundleOutput"
+      | "sourcemapUseAbsolutePath"
+      | "detectCyclicDependencies"
+      | "detectDuplicateDependencies"
+      | "typescriptValidation"
+      | "treeShake"
+    >
+  > & {
+    unstableTransformProfile?: TransformProfile;
+
     /**
      * Target platform for the bundle
      */
     platform: AllPlatforms;
   };
-
-export type BundleConfig = KitBundleConfig & {
-  /**
-   * Choose whether or not this will be a "developer" bundle. The alternative is a "production" bundle.
-   *
-   * When `true`, warnings are enabled, and the bundle is not minified by default.
-   * Further, optimizations like constant folding are disabled.
-   *
-   * When `false`, warnings are disabled and the bundle is minified by default.
-   */
-  dev: boolean;
-
-  /**
-   * Optionally choose whether or not the bundle is minified. When not set, minification is controlled by the `dev` property.
-   */
-  minify?: boolean;
-};

package/src/bundle.ts

@@ -1,27 +1,26 @@
+import type { TransformProfile } from "metro-babel-transformer";
 import type { Config as CLIConfig } from "@react-native-community/cli-types";
 import { BundleArgs, loadMetroConfig } from "@rnx-kit/metro-service";
-import { extendObjectArray } from "@rnx-kit/tools-language/properties";
 import type { AllPlatforms } from "@rnx-kit/tools-react-native/platform";
-import { getKitBundleConfigs } from "./bundle/kit-config";
+import { getCliPlatformBundleConfigs } from "./bundle/kit-config";
 import { metroBundle } from "./bundle/metro";
-import { applyKitBundleConfigOverrides } from "./bundle/overrides";
-import type { BundleConfig, KitBundleConfig } from "./bundle/types";
+import { applyBundleConfigOverrides } from "./bundle/overrides";
 
 export type CLIBundleOptions = {
   id?: string;
+  entryFile?: string;
   platform?: AllPlatforms;
-  entryPath?: string;
-  distPath?: string;
-  assetsPath?: string;
-  bundlePrefix?: string;
-  bundleEncoding?: BundleArgs["bundleEncoding"];
   dev: boolean;
   minify?: boolean;
-  experimentalTreeShake?: boolean; // Deprecated
-  treeShake?: boolean;
+  bundleOutput?: string;
+  bundleEncoding?: BundleArgs["bundleEncoding"];
   maxWorkers?: number;
   sourcemapOutput?: string;
   sourcemapSourcesRoot?: string;
+  sourcemapUseAbsolutePath?: boolean;
+  assetsDest?: string;
+  treeShake?: boolean;
+  unstableTransformProfile?: TransformProfile;
   resetCache?: boolean;
   config?: string;
 };
@@ -31,39 +30,22 @@ export async function rnxBundle(
   cliConfig: CLIConfig,
   cliOptions: CLIBundleOptions
 ): Promise<void> {
-  // experimentalTreeShake is deprecated. Only use it when treeShake is not specified.
-  if (cliOptions.experimentalTreeShake !== undefined) {
-    console.warn(
-      "Warning: The command-line parameter '--experimental-tree-shake' is deprecated. Use `--tree-shake` instead."
-    );
-    if (cliOptions.treeShake === undefined) {
-      cliOptions.treeShake = cliOptions.experimentalTreeShake;
-    }
-    delete cliOptions.experimentalTreeShake;
-  }
-
   const metroConfig = await loadMetroConfig(cliConfig, cliOptions);
 
-  const kitBundleConfigs = getKitBundleConfigs(
+  const bundleConfigs = getCliPlatformBundleConfigs(
     cliOptions.id,
     cliOptions.platform
   );
-  if (!kitBundleConfigs) {
-    return Promise.resolve();
-  }
 
-  applyKitBundleConfigOverrides(cliOptions, kitBundleConfigs);
-
-  const bundleConfigs = extendObjectArray<KitBundleConfig, BundleConfig>(
-    kitBundleConfigs,
-    {
-      dev: cliOptions.dev,
-      minify: cliOptions.minify,
-    }
-  );
+  applyBundleConfigOverrides(cliOptions, bundleConfigs);
 
   for (const bundleConfig of bundleConfigs) {
-    await metroBundle(metroConfig, bundleConfig);
+    await metroBundle(
+      metroConfig,
+      bundleConfig,
+      cliOptions.dev,
+      cliOptions.minify
+    );
   }
 
   return Promise.resolve();

package/src/bundler-plugin-defaults.ts

@@ -0,0 +1,10 @@
+import type { BundlerPlugins } from "@rnx-kit/config";
+
+export function getDefaultBundlerPlugins(): Required<BundlerPlugins> {
+  return {
+    detectCyclicDependencies: true,
+    detectDuplicateDependencies: true,
+    typescriptValidation: true,
+    treeShake: false,
+  };
+}

package/src/index.ts

@@ -4,5 +4,5 @@ export { rnxDepCheck, rnxDepCheckCommand } from "./dep-check";
 export { rnxStart } from "./start";
 export { rnxTest, rnxTestCommand } from "./test";
 export { rnxWriteThirdPartyNotices } from "./write-third-party-notices";
-export { parseBoolean } from "./parsers";
+export { parseBoolean, parseTransformProfile } from "./parsers";
 export { rnxClean } from "./clean";

package/src/metro-config.ts

@@ -1,3 +1,4 @@
+import type { TypeScriptValidationOptions } from "@rnx-kit/config";
 import {
   CyclicDependencies,
   PluginOptions as CyclicDetectorOptions,
@@ -15,7 +16,6 @@ import { AllPlatforms } from "@rnx-kit/tools-react-native/platform";
 import { Project } from "@rnx-kit/typescript-service";
 
 import { createProjectCache } from "./typescript/project-cache";
-import type { TypeScriptValidationOptions } from "./types";
 
 import type { DeltaResult, Graph } from "metro";
 import type { InputConfigT, SerializerConfigT } from "metro-config";
@@ -28,10 +28,14 @@ import type { InputConfigT, SerializerConfigT } from "metro-config";
  * Source file in node_modules (external packages) are ignored.
  *
  * @param options TypeScript validation options
+ * @param print Optional function to use when printing status messages to the Metro console
  * @returns Hook function
  */
-function createSerializerHook(options: TypeScriptValidationOptions) {
-  const projectCache = createProjectCache(options.print);
+function createSerializerHook(
+  options: TypeScriptValidationOptions,
+  print?: (message: string) => void
+) {
+  const projectCache = createProjectCache(print);
 
   const patternNodeModules = /[/\\]node_modules[/\\]/;
   const excludeNodeModules = (p: string) => !patternNodeModules.test(p);
@@ -116,13 +120,15 @@ const emptySerializerHook = (_graph: Graph, _delta: DeltaResult): void => {
  * @param detectDuplicateDependencies When true, duplicate dependency checking is enabled with a default set of options. Otherwise, the object allows for fine-grained control over the detection process.
  * @param typescriptValidation When true, TypeScript type-checking is enabled with a default set of options. Otherwise, the object allows for fine-grained control over the type-checking process.
  * @param treeShake When true, tree shaking is enabled.
+ * @param print Optional function to use when printing status messages to the Metro console
  */
 export function customizeMetroConfig(
   metroConfigReadonly: InputConfigT,
   detectCyclicDependencies: boolean | CyclicDetectorOptions,
   detectDuplicateDependencies: boolean | DuplicateDetectorOptions,
   typescriptValidation: boolean | TypeScriptValidationOptions,
-  treeShake: boolean
+  treeShake: boolean,
+  print?: (message: string) => void
 ): void {
   //  We will be making changes to the Metro configuration. Coerce from a
   //  type with readonly props to a type where the props are writeable.
@@ -163,9 +169,9 @@ export function customizeMetroConfig(
 
   let hook = emptySerializerHook;
   if (typeof typescriptValidation === "object") {
-    hook = createSerializerHook(typescriptValidation);
+    hook = createSerializerHook(typescriptValidation, print);
   } else if (typescriptValidation !== false) {
-    hook = createSerializerHook({});
+    hook = createSerializerHook({}, print);
   }
   metroConfig.serializer.experimentalSerializerHook = hook;
 }

package/src/parsers.ts

@@ -1,3 +1,5 @@
+import type { TransformProfile } from "metro-babel-transformer";
+
 export function parseBoolean(val: string): boolean {
   if (val === "false") {
     return false;
@@ -9,3 +11,20 @@ export function parseBoolean(val: string): boolean {
     "Invalid boolean value '" + val + "' -- must be true or false"
   );
 }
+
+export function parseTransformProfile(val: string): TransformProfile {
+  const allowedProfiles: TransformProfile[] = [
+    "hermes-stable",
+    "hermes-canary",
+    "default",
+  ];
+  if (val in allowedProfiles) {
+    return val as TransformProfile;
+  }
+  throw new Error(
+    "Invalid transform profile '" +
+      val +
+      "' -- must be one of " +
+      allowedProfiles.join(", ")
+  );
+}

package/src/serve/kit-config.ts

@@ -1,5 +1,6 @@
-import type { ServerWithRequiredParameters } from "@rnx-kit/config";
-import { getKitConfig, getServerConfig } from "@rnx-kit/config";
+import type { ServerConfig, BundlerPlugins } from "@rnx-kit/config";
+import { getKitConfig, getBundleConfig } from "@rnx-kit/config";
+import { getDefaultBundlerPlugins } from "../bundler-plugin-defaults";
 import { pickValues } from "@rnx-kit/tools-language/properties";
 
 export type ServerConfigOverrides = {
@@ -8,24 +9,35 @@ export type ServerConfigOverrides = {
   sourceExts?: string[];
 };
 
+export type CliServerConfig = ServerConfig & Required<BundlerPlugins>;
+
 /**
- * Get the kit's server configuration. Apply any overrides.
+ * Get the server configuration from the rnx-kit configuration. Apply any overrides.
  *
- * @param overrides Overrides to apply to the output server configuration. These take precedence over the values in the kit config.
- * @returns Overridden server configuration
+ * @param overrides Overrides to apply. These take precedence over the values in the rnx-kit configuration.
+ * @returns Server configuration
  */
 export function getKitServerConfig(
   overrides: ServerConfigOverrides
-): ServerWithRequiredParameters {
+): CliServerConfig {
   const kitConfig = getKitConfig();
-  if (!kitConfig) {
-    throw new Error(
-      "No kit configuration found for this react-native experience"
-    );
+  let serverConfig = kitConfig?.server;
+  if (!serverConfig && kitConfig) {
+    const maybeBundleConfig = getBundleConfig(kitConfig);
+    if (maybeBundleConfig) {
+      serverConfig = pickValues(maybeBundleConfig, [
+        "detectCyclicDependencies",
+        "detectDuplicateDependencies",
+        "typescriptValidation",
+        //"treeShake",  // don't pull in treeShake yet, since it doesn't work with the server
+      ]);
+    }
   }
 
   return {
-    ...getServerConfig(kitConfig),
+    ...getDefaultBundlerPlugins(),
+    ...serverConfig,
+    treeShake: false, // tree shaking does not work with the bundle server
     ...pickValues(overrides, ["projectRoot", "assetPlugins", "sourceExts"]),
   };
 }

package/src/start.ts

@@ -15,7 +15,6 @@ import qrcode from "qrcode";
 import readline from "readline";
 import { customizeMetroConfig } from "./metro-config";
 import { getKitServerConfig } from "./serve/kit-config";
-import type { TypeScriptValidationOptions } from "./types";
 
 type DevServerMiddleware = ReturnType<
   typeof CliServerApi["createDevServerMiddleware"]
@@ -31,18 +30,18 @@ type DevServerMiddleware7 = Pick<DevServerMiddleware, "middleware"> & {
 };
 
 export type CLIStartOptions = {
-  host: string;
   port: number;
+  host: string;
   projectRoot?: string;
   watchFolders?: string[];
   assetPlugins?: string[];
   sourceExts?: string[];
   maxWorkers?: number;
+  resetCache?: boolean;
   customLogReporterPath?: string;
   https?: boolean;
   key?: string;
   cert?: string;
-  resetCache?: boolean;
   config?: string;
   interactive: boolean;
 };
@@ -69,9 +68,6 @@ export async function rnxStart(
   cliOptions: CLIStartOptions
 ): Promise<void> {
   const serverConfig = getKitServerConfig(cliOptions);
-  if (!serverConfig) {
-    return Promise.resolve();
-  }
 
   const { createDevServerMiddleware, indexPageMiddleware } = friendlyRequire<
     typeof CliServerApi
@@ -140,17 +136,15 @@ export async function rnxStart(
   });
 
   // customize the metro config to include plugins, presets, etc.
-  const typescriptValidationOptions: TypeScriptValidationOptions = {
-    print: (message: string): void => {
-      terminal.log(message);
-    },
-  };
   customizeMetroConfig(
     metroConfig,
     serverConfig.detectCyclicDependencies,
     serverConfig.detectDuplicateDependencies,
-    serverConfig.typescriptValidation ? typescriptValidationOptions : false,
-    serverConfig.treeShake
+    serverConfig.typescriptValidation,
+    serverConfig.treeShake,
+    (message: string): void => {
+      terminal.log(message);
+    }
   );
 
   // create middleware -- a collection of plugins which handle incoming
@@ -165,8 +159,7 @@ export async function rnxStart(
 
   // merge the Metro config middleware with our middleware
   const enhanceMiddleware = metroConfig.server.enhanceMiddleware;
-  // eslint-disable-next-line
-  // @ts-ignore
+  // @ts-expect-error We want to assign to read-only `enhanceMiddleware`
   metroConfig.server.enhanceMiddleware = (
     metroMiddleware: Middleware,
     metroServer: Server

package/test/bundle/__mocks__/@rnx-kit/config.js

@@ -8,8 +8,7 @@ rnxKitConfig.__setMockConfig = (config) => {
 };
 
 rnxKitConfig.getKitConfig = () => kitConfig;
-rnxKitConfig.getBundleDefinition = actualKitConfig.getBundleDefinition;
-rnxKitConfig.getBundlePlatformDefinition =
-  actualKitConfig.getBundlePlatformDefinition;
+rnxKitConfig.getBundleConfig = actualKitConfig.getBundleConfig;
+rnxKitConfig.getPlatformBundleConfig = actualKitConfig.getPlatformBundleConfig;
 
 module.exports = rnxKitConfig;