@storm-software/workspace-tools 1.279.3 → 1.281.0

package/dist/chunk-D7XLAFS5.mjs

@@ -1,434 +0,0 @@
-import {
-  getProjectPlatform,
-  getRoot
-} from "./chunk-FHBOYSRN.mjs";
-import {
-  ProjectTagConstants,
-  addProjectTag,
-  isEqualProjectTag,
-  setDefaultProjectTags
-} from "./chunk-F66XEAID.mjs";
-
-// src/plugins/typescript/project-config.ts
-import {
-  createNodesFromFiles
-} from "@nx/devkit";
-import defu from "defu";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { readNxJson } from "nx/src/config/nx-json.js";
-import { readJsonFile } from "nx/src/utils/fileutils";
-import { readTargetsFromPackageJson } from "nx/src/utils/package-json";
-import { readTSConfig } from "pkg-types";
-var name = "storm-software/typescript";
-var createNodesV2 = [
-  "{project.json,**/project.json}",
-  async (configFiles, options = { includeApps: true }, context) => {
-    const nxJson = readNxJson(context.workspaceRoot);
-    return createNodesFromFiles(
-      async (file, options2 = { includeApps: true }, context2) => {
-        try {
-          const packageJson = createPackageJson(file, context2.workspaceRoot);
-          if (!packageJson) {
-            return {};
-          }
-          const tsconfig = await createTsconfig(file, context2.workspaceRoot);
-          if (!tsconfig) {
-            return {};
-          }
-          const projectConfig = createProjectFromPackageJsonNextToProjectJson(
-            file,
-            packageJson
-          );
-          if (options2?.includeApps === false && projectConfig.projectType === "application") {
-            return {};
-          }
-          const root = getRoot(projectConfig.root, context2);
-          const enableMarkdownlint = options2?.enableMarkdownlint !== false;
-          const enableEslint = options2?.enableEslint !== false;
-          const targets = readTargetsFromPackageJson(
-            packageJson,
-            nxJson,
-            projectConfig.root,
-            context2.workspaceRoot
-          );
-          if (join(context2.workspaceRoot, projectConfig.root).startsWith(
-            join(context2.workspaceRoot, "tools")
-          ) && options2?.lintInternalTools !== true) {
-            targets.lint ??= {
-              dependsOn: ["^lint"],
-              executor: "nx:run-commands",
-              options: {
-                command: "echo 'Skipping linting of internal tools package \"{projectName}\". This can be changed by setting `lintInternalTools` to `true` in the Storm TypeScript plugin options.' "
-              }
-            };
-          } else {
-            targets["lint-ls"] ??= {
-              cache: true,
-              inputs: ["linting", "typescript", "^production"],
-              dependsOn: ["^lint-ls"],
-              executor: "nx:run-commands",
-              options: {
-                command: 'pnpm exec ls-lint --config="node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" '
-              }
-            };
-            if (enableMarkdownlint) {
-              targets["lint-markdown"] ??= {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "{projectRoot}/**/*.md",
-                  "{projectRoot}/**/*.mdx"
-                ],
-                outputs: ["{projectRoot}/**/*.md", "{projectRoot}/**/*.mdx"],
-                dependsOn: ["^lint-markdown"],
-                executor: "nx:run-commands",
-                options: {
-                  command: 'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/base.markdownlint-cli2.jsonc" --fix'
-                }
-              };
-            }
-            if (enableEslint) {
-              let eslintConfig = checkEslintConfigAtPath(projectConfig.root);
-              if (!eslintConfig) {
-                eslintConfig = checkEslintConfigAtPath(context2.workspaceRoot);
-              }
-              if (eslintConfig) {
-                targets.lint ??= {
-                  cache: true,
-                  inputs: ["linting", "typescript", "^production"],
-                  outputs: [
-                    "{projectRoot}/**/*.{ts,tsx,js,jsx,json,md,mdx,yaml,yml,html,css,scss,sass,less,graphql,gql}"
-                  ],
-                  dependsOn: ["lint-markdown", "^lint"],
-                  executor: "@nx/eslint:lint",
-                  options: {
-                    format: "stylish",
-                    fix: true,
-                    errorOnUnmatchedPattern: false,
-                    cache: true,
-                    cacheLocation: "{workspaceRoot}/node_modules/.cache/eslint/{projectRoot}",
-                    eslintConfig
-                  }
-                };
-              }
-            }
-          }
-          targets["format-toml"] ??= {
-            cache: true,
-            inputs: ["linting", "{projectRoot}/**/*.toml"],
-            outputs: ["{projectRoot}/**/*.toml"],
-            dependsOn: ["^format-toml"],
-            executor: "nx:run-commands",
-            options: {
-              command: 'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" '
-            }
-          };
-          targets["format-readme"] ??= {
-            cache: true,
-            inputs: [
-              "linting",
-              "documentation",
-              "{projectRoot}/{README.md,package.json,Cargo.toml,executors.json,generators.json}"
-            ],
-            outputs: ["{projectRoot}/README.md"],
-            dependsOn: ["^format-readme"],
-            executor: "nx:run-commands",
-            options: {
-              command: 'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
-            }
-          };
-          targets["format-prettier"] ??= {
-            cache: true,
-            inputs: ["linting", "typescript", "^production"],
-            outputs: ["{projectRoot}/**/*"],
-            dependsOn: ["^format-prettier"],
-            executor: "nx:run-commands",
-            options: {
-              command: 'pnpm exec prettier "{projectRoot}/**/*" --write --ignore-unknown --no-error-on-unmatched-pattern --config="node_modules/@storm-software/prettier/config.json" --ignore-path="node_modules/@storm-software/prettier/.prettierignore" --cache --cache-location="node_modules/.cache/prettier/{projectRoot}" '
-            }
-          };
-          targets.format ??= {
-            cache: true,
-            inputs: ["linting", "typescript", "^production"],
-            outputs: ["{projectRoot}/**/*"],
-            dependsOn: [
-              "format-readme",
-              "format-toml",
-              "format-prettier",
-              "^format"
-            ],
-            executor: "nx:run-commands",
-            options: {
-              command: `echo 'Formatting the project files in "{projectRoot}"' `
-            }
-          };
-          targets["type-check"] ??= {
-            cache: true,
-            inputs: ["typescript", "^production"],
-            outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-            executor: "nx:run-commands",
-            dependsOn: ["^type-check", "^build"],
-            options: {
-              command: `pnpm exec tsc --noEmit --pretty --project ${join(
-                projectConfig.root,
-                "tsconfig.json"
-              )}`
-            }
-          };
-          targets.clean ??= {
-            cache: true,
-            executor: "nx:run-commands",
-            inputs: ["typescript", "^production"],
-            outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-            options: {
-              command: "pnpm exec rimraf dist/{projectRoot}",
-              color: true,
-              cwd: "{workspaceRoot}"
-            }
-          };
-          targets.rebuild ??= {
-            cache: false,
-            executor: "nx:run-commands",
-            dependsOn: ["clean", "^build"],
-            inputs: ["typescript", "^production"],
-            outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-            options: {
-              command: `pnpm exec nx run ${projectConfig.name}:build`
-            }
-          };
-          if (checkJestConfigAtPath(projectConfig.root)) {
-            targets.test ??= {
-              cache: true,
-              executor: "@nx/jest:jest",
-              inputs: ["testing", "typescript", "^production"],
-              outputs: ["{workspaceRoot}/coverage/{projectRoot}"],
-              defaultConfiguration: "development",
-              options: {
-                jestConfig: "{projectRoot}/jest.config.ts",
-                passWithNoTests: true
-              },
-              configurations: {
-                development: {
-                  ci: false,
-                  codeCoverage: true
-                },
-                production: {
-                  ci: true,
-                  codeCoverage: true
-                }
-              }
-            };
-          }
-          targets["docs"] ??= {
-            cache: true,
-            inputs: ["linting", "documentation", "typescript", "^production"],
-            outputs: ["{projectRoot}/docs"],
-            dependsOn: ["build", "format-readme", "lint-docs", "^docs"],
-            options: {}
-          };
-          targets["size-limit"] ??= {
-            cache: true,
-            inputs: ["testing", "typescript", "^production"],
-            outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-            dependsOn: ["build", "^size-limit"],
-            options: {}
-          };
-          const isPrivate = packageJson.private ?? false;
-          if (!isPrivate) {
-            addProjectTag(
-              projectConfig,
-              ProjectTagConstants.Registry.TAG_ID,
-              ProjectTagConstants.Registry.NPM,
-              { overwrite: true }
-            );
-            targets["nx-release-publish"] = {
-              cache: false,
-              dependsOn: ["build", "size-limit", "^nx-release-publish"],
-              executor: "@storm-software/workspace-tools:npm-publish",
-              options: {}
-            };
-            if (projectConfig.projectType === "application" || isEqualProjectTag(
-              projectConfig,
-              ProjectTagConstants.ProjectType.TAG_ID,
-              ProjectTagConstants.ProjectType.APPLICATION
-            ) || isEqualProjectTag(
-              projectConfig,
-              ProjectTagConstants.DistStyle.TAG_ID,
-              ProjectTagConstants.DistStyle.CLEAN
-            )) {
-              targets["clean-package"] ??= {
-                cache: true,
-                dependsOn: ["build"],
-                inputs: ["{workspaceRoot}/dist/{projectRoot}"],
-                outputs: ["{workspaceRoot}/dist/{projectRoot}"],
-                executor: "@storm-software/workspace-tools:clean-package",
-                options: {
-                  cleanReadMe: true,
-                  cleanComments: true
-                }
-              };
-              targets["nx-release-publish"].dependsOn?.push("clean-package");
-              targets["size-limit"].dependsOn?.push("clean-package");
-            }
-          }
-          addProjectTag(
-            projectConfig,
-            ProjectTagConstants.Language.TAG_ID,
-            ProjectTagConstants.Language.TYPESCRIPT,
-            { overwrite: true }
-          );
-          const platform = getProjectPlatform(projectConfig);
-          switch (platform) {
-            case "worker":
-              addProjectTag(
-                projectConfig,
-                ProjectTagConstants.Platform.TAG_ID,
-                ProjectTagConstants.Platform.WORKER,
-                { overwrite: true }
-              );
-              break;
-            case "node":
-              addProjectTag(
-                projectConfig,
-                ProjectTagConstants.Platform.TAG_ID,
-                ProjectTagConstants.Platform.NODE,
-                { overwrite: true }
-              );
-              break;
-            case "browser":
-              addProjectTag(
-                projectConfig,
-                ProjectTagConstants.Platform.TAG_ID,
-                ProjectTagConstants.Platform.BROWSER,
-                { overwrite: true }
-              );
-              break;
-            default:
-              addProjectTag(
-                projectConfig,
-                ProjectTagConstants.Platform.TAG_ID,
-                ProjectTagConstants.Platform.NEUTRAL,
-                { overwrite: true }
-              );
-              break;
-          }
-          setDefaultProjectTags(projectConfig, name);
-          return {
-            projects: {
-              [root]: defu(
-                {
-                  root,
-                  targets,
-                  release: {
-                    version: {
-                      generator: "@storm-software/workspace-tools:release-version"
-                    }
-                  }
-                },
-                projectConfig
-              )
-            }
-          };
-        } catch (e) {
-          console.error(e);
-          return {};
-        }
-      },
-      configFiles,
-      options,
-      context
-    );
-  }
-];
-function createProjectFromPackageJsonNextToProjectJson(projectJsonPath, packageJson) {
-  const { nx, name: name2 } = packageJson;
-  const root = dirname(projectJsonPath);
-  return {
-    ...nx,
-    name: name2,
-    root,
-    targets: {}
-  };
-}
-function createPackageJson(projectJsonPath, workspaceRoot) {
-  try {
-    const root = dirname(projectJsonPath);
-    const packageJsonPath = join(workspaceRoot, root, "package.json");
-    if (!existsSync(packageJsonPath)) {
-      return null;
-    }
-    return readJsonFile(packageJsonPath);
-  } catch (e) {
-    console.warn(e);
-    return null;
-  }
-}
-async function createTsconfig(projectJsonPath, workspaceRoot) {
-  try {
-    const root = dirname(projectJsonPath);
-    const tsconfigJsonPath = join(workspaceRoot, root, "tsconfig.json");
-    if (!existsSync(tsconfigJsonPath)) {
-      return null;
-    }
-    return readTSConfig(tsconfigJsonPath);
-  } catch (e) {
-    console.warn(e);
-    return null;
-  }
-}
-function checkEslintConfigAtPath(directory) {
-  const hasEslintConfigFile = (fileName) => {
-    return existsSync(join(directory, fileName));
-  };
-  if (hasEslintConfigFile(".eslintrc.js")) {
-    return ".eslintrc.js";
-  } else if (hasEslintConfigFile(".eslintrc.cjs")) {
-    return ".eslintrc.cjs";
-  } else if (hasEslintConfigFile(".eslintrc.yaml")) {
-    return ".eslintrc.yaml";
-  } else if (hasEslintConfigFile(".eslintrc.yml")) {
-    return ".eslintrc.yml";
-  } else if (hasEslintConfigFile(".eslintrc.json")) {
-    return ".eslintrc.json";
-  } else if (hasEslintConfigFile(".eslintrc")) {
-    return ".eslintrc";
-  } else if (hasEslintConfigFile("eslint.config.js")) {
-    return "eslint.config.js";
-  } else if (hasEslintConfigFile("eslint.config.cjs")) {
-    return "eslint.config.cjs";
-  } else if (hasEslintConfigFile("eslint.config.mjs")) {
-    return "eslint.config.mjs";
-  } else if (hasEslintConfigFile("eslint.config.ts")) {
-    return "eslint.config.ts";
-  } else if (hasEslintConfigFile("eslint.config.cts")) {
-    return "eslint.config.cts";
-  } else if (hasEslintConfigFile("eslint.config.mts")) {
-    return "eslint.config.mts";
-  }
-  return null;
-}
-function checkJestConfigAtPath(directory) {
-  const hasJestConfigFile = (fileName) => {
-    return existsSync(join(directory, fileName));
-  };
-  if (hasJestConfigFile("eslint.config.js")) {
-    return "jest.config.js";
-  } else if (hasJestConfigFile("eslint.config.cjs")) {
-    return "jest.config.cjs";
-  } else if (hasJestConfigFile("eslint.config.mjs")) {
-    return "jest.config.mjs";
-  } else if (hasJestConfigFile("eslint.config.ts")) {
-    return "jest.config.ts";
-  } else if (hasJestConfigFile("jest.config.cts")) {
-    return "jest.config.cts";
-  } else if (hasJestConfigFile("jest.config.mts")) {
-    return "jest.config.mts";
-  }
-  return null;
-}
-
-export {
-  name,
-  createNodesV2
-};