@storm-software/linting-tools 1.43.0 → 1.44.0

package/src/cli/index.ts

@@ -0,0 +1,300 @@
+import {
+  findWorkspaceRootSafe,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "@storm-software/config-tools";
+import type { StormConfig } from "@storm-software/config";
+import { lint } from "cspell";
+import { parseCircular, parseDependencyTree, prettyCircular } from "dpdm";
+import { runAlex } from "../alex";
+import { runManypkg } from "../manypkg";
+import { Command, Option } from "commander";
+
+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 skipCspell = new Option("--skip-cspell", "Should skip CSpell linting");
+
+    const skipAlex = new Option("--skip-alex", "Should skip Alex language linting");
+
+    const skipDepsVersion = new Option(
+      "--skip-deps-version",
+      "Should skip dependency version consistency linting"
+    );
+
+    const skipCircularDeps = new Option(
+      "--skip-circular-deps",
+      "Should skip circular dependency linting"
+    );
+
+    const skipManypkg = new Option("--skip-manypkg", "Should skip Manypkg linting");
+
+    program
+      .command("all")
+      .description("Run all linters for the workspace.")
+      .addOption(skipCspell)
+      .addOption(skipAlex)
+      .addOption(skipDepsVersion)
+      .addOption(skipCircularDeps)
+      .addOption(skipManypkg)
+      .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({
+  skipCspell,
+  skipAlex,
+  skipDepsVersion,
+  skipCircularDeps,
+  skipManypkg,
+  cspellConfig,
+  alexConfig,
+  alexIgnore,
+  manypkgType,
+  manypkgArgs,
+  manypkgFix
+}: {
+  skipCspell: boolean;
+  skipAlex: boolean;
+  skipDepsVersion: boolean;
+  skipCircularDeps: boolean;
+  skipManypkg: boolean;
+  cspellConfig: string;
+  alexConfig: string;
+  alexIgnore: string;
+  manypkgType: string;
+  manypkgArgs: string[];
+  manypkgFix: boolean;
+}) {
+  try {
+    writeInfo(_config, "⚡ Linting the Storm Workspace");
+
+    const promises = [] as Promise<any>[];
+    if (!skipCspell) {
+      promises.push(cspellAction(cspellConfig));
+    }
+
+    if (!skipAlex) {
+      promises.push(alexAction(alexConfig, alexIgnore));
+    }
+
+    if (!skipDepsVersion) {
+      promises.push(depsVersionAction());
+    }
+
+    if (!skipCircularDeps) {
+      promises.push(circularDepsAction());
+    }
+
+    if (!skipManypkg) {
+      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/constants.ts

@@ -0,0 +1,87 @@
+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]",
+    message: "Specify encoding as last argument instead of object with encoding key"
+  },
+  {
+    // ❌ readFile(…, {})
+    selector:
+      "CallExpression[callee.name=/readFileSync|readFile|writeFileSync|writeFile/] > .arguments:last-child[type=ObjectExpression][properties.length=0]",
+    message: "Specify encoding as last argument"
+  },
+  {
+    // ❌ readFileSync(…).toString(…)
+    selector: "CallExpression[callee.name=readFileSync][parent.property.name=toString]",
+    message: "toString is redundant, specify encoding as last argument"
+  },
+  {
+    // ❌ ….readFile(…, { encoding: … })
+    selector:
+      "CallExpression[callee.type=MemberExpression][callee.property.name=/readFileSync|readFile|writeFileSync|writeFile/] > .arguments:last-child[type=ObjectExpression][properties.length=1] Property[key.name=encoding]",
+    message: "Specify encoding as last argument instead of object with encoding key"
+  },
+  {
+    // ❌ ….readFile(…, {})
+    selector:
+      "CallExpression[callee.type=MemberExpression][callee.property.name=/readFileSync|readFile|writeFileSync|writeFile/] > .arguments:last-child[type=ObjectExpression][properties.length=0]",
+    message: "Specify encoding as last argument"
+  },
+  {
+    // ❌ 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]",
+    message: "`process.browser` is deprecated, use `!!globalThis.window`"
+  }
+  // {
+  //   // ❌ let { foo: { bar } } = baz
+  //   // ✅ let { bar } = baz.foo
+  //   // ✅ let { foo: { bar } } = await baz
+  //   selector:
+  //     'VariableDeclarator[init.type!=AwaitExpression] > ObjectPattern[properties.length=1][properties.0.value.type=ObjectPattern]',
+  //   message: 'Do not use nested destructuring.',
+  // },
+];
+
+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."
+  }
+];
+
+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." }
+];
+
+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,7 +1,6 @@
-const require = (await import('node:module')).createRequire(import.meta.url);const __filename = (await import('node:url')).fileURLToPath(import.meta.url);const __dirname = (await import('node:path')).dirname(__filename);
+import type { Linter } from "eslint";
 
-// packages/linting-tools/src/eslint/graphql/index.ts
-var config = {
+const config: Linter.Config = {
   root: true,
   overrides: [
     {
@@ -122,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 type { 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;

package/src/eslint/jest/index.ts

@@ -0,0 +1,16 @@
+import type { Linter } from "eslint";
+
+const config: Linter.Config = {
+  root: true,
+  overrides: [
+    {
+      files: ["*.spec.ts", "*.spec.tsx", "*.spec.js", "*.spec.jsx"],
+      env: {
+        jest: true
+      },
+      rules: {}
+    }
+  ]
+};
+
+export default config;

package/src/eslint/json/index.ts

@@ -0,0 +1,32 @@
+import type { Linter } from "eslint";
+import { CODE_BLOCK } from "../constants";
+
+const JSONC_FILES = ["tsconfig.json", "tsconfig.base.json", "nx.json", ".vscode/launch.json"];
+const config: Linter.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"
+      }
+    }
+  ]
+};
+
+export default config;

package/src/eslint/next/index.ts

@@ -0,0 +1,25 @@
+import { JS_FILES } from "../constants";
+
+const babelOptions = {
+  presets: (() => {
+    try {
+      require.resolve("next/babel");
+      return ["next/babel"];
+    } catch (_e) {
+      return [];
+    }
+  })()
+};
+
+const config = {
+  root: true,
+  extends: ["plugin:@next/next/recommended"],
+  overrides: [
+    {
+      files: JS_FILES,
+      parserOptions: { babelOptions }
+    }
+  ]
+};
+
+export default config;

package/src/eslint/react/index.ts

@@ -0,0 +1,25 @@
+import type { Linter } from "eslint";
+import reactRules from "../rules/react";
+import jsxA11yRules from "../rules/ts-docs";
+
+const config: Linter.Config = {
+  root: true,
+  extends: [
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended",
+    "plugin:jsx-a11y/recommended",
+    "plugin:import/react",
+    "prettier"
+  ],
+  settings: {
+    react: {
+      version: "detect"
+    }
+  },
+  rules: {
+    ...jsxA11yRules,
+    ...reactRules
+  }
+};
+
+export default config;

package/src/eslint/rules/import.ts

@@ -0,0 +1,85 @@
+import type { Linter } from "eslint";
+
+const config: Linter.RulesRecord = {
+  /**
+   * Disallow non-import statements appearing before import statements.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/first.md
+   */
+  "import/first": "error",
+  /**
+   * Require a newline after the last import/require.
+   *
+   * 🔧 Fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/newline-after-import.md
+   */
+  "import/newline-after-import": "warn",
+  /**
+   * Disallow import of modules using absolute paths.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-absolute-path.md
+   */
+  "import/no-absolute-path": "error",
+  /**
+   * Disallow cyclical dependencies between modules.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-cycle.md
+   */
+  "import/no-cycle": "error",
+  /**
+   * Disallow default exports.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-default-export.md
+   */
+  "import/no-default-export": "error",
+  /**
+   * Disallow the use of extraneous packages.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-extraneous-dependencies.md
+   */
+  "import/no-extraneous-dependencies": ["error", { includeInternal: true, includeTypes: true }],
+  /**
+   * Disallow mutable exports.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-mutable-exports.md
+   */
+  "import/no-mutable-exports": "error",
+  /**
+   * Disallow importing packages through relative paths.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-relative-packages.md
+   */
+  "import/no-relative-packages": "warn",
+  /**
+   * Disallow a module from importing itself.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-self-import.md
+   */
+  "import/no-self-import": "error",
+  /**
+   * Ensures that there are no useless path segments.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-useless-path-segments.md
+   */
+  "import/no-useless-path-segments": ["error"],
+  /**
+   * Enforce a module import order convention.
+   *
+   * 🔧 Fixable - https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/order.md
+   */
+  "import/order": [
+    "warn",
+    {
+      groups: [
+        "builtin", // Node.js built-in modules
+        "external", // Packages
+        "internal", // Aliased modules
+        "parent", // Relative parent
+        "sibling", // Relative sibling
+        "index" // Relative index
+      ],
+      "newlines-between": "never"
+    }
+  ]
+};
+
+export default config;

package/src/eslint/rules/jsx-a11y.ts

@@ -0,0 +1,8 @@
+import type { Linter } from "eslint";
+
+const config: Linter.RulesRecord = {
+  // This rule has been deprecated, but not yet removed.
+  "jsx-a11y/no-onchange": "off"
+};
+
+export default config;

package/src/eslint/{react/index.js → rules/react.ts}

@@ -1,7 +1,6 @@
-const require = (await import('node:module')).createRequire(import.meta.url);const __filename = (await import('node:url')).fileURLToPath(import.meta.url);const __dirname = (await import('node:path')).dirname(__filename);
+import type { Linter } from "eslint";
 
-// packages/linting-tools/src/eslint/rules/react.ts
-var config = {
+const config: Linter.RulesRecord = {
   // We recommend using TypeScript over `prop-types`, as `prop-types` can add
   // to a project's build size.
   "react/prop-types": "off",
@@ -100,40 +99,5 @@ var config = {
    */
   "react/self-closing-comp": "warn"
 };
-var react_default = config;
 
-// packages/linting-tools/src/eslint/rules/ts-docs.ts
-var config2 = {
-  /**
-   * Require TSDoc comments conform to the TSDoc specification.
-   *
-   * 🚫 Not fixable - https://github.com/microsoft/tsdoc/tree/master/eslint-plugin
-   */
-  "tsdoc/syntax": "error"
-};
-var ts_docs_default = config2;
-
-// packages/linting-tools/src/eslint/react/index.ts
-var config3 = {
-  root: true,
-  extends: [
-    "plugin:react/recommended",
-    "plugin:react-hooks/recommended",
-    "plugin:jsx-a11y/recommended",
-    "plugin:import/react",
-    "prettier"
-  ],
-  settings: {
-    react: {
-      version: "detect"
-    }
-  },
-  rules: {
-    ...ts_docs_default,
-    ...react_default
-  }
-};
-var react_default2 = config3;
-export {
-  react_default2 as default
-};
+export default config;