@storm-software/workspace-tools 1.228.1 → 1.229.1

package/dist/chunk-UDAQKEJS.mjs

@@ -0,0 +1,384 @@
+import {
+  isVerbose,
+  loadStormConfig,
+  writeDebug,
+  writeTrace
+} from "./chunk-WJ5TU6JU.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  correctPaths,
+  joinPaths
+} from "./chunk-PVTEDLBL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// ../build-tools/src/config.ts
+var DEFAULT_COMPILED_BANNER = `
+/**
+*      \u26A1 Built by Storm Software
+*/
+
+`;
+var DEFAULT_ENVIRONMENT = "production";
+var DEFAULT_TARGET = "esnext";
+var DEFAULT_ORGANIZATION = "storm-software";
+
+// ../build-tools/src/utilities/copy-assets.ts
+import { hfs as hfs2 } from "@humanfs/node";
+import { createProjectGraphAsync, readProjectsConfigurationFromProjectGraph } from "@nx/devkit";
+import { copyAssets as copyAssetsBase } from "@nx/js";
+import { glob } from "glob";
+
+// ../build-tools/src/utilities/read-nx-config.ts
+import { hfs } from "@humanfs/node";
+var readNxConfig = /* @__PURE__ */ __name(async (workspaceRoot) => {
+  let rootDir = workspaceRoot;
+  if (!rootDir) {
+    const config = await loadStormConfig();
+    rootDir = config.workspaceRoot;
+  }
+  const nxJsonPath = joinPaths(rootDir, "nx.json");
+  if (!await hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  return hfs.json(nxJsonPath);
+}, "readNxConfig");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(assets ?? []);
+  if (!pendingAssets?.some((asset) => asset?.glob === "*.md")) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "*.md",
+      output: "/"
+    });
+  }
+  if (generatePackageJson === false) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (!pendingAssets?.some((asset) => asset?.glob === "LICENSE")) {
+    pendingAssets.push({
+      input: "",
+      glob: "LICENSE",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  const nxJson = readNxConfig(config.workspaceRoot);
+  const projectGraph = await createProjectGraphAsync({
+    exitOnError: true
+  });
+  const projectsConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
+  if (!projectsConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const buildTarget = projectsConfigurations.projects[projectName]?.targets?.build;
+  if (!buildTarget) {
+    throw new Error(`The Build process failed because the project does not have a valid build target in the project.json file. Check if the file exists in the root of the project at ${joinPaths(projectRoot, "project.json")}`);
+  }
+  const result = await copyAssetsBase({
+    assets,
+    watch: false,
+    outputPath
+  }, {
+    root: config.workspaceRoot,
+    targetName: "build",
+    target: buildTarget,
+    projectName,
+    projectGraph,
+    projectsConfigurations,
+    nxJsonConfiguration: nxJson,
+    cwd: config.workspaceRoot,
+    isVerbose: isVerbose(config.logLevel)
+  });
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  if (includeSrc === true) {
+    writeDebug(`\u{1F4DD}  Adding banner and writing source files: ${joinPaths(outputPath, "src")}`, config);
+    const files = await glob([
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.ts"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.tsx"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.js"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(files.map(async (file) => hfs2.write(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await hfs2.text(file)}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+import { hfs as hfs3 } from "@humanfs/node";
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { Glob } from "glob";
+import { createProjectGraphAsync as createProjectGraphAsync2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph2 } from "nx/src/project-graph/project-graph";
+var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectGraph = await createProjectGraphAsync2({
+    exitOnError: true
+  });
+  const projectConfigurations = readProjectsConfigurationFromProjectGraph2(projectGraph);
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const projectJsonPath = joinPaths(workspaceRoot, projectRoot, "project.json");
+  if (!await hfs3.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const projectDependencies = calculateProjectBuildableDependencies(void 0, projectGraph, workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = [];
+  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== projectRoot && dep.node.data.root !== workspaceRoot)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = joinPaths(workspaceRoot, projectNode.data.root, "package.json");
+      if (await hfs3.isFile(projectPackageJsonPath)) {
+        const projectPackageJson = await hfs3.json(projectPackageJsonPath);
+        if (projectPackageJson.private !== false) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    writeTrace(`\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, packageJson.peerDependenciesMeta ?? {});
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+  } else {
+    writeTrace("\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (config, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot = config.workspaceRoot ? config.workspaceRoot : findWorkspaceRoot();
+  const workspacePackageJson = await hfs3.json(joinPaths(workspaceRoot, "package.json"));
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!packageJson.contributors && packageJson.author) {
+    packageJson.contributors = [
+      packageJson.author
+    ];
+  }
+  packageJson.repository ??= workspacePackageJson.repository;
+  packageJson.repository.directory ??= projectRoot ? projectRoot : joinPaths("packages", projectName);
+  return packageJson;
+}, "addWorkspacePackageJsonFields");
+var addPackageJsonExport = /* @__PURE__ */ __name((file, type = "module", sourceRoot) => {
+  let entry = file.replaceAll("\\", "/");
+  if (sourceRoot) {
+    entry = entry.replace(sourceRoot, "");
+  }
+  return {
+    "import": {
+      "types": `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
+      "default": `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
+    },
+    "require": {
+      "types": `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
+      "default": `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
+    },
+    "default": {
+      "types": `./dist/${entry}.d.ts`,
+      "default": `./dist/${entry}.js`
+    }
+  };
+}, "addPackageJsonExport");
+var addPackageJsonExports = /* @__PURE__ */ __name(async (sourceRoot, packageJson) => {
+  packageJson.exports ??= {};
+  const files = await new Glob("**/*.{ts,tsx}", {
+    absolute: false,
+    cwd: sourceRoot,
+    root: sourceRoot
+  }).walk();
+  files.forEach((file) => {
+    addPackageJsonExport(file, packageJson.type, sourceRoot);
+    const split = file.split(".");
+    split.pop();
+    const entry = split.join(".").replaceAll("\\", "/");
+    packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, sourceRoot);
+  });
+  packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+  packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  packageJson.exports ??= {};
+  packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+    if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+      ret[key.replace("/index", "")] = packageJson.exports[key];
+    }
+    return ret;
+  }, packageJson.exports);
+  packageJson.exports["./package.json"] ??= "./package.json";
+  packageJson.exports["."] = packageJson.exports["."] ?? addPackageJsonExport("index", packageJson.type, sourceRoot);
+  return packageJson;
+}, "addPackageJsonExports");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+import { glob as glob2 } from "glob";
+var getEntryPoints = /* @__PURE__ */ __name(async (config, projectRoot, sourceRoot, entry, emitOnAll = false) => {
+  const workspaceRoot = config.workspaceRoot ? config.workspaceRoot : findWorkspaceRoot();
+  const entryPoints = [];
+  if (entry) {
+    if (Array.isArray(entry)) {
+      entryPoints.push(...entry);
+    } else if (typeof entry === "string") {
+      entryPoints.push(entry);
+    } else {
+      entryPoints.push(...Object.values(entry));
+    }
+  }
+  if (emitOnAll) {
+    entryPoints.push(joinPaths(workspaceRoot, sourceRoot || projectRoot, "**/*.{ts,tsx}"));
+  }
+  const results = [];
+  for (const entryPoint in entryPoints) {
+    if (entryPoint.includes("*")) {
+      const files = await glob2(entryPoint, {
+        withFileTypes: true
+      });
+      results.push(...files.reduce((ret, filePath) => {
+        const result = correctPaths(joinPaths(filePath.path, filePath.name).replaceAll(correctPaths(workspaceRoot), "").replaceAll(correctPaths(projectRoot), ""));
+        if (result) {
+          writeDebug(`Trying to add entry point ${result} at "${joinPaths(filePath.path, filePath.name)}"`, config);
+          if (!results.includes(result)) {
+            results.push(result);
+          }
+        }
+        return ret;
+      }, []));
+    } else {
+      results.push(entryPoint);
+    }
+  }
+  return results;
+}, "getEntryPoints");
+
+// ../build-tools/src/utilities/get-env.ts
+var getEnv = /* @__PURE__ */ __name((builder, options) => {
+  return {
+    STORM_BUILD: builder,
+    STORM_ORG: options.orgName || DEFAULT_ORGANIZATION,
+    STORM_NAME: options.name,
+    STORM_ENV: options.envName || DEFAULT_ENVIRONMENT,
+    STORM_PLATFORM: options.platform,
+    STORM_FORMAT: JSON.stringify(options.format),
+    STORM_TARGET: JSON.stringify(options.target),
+    ...options.env
+  };
+}, "getEnv");
+
+// ../build-tools/src/plugins/swc.ts
+import { transform } from "@swc/core";
+
+// ../build-tools/src/plugins/ts-resolve.ts
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import path from "node:path";
+import _resolve from "resolve";
+
+// ../build-tools/src/plugins/type-definitions.ts
+import { stripIndents } from "@nx/devkit";
+import { relative } from "path";
+
+// ../build-tools/src/utilities/get-out-extension.ts
+function getOutExtension(format, pkgType) {
+  let jsExtension = ".js";
+  let dtsExtension = ".d.ts";
+  if (pkgType === "module" && format === "cjs") {
+    jsExtension = ".cjs";
+    dtsExtension = ".d.cts";
+  }
+  if (pkgType !== "module" && format === "esm") {
+    jsExtension = ".mjs";
+    dtsExtension = ".d.mts";
+  }
+  if (format === "iife") {
+    jsExtension = ".global.js";
+  }
+  return {
+    js: jsExtension,
+    dts: dtsExtension
+  };
+}
+__name(getOutExtension, "getOutExtension");
+
+// ../build-tools/src/utilities/task-graph.ts
+import { createTaskGraph, mapTargetDefaultsToDependencies } from "nx/src/tasks-runner/create-task-graph";
+
+export {
+  DEFAULT_COMPILED_BANNER,
+  DEFAULT_TARGET,
+  copyAssets,
+  addPackageDependencies,
+  addWorkspacePackageJsonFields,
+  addPackageJsonExport,
+  addPackageJsonExports,
+  getEntryPoints,
+  getEnv,
+  getOutExtension
+};

package/dist/chunk-ULBTYC2B.js

@@ -0,0 +1,190 @@
+"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;

package/dist/chunk-USUT2GLD.mjs

@@ -0,0 +1,26 @@
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/create-cli-options.ts
+import { names } from "@nx/devkit";
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = names(key).fileName;
+      if (Array.isArray(value)) {
+        args.push(`--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`);
+      } else {
+        args.push(`--${arg.toLowerCase()}=${value}`);
+      }
+    }
+  }
+  return args;
+}
+__name(createCliOptions, "createCliOptions");
+
+export {
+  createCliOptions
+};

package/dist/chunk-VYH45FO6.mjs

@@ -0,0 +1,55 @@
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/toml.ts
+import TOML from "@ltd/j-toml";
+import { logger } from "@nx/devkit";
+function parseCargoTomlWithTree(tree, projectRoot, projectName) {
+  const cargoTomlString = tree.read(`${projectRoot}/Cargo.toml`)?.toString();
+  if (!cargoTomlString) {
+    logger.error(`Cannot find a Cargo.toml file in the ${projectName}`);
+    throw new Error();
+  }
+  return parseCargoToml(cargoTomlString);
+}
+__name(parseCargoTomlWithTree, "parseCargoTomlWithTree");
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return TOML.parse(cargoString, {
+    x: {
+      comment: true
+    }
+  });
+}
+__name(parseCargoToml, "parseCargoToml");
+function stringifyCargoToml(cargoToml) {
+  const tomlString = TOML.stringify(cargoToml, {
+    newlineAround: "section"
+  });
+  if (Array.isArray(tomlString)) {
+    return tomlString.join("\n");
+  }
+  return tomlString;
+}
+__name(stringifyCargoToml, "stringifyCargoToml");
+function modifyCargoTable(toml, section, key, value) {
+  toml[section] ??= TOML.Section({});
+  toml[section][key] = typeof value === "object" && !Array.isArray(value) ? TOML.inline(value) : typeof value === "function" ? value() : value;
+}
+__name(modifyCargoTable, "modifyCargoTable");
+function modifyCargoNestedTable(toml, section, key, value) {
+  toml[section] ??= {};
+  toml[section][key] = TOML.Section(value);
+}
+__name(modifyCargoNestedTable, "modifyCargoNestedTable");
+
+export {
+  parseCargoTomlWithTree,
+  parseCargoToml,
+  stringifyCargoToml,
+  modifyCargoTable,
+  modifyCargoNestedTable
+};