@rnx-kit/cli 0.12.7 → 0.14.2

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

@@ -6,6 +6,8 @@ import {
   startServer,
 } from "@rnx-kit/metro-service";
 import chalk from "chalk";
+import type { Server as HttpServer } from "http";
+import type { Server as HttpsServer } from "https";
 import type { ReportableEvent, Reporter } from "metro";
 import type { Middleware } from "metro-config";
 import type Server from "metro/src/Server";
@@ -15,34 +17,32 @@ 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"]
 >;
 
-type DevServer = ReturnType<DevServerMiddleware["attachToServer"]>;
-
-type DevServerMiddleware7 = Pick<DevServerMiddleware, "middleware"> & {
-  websocketEndpoints: unknown;
-  debuggerProxyEndpoint: DevServer["debuggerProxy"];
-  messageSocketEndpoint: DevServer["messageSocket"];
-  eventsSocketEndpoint: DevServer["eventsSocket"];
+type DevServerMiddleware6 = Pick<DevServerMiddleware, "middleware"> & {
+  attachToServer: (server: HttpServer | HttpsServer) => {
+    debuggerProxy: DevServerMiddleware["debuggerProxyEndpoint"];
+    eventsSocket: DevServerMiddleware["eventsSocketEndpoint"];
+    messageSocket: DevServerMiddleware["messageSocketEndpoint"];
+  };
 };
 
 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;
 };
@@ -57,10 +57,10 @@ function friendlyRequire<T>(module: string): T {
   }
 }
 
-function hasWebsocketEndpoints(
-  devServer: DevServerMiddleware | DevServerMiddleware7
-): devServer is DevServerMiddleware7 {
-  return !("attachToServer" in devServer);
+function hasAttachToServerFunction(
+  devServer: DevServerMiddleware | DevServerMiddleware6
+): devServer is DevServerMiddleware6 {
+  return "attachToServer" in devServer;
 }
 
 export async function rnxStart(
@@ -69,9 +69,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 +137,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 +160,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
@@ -181,9 +175,9 @@ export async function rnxStart(
   // `createDevServerMiddleware` changed its return type in
   // https://github.com/react-native-community/cli/pull/1560
   let websocketEndpoints: unknown = undefined;
-  let messageSocketEndpoint: DevServer["messageSocket"];
+  let messageSocketEndpoint: DevServerMiddleware["messageSocketEndpoint"];
 
-  if (hasWebsocketEndpoints(devServer)) {
+  if (!hasAttachToServerFunction(devServer)) {
     websocketEndpoints = devServer.websocketEndpoints;
     messageSocketEndpoint = devServer.messageSocketEndpoint;
 
@@ -201,7 +195,7 @@ export async function rnxStart(
   };
   const serverInstance = await startServer(metroConfig, serverOptions);
 
-  if (!hasWebsocketEndpoints(devServer)) {
+  if (hasAttachToServerFunction(devServer)) {
     const { messageSocket, eventsSocket } =
       devServer.attachToServer(serverInstance);
     messageSocketEndpoint = messageSocket;

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;

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

@@ -0,0 +1 @@
+module.exports = jest.createMockFromModule("@rnx-kit/console");

package/test/bundle/__mocks__/@rnx-kit/metro-service.js

@@ -0,0 +1 @@
+module.exports = jest.createMockFromModule("@rnx-kit/metro-service");

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

@@ -1,55 +1,12 @@
 import "jest-extended";
-import type { BundleDefinitionWithRequiredParameters } from "@rnx-kit/config";
 import {
-  getKitBundleConfigs,
-  getKitBundleDefinition,
   getTargetPlatforms,
+  getCliPlatformBundleConfigs,
 } from "../../src/bundle/kit-config";
 
 const rnxKitConfig = require("@rnx-kit/config");
-const consoleWarnSpy = jest.spyOn(global.console, "warn");
 
-describe("CLI > Bundle > Kit Config > getKitBundleDefinition", () => {
-  beforeEach(() => {
-    rnxKitConfig.__setMockConfig(undefined);
-    consoleWarnSpy.mockReset();
-  });
-
-  test("throws when kit config is not found", () => {
-    expect(() => getKitBundleDefinition()).toThrowError();
-  });
-
-  test("returns undefined with a warning message when bundle configuration is missing", () => {
-    rnxKitConfig.__setMockConfig({});
-    expect(getKitBundleDefinition()).toBeUndefined();
-    expect(consoleWarnSpy).toBeCalledTimes(1);
-    expect(consoleWarnSpy).toBeCalledWith(
-      expect.anything(),
-      expect.stringContaining("No bundle configuration found")
-    );
-  });
-
-  test("returns undefined with a warning message when bundling is disabled", () => {
-    rnxKitConfig.__setMockConfig({ bundle: false });
-    expect(getKitBundleDefinition()).toBeUndefined();
-    expect(consoleWarnSpy).toBeCalledTimes(1);
-    expect(consoleWarnSpy).toBeCalledWith(
-      expect.anything(),
-      expect.stringContaining("Bundling is disabled")
-    );
-  });
-
-  test("returns a bundle definition when bundling is enabled", () => {
-    rnxKitConfig.__setMockConfig({ bundle: true });
-    const definition = getKitBundleDefinition();
-    expect(consoleWarnSpy).not.toBeCalled();
-    expect(definition).toBeObject();
-    expect(definition.entryPath).toBeString();
-    expect(definition.entryPath.length).toBeGreaterThan(0);
-  });
-});
-
-describe("CLI > Bundle > Kit Config > getTargetPlatforms  ", () => {
+describe("CLI > Bundle > Kit Config > getTargetPlatforms", () => {
   test("returns the override platform", () => {
     const platforms = getTargetPlatforms("ios", ["android", "ios", "windows"]);
     expect(platforms).toBeArrayOfSize(1);
@@ -71,78 +28,123 @@ describe("CLI > Bundle > Kit Config > getTargetPlatforms  ", () => {
   });
 });
 
-describe("CLI > Bundle > Kit Config > getKitBundleConfigs", () => {
-  const definition: BundleDefinitionWithRequiredParameters = {
-    entryPath: "start.js",
-    distPath: "out",
-    assetsPath: "out/assets",
-    bundlePrefix: "fabrikam",
+describe("CLI > Bundle > Kit Config > getCliPlatformBundleConfigs", () => {
+  const defaultConfig = {
+    entryFile: "index.js",
+    sourcemapUseAbsolutePath: false,
     detectCyclicDependencies: true,
     detectDuplicateDependencies: true,
     typescriptValidation: true,
-    treeShake: true,
-    targets: ["ios", "android"],
-    platforms: {
-      ios: {
-        entryPath: "entry.ios.js",
-      },
-    },
+    treeShake: false,
+  };
+
+  const defaultConfigIOS = {
+    ...defaultConfig,
+    bundleOutput: "index.ios.jsbundle",
+    platform: "ios",
+  };
+
+  const defaultConfigMacOS = {
+    ...defaultConfig,
+    bundleOutput: "index.macos.jsbundle",
+    platform: "macos",
+  };
+
+  const defaultConfigAndroid = {
+    ...defaultConfig,
+    bundleOutput: "index.android.bundle",
+    platform: "android",
+  };
+
+  const defaultConfigWindows = {
+    ...defaultConfig,
+    bundleOutput: "index.windows.bundle",
+    platform: "windows",
   };
 
   beforeEach(() => {
-    rnxKitConfig.__setMockConfig({
-      bundle: {
-        ...definition,
-      },
-    });
-    consoleWarnSpy.mockReset();
+    rnxKitConfig.__setMockConfig(undefined);
+  });
+
+  test("returns defaults for iOS when package has no config", () => {
+    const configs = getCliPlatformBundleConfigs(undefined, "ios");
+    expect(configs).toBeArrayOfSize(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(configs[0]).toEqual(defaultConfigMacOS);
   });
 
-  test("returns one kit bundle config when an override platform is given", () => {
-    const kitBundleConfigs = getKitBundleConfigs(undefined, "ios");
-    expect(kitBundleConfigs).toBeArrayOfSize(1);
+  test("returns defaults for Android when package has no config", () => {
+    const configs = getCliPlatformBundleConfigs(undefined, "android");
+    expect(configs).toBeArrayOfSize(1);
+    expect(configs[0]).toEqual(defaultConfigAndroid);
   });
 
-  test("sets the platform property", () => {
-    const kitBundleConfigs = getKitBundleConfigs();
-    expect(kitBundleConfigs).toBeArrayOfSize(2);
-    expect(kitBundleConfigs[0].platform).toEqual("ios");
-    expect(kitBundleConfigs[1].platform).toEqual("android");
+  test("returns defaults for Windows when package has no config", () => {
+    const configs = getCliPlatformBundleConfigs(undefined, "windows");
+    expect(configs).toBeArrayOfSize(1);
+    expect(configs[0]).toEqual(defaultConfigWindows);
   });
 
-  test("sets all bundle definition properties", () => {
-    const kitBundleConfigs = getKitBundleConfigs();
-    expect(kitBundleConfigs).toBeArrayOfSize(2);
-    expect(kitBundleConfigs[0]).toEqual({
-      ...definition,
-      entryPath: "entry.ios.js",
-      platform: "ios",
+  const testConfig = {
+    bundle: {
+      entryFile: "entry.js",
+      typescriptValidation: false,
+      assetsDest: "dist",
+      targets: ["ios", "macos", "android", "windows"],
+    },
+  };
+
+  test("returns config with defaults for all target platforms", () => {
+    rnxKitConfig.__setMockConfig(testConfig);
+    const configs = getCliPlatformBundleConfigs();
+    expect(configs).toBeArrayOfSize(4);
+    expect(configs[0]).toEqual({ ...defaultConfigIOS, ...testConfig.bundle });
+    expect(configs[1]).toEqual({ ...defaultConfigMacOS, ...testConfig.bundle });
+    expect(configs[2]).toEqual({
+      ...defaultConfigAndroid,
+      ...testConfig.bundle,
     });
-    expect(kitBundleConfigs[1]).toEqual({
-      ...definition,
-      platform: "android",
+    expect(configs[3]).toEqual({
+      ...defaultConfigWindows,
+      ...testConfig.bundle,
     });
   });
 
-  test("uses deprecated experimental_treeShake", () => {
-    const d: Record<string, unknown> = { ...definition };
-    delete d.treeShake;
-    d.experimental_treeShake = true;
-    rnxKitConfig.__setMockConfig({
-      bundle: {
-        ...d,
+  const testMultiConfig = {
+    bundle: [
+      {
+        id: "first",
+        entryFile: "first.js",
       },
+      {
+        id: "second",
+        entryFile: "second.js",
+      },
+    ],
+  };
+
+  test("returns the first config when no id is given", () => {
+    rnxKitConfig.__setMockConfig(testMultiConfig);
+    const configs = getCliPlatformBundleConfigs(undefined, "ios");
+    expect(configs).toBeArrayOfSize(1);
+    expect(configs[0]).toEqual({
+      ...defaultConfigIOS,
+      ...testMultiConfig.bundle[0],
+    });
+  });
+
+  test("returns the selected config when an id is given", () => {
+    rnxKitConfig.__setMockConfig(testMultiConfig);
+    const configs = getCliPlatformBundleConfigs("second", "android");
+    expect(configs).toBeArrayOfSize(1);
+    expect(configs[0]).toEqual({
+      ...defaultConfigAndroid,
+      ...testMultiConfig.bundle[1],
     });
-    consoleWarnSpy.mockReset();
-
-    const kitBundleConfigs = getKitBundleConfigs(undefined, "ios");
-    expect(kitBundleConfigs[0].treeShake).toBe(true);
-    expect(consoleWarnSpy).toBeCalledTimes(1);
-    expect(consoleWarnSpy).toBeCalledWith(
-      expect.stringContaining("deprecated")
-    );
-    expect(consoleWarnSpy).toBeCalledWith(
-      expect.stringContaining("experimental_treeShake")
-    );
   });
 });