@rnx-kit/cli 0.12.6 → 0.14.1

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")
-    );
   });
 });

package/test/bundle/metro.test.ts

@@ -1,115 +1,75 @@
-import type { AllPlatforms } from "@rnx-kit/tools-react-native/platform";
-import path from "path";
-import { createMetroBundleArgs } from "../../src/bundle/metro";
-import type { BundleConfig } from "../../src/bundle/types";
+import "jest-extended";
+import { metroBundle } from "../../src/bundle/metro";
+import type { CliPlatformBundleConfig } from "../../src/bundle/types";
 
-describe("CLI > Bundle > Metro > createMetroBundleArgs", () => {
-  const bundleConfig: BundleConfig = {
-    detectCyclicDependencies: true,
-    detectDuplicateDependencies: true,
-    typescriptValidation: true,
-    treeShake: true,
-    entryPath: "out/entry.js",
-    distPath: "out",
-    assetsPath: "out/assets",
-    bundlePrefix: "my-app",
-    platform: "ios",
-    dev: true,
-    minify: true,
-    sourceMapPath: "abc.map",
-    sourceMapSourceRootPath: "root-path-for-source-maps",
-  };
-
-  test("sets assetsDest", () => {
-    expect(createMetroBundleArgs(bundleConfig).assetsDest).toEqual(
-      bundleConfig.assetsPath
-    );
-  });
-
-  test("sets entryFile", () => {
-    expect(createMetroBundleArgs(bundleConfig).entryFile).toEqual(
-      bundleConfig.entryPath
-    );
-  });
-
-  test("sets minify", () => {
-    expect(createMetroBundleArgs(bundleConfig).minify).toEqual(
-      bundleConfig.minify
-    );
-  });
-
-  test("sets platform", () => {
-    expect(createMetroBundleArgs(bundleConfig).platform).toEqual(
-      bundleConfig.platform
-    );
-  });
-
-  test("sets dev", () => {
-    expect(createMetroBundleArgs(bundleConfig).dev).toEqual(bundleConfig.dev);
-  });
-
-  function testBundleFileExtension(
-    platform: AllPlatforms,
-    expectedExtension: string
-  ): void {
-    const copy: BundleConfig = { ...bundleConfig, platform };
-    const args = createMetroBundleArgs(copy);
-    expect(path.extname(args.bundleOutput).toLowerCase()).toEqual(
-      expectedExtension
-    );
-  }
+const { getDefaultConfig } = require("metro-config");
 
-  test("sets bundle file extension to .bundle for android", () => {
-    testBundleFileExtension("android", ".bundle");
-  });
+const mockCreateDirectory = jest.fn();
+const toolsNodeFS = require("@rnx-kit/tools-node/fs");
+toolsNodeFS.createDirectory = mockCreateDirectory;
 
-  test("sets bundle file extension to .jsbundle for ios", () => {
-    testBundleFileExtension("ios", ".jsbundle");
-  });
+const metroService = require("@rnx-kit/metro-service");
+const mockBundle = metroService.bundle;
 
-  test("sets bundle file extension to .jsbundle for macos", () => {
-    testBundleFileExtension("macos", ".jsbundle");
+describe("CLI > Bundle > Metro > metroBundle", () => {
+  afterEach(() => {
+    jest.resetAllMocks();
   });
 
-  test("sets bundle file extension to .bundle for windows", () => {
-    testBundleFileExtension("windows", ".bundle");
-  });
+  const bundleConfigNoPlugins: CliPlatformBundleConfig = {
+    entryFile: "out/entry.js",
+    bundleOutput: "src/main.jsbundle",
+    detectCyclicDependencies: false,
+    detectDuplicateDependencies: false,
+    typescriptValidation: false,
+    treeShake: false,
+    platform: "ios",
+    sourcemapOutput: "map/main.map",
+    sourcemapSourcesRoot: "root-path-for-source-maps",
+    sourcemapUseAbsolutePath: false,
+    assetsDest: "dist",
+  };
 
-  test("sets bundle file extension to .bundle for win32", () => {
-    testBundleFileExtension("win32", ".bundle");
-  });
+  const bundleConfig: CliPlatformBundleConfig = {
+    ...bundleConfigNoPlugins,
+    detectCyclicDependencies: true,
+    detectDuplicateDependencies: true,
+    typescriptValidation: true,
+    treeShake: true,
+  };
 
-  test("sets bundleOutput to prefix + platform + extension under distPath", () => {
-    expect(createMetroBundleArgs(bundleConfig).bundleOutput).toEqual(
-      path.join(bundleConfig.distPath, "my-app.ios.jsbundle")
-    );
-  });
+  const dev = true;
+  const minify = true;
 
-  test("sets bundleEncoding", () => {
-    expect(createMetroBundleArgs(bundleConfig).bundleEncoding).toEqual(
-      bundleConfig.bundleEncoding
-    );
+  it("does not use a custom serializer when all plugins are disabled", async () => {
+    const metroConfig = await getDefaultConfig();
+    expect(metroConfig.serializer.customSerializer).toBeNil();
+    await metroBundle(metroConfig, bundleConfigNoPlugins, dev, minify);
+    expect(metroConfig.serializer.customSerializer).toBeNil();
   });
 
-  test("always sets sourcemapOutput in dev mode", () => {
-    const copy: BundleConfig = { ...bundleConfig, dev: true };
-    delete copy.sourceMapPath;
-
-    const args = createMetroBundleArgs(copy);
-    expect(args.sourcemapOutput).toEqual(args.bundleOutput + ".map");
+  it("uses a custom serializer when at least one plugin is enabled", async () => {
+    const metroConfig = await getDefaultConfig();
+    expect(metroConfig.serializer.customSerializer).toBeNil();
+    await metroBundle(metroConfig, bundleConfig, dev, minify);
+    expect(metroConfig.serializer.customSerializer).not.toBeNil();
   });
 
-  test("sets sourcemapOutput in production mode", () => {
-    const copy: BundleConfig = { ...bundleConfig, dev: false };
-    const args = createMetroBundleArgs(copy);
-    expect(args.sourcemapOutput).toEqual(
-      path.join(bundleConfig.distPath, bundleConfig.sourceMapPath)
-    );
+  it("creates directories for the bundle, the source map, and assets", async () => {
+    await metroBundle(await getDefaultConfig(), bundleConfig, dev, minify);
+    expect(mockCreateDirectory).toHaveBeenCalledTimes(3);
+    expect(mockCreateDirectory).toHaveBeenNthCalledWith(1, "src");
+    expect(mockCreateDirectory).toHaveBeenNthCalledWith(2, "map");
+    expect(mockCreateDirectory).toHaveBeenNthCalledWith(3, "dist");
   });
 
-  test("sets sourcemapSourcesRoot", () => {
-    expect(createMetroBundleArgs(bundleConfig).sourcemapSourcesRoot).toEqual(
-      bundleConfig.sourceMapSourceRootPath
-    );
+  it("invokes the Metro bundler using all input parameters", async () => {
+    await metroBundle(await getDefaultConfig(), bundleConfig, dev, minify);
+    expect(mockBundle).toHaveBeenCalledTimes(1);
+    expect(mockBundle.mock.calls[0][0]).toEqual({
+      ...bundleConfig,
+      dev,
+      minify,
+    });
   });
 });

package/test/bundle/overrides.test.ts

@@ -1,29 +1,33 @@
 import "jest-extended";
-import { applyKitBundleConfigOverrides } from "../../src/bundle/overrides";
-import type { KitBundleConfig } from "../../src/bundle/types";
+import { applyBundleConfigOverrides } from "../../src/bundle/overrides";
+import type { CliPlatformBundleConfig } from "../../src/bundle/types";
 
-describe("CLI > Bundle > Overrides > applyKitBundleConfigOverrides", () => {
-  const config: KitBundleConfig = {
+describe("CLI > Bundle > Overrides > applyBundleConfigOverrides", () => {
+  const config: CliPlatformBundleConfig = {
+    entryFile: "src/index.js",
+    bundleOutput: "main.jsbundle",
+    sourcemapUseAbsolutePath: false,
     detectCyclicDependencies: true,
     detectDuplicateDependencies: true,
     typescriptValidation: true,
     treeShake: true,
-    entryPath: "dist/index.js",
-    distPath: "dist",
-    assetsPath: "dist",
-    bundlePrefix: "main",
     platform: "ios",
   };
 
   test("has no effect when no overrides are given", () => {
     const copy = { ...config };
-    applyKitBundleConfigOverrides({}, [copy]);
+    applyBundleConfigOverrides({}, [copy]);
     expect(copy).toEqual(config);
   });
 
   function testOverride(name: string, value: unknown) {
     const copy = { ...config };
-    applyKitBundleConfigOverrides(
+    if (name in copy) {
+      if (name !== undefined && name !== null) {
+        expect(copy[name]).not.toEqual(value);
+      }
+    }
+    applyBundleConfigOverrides(
       {
         [name]: value,
       },
@@ -35,35 +39,35 @@ describe("CLI > Bundle > Overrides > applyKitBundleConfigOverrides", () => {
     });
   }
 
-  test("changes entryPath using an override", () => {
-    testOverride("entryPath", "out/entry.js");
+  test("changes entryFile using an override", () => {
+    testOverride("entryFile", "foo.js");
   });
 
-  test("changes distPath using an override", () => {
-    testOverride("distPath", "out");
+  test("changes bundleOutput using an override", () => {
+    testOverride("bundleOutput", "foo.bundle");
   });
 
-  test("changes assetsPath using an override", () => {
-    testOverride("assetsPath", "out/assets");
+  test("sets bundleEncoding using an override", () => {
+    testOverride("bundleEncoding", "utf8");
   });
 
-  test("changes bundlePrefix using an override", () => {
-    testOverride("bundlePrefix", "main");
+  test("sets sourcemapOutput using an override", () => {
+    testOverride("sourcemapOutput", "out/foo.map");
   });
 
-  test("changes bundleEncoding using an override", () => {
-    testOverride("bundleEncoding", "utf8");
+  test("sets sourcemapSourcesRoot using an override", () => {
+    testOverride("sourcemapSourcesRoot", "/myrepo/packags/foo");
   });
 
-  test("changes sourcemapOutput using an override", () => {
-    testOverride("sourcemapOutput", "out/entry.map");
+  test("changes sourcemapUseAbsolutePath using an override", () => {
+    testOverride("sourcemapUseAbsolutePath", true);
   });
 
-  test("changes sourcemapSourcesRoot using an override", () => {
-    testOverride("sourcemapSourcesRoot", "out");
+  test("sets assetsDest using an override", () => {
+    testOverride("assetsDest", "dist");
   });
 
   test("changes treeShake using an override", () => {
-    testOverride("treeShake", true);
+    testOverride("treeShake", false);
   });
 });

package/test/copy-assets/assembleAarBundle.test.ts

@@ -5,6 +5,7 @@ import { assembleAarBundle } from "../../src/copy-assets";
 
 jest.mock("child_process");
 jest.mock("fs");
+jest.unmock("@rnx-kit/console");
 
 export const options = {
   platform: "android" as const,

package/lib/types.d.ts

@@ -1,5 +0,0 @@
-export declare type TypeScriptValidationOptions = {
-    print?: (message: string) => void;
-    throwOnError?: boolean;
-};
-//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,2BAA2B,GAAG;IACxC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC"}

package/lib/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/src/types.ts

@@ -1,4 +0,0 @@
-export type TypeScriptValidationOptions = {
-  print?: (message: string) => void;
-  throwOnError?: boolean;
-};