@storm-software/workspace-tools/dist/chunk-ULBTYC2B.js

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

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }

var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');

// src/utils/cargo.ts
var _devkit = require('@nx/devkit');
var _child_process = require('child_process');
var _path = require('path');
var INVALID_CARGO_ARGS = [
  "allFeatures",
  "allTargets",
  "main",
  "outputPath",
  "package",
  "tsConfig"
];
var childProcess;
var buildCargoCommand = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (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));
}
_chunk3GQAWCBQjs.__name.call(void 0, cargoCommand, "cargoCommand");
function cargoRunCommand(...args) {
  console.log(`> cargo ${args.join(" ")}`);
  return new Promise((resolve, reject) => {
    childProcess = exports.childProcess = _child_process.spawn.call(void 0, "cargo", [
      ...args,
      "--color",
      "always"
    ], {
      cwd: process.cwd(),
      windowsHide: true,
      detached: true,
      shell: false,
      stdio: [
        "inherit",
        "inherit",
        "inherit"
      ]
    });
    process.on("exit", () => _optionalChain([childProcess, 'optionalAccess', _ => _.kill, 'call', _2 => _2()]));
    process.on("SIGTERM", () => _optionalChain([childProcess, 'optionalAccess', _3 => _3.kill, 'call', _4 => _4()]));
    process.on("SIGINT", () => _optionalChain([childProcess, 'optionalAccess', _5 => _5.kill, 'call', _6 => _6()]));
    childProcess.on("error", (_err) => {
      reject({
        success: false
      });
    });
    childProcess.on("exit", (code) => {
      childProcess = exports.childProcess = null;
      if (code === 0) {
        resolve({
          success: true
        });
      } else {
        reject({
          success: false
        });
      }
    });
  });
}
_chunk3GQAWCBQjs.__name.call(void 0, cargoRunCommand, "cargoRunCommand");
function cargoCommandSync(args = "", options) {
  const normalizedOptions = {
    stdio: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.stdio]), () => ( "inherit")),
    env: {
      ...process.env,
      ..._optionalChain([options, 'optionalAccess', _8 => _8.env])
    }
  };
  try {
    return {
      output: _child_process.execSync.call(void 0, `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
    };
  }
}
_chunk3GQAWCBQjs.__name.call(void 0, 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);
}
_chunk3GQAWCBQjs.__name.call(void 0, cargoMetadata, "cargoMetadata");
function isExternal(packageOrDep, workspaceRoot2) {
  const isRegistry = _nullishCoalesce(_optionalChain([packageOrDep, 'access', _9 => _9.source, 'optionalAccess', _10 => _10.startsWith, 'call', _11 => _11("registry+")]), () => ( false));
  const isGit = _nullishCoalesce(_optionalChain([packageOrDep, 'access', _12 => _12.source, 'optionalAccess', _13 => _13.startsWith, 'call', _14 => _14("git+")]), () => ( false));
  const isOutsideWorkspace = "path" in packageOrDep && _path.relative.call(void 0, workspaceRoot2, packageOrDep.path).startsWith("..");
  return isRegistry || isGit || isOutsideWorkspace;
}
_chunk3GQAWCBQjs.__name.call(void 0, isExternal, "isExternal");
function runProcess(processCmd, ...args) {
  const metadata = cargoMetadata();
  const targetDir = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _15 => _15.target_directory]), () => ( _devkit.joinPathFragments.call(void 0, _devkit.workspaceRoot, "dist", "cargo")));
  return new Promise((resolve) => {
    if (process.env.VERCEL) {
      return resolve({
        success: true
      });
    }
    _child_process.execSync.call(void 0, `${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
    });
  });
}
_chunk3GQAWCBQjs.__name.call(void 0, runProcess, "runProcess");











exports.INVALID_CARGO_ARGS = INVALID_CARGO_ARGS; exports.childProcess = childProcess; exports.buildCargoCommand = buildCargoCommand; exports.cargoCommand = cargoCommand; exports.cargoRunCommand = cargoRunCommand; exports.cargoCommandSync = cargoCommandSync; exports.cargoMetadata = cargoMetadata; exports.isExternal = isExternal; exports.runProcess = runProcess;