eslint-plugin-kirklin 0.5.6 → 0.9.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-PRESENT Kirk Lin<https://github.com/kirklin>
+Copyright (c) 2021-PRESENT Anthony Fu <https://github.com/kirklin>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,27 @@
+# eslint-plugin-kirklin
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+
+Anthony extended ESLint rules. For [kirklin/eslint-config](https://github.com/kirklin/eslint-config).
+
+[Rules List](./src/rules)
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/kirklin/static/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/kirklin/static/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+[MIT](./LICENSE) License © 2023-PRESENT [Anthony Fu](https://github.com/kirklin)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-kirklin?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/eslint-plugin-kirklin
+[npm-downloads-src]: https://img.shields.io/npm/dm/eslint-plugin-kirklin?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/eslint-plugin-kirklin

package/dist/index.cjs

@@ -1,21 +1,66 @@
 'use strict';
 
-const utils = require('@typescript-eslint/utils');
+const version = "0.9.0";
 
-const createEslintRule = utils.ESLintUtils.RuleCreator(
-  (ruleName) => ruleName
+const hasDocs = [
+  "consistent-list-newline",
+  "if-newline",
+  "import-dedupe",
+  "top-level-function"
+];
+const blobUrl = "https://github.com/kirklin/eslint-plugin-kirklin/blob/main/src/rules/";
+function RuleCreator(urlCreator) {
+  return function createNamedRule({
+    name,
+    meta,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name)
+        }
+      },
+      ...rule
+    });
+  };
+}
+function createRule({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: (context) => {
+      const optionsWithDefault = context.options.map((options, index) => {
+        return {
+          ...defaultOptions[index] || {},
+          ...options || {}
+        };
+      });
+      return create(context, optionsWithDefault);
+    },
+    defaultOptions,
+    meta
+  };
+}
+const createEslintRule = RuleCreator(
+  (ruleName) => hasDocs.includes(ruleName) ? `${blobUrl}${ruleName}.md` : `${blobUrl}${ruleName}.test.ts`
 );
 
-const RULE_NAME$4 = "generic-spacing";
+const RULE_NAME$a = "generic-spacing";
+const PRESERVE_PREFIX_SPACE_BEFORE_GENERIC = /* @__PURE__ */ new Set(["TSCallSignatureDeclaration", "ArrowFunctionExpression", "TSFunctionType", "FunctionExpression"]);
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$a,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Spaces around generic type parameters",
-      recommended: "error"
+      recommended: "stylistic"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       genericSpacingMismatch: "Generic spaces mismatch"
@@ -26,7 +71,7 @@ const genericSpacing = createEslintRule({
     const sourceCode = context.getSourceCode();
     return {
       TSTypeParameterDeclaration: (node) => {
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression", "TSFunctionType"].includes(node.parent.type)) {
+        if (!PRESERVE_PREFIX_SPACE_BEFORE_GENERIC.has(node.parent.type)) {
           const pre = sourceCode.text.slice(0, node.range[0]);
           const preSpace = pre.match(/(\s+)$/)?.[0];
           if (preSpace && preSpace.length) {
@@ -46,7 +91,7 @@ const genericSpacing = createEslintRule({
           const from = prev.range[1];
           const to = current.range[0];
           const span = sourceCode.text.slice(from, to);
-          if (span !== ", " && !span.match(/,\n/)) {
+          if (span !== ", " && !span.match(/,\s*\r?\n/)) {
             context.report({
               *fix(fixer) {
                 yield fixer.replaceTextRange([from, to], ", ");
@@ -87,16 +132,16 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "if-newline";
+const RULE_NAME$9 = "if-newline";
 const ifNewline = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$9,
   meta: {
-    type: "problem",
+    type: "layout",
     docs: {
       description: "Newline after if",
-      recommended: "error"
+      recommended: "stylistic"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       missingIfNewline: "Expect newline after if"
@@ -130,14 +175,14 @@ const ifNewline = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "import-dedupe";
+const RULE_NAME$8 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$8,
   meta: {
     type: "problem",
     docs: {
       description: "Fix duplication in imports",
-      recommended: "error"
+      recommended: "strict"
     },
     fixable: "code",
     schema: [],
@@ -180,41 +225,13 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$1 = "no-const-enum";
-const noConstEnum = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow using `const enum` expression",
-      recommended: "error"
-    },
-    schema: [],
-    messages: {
-      noConstEnum: "Do not use `const enum` expression"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => ({
-    TSEnumDeclaration(node) {
-      if (node.const) {
-        context.report({
-          node,
-          messageId: "noConstEnum"
-        });
-      }
-    }
-  })
-});
-
-const RULE_NAME = "prefer-inline-type-import";
+const RULE_NAME$7 = "prefer-inline-type-import";
 const preferInlineTypeImport = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$7,
   meta: {
     type: "suggestion",
     docs: {
-      description: "Inline type import",
-      recommended: "error"
+      description: "Inline type import"
     },
     fixable: "code",
     schema: [],
@@ -249,7 +266,13 @@ const preferInlineTypeImport = createEslintRule({
 });
 function* removeTypeSpecifier(fixer, sourceCode, node) {
   const importKeyword = sourceCode.getFirstToken(node);
+  if (!importKeyword) {
+    return;
+  }
   const typeIdentifier = sourceCode.getTokenAfter(importKeyword);
+  if (!typeIdentifier) {
+    return;
+  }
   yield fixer.remove(typeIdentifier);
   if (importKeyword.loc.end.column + 1 === typeIdentifier.loc.start.column) {
     yield fixer.removeRange([
@@ -259,14 +282,471 @@ function* removeTypeSpecifier(fixer, sourceCode, node) {
   }
 }
 
-const index = {
+const RULE_NAME$6 = "top-level-function";
+const topLevelFunction = createEslintRule({
+  name: RULE_NAME$6,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce top-level functions to be declared with function keyword",
+      recommended: "stylistic"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      topLevelFunctionDeclaration: "Top-level functions should be declared with function keyword"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      VariableDeclaration(node) {
+        if (node.parent.type !== "Program" && node.parent.type !== "ExportNamedDeclaration") {
+          return;
+        }
+        if (node.declarations.length !== 1) {
+          return;
+        }
+        if (node.kind !== "const") {
+          return;
+        }
+        if (node.declare) {
+          return;
+        }
+        const declaration = node.declarations[0];
+        if (declaration.init?.type !== "ArrowFunctionExpression") {
+          return;
+        }
+        if (declaration.id?.type !== "Identifier") {
+          return;
+        }
+        if (declaration.id.typeAnnotation) {
+          return;
+        }
+        if (declaration.init.body.type !== "BlockStatement" && declaration.id?.loc.start.line === declaration.init?.body.loc.end.line) {
+          return;
+        }
+        const arrowFn = declaration.init;
+        const body = declaration.init.body;
+        const id = declaration.id;
+        context.report({
+          node,
+          loc: {
+            start: id.loc.start,
+            end: body.loc.start
+          },
+          messageId: "topLevelFunctionDeclaration",
+          fix(fixer) {
+            const code = context.getSourceCode().text;
+            const textName = code.slice(id.range[0], id.range[1]);
+            const textArgs = arrowFn.params.length ? code.slice(arrowFn.params[0].range[0], arrowFn.params[arrowFn.params.length - 1].range[1]) : "";
+            const textBody = body.type === "BlockStatement" ? code.slice(body.range[0], body.range[1]) : `{
+  return ${code.slice(body.range[0], body.range[1])}
+}`;
+            const textGeneric = arrowFn.typeParameters ? code.slice(arrowFn.typeParameters.range[0], arrowFn.typeParameters.range[1]) : "";
+            const textTypeReturn = arrowFn.returnType ? code.slice(arrowFn.returnType.range[0], arrowFn.returnType.range[1]) : "";
+            const textAsync = arrowFn.async ? "async " : "";
+            const final = `${textAsync}function ${textName} ${textGeneric}(${textArgs})${textTypeReturn} ${textBody}`;
+            return fixer.replaceTextRange([node.range[0], node.range[1]], final);
+          }
+        });
+      }
+    };
+  }
+});
+
+const RULE_NAME$5 = "no-import-node-modules-by-path";
+const noImportNodeModulesByPath = createEslintRule({
+  name: RULE_NAME$5,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevent importing modules in `node_modules` folder by relative or absolute path",
+      recommended: "recommended"
+    },
+    schema: [],
+    messages: {
+      noImportNodeModulesByPath: "Do not import modules in `node_modules` folder by path"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      "ImportDeclaration": (node) => {
+        if (node.source.value.includes("/node_modules/")) {
+          context.report({
+            node,
+            messageId: "noImportNodeModulesByPath"
+          });
+        }
+      },
+      'CallExpression[callee.name="require"]': (node) => {
+        const value = node.arguments[0]?.value;
+        if (typeof value === "string" && value.includes("/node_modules/")) {
+          context.report({
+            node,
+            messageId: "noImportNodeModulesByPath"
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$4 = "no-ts-export-equal";
+const noTsExportEqual = createEslintRule({
+  name: RULE_NAME$4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Do not use `exports =`",
+      recommended: "recommended"
+    },
+    schema: [],
+    messages: {
+      noTsExportEqual: "Use ESM `export default` instead"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const extension = context.getFilename().split(".").pop();
+    if (!extension) {
+      return {};
+    }
+    if (!["ts", "tsx", "mts", "cts"].includes(extension)) {
+      return {};
+    }
+    return {
+      TSExportAssignment(node) {
+        context.report({
+          node,
+          messageId: "noTsExportEqual"
+        });
+      }
+    };
+  }
+});
+
+const RULE_NAME$3 = "no-cjs-exports";
+const noCjsExports = createEslintRule({
+  name: RULE_NAME$3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Do not use CJS exports"
+    },
+    schema: [],
+    messages: {
+      noCjsExports: "Use ESM export instead"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const extension = context.getFilename().split(".").pop();
+    if (!extension) {
+      return {};
+    }
+    if (!["ts", "tsx", "mts", "cts"].includes(extension)) {
+      return {};
+    }
+    return {
+      'MemberExpression[object.name="exports"]': function(node) {
+        context.report({
+          node,
+          messageId: "noCjsExports"
+        });
+      },
+      'MemberExpression[object.name="module"][property.name="exports"]': function(node) {
+        context.report({
+          node,
+          messageId: "noCjsExports"
+        });
+      }
+    };
+  }
+});
+
+const RULE_NAME$2 = "no-const-enum";
+const noConstEnum = createEslintRule({
+  name: RULE_NAME$2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Deprecated. Use `'no-restricted-syntax': ['error', 'TSEnumDeclaration[const=true]']` instead."
+    },
+    schema: [],
+    messages: {
+      noConstEnum: "Do not use `const enum` expression"
+    },
+    deprecated: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      TSEnumDeclaration: (node) => {
+        if (node.const) {
+          context.report({
+            node,
+            messageId: "noConstEnum"
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$1 = "named-tuple-spacing";
+const RE = /^([\w_$]+)(\s*)(\?\s*)?:(\s*)(.*)$/;
+const namedTupleSpacing = createEslintRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Expect space before type declaration in named tuple",
+      recommended: "stylistic"
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      expectedSpaceAfter: "Expected a space after the ':'.",
+      unexpectedSpaceBetween: "Unexpected space between '?' and the ':'.",
+      unexpectedSpaceBefore: "Unexpected space before the ':'."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      TSNamedTupleMember: (node) => {
+        const code = sourceCode.text.slice(node.range[0], node.range[1]);
+        const match = code.match(RE);
+        if (!match) {
+          return;
+        }
+        const labelName = node.label.name;
+        const spaceBeforeColon = match[2];
+        const optionalMark = match[3];
+        const spacesAfterColon = match[4];
+        const elementType = match[5];
+        function getReplaceValue() {
+          let ret = labelName;
+          if (node.optional) {
+            ret += "?";
+          }
+          ret += ": ";
+          ret += elementType;
+          return ret;
+        }
+        if (optionalMark?.length > 1) {
+          context.report({
+            node,
+            messageId: "unexpectedSpaceBetween",
+            *fix(fixer) {
+              yield fixer.replaceTextRange(node.range, code.replace(RE, getReplaceValue()));
+            }
+          });
+        }
+        if (spaceBeforeColon?.length) {
+          context.report({
+            node,
+            messageId: "unexpectedSpaceBefore",
+            *fix(fixer) {
+              yield fixer.replaceTextRange(node.range, code.replace(RE, getReplaceValue()));
+            }
+          });
+        }
+        if (spacesAfterColon != null && spacesAfterColon.length !== 1) {
+          context.report({
+            node,
+            messageId: "expectedSpaceAfter",
+            *fix(fixer) {
+              yield fixer.replaceTextRange(node.range, code.replace(RE, getReplaceValue()));
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME = "consistent-list-newline";
+const consistentListNewline = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Having line breaks styles to object, array and named imports",
+      recommended: "stylistic"
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      shouldWrap: "Should have line breaks between items",
+      shouldNotWrap: "Should not have line breaks between items"
+    }
+  },
+  defaultOptions: [{}],
+  create: (context, [options = {}] = [{}]) => {
+    function removeLines(fixer, start, end) {
+      const range = [start, end];
+      const code = context.getSourceCode().text.slice(...range);
+      return fixer.replaceTextRange(range, code.replace(/(\r\n|\n)/g, ""));
+    }
+    function check(node, children, prevNode, nextNode) {
+      const items = children.filter(Boolean);
+      if (items.length === 0) {
+        return;
+      }
+      const startLine = prevNode ? prevNode.loc.end.line : node.loc.start.line;
+      let mode = null;
+      let lastLine = startLine;
+      items.forEach((item, idx) => {
+        if (mode == null) {
+          mode = item.loc.start.line === lastLine ? "inline" : "newline";
+          lastLine = item.loc.end.line;
+          return;
+        }
+        const currentStart = item.loc.start.line;
+        if (mode === "newline" && currentStart === lastLine) {
+          context.report({
+            node: item,
+            messageId: "shouldWrap",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(item, "\n");
+            }
+          });
+        } else if (mode === "inline" && currentStart !== lastLine) {
+          const lastItem2 = items[idx - 1];
+          context.report({
+            node: item,
+            messageId: "shouldNotWrap",
+            *fix(fixer) {
+              yield removeLines(fixer, lastItem2.range[1], item.range[0]);
+            }
+          });
+        }
+        lastLine = item.loc.end.line;
+      });
+      const endLoc = nextNode?.loc.start ?? node.loc.end;
+      const endRange = nextNode?.range[0] ? nextNode?.range[0] - 1 : node.range[1];
+      const lastItem = items[items.length - 1];
+      if (mode === "newline" && endLoc.line === lastLine) {
+        context.report({
+          node: lastItem,
+          messageId: "shouldWrap",
+          *fix(fixer) {
+            yield fixer.insertTextAfter(lastItem, "\n");
+          }
+        });
+      } else if (mode === "inline" && endLoc.line !== lastLine) {
+        if (items.length === 1 && items[0].loc.start.line !== items[1]?.loc.start.line) {
+          return;
+        }
+        context.report({
+          node: lastItem,
+          messageId: "shouldNotWrap",
+          *fix(fixer) {
+            yield removeLines(fixer, lastItem.range[1], endRange);
+          }
+        });
+      }
+    }
+    const listenser = {
+      ObjectExpression: (node) => {
+        check(node, node.properties);
+      },
+      ArrayExpression: (node) => {
+        check(node, node.elements);
+      },
+      ImportDeclaration: (node) => {
+        check(node, node.specifiers);
+      },
+      ExportNamedDeclaration: (node) => {
+        check(node, node.specifiers);
+      },
+      FunctionDeclaration: (node) => {
+        check(
+          node,
+          node.params,
+          node.typeParameters || void 0,
+          node.returnType || node.body
+        );
+      },
+      FunctionExpression: (node) => {
+        check(
+          node,
+          node.params,
+          node.typeParameters || void 0,
+          node.returnType || node.body
+        );
+      },
+      ArrowFunctionExpression: (node) => {
+        check(
+          node,
+          node.params,
+          node.typeParameters || void 0,
+          node.returnType || node.body
+        );
+      },
+      CallExpression: (node) => {
+        const startNode = node.typeArguments?.params.length ? node.typeArguments.params[node.typeArguments.params.length - 1] : node.callee.type === "MemberExpression" ? node.callee.property : node.callee;
+        check(node, node.arguments, startNode);
+      },
+      TSInterfaceDeclaration: (node) => {
+        check(node, node.body.body);
+      },
+      TSTypeLiteral: (node) => {
+        check(node, node.members);
+      },
+      TSTupleType: (node) => {
+        check(node, node.elementTypes);
+      },
+      NewExpression: (node) => {
+        check(node, node.arguments, node.callee);
+      },
+      TSTypeParameterDeclaration(node) {
+        check(node, node.params);
+      },
+      TSTypeParameterInstantiation(node) {
+        check(node, node.params);
+      },
+      ObjectPattern(node) {
+        check(node, node.properties, void 0, node.typeAnnotation);
+      },
+      ArrayPattern(node) {
+        check(node, node.elements);
+      }
+    };
+    Object.keys(options).forEach((key) => {
+      if (options[key] === false) {
+        delete listenser[key];
+      }
+    });
+    return listenser;
+  }
+});
+
+const plugin = {
+  meta: {
+    name: "kirklin",
+    version
+  },
   rules: {
+    "consistent-list-newline": consistentListNewline,
+    "generic-spacing": genericSpacing,
     "if-newline": ifNewline,
     "import-dedupe": importDedupe,
+    "named-tuple-spacing": namedTupleSpacing,
+    "no-cjs-exports": noCjsExports,
+    "no-import-node-modules-by-path": noImportNodeModulesByPath,
+    "no-ts-export-equal": noTsExportEqual,
     "prefer-inline-type-import": preferInlineTypeImport,
-    "generic-spacing": genericSpacing,
+    "top-level-function": topLevelFunction,
+    /**
+     * @deprecated Use `'no-restricted-syntax': ['error', 'TSEnumDeclaration[const=true]']` instead.
+     */
     "no-const-enum": noConstEnum
   }
 };
 
-module.exports = index;
+module.exports = plugin;