@storm-software/linting-tools 1.32.5 → 1.33.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+
+
+## 1.33.0 (2024-01-26)
+
+
+### 🚀 Features
+
+- **workspace-tools:** Added custom `npm-publish` executor ([3e6292dd](https://github.com/storm-software/storm-ops/commit/3e6292dd))
+
+
+### ❤️  Thank You
+
+- Patrick Sullivan
+
 ## 1.32.5 (2024-01-26)
 
 

package/jest.config.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: "linting-tools",
+  preset: "../../jest.preset.js",
+  testEnvironment: "node",
+  transform: {
+    "^.+\\.[tj]s$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }]
+  },
+  moduleFileExtensions: ["ts", "js", "html"],
+  coverageDirectory: "../../coverage/packages/linting-tools"
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/linting-tools",
-  "version": "1.32.5",
+  "version": "1.33.1",
   "private": false,
   "description": "⚡ A package containing various linting tools used to validate syntax, enforce design standards, and format code in a Storm workspace.",
   "keywords": [

package/project.json

@@ -0,0 +1,96 @@
+{
+  "name": "linting-tools",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/linting-tools/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/linting-tools",
+        "tsConfig": "packages/linting-tools/tsconfig.json",
+        "project": "packages/linting-tools/package.json",
+        "main": "packages/linting-tools/src/cli/index.ts",
+        "additionalEntryPoints": [
+          "packages/linting-tools/bin/lint.ts",
+          "packages/linting-tools/src/eslint/graphql/index.ts",
+          "packages/linting-tools/src/eslint/javascript/index.ts",
+          "packages/linting-tools/src/eslint/json/index.ts",
+          "packages/linting-tools/src/eslint/jest/index.ts",
+          "packages/linting-tools/src/eslint/next/index.ts",
+          "packages/linting-tools/src/eslint/react/index.ts",
+          "packages/linting-tools/src/eslint/typescript/index.ts",
+          "packages/linting-tools/src/manypkg/index.ts"
+        ],
+        "deleteOutputPath": true,
+        "bundle": true,
+        "sourcemap": false,
+        "minify": false,
+        "skipTypeCheck": false,
+        "thirdParty": true,
+        "format": ["esm"],
+        "esbuildOptions": {
+          "banner": {
+            "js": "import { fileURLToPath as _fileURLToPath } from 'url';\nimport _path from 'node:path';\nimport { createRequire as topLevelCreateRequire } from 'module';\nconst require = topLevelCreateRequire(import.meta.url);\nconst __filename = _fileURLToPath(import.meta.url);\nconst __dirname = _path.dirname(__filename);"
+          }
+        },
+        "assets": [
+          {
+            "input": "packages/linting-tools",
+            "glob": "README.md",
+            "output": "/"
+          },
+          {
+            "input": "packages/linting-tools",
+            "glob": "CHANGELOG.md",
+            "output": "/"
+          },
+          {
+            "input": "",
+            "glob": "LICENSE",
+            "output": "/"
+          },
+          {
+            "input": "packages/linting-tools",
+            "glob": "bin/**/*",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "alex/**/.{alexrc,alexignore}",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "biome/biome.json",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "cspell/**/dictionary.txt",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "cspell/**/*.json",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "prettier/**/*.*",
+            "output": "."
+          },
+          {
+            "input": "packages/linting-tools/src",
+            "glob": "tsconfig/**/*.*",
+            "output": "."
+          }
+        ]
+      }
+    },
+    "lint": {},
+    "test": {}
+  },
+  "tags": ["type:util", "scope:tools"]
+}

package/src/alex/index.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { filter } from "alex/filter";
+import retextEnglish from "retext-english";
+import retextEquality from "retext-equality";
+import retextProfanities from "retext-profanities";
+import supportsColor from "supports-color";
+import { PluggableList, unified } from "unified";
+import { engine } from "unified-engine";
+import vfileReporter from "vfile-reporter";
+
+Error.stackTraceLimit = Infinity;
+
+export const runAlex = (
+  rcName = "@storm-software/linting-tools/alex/.alexrc",
+  ignoreName = "@storm-software/linting-tools/alex/.alexignore"
+) => {
+  return new Promise(
+    (resolve: (value: unknown) => void, reject: (reason?: any) => void) =>
+      engine(
+        {
+          processor: unified(),
+          files: ["**/*.{txt,js,jsx,ts,tsx,md,mdx,json}"],
+          extensions: [
+            "txt",
+            "text",
+            "md",
+            "markdown",
+            "mkd",
+            "mkdn",
+            "mkdown",
+            "ron"
+          ],
+          configTransform: transform,
+          out: false,
+          output: false,
+          rcName,
+          rcPath: undefined,
+          packageField: "alex",
+          color: Boolean(supportsColor.stderr),
+          reporter: vfileReporter,
+          reporterOptions: {
+            verbose: false
+          },
+          quiet: true,
+          ignoreName,
+          ignorePatterns: [
+            "**/CODE_OF_CONDUCT.md",
+            "**/dist/**",
+            "**/node_modules/**"
+          ],
+          silent: false,
+          silentlyIgnore: true,
+          frail: true,
+          defaultConfig: transform({})
+        },
+        (error, code) => {
+          if (error) {
+            console.error(error.message);
+            return reject(code);
+          }
+          return resolve(code);
+        }
+      )
+  );
+};
+
+const transform = (options: any) => {
+  return {
+    plugins: [
+      retextEnglish,
+      [retextProfanities, { sureness: options.profanitySureness }],
+      [retextEquality, { noBinary: options.noBinary }],
+      [
+        filter,
+        {
+          allow: options.allow,
+          deny: options.deny
+        }
+      ]
+    ] as PluggableList
+  };
+};

package/src/cli/index.ts

@@ -0,0 +1,289 @@
+import {
+  type StormConfig,
+  findWorkspaceRootSafe,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "@storm-software/config-tools";
+import { Command, Option } from "commander";
+import { lint } from "cspell";
+import { parseCircular, parseDependencyTree, prettyCircular } from "dpdm";
+import { runAlex } from "../alex";
+import { runManypkg } from "../manypkg";
+export { findWorkspaceRootSafe } from "@storm-software/config-tools";
+
+let _config: Partial<StormConfig> = {};
+
+export function createProgram(config: StormConfig) {
+  try {
+    _config = config;
+    writeInfo(config, "⚡ Running Storm Linting Tools");
+
+    const root = findWorkspaceRootSafe();
+    process.env.STORM_WORKSPACE_ROOT ??= root;
+    process.env.NX_WORKSPACE_ROOT_PATH ??= root;
+    root && process.chdir(root);
+
+    const program = new Command("storm-lint");
+    program.version("1.0.0", "-v --version", "display CLI version");
+
+    program
+      .description("⚡ Lint the Storm Workspace")
+      .showHelpAfterError()
+      .showSuggestionAfterError();
+
+    const cspellConfig = new Option("--cspell-config <file>", "CSpell config file path").default(
+      "@storm-software/linting-tools/cspell/config.js"
+    );
+
+    program
+      .command("cspell")
+      .description("Run spell-check lint for the workspace.")
+      .addOption(cspellConfig)
+      .action(cspellAction);
+
+    const alexConfig = new Option("--alex-config <file>", "Alex.js config file path").default(
+      "@storm-software/linting-tools/alex/.alexrc"
+    );
+
+    const alexIgnore = new Option("--alex-ignore <file>", "Alex.js Ignore file path").default(
+      "@storm-software/linting-tools/alex/.alexignore"
+    );
+
+    program
+      .command("alex")
+      .description("Run spell-check lint for the workspace.")
+      .addOption(alexConfig)
+      .addOption(alexIgnore)
+      .action(alexAction);
+
+    program
+      .command("deps-version")
+      .description("Run dependency version consistency lint for the workspace.")
+      .action(depsVersionAction);
+
+    program
+      .command("circular-deps")
+      .description("Run circular dependency lint for the workspace.")
+      .action(circularDepsAction);
+
+    const manypkgType = new Option("--manypkg-type <type>", "The manypkg command to run").default(
+      "check"
+    );
+
+    const manypkgArgs = new Option(
+      "--manypkg-args <args>",
+      "The args provided to the manypkg command"
+    ).default([]);
+
+    const manypkgFix = new Option(
+      "--manypkg-fix <args>",
+      "The args provided to the manypkg command"
+    ).default(true);
+
+    program
+      .command("manypkg")
+      .description("Run package lint with Manypkg for the workspace.")
+      .addOption(manypkgType)
+      .addOption(manypkgArgs)
+      .addOption(manypkgFix)
+      .action(manypkgAction);
+
+    const cspellSkip = new Option("--skip-cspell", "Should skip CSpell linting");
+
+    const alexSkip = new Option("--skip-alex", "Should skip Alex language linting");
+
+    const depsVersionSkip = new Option(
+      "--skip-deps-version",
+      "Should skip dependency version consistency linting"
+    );
+
+    const circularDepsSkip = new Option(
+      "--skip-circular-deps",
+      "Should skip circular dependency linting"
+    );
+
+    const manypkgSkip = new Option("--skip-manypkg", "Should skip Manypkg linting");
+
+    program
+      .command("all")
+      .description("Run all linters for the workspace.")
+      .addOption(cspellSkip)
+      .addOption(alexSkip)
+      .addOption(depsVersionSkip)
+      .addOption(circularDepsSkip)
+      .addOption(manypkgSkip)
+      .addOption(cspellConfig)
+      .addOption(alexConfig)
+      .addOption(alexIgnore)
+      .addOption(manypkgType)
+      .addOption(manypkgArgs)
+      .addOption(manypkgFix)
+      .action(allAction);
+
+    return program;
+  } catch (e) {
+    writeFatal(config, `A fatal error occurred while running the program: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function allAction(
+  cspellSkip: boolean,
+  alexSkip: boolean,
+  depsVersionSkip: boolean,
+  circularDepsSkip: boolean,
+  manypkgSkip: boolean,
+  cspellConfig: string,
+  alexConfig: string,
+  alexIgnore: string,
+  manypkgType: string,
+  manypkgArgs: string[],
+  manypkgFix: boolean
+) {
+  try {
+    writeInfo(_config, "⚡ Linting the Storm Workspace");
+
+    const promises = [];
+    if (!cspellSkip) {
+      promises.push(cspellAction(cspellConfig));
+    }
+
+    if (!alexSkip) {
+      promises.push(alexAction(alexConfig, alexIgnore));
+    }
+
+    if (!depsVersionSkip) {
+      promises.push(depsVersionAction());
+    }
+
+    if (!circularDepsSkip) {
+      promises.push(circularDepsAction());
+    }
+
+    if (!manypkgSkip) {
+      promises.push(manypkgAction(manypkgType, manypkgArgs, manypkgFix));
+    }
+
+    await Promise.all(promises);
+    writeSuccess(_config, "Successfully linted the workspace ✅");
+  } catch (e) {
+    writeFatal(_config, `A fatal error occurred while linting the workspace: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function cspellAction(cspellConfig: string) {
+  try {
+    console.log("⚡Linting the workspace spelling");
+    const result = await lint(["**/*.{txt,js,jsx,ts,tsx,md,mdx}"], {
+      cache: true,
+      summary: true,
+      issues: true,
+      progress: false,
+      relative: true,
+      dot: true,
+      debug: true,
+      gitignore: true,
+      root: process.env.STORM_WORKSPACE_ROOT ? process.env.STORM_WORKSPACE_ROOT : process.cwd(),
+      defaultConfiguration: false,
+      config: cspellConfig
+    });
+    if (result.errors) {
+      writeError(_config, "Spelling linting has failed ❌");
+      process.exit(1);
+    }
+
+    writeSuccess(_config, "Spelling linting is complete ✅");
+  } catch (e) {
+    console.error(e);
+    process.exit(1);
+  }
+}
+
+async function alexAction(alexConfig: string, alexIgnore: string) {
+  try {
+    writeInfo(_config, "⚡ Linting the workspace language with alexjs.com");
+
+    if (await runAlex(alexConfig, alexIgnore)) {
+      writeError(_config, "Language linting has failed ❌");
+      process.exit(1);
+    }
+
+    writeSuccess(_config, "Language linting is complete ✅");
+  } catch (e) {
+    writeFatal(
+      _config,
+      `A fatal error occurred while language linting the workspace: ${e.message}`
+    );
+    process.exit(1);
+  }
+}
+
+async function depsVersionAction() {
+  try {
+    writeInfo(_config, "⚡ Linting the workspace dependency version consistency");
+
+    const { CDVC } = await import("check-dependency-version-consistency");
+    const cdvc = new CDVC(".", { fix: true });
+
+    // Show output for dependencies we fixed.
+    if (cdvc.hasMismatchingDependenciesFixable) {
+      writeDebug(_config, cdvc.toFixedSummary());
+    }
+
+    // Show output for dependencies that still have mismatches.
+    if (cdvc.hasMismatchingDependenciesNotFixable) {
+      writeError(_config, "Dependency version consistency linting has failed ❌");
+      writeError(_config, cdvc.toMismatchSummary());
+      process.exit(1);
+    }
+
+    writeSuccess(_config, "Dependency Version linting is complete ✅");
+  } catch (e) {
+    writeFatal(
+      _config,
+      `A fatal error occurred while dependency Version linting the workspace: ${e.message}`
+    );
+    process.exit(1);
+  }
+}
+
+async function circularDepsAction() {
+  try {
+    writeInfo(_config, "⚡ Linting the workspace circular dependency");
+
+    const tree = await parseDependencyTree("**/*.*", {
+      tsconfig: "./tsconfig.base.json",
+      transform: true,
+      skipDynamicImports: false
+    });
+
+    const circulars = parseCircular(tree);
+    writeTrace(_config, prettyCircular(circulars));
+
+    writeSuccess(_config, "Circular dependency linting is complete ✅");
+  } catch (e) {
+    writeFatal(
+      _config,
+      `A fatal error occurred while circular dependency linting the workspace: ${e.message}`
+    );
+    process.exit(1);
+  }
+}
+
+async function manypkgAction(manypkgType = "check", manypkgArgs: string[], manypkgFix: boolean) {
+  try {
+    writeInfo(_config, "⚡ Linting the workspace's packages with Manypkg");
+
+    await runManypkg(manypkgType, manypkgArgs, manypkgFix);
+
+    writeSuccess(_config, "Manypkg linting is complete ✅");
+  } catch (e) {
+    writeFatal(_config, `A fatal error occurred while manypkg linting the workspace: ${e.message}`);
+    process.exit(1);
+  }
+}

package/src/eslint/{json/index.js → constants.ts}

@@ -1,12 +1,4 @@
-import { fileURLToPath as _fileURLToPath } from 'url';
-import _path from 'node:path';
-import { createRequire as topLevelCreateRequire } from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-const __filename = _fileURLToPath(import.meta.url);
-const __dirname = _path.dirname(__filename);
-
-// packages/linting-tools/src/eslint/constants.ts
-var RESTRICTED_SYNTAX = [
+export const RESTRICTED_SYNTAX = [
   {
     // ❌ readFile(…, { encoding: … })
     selector: `CallExpression[callee.name=/readFileSync|readFile|writeFileSync|writeFile/] > .arguments:last-child[type=ObjectExpression][properties.length=1] Property[key.name=encoding]`,
@@ -34,12 +26,15 @@ var RESTRICTED_SYNTAX = [
   },
   {
     // ❌ Boolean(…)
-    selector: "CallExpression[callee.name=Boolean][arguments.1.elements.length!=0]",
-    message: "Prefer `!!\u2026` over `Boolean(\u2026)` because TypeScript infers a narrow literal boolean `type: true` instead of `type: boolean`."
+    selector:
+      "CallExpression[callee.name=Boolean][arguments.1.elements.length!=0]",
+    message:
+      "Prefer `!!…` over `Boolean(…)` because TypeScript infers a narrow literal boolean `type: true` instead of `type: boolean`."
   },
   {
     // ❌ process.browser
-    selector: "ExpressionStatement[expression.object.name=process][expression.property.name=browser]",
+    selector:
+      "ExpressionStatement[expression.object.name=process][expression.property.name=browser]",
     message: "`process.browser` is deprecated, use `!!globalThis.window`"
   }
   // {
@@ -51,50 +46,42 @@ var RESTRICTED_SYNTAX = [
   //   message: 'Do not use nested destructuring.',
   // },
 ];
-var REACT_RESTRICTED_SYNTAX = [
+
+export const REACT_RESTRICTED_SYNTAX = [
   ...RESTRICTED_SYNTAX,
   {
     // ❌ useMemo(…, [])
-    selector: "CallExpression[callee.name=useMemo][arguments.1.type=ArrayExpression][arguments.1.elements.length=0]",
-    message: "`useMemo` with an empty dependency array can't provide a stable reference, use `useRef` instead."
+    selector:
+      "CallExpression[callee.name=useMemo][arguments.1.type=ArrayExpression][arguments.1.elements.length=0]",
+    message:
+      "`useMemo` with an empty dependency array can't provide a stable reference, use `useRef` instead."
   }
 ];
-var CODE_BLOCK = "**/*.md{,x}/*";
 
-// packages/linting-tools/src/eslint/json/index.ts
-var JSONC_FILES = [
-  "tsconfig.json",
-  "tsconfig.base.json",
-  "nx.json",
-  ".vscode/launch.json"
+export const RESTRICTED_GLOBALS = [
+  "stop",
+  { name: "isNaN", message: "Use Number.isNaN instead" }
+];
+
+export const RESTRICTED_MODULES = [
+  { name: "axios", message: "Use `fetch/node-fetch` instead." },
+  { name: "moment", message: "Use `dayjs/date-fns` instead." },
+  { name: "classnames", message: "Use `clsx` instead because it is faster." },
+  {
+    name: "lodash/isString.js",
+    message: "Use `typeof yourVar === 'string'` instead."
+  },
+  { name: "lodash/isArray.js", message: "Use `Array.isArray` instead." },
+  { name: "lodash/flatten.js", message: "Use `Array#flat()` instead." },
+  {
+    name: "lodash/compact.js",
+    message: "Use `Array#filter(Boolean)` instead."
+  },
+  { name: "lodash/identity.js", message: "Use `(value) => value` instead." }
 ];
-var config = {
-  root: true,
-  overrides: [
-    {
-      files: "*.json",
-      excludedFiles: JSONC_FILES,
-      extends: "plugin:jsonc/recommended-with-json"
-    },
-    {
-      files: ["*.jsonc", ...JSONC_FILES],
-      extends: "plugin:jsonc/recommended-with-jsonc"
-    },
-    {
-      files: "*.json5",
-      extends: "plugin:jsonc/recommended-with-json5"
-    },
-    {
-      files: "*.json{,c,5}",
-      excludedFiles: CODE_BLOCK,
-      plugins: ["unicorn"],
-      rules: {
-        "unicorn/filename-case": "error"
-      }
-    }
-  ]
-};
-var json_default = config;
-export {
-  json_default as default
-};
+
+export const JS_FILES = ["*.js?(x)", "*.mjs"];
+
+export const CODE_BLOCK = "**/*.md{,x}/*";
+export const CODE_FILE = "*.{,c,m}{j,t}s{,x}";
+export const TS_FILE = "*.{,c,m}ts{,x}";

package/src/eslint/graphql/{index.js → index.ts}

@@ -1,12 +1,6 @@
-import { fileURLToPath as _fileURLToPath } from 'url';
-import _path from 'node:path';
-import { createRequire as topLevelCreateRequire } from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-const __filename = _fileURLToPath(import.meta.url);
-const __dirname = _path.dirname(__filename);
+import { Linter } from "eslint";
 
-// packages/linting-tools/src/eslint/graphql/index.ts
-var config = {
+const config: Linter.Config = {
   root: true,
   overrides: [
     {
@@ -127,7 +121,5 @@ var config = {
     }
   ]
 };
-var graphql_default = config;
-export {
-  graphql_default as default
-};
+
+export default config;

package/src/eslint/index.ts

@@ -0,0 +1,7 @@
+export * from "./graphql";
+export * from "./javascript";
+export * from "./jest";
+export * from "./json";
+export * from "./next";
+export * from "./react";
+export * from "./typescript";

package/src/eslint/javascript/index.ts

@@ -0,0 +1,22 @@
+import { Linter } from "eslint";
+import importRules from "../rules/import";
+import stormRules from "../rules/storm";
+import unicornRules from "../rules/unicorn";
+
+const config: Linter.Config = {
+  root: true,
+  overrides: [
+    {
+      files: ["*.js", "*.jsx"],
+      extends: ["plugin:@nx/javascript"],
+      plugins: ["unicorn", "import"],
+      rules: {
+        ...importRules,
+        ...unicornRules,
+        ...stormRules
+      }
+    }
+  ]
+};
+
+export default config;