targets.ts

import assert from "node:assert";
import cp from "node:child_process";

import { assertFixable } from "@react-native-node-api/cli-utils";
import { getInstalledTargets } from "./rustup.js";

export const ANDROID_TARGETS = [
  "aarch64-linux-android",
  "armv7-linux-androideabi",
  "i686-linux-android",
  "x86_64-linux-android",
  // "arm-linux-androideabi",
  // "thumbv7neon-linux-androideabi",
] as const;

export type AndroidTargetName = (typeof ANDROID_TARGETS)[number];

// TODO: Consider calling out to rustup to generate this list or just use @napi-rs/triples
export const APPLE_TARGETS = [
  "aarch64-apple-darwin",
  "x86_64-apple-darwin",

  "aarch64-apple-ios",
  "aarch64-apple-ios-sim",
  "x86_64-apple-ios", // Simulator (despite the missing -sim suffix)

  // "aarch64-apple-ios-macabi", // Catalyst
  // "x86_64-apple-ios-macabi", // Catalyst

  "aarch64-apple-visionos",
  "aarch64-apple-visionos-sim",

  "aarch64-apple-tvos",
  // "arm64e-apple-tvos",
  "aarch64-apple-tvos-sim",
  "x86_64-apple-tvos", // Simulator (despite the missing -sim suffix)

  // "aarch64-apple-watchos",
  // "aarch64-apple-watchos-sim",
  // "arm64_32-apple-watchos",
  // "arm64e-apple-darwin",
  // "arm64e-apple-ios",
  // "armv7k-apple-watchos",
  // "armv7s-apple-ios",
  // "i386-apple-ios",
  // "i686-apple-darwin",
  // "x86_64-apple-watchos-sim",
  // "x86_64h-apple-darwin",
] as const;
export type AppleTargetName = (typeof APPLE_TARGETS)[number];

const APPLE_ARCHITECTURES = [
  "aarch64",
  "arm64_32",
  "arm64e",
  "armv7",
  "armv7s",
  "x86_64",
  "x86_64h",
  "i386",
  "i686",
] as const;
export type AppleArchitecture = (typeof APPLE_ARCHITECTURES)[number];
export function isAppleArchitecture(
  architecture: string,
): architecture is AppleArchitecture {
  return (APPLE_ARCHITECTURES as readonly string[]).includes(architecture);
}

const APPLE_OPERATING_SYSTEMS = [
  "darwin",
  "ios",
  "tvos",
  "visionos",
  "watchos",
] as const;
export type AppleOperatingSystem = (typeof APPLE_OPERATING_SYSTEMS)[number];
export function isAppleOperatingSystem(os: string): os is AppleOperatingSystem {
  return (APPLE_OPERATING_SYSTEMS as readonly string[]).includes(os);
}

const APPLE_VARIANTS = ["sim", "macabi"] as const;
export type AppleVariant = (typeof APPLE_VARIANTS)[number];
export function isAppleVariant(variant: string): variant is AppleVariant {
  return (APPLE_VARIANTS as readonly string[]).includes(variant);
}

export function parseAppleTargetName(target: AppleTargetName): {
  architecture: AppleArchitecture;
  os: AppleOperatingSystem;
  variant?: AppleVariant;
} {
  const [architecture, vendor, os, variant] = target.split("-");
  assert(vendor === "apple", "Expected vendor to be apple");
  assert(
    isAppleArchitecture(architecture),
    `Unexpected architecture: ${architecture}`,
  );
  assert(isAppleOperatingSystem(os), `Unexpected operating system: ${os}`);
  assert(
    typeof variant === "undefined" || isAppleVariant(variant),
    `Unexpected variant: ${variant}`,
  );
  return {
    architecture,
    os,
    variant,
  };
}

export const ALL_TARGETS = [...ANDROID_TARGETS, ...APPLE_TARGETS] as const;
export type TargetName = (typeof ALL_TARGETS)[number];

const THIRD_TIER_TARGETS: Set<TargetName> = new Set([
  "aarch64-apple-visionos",
  "aarch64-apple-visionos-sim",

  "aarch64-apple-tvos",
  "aarch64-apple-tvos-sim",
  "x86_64-apple-tvos",
]);

export function assertNightlyToolchain() {
  const toolchainLines = cp
    .execFileSync("rustup", ["toolchain", "list"], {
      encoding: "utf-8",
    })
    .split("\n");

  const nightlyLines = toolchainLines.filter((line) =>
    line.startsWith("nightly-"),
  );
  assertFixable(
    nightlyLines.length > 0,
    "You need to use a nightly Rust toolchain",
    {
      command: "rustup toolchain install nightly --component rust-src",
    },
  );

  const componentLines = cp
    .execFileSync("rustup", ["component", "list", "--toolchain", "nightly"], {
      encoding: "utf-8",
    })
    .split("\n");
  assertFixable(
    componentLines.some((line) => line === "rust-src (installed)"),
    "You need to install the rust-src component for the nightly Rust toolchain",
    {
      command: "rustup toolchain install nightly --component rust-src",
    },
  );
}

/**
 * Ensure the targets are either installed into the Rust toolchain or available via nightly Rust toolchain.
 * We do this up-front because the error message and fix is very unclear from the failure when missing.
 */
export function ensureAvailableTargets(expectedTargets: Set<TargetName>) {
  const installedTargets = getInstalledTargets();

  const missingInstallableTargets = expectedTargets
    .difference(installedTargets)
    .difference(THIRD_TIER_TARGETS);

  assertFixable(
    missingInstallableTargets.size === 0,
    `You need to add these targets to your toolchain: ${[
      ...missingInstallableTargets,
    ].join(", ")}`,
    {
      command: `rustup target add ${[...missingInstallableTargets].join(" ")}`,
    },
  );

  const expectedThirdTierTargets =
    expectedTargets.intersection(THIRD_TIER_TARGETS);
  if (expectedThirdTierTargets.size > 0) {
    assertNightlyToolchain();
  }
}

export function isAndroidTarget(
  target: TargetName,
): target is AndroidTargetName {
  return ANDROID_TARGETS.includes(target as (typeof ANDROID_TARGETS)[number]);
}

export function isAppleTarget(target: TargetName): target is AppleTargetName {
  return APPLE_TARGETS.includes(target as (typeof APPLE_TARGETS)[number]);
}

export function isThirdTierTarget(target: TargetName): boolean {
  return THIRD_TIER_TARGETS.has(target);
}

export function filterTargetsByPlatform(
  targets: Set<TargetName>,
  platform: "android",
): AndroidTargetName[];
export function filterTargetsByPlatform(
  targets: Set<TargetName>,
  platform: "apple",
): AppleTargetName[];
export function filterTargetsByPlatform(
  targets: Set<TargetName>,
  platform: "apple" | "android",
) {
  if (platform === "android") {
    return [...targets].filter(isAndroidTarget);
  } else if (platform === "apple") {
    return [...targets].filter(isAppleTarget);
  } else {
    throw new Error(`Unexpected platform ${platform as string}`);
  }
}