Architecture Handling

enum Arch {
  ia32,
  x64,
  armv7l,
  arm64,
  universal
}

type ArchType = "x64" | "ia32" | "armv7l" | "arm64" | "universal";

import { Arch } from "builder-util";

// Use architecture enum values
const targetArch = Arch.x64;
const armArch = Arch.arm64;
const universalArch = Arch.universal;

// Architecture comparison
if (targetArch === Arch.x64) {
  console.log("Building for 64-bit x86");
}

/**
 * Convert string to architecture enum
 * @param name - Architecture name string
 * @returns Corresponding Arch enum value
 */
function archFromString(name: string): Arch;

/**
 * Get default architecture from string, defaulting to x64
 * @param name - Optional architecture name
 * @returns Arch enum value, defaults to x64 if not specified
 */
function defaultArchFromString(name?: string): Arch;

/**
 * Convert architecture to Linux-specific architecture string
 * @param arch - Architecture enum value
 * @param targetName - Target platform name for context
 * @returns Linux architecture string
 */
function toLinuxArchString(arch: Arch, targetName: string): string;

import { archFromString, defaultArchFromString, toLinuxArchString, Arch } from "builder-util";

// Convert string to architecture
const arch1 = archFromString("x64");        // Arch.x64
const arch2 = archFromString("arm64");      // Arch.arm64
const arch3 = archFromString("ia32");       // Arch.ia32

// Get default architecture
const defaultArch = defaultArchFromString();           // Arch.x64
const specifiedArch = defaultArchFromString("arm64");  // Arch.arm64

// Convert to Linux architecture strings
const linuxX64 = toLinuxArchString(Arch.x64, "linux");       // "x86_64"
const linuxArm = toLinuxArchString(Arch.arm64, "linux");     // "aarch64"
const linuxIa32 = toLinuxArchString(Arch.ia32, "linux");     // "i386"

/**
 * Get CLI names for all supported architectures
 * @returns Array of architecture names for CLI usage
 */
function getArchCliNames(): Array<string>;

/**
 * Get architecture suffix for filenames
 * @param arch - Architecture enum value
 * @param defaultArch - Optional default architecture for comparison
 * @returns Architecture suffix string, empty if matches default
 */
function getArchSuffix(arch: Arch, defaultArch?: string): string;

/**
 * Get architecture name for specific file extensions
 * @param arch - Architecture enum value  
 * @param ext - File extension for context
 * @returns Architecture name string for artifacts
 */
function getArtifactArchName(arch: Arch, ext: string): string;

import { getArchCliNames, getArchSuffix, getArtifactArchName, Arch } from "builder-util";

// Get all CLI architecture names
const cliNames = getArchCliNames();
// Result: ["ia32", "x64", "armv7l", "arm64", "universal"]

// Generate architecture suffixes for filenames
const x64Suffix = getArchSuffix(Arch.x64);              // "-x64"
const armSuffix = getArchSuffix(Arch.arm64);            // "-arm64"
const defaultSuffix = getArchSuffix(Arch.x64, "x64");   // "" (matches default)

// Get artifact names for different file types
const exeName = getArtifactArchName(Arch.x64, ".exe");      // "x64"
const dmgName = getArtifactArchName(Arch.arm64, ".dmg");    // "arm64"
const appxName = getArtifactArchName(Arch.ia32, ".appx");   // "ia32"

import { Arch, getArchSuffix, toLinuxArchString } from "builder-util";

// Build for multiple architectures
const targetArchs = [Arch.x64, Arch.arm64, Arch.ia32];

for (const arch of targetArchs) {
  const suffix = getArchSuffix(arch);
  const outputName = `myapp${suffix}`;
  
  console.log(`Building ${outputName} for ${arch}`);
  
  if (process.platform === "linux") {
    const linuxArch = toLinuxArchString(arch, "linux");
    console.log(`Linux architecture: ${linuxArch}`);
  }
}

import { archFromString, defaultArchFromString } from "builder-util";

// Detect architecture from environment or command line
const envArch = process.env.TARGET_ARCH;
const buildArch = envArch ? archFromString(envArch) : defaultArchFromString();

console.log(`Building for architecture: ${buildArch}`);

// Validate architecture
const validArchs = ["ia32", "x64", "armv7l", "arm64", "universal"];
if (envArch && !validArchs.includes(envArch)) {
  throw new Error(`Invalid architecture: ${envArch}`);
}

import { Arch, toLinuxArchString, getArtifactArchName } from "builder-util";

function getPlatformSpecificName(arch: Arch, platform: string, ext: string): string {
  const artifactName = getArtifactArchName(arch, ext);
  
  switch (platform) {
    case "linux":
      const linuxArch = toLinuxArchString(arch, "linux");
      return `app-${linuxArch}${ext}`;
    
    case "win32":
      return `app-${artifactName}${ext}`;
    
    case "darwin":
      if (arch === Arch.universal) {
        return `app-universal${ext}`;
      }
      return `app-${artifactName}${ext}`;
    
    default:
      return `app-${artifactName}${ext}`;
  }
}

// Usage
const windowsName = getPlatformSpecificName(Arch.x64, "win32", ".exe");
const linuxName = getPlatformSpecificName(Arch.arm64, "linux", ".AppImage");
const macName = getPlatformSpecificName(Arch.universal, "darwin", ".dmg");

import { archFromString, getArchCliNames } from "builder-util";

function validateArchitecture(archString: string): boolean {
  const validArchs = getArchCliNames();
  return validArchs.includes(archString);
}

function parseArchitectures(input: Array<string>): Array<Arch> {
  return input
    .filter(validateArchitecture)
    .map(archFromString);
}

// Usage
const userInput = ["x64", "arm64", "invalid-arch"];
const validArchs = parseArchitectures(userInput);
// Result: [Arch.x64, Arch.arm64]