@rnx-kit/cli 0.11.2 → 0.12.2

package/src/copy-assets.ts

@@ -0,0 +1,434 @@
+import type { Config as CLIConfig } from "@react-native-community/cli-types";
+import { error, info, warn } from "@rnx-kit/console";
+import { isNonEmptyArray } from "@rnx-kit/tools-language/array";
+import type { PackageManifest } from "@rnx-kit/tools-node/package";
+import { findPackageDir, readPackage } from "@rnx-kit/tools-node/package";
+import type { AllPlatforms } from "@rnx-kit/tools-react-native";
+import { parsePlatform } from "@rnx-kit/tools-react-native";
+import { spawnSync } from "child_process";
+import * as fs from "fs-extra";
+import * as os from "os";
+import * as path from "path";
+
+export type AndroidArchive = {
+  targetName: string;
+  version?: string;
+  output?: string;
+};
+
+export type NativeAssets = {
+  assets?: string[];
+  strings?: string[];
+  aar?: AndroidArchive & {
+    env?: Record<string, string | number>;
+    dependencies?: Record<string, AndroidArchive>;
+  };
+  xcassets?: string[];
+};
+
+export type Options = {
+  platform: AllPlatforms;
+  assetsDest: string;
+  bundleAar: boolean;
+  xcassetsDest?: string;
+  [key: string]: unknown;
+};
+
+export type Context = {
+  projectRoot: string;
+  manifest: PackageManifest;
+  options: Options;
+};
+
+export type AssetsConfig = {
+  getAssets?: (context: Context) => Promise<NativeAssets>;
+};
+
+function ensureOption(options: Options, opt: string, flag = opt) {
+  if (options[opt] == null) {
+    error(`Missing required option: --${flag}`);
+    process.exit(1);
+  }
+}
+
+function findGradleProject(projectRoot: string): string | undefined {
+  if (fs.existsSync(path.join(projectRoot, "android", "build.gradle"))) {
+    return path.join(projectRoot, "android");
+  }
+  if (fs.existsSync(path.join(projectRoot, "build.gradle"))) {
+    return projectRoot;
+  }
+  return undefined;
+}
+
+function isAssetsConfig(config: unknown): config is AssetsConfig {
+  return typeof config === "object" && config !== null && "getAssets" in config;
+}
+
+function keysOf(record: Record<string, unknown> | undefined): string[] {
+  return record ? Object.keys(record) : [];
+}
+
+export function versionOf(pkgName: string): string {
+  const { version } = readPackage(require.resolve(`${pkgName}/package.json`));
+  return version;
+}
+
+function getAndroidPaths(
+  context: Context,
+  packageName: string,
+  { targetName, version, output }: AndroidArchive
+) {
+  const projectRoot = path.dirname(
+    require.resolve(`${packageName}/package.json`)
+  );
+
+  switch (packageName) {
+    case "hermes-engine":
+      return {
+        projectRoot,
+        output: path.join(projectRoot, "android", "hermes-release.aar"),
+        destination: path.join(
+          context.options.assetsDest,
+          "aar",
+          `hermes-release-${versionOf(packageName)}.aar`
+        ),
+      };
+
+    case "react-native":
+      return {
+        projectRoot,
+        output: path.join(projectRoot, "android"),
+        destination: path.join(
+          context.options.assetsDest,
+          "aar",
+          "react-native"
+        ),
+      };
+
+    default: {
+      const androidProject = findGradleProject(projectRoot);
+      return {
+        projectRoot,
+        androidProject,
+        output:
+          output ||
+          (androidProject &&
+            path.join(
+              androidProject,
+              "build",
+              "outputs",
+              "aar",
+              `${targetName}-release.aar`
+            )),
+        destination: path.join(
+          context.options.assetsDest,
+          "aar",
+          `${targetName}-${version || versionOf(packageName)}.aar`
+        ),
+      };
+    }
+  }
+}
+
+async function assembleAarBundle(
+  context: Context,
+  packageName: string,
+  { aar }: NativeAssets
+): Promise<void> {
+  if (!aar) {
+    return;
+  }
+
+  const findUp = require("find-up");
+  const gradlew = await findUp(
+    os.platform() === "win32" ? "gradlew.bat" : "gradlew"
+  );
+  if (!gradlew) {
+    warn(`Skipped \`${packageName}\`: cannot find \`gradlew\``);
+    return;
+  }
+
+  const { androidProject, output } = getAndroidPaths(context, packageName, aar);
+  if (!androidProject || !output) {
+    warn(`Skipped \`${packageName}\`: cannot find \`build.gradle\``);
+    return;
+  }
+
+  const { targetName, version, env, dependencies } = aar;
+  const targets = [`:${targetName}:assembleRelease`];
+  const targetsToCopy: [string, string][] = [];
+  if (dependencies) {
+    for (const [dependencyName, aar] of Object.entries(dependencies)) {
+      const { output, destination } = getAndroidPaths(
+        context,
+        dependencyName,
+        aar
+      );
+      if (output) {
+        if (!fs.existsSync(output)) {
+          targets.push(`:${aar.targetName}:assembleRelease`);
+          targetsToCopy.push([output, destination]);
+        } else if (!fs.existsSync(destination)) {
+          targetsToCopy.push([output, destination]);
+        }
+      }
+    }
+  }
+
+  // Run only one Gradle task at a time
+  spawnSync(gradlew, targets, {
+    cwd: androidProject,
+    stdio: "inherit",
+    env: {
+      ENABLE_HERMES: "true",
+      NODE_MODULES_PATH: path.join(process.cwd(), "node_modules"),
+      REACT_NATIVE_VERSION: versionOf("react-native"),
+      ...process.env,
+      ...env,
+    },
+  });
+
+  const destination = path.join(context.options.assetsDest, "aar");
+  await fs.ensureDir(destination);
+
+  const aarVersion = version || versionOf(packageName);
+  const dest = path.join(destination, `${targetName}-${aarVersion}.aar`);
+  await Promise.all([
+    fs.copy(output, dest),
+    ...targetsToCopy.map(([src, dest]) => fs.copy(src, dest)),
+  ]);
+}
+
+async function copyFiles(files: unknown, destination: string): Promise<void> {
+  if (!isNonEmptyArray<string>(files)) {
+    return;
+  }
+
+  await fs.ensureDir(destination);
+  await Promise.all(
+    files.map((file) => {
+      const basename = path.basename(file);
+      return fs.copy(file, `${destination}/${basename}`);
+    })
+  );
+}
+
+async function copyXcodeAssets(
+  xcassets: unknown,
+  destination: string
+): Promise<void> {
+  if (!isNonEmptyArray<string>(xcassets)) {
+    return;
+  }
+
+  await fs.ensureDir(destination);
+  await Promise.all(
+    xcassets.map((catalog) => {
+      const dest = `${destination}/${path.basename(catalog)}`;
+      return fs.copy(catalog, dest);
+    })
+  );
+}
+
+export async function copyAssets(
+  { options: { assetsDest, xcassetsDest } }: Context,
+  packageName: string,
+  { assets, strings, xcassets }: NativeAssets
+): Promise<void> {
+  const tasks = [
+    copyFiles(assets, `${assetsDest}/assets/${packageName}`),
+    copyFiles(strings, `${assetsDest}/strings/${packageName}`),
+  ];
+
+  if (typeof xcassetsDest === "string") {
+    tasks.push(copyXcodeAssets(xcassets, xcassetsDest));
+  }
+
+  await Promise.all(tasks);
+}
+
+export async function gatherConfigs({
+  projectRoot,
+  manifest,
+}: Context): Promise<Record<string, AssetsConfig | null> | undefined> {
+  const { dependencies, devDependencies } = manifest;
+  const packages = [...keysOf(dependencies), ...keysOf(devDependencies)];
+  if (packages.length === 0) {
+    return;
+  }
+
+  const resolveOptions = { paths: [projectRoot] };
+  const assetsConfigs: Record<string, AssetsConfig | null> = {};
+
+  for (const pkg of packages) {
+    try {
+      const pkgPath = path.dirname(
+        require.resolve(`${pkg}/package.json`, resolveOptions)
+      );
+      const reactNativeConfig = `${pkgPath}/react-native.config.js`;
+      if (fs.existsSync(reactNativeConfig)) {
+        const { nativeAssets } = require(reactNativeConfig);
+        if (nativeAssets) {
+          assetsConfigs[pkg] = nativeAssets;
+        }
+      }
+    } catch (err) {
+      warn(err);
+    }
+  }
+
+  // Overrides from project config
+  const reactNativeConfig = `${projectRoot}/react-native.config.js`;
+  if (fs.existsSync(reactNativeConfig)) {
+    const { nativeAssets } = require(reactNativeConfig);
+    const overrides = Object.entries(nativeAssets);
+    for (const [pkgName, config] of overrides) {
+      if (config === null || isAssetsConfig(config)) {
+        assetsConfigs[pkgName] = config;
+      }
+    }
+  }
+
+  return assetsConfigs;
+}
+
+/**
+ * Copies additional assets not picked by bundlers into desired directory.
+ *
+ * The way this works is by scanning all direct dependencies of the current
+ * project for a file, `react-native.config.js`, whose contents include a
+ * field, `nativeAssets`, and a function that returns assets to copy:
+ *
+ * ```js
+ * // react-native.config.js
+ * module.exports = {
+ *   nativeAssets: {
+ *     getAssets: (context) => {
+ *       return {
+ *         assets: [],
+ *         strings: [],
+ *         xcassets: [],
+ *       };
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * We also allow the project itself to override this where applicable. The
+ * format is similar and looks like this:
+ *
+ * ```js
+ * // react-native.config.js
+ * module.exports = {
+ *   nativeAssets: {
+ *     "some-library": {
+ *       getAssets: (context) => {
+ *         return {
+ *           assets: [],
+ *           strings: [],
+ *           xcassets: [],
+ *         };
+ *       }
+ *     },
+ *     "another-library": {
+ *       getAssets: (context) => {
+ *         return {
+ *           assets: [],
+ *           strings: [],
+ *           xcassets: [],
+ *         };
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @param options Options dictate what gets copied where
+ */
+export async function copyProjectAssets(options: Options): Promise<void> {
+  const projectRoot = findPackageDir() || process.cwd();
+  const content = await fs.readFile(`${projectRoot}/package.json`, {
+    encoding: "utf-8",
+  });
+  const manifest: PackageManifest = JSON.parse(content);
+  const context = { projectRoot, manifest, options };
+  const assetConfigs = await gatherConfigs(context);
+  if (!assetConfigs) {
+    return;
+  }
+
+  const dependencies = Object.entries(assetConfigs);
+  for (const [packageName, config] of dependencies) {
+    if (!isAssetsConfig(config)) {
+      continue;
+    }
+
+    const { getAssets } = config;
+    if (typeof getAssets !== "function") {
+      warn(`Skipped \`${packageName}\`: getAssets is not a function`);
+      continue;
+    }
+
+    const assets = await getAssets(context);
+    if (options.bundleAar && assets.aar) {
+      info(`Assembling "${packageName}"`);
+      await assembleAarBundle(context, packageName, assets);
+    } else {
+      info(`Copying assets for "${packageName}"`);
+      await copyAssets(context, packageName, assets);
+    }
+  }
+
+  if (options.bundleAar) {
+    const dummyAar = { targetName: "dummy" };
+    const copyTasks = [];
+    for (const dependencyName of ["hermes-engine", "react-native"]) {
+      const { output, destination } = getAndroidPaths(
+        context,
+        dependencyName,
+        dummyAar
+      );
+      if (
+        output &&
+        (!fs.existsSync(destination) || fs.statSync(destination).isDirectory())
+      ) {
+        info(`Copying Android Archive of "${dependencyName}"`);
+        copyTasks.push(fs.copy(output, destination));
+      }
+    }
+    await Promise.all(copyTasks);
+  }
+}
+
+export const rnxCopyAssetsCommand = {
+  name: "rnx-copy-assets",
+  description:
+    "Copies additional assets not picked by bundlers into desired directory.",
+  func: (_argv: string[], _config: CLIConfig, options: Options) => {
+    ensureOption(options, "platform");
+    ensureOption(options, "assetsDest", "assets-dest");
+    return copyProjectAssets(options);
+  },
+  options: [
+    {
+      name: "--platform <string>",
+      description: "platform to target",
+      parse: parsePlatform,
+    },
+    {
+      name: "--assets-dest <string>",
+      description: "path of the directory to copy assets into",
+    },
+    {
+      name: "--bundle-aar <boolean>",
+      description: "whether to bundle AARs of dependencies",
+      default: false,
+    },
+    {
+      name: "--xcassets-dest <string>",
+      description:
+        "path of the directory to copy Xcode asset catalogs into. Asset catalogs will only be copied if a destination path is specified.",
+    },
+  ],
+};

package/src/index.ts

@@ -1,4 +1,5 @@
 export { rnxBundle } from "./bundle";
+export { copyProjectAssets, rnxCopyAssetsCommand } from "./copy-assets";
 export { rnxDepCheck, rnxDepCheckCommand } from "./dep-check";
 export { rnxStart } from "./start";
 export { rnxTest, rnxTestCommand } from "./test";

package/src/metro-config.ts

@@ -109,14 +109,14 @@ const emptySerializerHook = (_graph: Graph, _delta: DeltaResult): void => {
  * @param detectCyclicDependencies When true, cyclic dependency checking is enabled with a default set of options. Otherwise the object allows for fine-grained control over the detection process.
  * @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 experimental_treeShake When true, experimental tree-shaking is enabled.
+ * @param treeShake When true, tree shaking is enabled.
  */
 export function customizeMetroConfig(
   metroConfigReadonly: InputConfigT,
   detectCyclicDependencies: boolean | CyclicDetectorOptions,
   detectDuplicateDependencies: boolean | DuplicateDetectorOptions,
   typescriptValidation: boolean | TypeScriptValidationOptions,
-  experimental_treeShake: boolean
+  treeShake: boolean
 ): 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.
@@ -134,7 +134,7 @@ export function customizeMetroConfig(
     plugins.push(CyclicDependencies());
   }
 
-  if (experimental_treeShake) {
+  if (treeShake) {
     metroConfig.serializer.customSerializer = MetroSerializerEsbuild(plugins);
     Object.assign(metroConfig.transformer, esbuildTransformerConfig);
   } else if (plugins.length > 0) {

package/src/start.ts

@@ -131,7 +131,7 @@ export async function rnxStart(
     serverConfig.detectCyclicDependencies,
     serverConfig.detectDuplicateDependencies,
     serverConfig.typescriptValidation ? typescriptValidationOptions : false,
-    serverConfig.experimental_treeShake
+    serverConfig.treeShake
   );
 
   // create middleware -- a collection of plugins which handle incoming

package/test/__mocks__/fs-extra.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const fs = jest.createMockFromModule("fs-extra");
+
+const { vol } = require("memfs");
+
+/** @type {(newMockFiles: { [filename: string]: string }) => void} */
+fs.__setMockFiles = (files) => {
+  vol.reset();
+  vol.fromJSON(files);
+};
+
+fs.__toJSON = () => vol.toJSON();
+
+fs.copy = (...args) => vol.promises.copyFile(...args);
+fs.ensureDir = (dir) => vol.promises.mkdir(dir, { recursive: true });
+fs.pathExists = (...args) => Promise.resolve(vol.existsSync(...args));
+fs.readFile = (...args) => vol.promises.readFile(...args);
+
+module.exports = fs;

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

@@ -80,7 +80,7 @@ describe("CLI > Bundle > Kit Config > getKitBundleConfigs", () => {
     detectCyclicDependencies: true,
     detectDuplicateDependencies: true,
     typescriptValidation: true,
-    experimental_treeShake: true,
+    treeShake: true,
     targets: ["ios", "android"],
     platforms: {
       ios: {
@@ -123,4 +123,26 @@ describe("CLI > Bundle > Kit Config > getKitBundleConfigs", () => {
       platform: "android",
     });
   });
+
+  test("uses deprecated experimental_treeShake", () => {
+    const d: Record<string, unknown> = { ...definition };
+    delete d.treeShake;
+    d.experimental_treeShake = true;
+    rnxKitConfig.__setMockConfig({
+      bundle: {
+        ...d,
+      },
+    });
+    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

@@ -8,7 +8,7 @@ describe("CLI > Bundle > Metro > createMetroBundleArgs", () => {
     detectCyclicDependencies: true,
     detectDuplicateDependencies: true,
     typescriptValidation: true,
-    experimental_treeShake: true,
+    treeShake: true,
     entryPath: "out/entry.js",
     distPath: "out",
     assetsPath: "out/assets",

package/test/bundle/overrides.test.ts

@@ -7,7 +7,7 @@ describe("CLI > Bundle > Overrides > applyKitBundleConfigOverrides", () => {
     detectCyclicDependencies: true,
     detectDuplicateDependencies: true,
     typescriptValidation: true,
-    experimental_treeShake: true,
+    treeShake: true,
     entryPath: "dist/index.js",
     distPath: "dist",
     assetsPath: "dist",
@@ -63,17 +63,7 @@ describe("CLI > Bundle > Overrides > applyKitBundleConfigOverrides", () => {
     testOverride("sourcemapSourcesRoot", "out");
   });
 
-  test("set experimental_treeShake using override experimentalTreeShake", () => {
-    const copy = { ...config };
-    applyKitBundleConfigOverrides(
-      {
-        experimentalTreeShake: true,
-      },
-      [copy]
-    );
-    expect(copy).toEqual({
-      ...config,
-      experimental_treeShake: true,
-    });
+  test("changes treeShake using an override", () => {
+    testOverride("treeShake", true);
   });
 });

package/test/copy-assets.test.ts

@@ -0,0 +1,123 @@
+import fs from "fs-extra";
+import * as path from "path";
+import { copyAssets, gatherConfigs, versionOf } from "../src/copy-assets";
+
+const options = {
+  platform: "ios" as const,
+  assetsDest: "dist",
+  bundleAar: false,
+  xcassetsDest: "xcassets",
+};
+
+const context = {
+  projectRoot: path.resolve(__dirname, ".."),
+  manifest: {
+    name: "@rnx-kit/cli",
+    version: "0.0.0-dev",
+  },
+  options,
+};
+
+function findFiles() {
+  // @ts-ignore `__toJSON`
+  return Object.entries(fs.__toJSON());
+}
+
+function mockFiles(files: Record<string, string> = {}) {
+  // @ts-ignore `__setMockFiles`
+  fs.__setMockFiles(files);
+}
+
+describe("copyAssets", () => {
+  afterEach(() => {
+    mockFiles();
+  });
+
+  afterAll(() => {
+    jest.clearAllMocks();
+  });
+
+  test("returns early if there is nothing to copy", async () => {
+    await copyAssets(context, "test", {});
+    expect(findFiles()).toEqual([]);
+  });
+
+  test("copies assets", async () => {
+    const filename = "arnolds-greatest-movies.md";
+    const content = "all of them";
+    mockFiles({ [filename]: content });
+
+    await copyAssets(context, "test", { assets: [filename] });
+
+    expect(findFiles()).toEqual([
+      [expect.stringContaining(filename), content],
+      [
+        expect.stringMatching(
+          `dist[/\\\\]assets[/\\\\]test[/\\\\]${filename}$`
+        ),
+        content,
+      ],
+    ]);
+  });
+
+  test("copies strings", async () => {
+    const filename = "arnolds-greatest-lines.md";
+    const content = "all of them";
+    mockFiles({ [filename]: content });
+
+    await copyAssets(context, "test", { strings: [filename] });
+
+    expect(findFiles()).toEqual([
+      [expect.stringContaining(filename), content],
+      [
+        expect.stringMatching(
+          `dist[/\\\\]strings[/\\\\]test[/\\\\]${filename}$`
+        ),
+        content,
+      ],
+    ]);
+  });
+
+  test("copies Xcode asset catalogs", async () => {
+    const filename = "arnolds-greatest-assets.xcassets";
+    const content = "all of them";
+    mockFiles({ [filename]: content });
+
+    await copyAssets(context, "test", { xcassets: [filename] });
+
+    expect(findFiles()).toEqual([
+      [expect.stringContaining(filename), content],
+      [expect.stringMatching(`xcassets[/\\\\]${filename}$`), content],
+    ]);
+  });
+
+  test("does not copy Xcode asset catalogs if destination path is unset", async () => {
+    const filename = "arnolds-greatest-assets.xcassets";
+    const content = "all of them";
+    mockFiles({ [filename]: content });
+
+    await copyAssets(
+      { ...context, options: { ...options, xcassetsDest: undefined } },
+      "test",
+      { xcassets: [filename] }
+    );
+
+    expect(findFiles()).toEqual([[expect.stringContaining(filename), content]]);
+  });
+});
+
+describe("gatherConfigs", () => {
+  test("returns early if there is nothing to copy", async () => {
+    expect(await gatherConfigs(context)).toBeUndefined();
+  });
+});
+
+describe("versionOf", () => {
+  test("returns the version of specified package", () => {
+    expect(versionOf("@rnx-kit/tools-node")).toMatch(/^\d+[.\d]+$/);
+  });
+
+  test("throws if package is not installed", () => {
+    expect(() => versionOf("some-package-that-does-not-exist")).toThrow();
+  });
+});