@rnx-kit/cli 0.15.3 → 0.16.0

package/src/bundle/types.ts

@@ -28,10 +28,8 @@ export type CliPlatformBundleConfig = BundleParameters &
       | "entryFile"
       | "bundleOutput"
       | "sourcemapUseAbsolutePath"
-      | "detectCyclicDependencies"
-      | "detectDuplicateDependencies"
-      | "typescriptValidation"
       | "treeShake"
+      | "plugins"
     >
   > & {
     unstableTransformProfile?: TransformProfile;

package/src/metro-config.ts

@@ -1,4 +1,5 @@
-import type { BundlerPlugins } from "@rnx-kit/config";
+import type { BundleParameters } from "@rnx-kit/config";
+import { warn } from "@rnx-kit/console";
 import { CyclicDependencies } from "@rnx-kit/metro-plugin-cyclic-dependencies-detector";
 import { DuplicateDependencies } from "@rnx-kit/metro-plugin-duplicates-checker";
 import { TypeScriptPlugin } from "@rnx-kit/metro-plugin-typescript";
@@ -9,44 +10,158 @@ import {
   MetroSerializer as MetroSerializerEsbuild,
 } from "@rnx-kit/metro-serializer-esbuild";
 import type { InputConfigT, SerializerConfigT } from "metro-config";
+import { getDefaultBundlerPlugins } from "./bundle/defaultPlugins";
+
+type MetroExtraParams = Pick<
+  BundleParameters,
+  | "detectCyclicDependencies"
+  | "detectDuplicateDependencies"
+  | "typescriptValidation"
+  | "plugins"
+  | "treeShake"
+>;
+
+function resolvePlugin(name: string): string {
+  try {
+    return require.resolve(name);
+  } catch (_) {
+    return require.resolve(name, { paths: [process.cwd()] });
+  }
+}
+
+function importPlugin(name: string) {
+  const plugin = require(resolvePlugin(name));
+  return plugin.default || plugin;
+}
+
+function readLegacyOptions({
+  detectCyclicDependencies,
+  detectDuplicateDependencies,
+  typescriptValidation,
+}: MetroExtraParams): string | undefined {
+  const oldOptions = [];
+  const deprecatedOptions: Record<string, Record<string, unknown> | true> = {};
+
+  if (detectCyclicDependencies) {
+    oldOptions.push("detectCyclicDependencies");
+    deprecatedOptions["@rnx-kit/metro-plugin-cyclic-dependencies-detector"] =
+      detectCyclicDependencies;
+  }
+  if (detectDuplicateDependencies) {
+    oldOptions.push("detectDuplicateDependencies");
+    deprecatedOptions["@rnx-kit/metro-plugin-duplicates-checker"] =
+      detectDuplicateDependencies;
+  }
+  if (typescriptValidation) {
+    oldOptions.push("typescriptValidation");
+    deprecatedOptions["@rnx-kit/metro-plugin-typescript"] =
+      typescriptValidation;
+  }
+
+  if (oldOptions.length === 0) {
+    return undefined;
+  }
+
+  return (
+    `'${oldOptions.join("', '")}' have been replaced by a new 'plugins' ` +
+    "option. Below is an equivalent config:\n" +
+    "\n" +
+    '    "plugins": [\n' +
+    Object.entries(deprecatedOptions)
+      .map(([name, options]) => {
+        if (typeof options === "object") {
+          const json = JSON.stringify(options, null, 2)
+            .split("\n")
+            .join("\n      ");
+          return `      ["${name}", ${json}]`;
+        } else {
+          return `      "${name}"`;
+        }
+      })
+      .join(",\n") +
+    "\n" +
+    "    ]\n" +
+    "\n" +
+    "For more details, see " +
+    "https://github.com/microsoft/rnx-kit/tree/main/packages/cli#readme"
+  );
+}
 
 /**
  * Customize the Metro configuration.
  *
  * @param metroConfigReadonly Metro configuration
- * @param bundlerPlugins Plugins used to further customize Metro configuration
+ * @param extraParams Parameters used to further customize Metro configuration
  * @param print Optional function to use when printing status messages to the Metro console
  */
 export function customizeMetroConfig(
   metroConfigReadonly: InputConfigT,
-  {
-    detectCyclicDependencies,
-    detectDuplicateDependencies,
-    treeShake,
-    typescriptValidation,
-  }: BundlerPlugins,
+  extraParams: MetroExtraParams,
   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.
+  // We will be making changes to the Metro configuration. Coerce from a type
+  // with readonly props to a type where the props are writeable.
   const metroConfig = metroConfigReadonly as InputConfigT;
 
-  const plugins: MetroPlugin[] = [];
-  if (typeof detectDuplicateDependencies === "object") {
-    plugins.push(DuplicateDependencies(detectDuplicateDependencies));
-  } else if (detectDuplicateDependencies !== false) {
-    plugins.push(DuplicateDependencies());
-  }
-  if (typeof detectCyclicDependencies === "object") {
-    plugins.push(CyclicDependencies(detectCyclicDependencies));
-  } else if (detectCyclicDependencies !== false) {
-    plugins.push(CyclicDependencies());
+  const metroPlugins: MetroPlugin[] = [];
+  const serializerHooks: Record<
+    string,
+    SerializerConfigT["experimentalSerializerHook"]
+  > = {};
+
+  const legacyWarning = readLegacyOptions(extraParams);
+  if (legacyWarning) {
+    warn(legacyWarning);
+
+    const {
+      detectCyclicDependencies,
+      detectDuplicateDependencies,
+      typescriptValidation,
+    } = extraParams;
+
+    if (typeof detectDuplicateDependencies === "object") {
+      metroPlugins.push(DuplicateDependencies(detectDuplicateDependencies));
+    } else if (detectDuplicateDependencies !== false) {
+      metroPlugins.push(DuplicateDependencies());
+    }
+
+    if (typeof detectCyclicDependencies === "object") {
+      metroPlugins.push(CyclicDependencies(detectCyclicDependencies));
+    } else if (detectCyclicDependencies !== false) {
+      metroPlugins.push(CyclicDependencies());
+    }
+
+    if (typescriptValidation !== false) {
+      const plugin = TypeScriptPlugin(typescriptValidation, print);
+      serializerHooks["@rnx-kit/metro-plugin-typescript"] = plugin;
+    }
+  } else {
+    const plugins = extraParams.plugins || getDefaultBundlerPlugins().plugins;
+    for (const entry of plugins) {
+      const [module, options] = Array.isArray(entry)
+        ? entry
+        : [entry, undefined];
+      const plugin = importPlugin(module);
+      switch (plugin.type) {
+        case "serializer":
+          metroPlugins.push(plugin(options));
+          break;
+
+        case "serializerHook":
+          serializerHooks[module] = plugin(options, print);
+          break;
+
+        default:
+          throw new Error(`${module}: unknown plugin type: ${plugin.type}`);
+      }
+    }
   }
 
-  if (treeShake) {
-    metroConfig.serializer.customSerializer = MetroSerializerEsbuild(plugins);
+  if (extraParams.treeShake) {
+    metroConfig.serializer.customSerializer =
+      MetroSerializerEsbuild(metroPlugins);
     Object.assign(metroConfig.transformer, esbuildTransformerConfig);
-  } else if (plugins.length > 0) {
+  } else if (metroPlugins.length > 0) {
     // MetroSerializer acts as a CustomSerializer, and it works with both
     // older and newer versions of Metro. Older versions expect a return
     // value, while newer versions expect a promise.
@@ -58,12 +173,25 @@ export function customizeMetroConfig(
     // Since it can handle either scenario, just coerce it to whatever
     // the current version of Metro expects.
     metroConfig.serializer.customSerializer = MetroSerializer(
-      plugins
+      metroPlugins
     ) as SerializerConfigT["customSerializer"];
   } else {
     delete metroConfig.serializer.customSerializer;
   }
 
-  const hook = TypeScriptPlugin(typescriptValidation, print);
-  metroConfig.serializer.experimentalSerializerHook = hook;
+  const hooks = Object.values(serializerHooks);
+  switch (hooks.length) {
+    case 0:
+      break;
+    case 1:
+      metroConfig.serializer.experimentalSerializerHook = hooks[0];
+      break;
+    default:
+      metroConfig.serializer.experimentalSerializerHook = (graph, delta) => {
+        for (const hook of hooks) {
+          hook(graph, delta);
+        }
+      };
+      break;
+  }
 }

package/src/serve/kit-config.ts

@@ -1,15 +1,18 @@
-import type { ServerConfig, BundlerPlugins } from "@rnx-kit/config";
-import { getKitConfig, getBundleConfig } from "@rnx-kit/config";
+import type { ServerConfig } from "@rnx-kit/config";
+import { getBundleConfig, getKitConfig } from "@rnx-kit/config";
 import { pickValues } from "@rnx-kit/tools-language/properties";
 import { getDefaultBundlerPlugins } from "../bundle/defaultPlugins";
 
-export type ServerConfigOverrides = {
+type ServerConfigOverrides = {
   projectRoot?: string;
   assetPlugins?: string[];
   sourceExts?: string[];
 };
 
-export type CliServerConfig = ServerConfig & Required<BundlerPlugins>;
+type CliServerConfig = ServerConfig & {
+  plugins: Required<ServerConfig>["plugins"];
+  treeShake: false;
+};
 
 /**
  * Get the server configuration from the rnx-kit configuration. Apply any overrides.
@@ -29,7 +32,7 @@ export function getKitServerConfig(
         "detectCyclicDependencies",
         "detectDuplicateDependencies",
         "typescriptValidation",
-        //"treeShake",  // don't pull in treeShake yet, since it doesn't work with the server
+        "plugins",
       ]);
     }
   }

package/src/start.ts

@@ -19,7 +19,7 @@ import { customizeMetroConfig } from "./metro-config";
 import { getKitServerConfig } from "./serve/kit-config";
 
 type DevServerMiddleware = ReturnType<
-  typeof CliServerApi["createDevServerMiddleware"]
+  (typeof CliServerApi)["createDevServerMiddleware"]
 >;
 
 type DevServerMiddleware6 = Pick<DevServerMiddleware, "middleware"> & {

package/test/bundle/kit-config.test.ts

@@ -1,4 +1,3 @@
-import "jest-extended";
 import {
   getTargetPlatforms,
   getCliPlatformBundleConfigs,
@@ -9,8 +8,9 @@ const rnxKitConfig = require("@rnx-kit/config");
 describe("CLI > Bundle > Kit Config > getTargetPlatforms", () => {
   test("returns the override platform", () => {
     const platforms = getTargetPlatforms("ios", ["android", "ios", "windows"]);
-    expect(platforms).toBeArrayOfSize(1);
-    expect(platforms).toIncludeSameMembers(["ios"]);
+    expect(Array.isArray(platforms)).toBe(true);
+    expect(platforms.length).toBe(1);
+    expect(platforms).toEqual(["ios"]);
   });
 
   test("returns the target platforms", () => {
@@ -19,8 +19,9 @@ describe("CLI > Bundle > Kit Config > getTargetPlatforms", () => {
       "ios",
       "windows",
     ]);
-    expect(platforms).toBeArrayOfSize(3);
-    expect(platforms).toIncludeSameMembers(["android", "ios", "windows"]);
+    expect(Array.isArray(platforms)).toBe(true);
+    expect(platforms.length).toBe(3);
+    expect(platforms).toEqual(["android", "ios", "windows"]);
   });
 
   test("throws when no override or target platform is given", () => {
@@ -32,10 +33,12 @@ describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
   const defaultConfig = {
     entryFile: "index.js",
     sourcemapUseAbsolutePath: false,
-    detectCyclicDependencies: true,
-    detectDuplicateDependencies: true,
-    typescriptValidation: true,
     treeShake: false,
+    plugins: [
+      "@rnx-kit/metro-plugin-cyclic-dependencies-detector",
+      "@rnx-kit/metro-plugin-duplicates-checker",
+      "@rnx-kit/metro-plugin-typescript",
+    ],
   };
 
   const defaultConfigIOS = {
@@ -68,25 +71,29 @@ describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
 
   test("returns defaults for iOS when package has no config", () => {
     const configs = getCliPlatformBundleConfigs(undefined, "ios");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual(defaultConfigIOS);
   });
 
   test("returns defaults for MacOS when package has no config", () => {
     const configs = getCliPlatformBundleConfigs(undefined, "macos");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual(defaultConfigMacOS);
   });
 
   test("returns defaults for Android when package has no config", () => {
     const configs = getCliPlatformBundleConfigs(undefined, "android");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual(defaultConfigAndroid);
   });
 
   test("returns defaults for Windows when package has no config", () => {
     const configs = getCliPlatformBundleConfigs(undefined, "windows");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual(defaultConfigWindows);
   });
 
@@ -102,7 +109,8 @@ describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
   test("returns config with defaults for all target platforms", () => {
     rnxKitConfig.__setMockConfig(testConfig);
     const configs = getCliPlatformBundleConfigs();
-    expect(configs).toBeArrayOfSize(4);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(4);
     expect(configs[0]).toEqual({ ...defaultConfigIOS, ...testConfig.bundle });
     expect(configs[1]).toEqual({ ...defaultConfigMacOS, ...testConfig.bundle });
     expect(configs[2]).toEqual({
@@ -131,7 +139,8 @@ describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
   test("returns the first config when no id is given", () => {
     rnxKitConfig.__setMockConfig(testMultiConfig);
     const configs = getCliPlatformBundleConfigs(undefined, "ios");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual({
       ...defaultConfigIOS,
       ...testMultiConfig.bundle[0],
@@ -141,7 +150,8 @@ describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
   test("returns the selected config when an id is given", () => {
     rnxKitConfig.__setMockConfig(testMultiConfig);
     const configs = getCliPlatformBundleConfigs("second", "android");
-    expect(configs).toBeArrayOfSize(1);
+    expect(Array.isArray(configs)).toBe(true);
+    expect(configs.length).toBe(1);
     expect(configs[0]).toEqual({
       ...defaultConfigAndroid,
       ...testMultiConfig.bundle[1],

package/test/bundle/metro.test.ts

@@ -1,4 +1,3 @@
-import "jest-extended";
 import { metroBundle } from "../../src/bundle/metro";
 import type { CliPlatformBundleConfig } from "../../src/bundle/types";
 
@@ -19,10 +18,8 @@ describe("CLI > Bundle > Metro > metroBundle", () => {
   const bundleConfigNoPlugins: CliPlatformBundleConfig = {
     entryFile: "out/entry.js",
     bundleOutput: "src/main.jsbundle",
-    detectCyclicDependencies: false,
-    detectDuplicateDependencies: false,
-    typescriptValidation: false,
     treeShake: false,
+    plugins: [],
     platform: "ios",
     sourcemapOutput: "map/main.map",
     sourcemapSourcesRoot: "root-path-for-source-maps",
@@ -32,10 +29,12 @@ describe("CLI > Bundle > Metro > metroBundle", () => {
 
   const bundleConfig: CliPlatformBundleConfig = {
     ...bundleConfigNoPlugins,
-    detectCyclicDependencies: true,
-    detectDuplicateDependencies: true,
-    typescriptValidation: true,
     treeShake: true,
+    plugins: [
+      "@rnx-kit/metro-plugin-cyclic-dependencies-detector",
+      "@rnx-kit/metro-plugin-duplicates-checker",
+      "@rnx-kit/metro-plugin-typescript",
+    ],
   };
 
   const dev = true;
@@ -43,16 +42,16 @@ describe("CLI > Bundle > Metro > metroBundle", () => {
 
   it("does not use a custom serializer when all plugins are disabled", async () => {
     const metroConfig = await getDefaultConfig();
-    expect(metroConfig.serializer.customSerializer).toBeNil();
+    expect(metroConfig.serializer.customSerializer).toBeFalsy();
     await metroBundle(metroConfig, bundleConfigNoPlugins, dev, minify);
-    expect(metroConfig.serializer.customSerializer).toBeNil();
+    expect(metroConfig.serializer.customSerializer).toBeFalsy();
   });
 
   it("uses a custom serializer when at least one plugin is enabled", async () => {
     const metroConfig = await getDefaultConfig();
-    expect(metroConfig.serializer.customSerializer).toBeNil();
+    expect(metroConfig.serializer.customSerializer).toBeFalsy();
     await metroBundle(metroConfig, bundleConfig, dev, minify);
-    expect(metroConfig.serializer.customSerializer).not.toBeNil();
+    expect(metroConfig.serializer.customSerializer).toBeTruthy();
   });
 
   it("creates directories for the bundle, the source map, and assets", async () => {

package/test/bundle/overrides.test.ts

@@ -1,4 +1,3 @@
-import "jest-extended";
 import {
   applyBundleConfigOverrides,
   overridableCommonBundleOptions,
@@ -10,10 +9,12 @@ describe("CLI > Bundle > Overrides > applyBundleConfigOverrides", () => {
     entryFile: "src/index.js",
     bundleOutput: "main.jsbundle",
     sourcemapUseAbsolutePath: false,
-    detectCyclicDependencies: true,
-    detectDuplicateDependencies: true,
-    typescriptValidation: true,
     treeShake: true,
+    plugins: [
+      "@rnx-kit/metro-plugin-cyclic-dependencies-detector",
+      "@rnx-kit/metro-plugin-duplicates-checker",
+      "@rnx-kit/metro-plugin-typescript",
+    ],
     indexedRamBundle: false,
     platform: "ios",
   };

package/test/metro-config.test.ts

@@ -1,18 +1,36 @@
-import { CyclicDependencies } from "@rnx-kit/metro-plugin-cyclic-dependencies-detector";
-import { DuplicateDependencies } from "@rnx-kit/metro-plugin-duplicates-checker";
+import CyclicDependencies from "@rnx-kit/metro-plugin-cyclic-dependencies-detector";
+import DuplicateDependencies from "@rnx-kit/metro-plugin-duplicates-checker";
 import type { InputConfigT } from "metro-config";
 import { customizeMetroConfig } from "../src/metro-config";
 
-jest.mock("@rnx-kit/metro-plugin-cyclic-dependencies-detector", () => {
-  return {
-    CyclicDependencies: jest.fn(),
+function mockPlugin(moduleName: string) {
+  const state: { timesCalled: number; options?: Record<string, unknown> } = {
+    timesCalled: 0,
+  };
+
+  function PluginMock(options: Record<string, unknown>) {
+    state.timesCalled = state.timesCalled + 1;
+    state.options = options;
+    return () => ({});
+  }
+
+  const Plugin = jest.requireActual(moduleName);
+  PluginMock.type = Plugin.default.type;
+  PluginMock.__context = state;
+  PluginMock.mockClear = () => {
+    state.timesCalled = 0;
+    state.options = undefined;
   };
+
+  return PluginMock;
+}
+
+jest.mock("@rnx-kit/metro-plugin-cyclic-dependencies-detector", () => {
+  return mockPlugin("@rnx-kit/metro-plugin-cyclic-dependencies-detector");
 });
 
 jest.mock("@rnx-kit/metro-plugin-duplicates-checker", () => {
-  return {
-    DuplicateDependencies: jest.fn(),
-  };
+  return mockPlugin("@rnx-kit/metro-plugin-duplicates-checker");
 });
 
 // Always use a new mock since `customizeMetroConfig()` modifies the object.
@@ -26,10 +44,14 @@ function makeMockConfig(): InputConfigT {
   } as unknown as InputConfigT;
 }
 
+function toMock(module: unknown): ReturnType<typeof mockPlugin> {
+  return module as ReturnType<typeof mockPlugin>;
+}
+
 describe("cli/metro-config/customizeMetroConfig", () => {
   afterEach(() => {
-    (CyclicDependencies as any).mockClear();
-    (DuplicateDependencies as any).mockClear();
+    toMock(CyclicDependencies).mockClear();
+    toMock(DuplicateDependencies).mockClear();
   });
 
   test("returns a config with plugins by default", () => {
@@ -47,15 +69,14 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).toHaveBeenCalledWith();
-    expect(DuplicateDependencies).toHaveBeenCalledWith();
+    expect(toMock(CyclicDependencies).__context).toEqual({ timesCalled: 1 });
+    expect(toMock(DuplicateDependencies).__context).toEqual({ timesCalled: 1 });
   });
 
   test("returns a config without a custom serializer when there are no plugins", () => {
     const inputConfig = makeMockConfig();
     customizeMetroConfig(inputConfig, {
-      detectCyclicDependencies: false,
-      detectDuplicateDependencies: false,
+      plugins: ["@rnx-kit/metro-plugin-typescript"],
     });
 
     expect(inputConfig).toEqual({
@@ -68,14 +89,17 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).not.toHaveBeenCalled();
-    expect(DuplicateDependencies).not.toHaveBeenCalled();
+    expect(toMock(CyclicDependencies).__context).toEqual({ timesCalled: 0 });
+    expect(toMock(DuplicateDependencies).__context).toEqual({ timesCalled: 0 });
   });
 
   test("returns a config with only duplicates plugin", () => {
     const inputConfig = makeMockConfig();
     customizeMetroConfig(inputConfig, {
-      detectCyclicDependencies: false,
+      plugins: [
+        "@rnx-kit/metro-plugin-duplicates-checker",
+        "@rnx-kit/metro-plugin-typescript",
+      ],
     });
 
     expect(inputConfig).toEqual({
@@ -89,14 +113,17 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).not.toHaveBeenCalled();
-    expect(DuplicateDependencies).toHaveBeenCalledWith();
+    expect(toMock(CyclicDependencies).__context).toEqual({ timesCalled: 0 });
+    expect(toMock(DuplicateDependencies).__context).toEqual({ timesCalled: 1 });
   });
 
   test("returns a config with only cyclic dependencies plugin", () => {
     const inputConfig = makeMockConfig();
     customizeMetroConfig(inputConfig, {
-      detectDuplicateDependencies: false,
+      plugins: [
+        "@rnx-kit/metro-plugin-cyclic-dependencies-detector",
+        "@rnx-kit/metro-plugin-typescript",
+      ],
     });
 
     expect(inputConfig).toEqual({
@@ -110,8 +137,8 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).toHaveBeenCalledWith();
-    expect(DuplicateDependencies).not.toHaveBeenCalled();
+    expect(toMock(CyclicDependencies).__context).toEqual({ timesCalled: 1 });
+    expect(toMock(DuplicateDependencies).__context).toEqual({ timesCalled: 0 });
   });
 
   test("forwards plugin options", () => {
@@ -119,8 +146,17 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     const cyclicDependenciesOptions = { cyclicDependencies: true } as any;
     const duplicateDependencesOptions = { duplicateDependencies: true } as any;
     customizeMetroConfig(inputConfig, {
-      detectCyclicDependencies: cyclicDependenciesOptions,
-      detectDuplicateDependencies: duplicateDependencesOptions,
+      plugins: [
+        [
+          "@rnx-kit/metro-plugin-cyclic-dependencies-detector",
+          cyclicDependenciesOptions,
+        ],
+        [
+          "@rnx-kit/metro-plugin-duplicates-checker",
+          duplicateDependencesOptions,
+        ],
+        "@rnx-kit/metro-plugin-typescript",
+      ],
     });
 
     expect(inputConfig).toEqual({
@@ -134,18 +170,21 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).toHaveBeenCalledWith(cyclicDependenciesOptions);
-    expect(DuplicateDependencies).toHaveBeenCalledWith(
-      duplicateDependencesOptions
-    );
+    expect(toMock(CyclicDependencies).__context).toEqual({
+      timesCalled: 1,
+      options: cyclicDependenciesOptions,
+    });
+    expect(toMock(DuplicateDependencies).__context).toEqual({
+      timesCalled: 1,
+      options: duplicateDependencesOptions,
+    });
   });
 
   test("returns a config with a custom serializer when tree shaking is enabled", () => {
     const inputConfig = makeMockConfig();
     customizeMetroConfig(inputConfig, {
-      detectCyclicDependencies: false,
-      detectDuplicateDependencies: false,
       treeShake: true,
+      plugins: ["@rnx-kit/metro-plugin-typescript"],
     });
 
     expect(inputConfig).toEqual({
@@ -161,7 +200,7 @@ describe("cli/metro-config/customizeMetroConfig", () => {
     expect(typeof inputConfig.serializer.experimentalSerializerHook).toBe(
       "function"
     );
-    expect(CyclicDependencies).not.toHaveBeenCalled();
-    expect(DuplicateDependencies).not.toHaveBeenCalled();
+    expect(toMock(CyclicDependencies).__context).toEqual({ timesCalled: 0 });
+    expect(toMock(DuplicateDependencies).__context).toEqual({ timesCalled: 0 });
   });
 });