@storm-software/workspace-tools/dist/chunk-JIAGNEII.mjs

Tools for managing a Storm workspace, including various Nx generators and executors for common development tasks.

import {
  __name
} from "./chunk-2BPV2XV2.mjs";

// src/utils/cargo.ts
import { joinPathFragments, workspaceRoot } from "@nx/devkit";
import { execSync, spawn } from "node:child_process";
import { relative } from "node:path";
var INVALID_CARGO_ARGS = [
  "allFeatures",
  "allTargets",
  "main",
  "outputPath",
  "package",
  "tsConfig"
];
var childProcess;
var buildCargoCommand = /* @__PURE__ */ __name((baseCommand, options, context) => {
  const args = [];
  if (options.toolchain && options.toolchain !== "stable") {
    args.push(`+${options.toolchain}`);
  }
  args.push(baseCommand);
  for (const [key, value] of Object.entries(options)) {
    if (key === "toolchain" || key === "release" || INVALID_CARGO_ARGS.includes(key)) {
      continue;
    }
    if (typeof value === "boolean") {
      if (value) {
        args.push(`--${key}`);
      }
    } else if (Array.isArray(value)) {
      for (const item of value) {
        args.push(`--${key}`, item);
      }
    } else {
      args.push(`--${key}`, String(value));
    }
  }
  if (context.projectName) {
    args.push("-p", context.projectName);
  }
  if (options.allFeatures && !args.includes("--all-features")) {
    args.push("--all-features");
  }
  if (options.allTargets && !args.includes("--all-targets")) {
    args.push("--all-targets");
  }
  if (options.release && !args.includes("--profile")) {
    args.push("--release");
  }
  if (options.outputPath && !args.includes("--target-dir")) {
    args.push("--target-dir", options.outputPath);
  }
  return args;
}, "buildCargoCommand");
async function cargoCommand(...args) {
  console.log(`> cargo ${args.join(" ")}`);
  args.push("--color", "always");
  return await Promise.resolve(runProcess("cargo", ...args));
}
__name(cargoCommand, "cargoCommand");
function cargoRunCommand(...args) {
  console.log(`> cargo ${args.join(" ")}`);
  return new Promise((resolve, reject) => {
    childProcess = spawn("cargo", [
      ...args,
      "--color",
      "always"
    ], {
      cwd: process.cwd(),
      windowsHide: true,
      detached: true,
      shell: false,
      stdio: [
        "inherit",
        "inherit",
        "inherit"
      ]
    });
    process.on("exit", () => childProcess?.kill());
    process.on("SIGTERM", () => childProcess?.kill());
    process.on("SIGINT", () => childProcess?.kill());
    childProcess.on("error", (_err) => {
      reject({
        success: false
      });
    });
    childProcess.on("exit", (code) => {
      childProcess = null;
      if (code === 0) {
        resolve({
          success: true
        });
      } else {
        reject({
          success: false
        });
      }
    });
  });
}
__name(cargoRunCommand, "cargoRunCommand");
function cargoCommandSync(args = "", options) {
  const normalizedOptions = {
    stdio: options?.stdio ?? "inherit",
    env: {
      ...process.env,
      ...options?.env
    }
  };
  try {
    return {
      output: execSync(`cargo ${args}`, {
        encoding: "utf8",
        windowsHide: true,
        stdio: normalizedOptions.stdio,
        env: normalizedOptions.env,
        maxBuffer: 1024 * 1024 * 10
      }),
      success: true
    };
  } catch (e) {
    return {
      output: e,
      success: false
    };
  }
}
__name(cargoCommandSync, "cargoCommandSync");
function cargoMetadata() {
  const output = cargoCommandSync("metadata --format-version=1", {
    stdio: "pipe"
  });
  if (!output.success) {
    console.error("Failed to get cargo metadata");
    return null;
  }
  return JSON.parse(output.output);
}
__name(cargoMetadata, "cargoMetadata");
function isExternal(packageOrDep, workspaceRoot2) {
  const isRegistry = packageOrDep.source?.startsWith("registry+") ?? false;
  const isGit = packageOrDep.source?.startsWith("git+") ?? false;
  const isOutsideWorkspace = "path" in packageOrDep && relative(workspaceRoot2, packageOrDep.path).startsWith("..");
  return isRegistry || isGit || isOutsideWorkspace;
}
__name(isExternal, "isExternal");
function runProcess(processCmd, ...args) {
  const metadata = cargoMetadata();
  const targetDir = metadata?.target_directory ?? joinPathFragments(workspaceRoot, "dist", "cargo");
  return new Promise((resolve) => {
    if (process.env.VERCEL) {
      return resolve({
        success: true
      });
    }
    execSync(`${processCmd} ${args.join(" ")}`, {
      cwd: process.cwd(),
      env: {
        ...process.env,
        RUSTC_WRAPPER: "",
        CARGO_TARGET_DIR: targetDir,
        CARGO_BUILD_TARGET_DIR: targetDir
      },
      windowsHide: true,
      stdio: [
        "inherit",
        "inherit",
        "inherit"
      ]
    });
    resolve({
      success: true
    });
  });
}
__name(runProcess, "runProcess");

export {
  INVALID_CARGO_ARGS,
  childProcess,
  buildCargoCommand,
  cargoCommand,
  cargoRunCommand,
  cargoCommandSync,
  cargoMetadata,
  isExternal,
  runProcess
};