@storm-software/workspace-tools 1.120.0 → 1.121.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/workspace-tools",
-  "version": "1.120.0",
+  "version": "1.121.0",
   "type": "commonjs",
   "description": "⚡ A Nx plugin package that contains various executors and generators used in a Storm workspaces.",
   "repository": {
@@ -34,7 +34,9 @@
     "./executors/*/schema.json": "./src/executors/*/schema.json",
     "./plugins/rust": "./src/plugins/rust/index.js",
     "./plugins/typescript": "./src/plugins/typescript/index.js",
-    "./preset": "./src/generators/preset/preset.js"
+    "./preset": "./src/generators/preset/preset.js",
+    "./utils": "./src/utils/index.js",
+    "./utils/*": "./src/utils/*.js"
   },
   "typings": "./declarations.d.ts",
   "keywords": [

package/src/plugins/typescript/index.js

@@ -251,8 +251,10 @@ var createNodes = [
         ProjectTagConstants.DistStyle.CLEAN
       )) {
         targets["clean-package"] = {
-          cache: false,
+          cache: true,
           dependsOn: ["build"],
+          inputs: ["typescript", "^production"],
+          outputs: ["{workspaceRoot}/dist/{projectRoot}"],
           executor: "@storm-software/workspace-tools:clean-package",
           options: {
             cleanReadMe: true,

package/src/utils/create-cli-options.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/workspace-tools/src/utils/create-cli-options.ts
+var create_cli_options_exports = {};
+__export(create_cli_options_exports, {
+  createCliOptions: () => createCliOptions
+});
+module.exports = __toCommonJS(create_cli_options_exports);
+var import_devkit = require("@nx/devkit");
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = (0, import_devkit.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCliOptions
+});

package/src/utils/lock-file.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/workspace-tools/src/utils/lock-file.ts
+var lock_file_exports = {};
+__export(lock_file_exports, {
+  LOCK_FILES: () => LOCK_FILES,
+  NPM_LOCK_FILE: () => NPM_LOCK_FILE,
+  NPM_LOCK_PATH: () => NPM_LOCK_PATH,
+  PNPM_LOCK_FILE: () => PNPM_LOCK_FILE,
+  PNPM_LOCK_PATH: () => PNPM_LOCK_PATH,
+  YARN_LOCK_FILE: () => YARN_LOCK_FILE,
+  YARN_LOCK_PATH: () => YARN_LOCK_PATH,
+  getLockFileDependencies: () => getLockFileDependencies,
+  getLockFileName: () => getLockFileName,
+  getLockFileNodes: () => getLockFileNodes,
+  lockFileExists: () => lockFileExists
+});
+module.exports = __toCommonJS(lock_file_exports);
+var import_node_fs = require("node:fs");
+var import_devkit_exports = require("nx/src/devkit-exports");
+var import_node_path = require("node:path");
+var import_yarn_parser = require("nx/src/plugins/js/lock-file/yarn-parser");
+var import_pnpm_parser = require("nx/src/plugins/js/lock-file/pnpm-parser");
+var import_npm_parser = require("nx/src/plugins/js/lock-file/npm-parser");
+var YARN_LOCK_FILE = "yarn.lock";
+var NPM_LOCK_FILE = "package-lock.json";
+var PNPM_LOCK_FILE = "pnpm-lock.yaml";
+var LOCK_FILES = [YARN_LOCK_FILE, NPM_LOCK_FILE, PNPM_LOCK_FILE];
+var YARN_LOCK_PATH = (0, import_node_path.join)(import_devkit_exports.workspaceRoot, YARN_LOCK_FILE);
+var NPM_LOCK_PATH = (0, import_node_path.join)(import_devkit_exports.workspaceRoot, NPM_LOCK_FILE);
+var PNPM_LOCK_PATH = (0, import_node_path.join)(import_devkit_exports.workspaceRoot, PNPM_LOCK_FILE);
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      const packageJson = (0, import_devkit_exports.readJsonFile)((0, import_node_path.join)(context.workspaceRoot, "package.json"));
+      return (0, import_yarn_parser.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
+    }
+    if (packageManager === "pnpm") {
+      return (0, import_pnpm_parser.getPnpmLockfileNodes)(contents, lockFileHash);
+    }
+    if (packageManager === "npm") {
+      return (0, import_npm_parser.getNpmLockfileNodes)(contents, lockFileHash);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      import_devkit_exports.output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function getLockFileDependencies(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      return (0, import_yarn_parser.getYarnLockfileDependencies)(contents, lockFileHash, context);
+    }
+    if (packageManager === "pnpm") {
+      return (0, import_pnpm_parser.getPnpmLockfileDependencies)(contents, lockFileHash, context);
+    }
+    if (packageManager === "npm") {
+      return (0, import_npm_parser.getNpmLockfileDependencies)(contents, lockFileHash, context);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      import_devkit_exports.output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function lockFileExists(packageManager) {
+  if (packageManager === "yarn") {
+    return (0, import_node_fs.existsSync)(YARN_LOCK_PATH);
+  }
+  if (packageManager === "pnpm") {
+    return (0, import_node_fs.existsSync)(PNPM_LOCK_PATH);
+  }
+  if (packageManager === "npm") {
+    return (0, import_node_fs.existsSync)(NPM_LOCK_PATH);
+  }
+  throw new Error(`Unknown package manager ${packageManager} or lock file missing`);
+}
+function getLockFileName(packageManager) {
+  if (packageManager === "yarn") {
+    return YARN_LOCK_FILE;
+  }
+  if (packageManager === "pnpm") {
+    return PNPM_LOCK_FILE;
+  }
+  if (packageManager === "npm") {
+    return NPM_LOCK_FILE;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function errorBodyLines(originalError, additionalInfo = []) {
+  const result = [
+    "Please open an issue at `https://github.com/storm-software/storm-ops/issues/new?template=1-bug.yml` and provide a reproduction.",
+    ...additionalInfo
+  ];
+  if (originalError.message) {
+    result.push(`
+Original error: ${originalError.message}
+
+`);
+  }
+  if (originalError.stack) {
+    result.push(originalError.stack);
+  }
+  return result;
+}
+function isPostInstallProcess() {
+  return process.env.npm_command === "install" && process.env.npm_lifecycle_event === "postinstall";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOCK_FILES,
+  NPM_LOCK_FILE,
+  NPM_LOCK_PATH,
+  PNPM_LOCK_FILE,
+  PNPM_LOCK_PATH,
+  YARN_LOCK_FILE,
+  YARN_LOCK_PATH,
+  getLockFileDependencies,
+  getLockFileName,
+  getLockFileNodes,
+  lockFileExists
+});

package/src/utils/project-tags.js

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/workspace-tools/src/utils/project-tags.ts
+var project_tags_exports = {};
+__export(project_tags_exports, {
+  ProjectTagConstants: () => ProjectTagConstants,
+  addProjectTag: () => addProjectTag,
+  formatProjectTag: () => formatProjectTag,
+  getProjectTag: () => getProjectTag,
+  hasProjectTag: () => hasProjectTag,
+  isEqualProjectTag: () => isEqualProjectTag,
+  setDefaultProjectTags: () => setDefaultProjectTags
+});
+module.exports = __toCommonJS(project_tags_exports);
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  }
+};
+var formatProjectTag = (variant, value) => {
+  return `${variant}:${value}`;
+};
+var hasProjectTag = (project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some(
+    (tag) => tag.startsWith(prefix) && tag.length > prefix.length
+  );
+};
+var getProjectTag = (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return tag?.replace(prefix, "");
+};
+var isEqualProjectTag = (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+};
+var addProjectTag = (project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = project.tags ?? [];
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter(
+      (tag) => !tag.startsWith(formatProjectTag(variant, ""))
+    );
+    project.tags.push(formatProjectTag(variant, value));
+  }
+};
+var setDefaultProjectTags = (project) => {
+  project.tags = project.tags ?? [];
+  addProjectTag(
+    project,
+    ProjectTagConstants.ProjectType.TAG_ID,
+    project.projectType === "application" ? ProjectTagConstants.ProjectType.APPLICATION : ProjectTagConstants.ProjectType.LIBRARY,
+    { overwrite: true }
+  );
+  addProjectTag(
+    project,
+    ProjectTagConstants.DistStyle.TAG_ID,
+    project.targets && Object.keys(project.targets).includes("clean-package") ? ProjectTagConstants.DistStyle.CLEAN : ProjectTagConstants.DistStyle.NORMAL,
+    { overwrite: true }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectTagConstants,
+  addProjectTag,
+  formatProjectTag,
+  getProjectTag,
+  hasProjectTag,
+  isEqualProjectTag,
+  setDefaultProjectTags
+});