@borela-tech/eslint-config 2.3.0 → 2.4.0

package/dist/index.mjs

@@ -82,7 +82,7 @@ function checkArray(sourceCode, context, node2) {
     node: elements[0]
   });
 }
-const messageIds$c = {
+const messageIds$d = {
   arrayItemsOnNewLine: "arrayItemsOnNewLine"
 };
 const arrayItemsLineBreak = {
@@ -99,7 +99,7 @@ const arrayItemsLineBreak = {
       description: "Enforce each array item to be on its own line when the array expression exceeds a configurable maximum line length."
     },
     fixable: "code",
-    messages: messageIds$c,
+    messages: messageIds$d,
     schema: [{
       additionalProperties: false,
       properties: {
@@ -305,7 +305,7 @@ function checkObjectExpression(sourceCode, context, node2) {
   checkClosingBrace(sourceCode, context, node2, closingBrace);
   checkNestedObjects(sourceCode, context, node2, checkObjectExpression);
 }
-const messageIds$b = {
+const messageIds$c = {
   braceOnPropertyLine: "Opening brace should be on its own line",
   propertiesOnSameLine: "Multi-line objects must have each property on its own line"
 };
@@ -323,7 +323,7 @@ const braceStyleObjectLiteral = {
       description: "Enforce consistent brace positioning for object literals."
     },
     fixable: "code",
-    messages: messageIds$b,
+    messages: messageIds$c,
     schema: [{
       additionalProperties: false,
       properties: {},
@@ -378,7 +378,7 @@ function isBracketOnOwnLine(sourceCode, openingBracket) {
   );
   return textBetween.includes("\n");
 }
-const messageIds$a = {
+const messageIds$b = {
   compactItems: "Array items should be compact when the array spans multiple lines."
 };
 const compactArrayItems = {
@@ -422,7 +422,7 @@ const compactArrayItems = {
       description: "Enforce arrays with multiline items to have a compact, inline bracket style."
     },
     fixable: "code",
-    messages: messageIds$a,
+    messages: messageIds$b,
     schema: [],
     type: "layout"
   }
@@ -473,11 +473,11 @@ function getExportedNames(node2) {
 function stripExtension(filename) {
   return path.basename(filename, path.extname(filename));
 }
-function isExempt$1(filename) {
+function isExempt$2(filename) {
   const name = stripExtension(filename);
   return name === "index" || name.endsWith(".test") || name.endsWith(".spec") || name.endsWith(".config");
 }
-const messageIds$9 = {
+const messageIds$a = {
   filenameMismatch: "File name must be '{{expectedName}}' instead of '{{currentName}}'."
 };
 const exportFilenameMatch = {
@@ -486,7 +486,7 @@ const exportFilenameMatch = {
     const baseName = path.basename(fileName);
     const ext = path.extname(baseName);
     const fileNameWithoutExt = baseName.slice(0, -ext.length);
-    if (isExempt$1(fileName))
+    if (isExempt$2(fileName))
       return {};
     const exportNames = [];
     return {
@@ -515,7 +515,7 @@ const exportFilenameMatch = {
     docs: {
       description: "Enforce filename matches the single named export."
     },
-    messages: messageIds$9,
+    messages: messageIds$a,
     schema: [],
     type: "suggestion"
   }
@@ -685,7 +685,7 @@ function checkCall(sourceCode, context, node2) {
   else
     checkMultilineArgs(sourceCode, context, args, maxLength);
 }
-const messageIds$8 = {
+const messageIds$9 = {
   exceedsMaxLength: "Refactor this function call as it exceeds {{maxLength}} characters",
   multipleOnSameLine: "Each argument must be on its own line"
 };
@@ -706,7 +706,7 @@ const functionCallArgumentLineBreak = {
       description: "Enforce each function call argument to be on its own line when line exceeds max length."
     },
     fixable: "code",
-    messages: messageIds$8,
+    messages: messageIds$9,
     schema: [{
       additionalProperties: false,
       properties: {
@@ -818,7 +818,7 @@ function getFunctionExpressionName(node2) {
     return nameFromMethod;
   return null;
 }
-function getFunctionName(node2) {
+function getFunctionName$1(node2) {
   if (node2.type === "FunctionDeclaration" && node2.id?.name)
     return node2.id.name;
   if (node2.type === "FunctionExpression")
@@ -827,7 +827,7 @@ function getFunctionName(node2) {
     return getArrowFunctionExpressionName(node2);
   return null;
 }
-const messageIds$7 = {
+const messageIds$8 = {
   tooHighCognitiveComplexity: "Function '{{name}}' has cognitive complexity of {{actual}} (max: {{max}}). Consider extracting sub-functions.",
   tooHighCognitiveComplexityAnonymous: "Anonymous function has cognitive complexity of {{actual}} (max: {{max}}). Consider extracting sub-functions."
 };
@@ -839,7 +839,7 @@ const functionCognitiveComplexity = {
     function checkFunction2(node2) {
       const complexity = calculateCognitiveComplexity(node2);
       if (complexity > maxCognitiveComplexity) {
-        const name = getFunctionName(node2);
+        const name = getFunctionName$1(node2);
         if (name) {
           context.report({
             data: {
@@ -878,7 +878,7 @@ const functionCognitiveComplexity = {
     docs: {
       description: "Enforce cognitive complexity threshold for functions."
     },
-    messages: messageIds$7,
+    messages: messageIds$8,
     schema: [{
       additionalProperties: false,
       properties: {
@@ -1025,7 +1025,7 @@ function checkFunction$1(sourceCode, context, node2) {
   else
     checkMultilineParams(sourceCode, context, params, parens, maxLength);
 }
-const messageIds$6 = {
+const messageIds$7 = {
   exceedsMaxLength: "Refactor this function signature as it exceeds {{maxLength}} characters",
   multipleOnSameLine: "Each parameter must be on its own line"
 };
@@ -1060,7 +1060,7 @@ const functionParameterLineBreak = {
       description: "Enforce each function parameter to be on its own line when line exceeds max length."
     },
     fixable: "code",
-    messages: messageIds$6,
+    messages: messageIds$7,
     schema: [{
       additionalProperties: false,
       properties: {
@@ -1382,7 +1382,7 @@ function checkInterface(sourceCode, context, node2) {
   else
     checkMultilineMembers(sourceCode, context, body.body, maxLength);
 }
-const messageIds$5 = {
+const messageIds$6 = {
   exceedsMaxLength: "Interface line exceeds {{maxLength}} characters",
   multipleOnSameLine: "Interface members should each be on their own line when line exceeds {{maxLength}} characters"
 };
@@ -1400,7 +1400,7 @@ const interfacePropertyLineBreak = {
       description: "Enforce each interface member to be on its own line when line exceeds max length."
     },
     fixable: "code",
-    messages: messageIds$5,
+    messages: messageIds$6,
     schema: [{
       additionalProperties: false,
       properties: {
@@ -1450,7 +1450,7 @@ function handleTSTypeAliasDeclaration(node2, types) {
   if (isTopLevel(node2) && node2.id?.name)
     types.add(node2.id.name);
 }
-function isExempt(filename) {
+function isExempt$1(filename) {
   const name = path.basename(filename, path.extname(filename));
   const isTest = name.endsWith(".test");
   const isSpec = name.endsWith(".spec");
@@ -1460,13 +1460,13 @@ function isExempt(filename) {
 function isExportedDeclaration(parent) {
   return parent?.type === "ExportNamedDeclaration";
 }
-const messageIds$4 = {
+const messageIds$5 = {
   tooManyDeclarations: "File has {{count}} declarations. Put each function/class/const/type declaration in its own file."
 };
 const maxDeclarationsPerFile = {
   create(context) {
     const filename = context.filename;
-    if (isExempt(filename))
+    if (isExempt$1(filename))
       return {};
     const functions = /* @__PURE__ */ new Set();
     const types = /* @__PURE__ */ new Set();
@@ -1524,7 +1524,7 @@ const maxDeclarationsPerFile = {
     docs: {
       description: "Enforce single top-level declaration per file."
     },
-    messages: messageIds$4,
+    messages: messageIds$5,
     schema: [],
     type: "suggestion"
   }
@@ -1582,6 +1582,306 @@ const multilineUnionTypeAliases = {
     type: "layout"
   }
 };
+function isExempt(name) {
+  return name.startsWith("_");
+}
+function isPascalCase(name) {
+  if (!/^[A-Z]/.test(name))
+    return false;
+  return /^[A-Z][\dA-Za-z]*$/.test(name);
+}
+function isSeparator(char) {
+  return char === "_" || char === "-" || char === " ";
+}
+function isWordBoundary(char, currentWord, prevChar, nextChar) {
+  if (!currentWord)
+    return false;
+  const isUpper = /[A-Z]/.test(char);
+  const prevIsUpper = /[A-Z]/.test(prevChar);
+  const nextIsLower = /[a-z]/.test(nextChar);
+  if (isUpper) {
+    const isStartOfNewWord = !prevIsUpper || prevIsUpper && nextIsLower;
+    return isStartOfNewWord;
+  }
+  return false;
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function wordsToCamelCase(words) {
+  if (words.length === 0)
+    return "";
+  if (words.length === 1)
+    return words[0].toLowerCase();
+  const firstWord = words[0].toLowerCase();
+  const restWords = words.slice(1).map(capitalize);
+  return firstWord + restWords.join("");
+}
+function toCamelCase(name) {
+  const words = [];
+  let currentWord = "";
+  for (let i = 0; i < name.length; i++) {
+    const char = name[i];
+    const prevChar = i > 0 ? name[i - 1] : "";
+    const nextChar = i < name.length - 1 ? name[i + 1] : "";
+    if (isSeparator(char)) {
+      if (currentWord) {
+        words.push(currentWord.toLowerCase());
+        currentWord = "";
+      }
+      continue;
+    }
+    if (isWordBoundary(char, currentWord, prevChar, nextChar)) {
+      words.push(currentWord.toLowerCase());
+      currentWord = char;
+      continue;
+    }
+    currentWord += char;
+  }
+  if (currentWord)
+    words.push(currentWord.toLowerCase());
+  return wordsToCamelCase(words);
+}
+function toPascalCase$1(name) {
+  const camelCase = toCamelCase(name);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+function checkClass(id, context) {
+  if (!id)
+    return;
+  const name = id.name;
+  if (isExempt(name))
+    return;
+  if (!isPascalCase(name)) {
+    context.report({
+      data: {
+        name,
+        type: "Class"
+      },
+      fix(fixer) {
+        return fixer.replaceText(id, toPascalCase$1(name));
+      },
+      messageId: "notPascalCase",
+      node: id
+    });
+  }
+}
+function checkNamedEntity(name, node2, type, context) {
+  if (isExempt(name))
+    return;
+  if (!isPascalCase(name)) {
+    context.report({
+      data: { name, type },
+      fix(fixer) {
+        return fixer.replaceText(node2, toPascalCase$1(name));
+      },
+      messageId: "notPascalCase",
+      node: node2
+    });
+  }
+}
+function isCamelCase(name) {
+  if (!/^[a-z]/.test(name))
+    return false;
+  return /^[a-z][\dA-Za-z]*$/.test(name);
+}
+function isUpperCase(name) {
+  return /^[A-Z][\dA-Z_]*$/.test(name);
+}
+function checkConstant(name, node2, context) {
+  if (!isCamelCase(name) && !isUpperCase(name)) {
+    context.report({
+      data: { name },
+      messageId: "notUpperCase",
+      node: node2
+    });
+  }
+}
+function checkVariable(name, node2, context) {
+  if (!isCamelCase(name)) {
+    context.report({
+      data: { name },
+      fix(fixer) {
+        return fixer.replaceText(node2, toCamelCase(name));
+      },
+      messageId: "notCamelCase",
+      node: node2
+    });
+  }
+}
+function isFunction(init) {
+  if (!init)
+    return false;
+  return init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression";
+}
+function checkVariableDeclarator(node2, context) {
+  const id = node2.id;
+  const name = id.name;
+  if (isExempt(name))
+    return;
+  if (isFunction(node2.init))
+    return;
+  const parent = node2.parent;
+  if (parent?.type !== "VariableDeclaration")
+    return;
+  const kind = parent.kind;
+  if (kind === "const")
+    checkConstant(name, id, context);
+  else
+    checkVariable(name, id, context);
+}
+function getFunctionName(node2, parent) {
+  if (node2.type === "FunctionDeclaration" && node2.id)
+    return node2.id.name;
+  if ((node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") && parent?.type === "VariableDeclarator" && parent.id.type === "Identifier")
+    return parent.id.name;
+  return null;
+}
+function getReturnTypeText(sourceCode, node2) {
+  if (!node2.returnType)
+    return void 0;
+  return sourceCode.getText(node2.returnType.typeAnnotation);
+}
+function isReactComponent(returnTypeText) {
+  if (!returnTypeText)
+    return false;
+  const patterns = [
+    "JSX.Element",
+    "React.JSX.Element",
+    "ReactElement",
+    "ReactNode"
+  ];
+  return patterns.some((pattern) => returnTypeText.includes(pattern));
+}
+const messageIds$4 = {
+  notCamelCase: 'Function "{{name}}" should use camelCase',
+  notPascalCase: '{{type}} "{{name}}" should use PascalCase',
+  notUpperCase: 'Constant "{{name}}" should use UPPER_CASE'
+};
+function getFunctionIdentifierNodeForFixer(node2, parent) {
+  if (node2.type === "FunctionDeclaration")
+    return node2.id;
+  if (parent?.type === "VariableDeclarator")
+    return parent.id;
+  return null;
+}
+function getFunctionNameForFixer(node2, parent) {
+  if (node2.type === "FunctionDeclaration" && node2.id)
+    return node2.id.name;
+  if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier")
+    return parent.id.name;
+  return "";
+}
+function createFunctionFixer(node2, parent, convert) {
+  return (fixer) => {
+    const fixedName = convert(getFunctionNameForFixer(node2, parent));
+    const identifierNode = getFunctionIdentifierNodeForFixer(node2, parent);
+    if (identifierNode)
+      return fixer.replaceText(identifierNode, fixedName);
+    return null;
+  };
+}
+function getFunctionReportNode(node2, parent) {
+  if (node2.type === "FunctionDeclaration")
+    return node2;
+  return parent ?? node2;
+}
+function reportComponentViolation(node2, parent, name, context) {
+  if (isPascalCase(name))
+    return;
+  context.report({
+    data: {
+      name,
+      type: "React component"
+    },
+    fix: createFunctionFixer(node2, parent, toPascalCase$1),
+    messageId: "notPascalCase",
+    node: getFunctionReportNode(node2, parent)
+  });
+}
+function reportFunctionViolation(node2, parent, name, context) {
+  if (isCamelCase(name))
+    return;
+  context.report({
+    data: { name },
+    fix: createFunctionFixer(node2, parent, toCamelCase),
+    messageId: "notCamelCase",
+    node: getFunctionReportNode(node2, parent)
+  });
+}
+const namingConvention = {
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      ArrowFunctionExpression(node2) {
+        checkFunction2(node2, node2.parent);
+      },
+      ClassDeclaration(node2) {
+        checkClass(node2.id, context);
+      },
+      ClassExpression(node2) {
+        checkClass(node2.id, context);
+      },
+      FunctionDeclaration(node2) {
+        checkFunction2(node2);
+      },
+      FunctionExpression(node2) {
+        checkFunction2(node2, node2.parent);
+      },
+      TSEnumDeclaration(node2) {
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Enum",
+          context
+        );
+      },
+      TSInterfaceDeclaration(node2) {
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Interface",
+          context
+        );
+      },
+      TSTypeAliasDeclaration(node2) {
+        if (node2.id.type !== "Identifier")
+          return;
+        checkNamedEntity(
+          node2.id.name,
+          node2.id,
+          "Type",
+          context
+        );
+      },
+      VariableDeclarator(node2) {
+        if (node2.id.type !== "Identifier")
+          return;
+        checkVariableDeclarator(node2, context);
+      }
+    };
+    function checkFunction2(node2, parent) {
+      const name = getFunctionName(node2, parent);
+      if (!name || isExempt(name))
+        return;
+      const returnTypeText = getReturnTypeText(sourceCode, node2);
+      const isComponent = isReactComponent(returnTypeText);
+      if (isComponent)
+        reportComponentViolation(node2, parent, name, context);
+      else
+        reportFunctionViolation(node2, parent, name, context);
+    }
+  },
+  meta: {
+    docs: {
+      description: "Enforce consistent naming conventions."
+    },
+    fixable: "code",
+    messages: messageIds$4,
+    schema: [],
+    type: "suggestion"
+  }
+};
 function checkTypeParameters(node2, containsInline) {
   if (!("typeParameters" in node2) || !node2.typeParameters)
     return null;
@@ -2227,7 +2527,7 @@ const messageIds$2 = {
 const oneExportPerFile = {
   create(context) {
     const filename = context.filename;
-    if (isExempt$1(filename))
+    if (isExempt$2(filename))
       return {};
     let exportCount = 0;
     return {
@@ -3219,6 +3519,7 @@ const customRules = {
         "interface-property-line-break": interfacePropertyLineBreak,
         "max-declarations-per-file": maxDeclarationsPerFile,
         "multiline-union-type-aliases": multilineUnionTypeAliases,
+        "naming-convention": namingConvention,
         "no-inline-object-types": noInlineObjectTypes,
         "no-unnecessary-braces": noUnnecessaryBraces,
         "object-property-line-break": objectPropertyLineBreak,
@@ -3263,6 +3564,7 @@ const customRules = {
     ],
     "@borela-tech/max-declarations-per-file": "error",
     "@borela-tech/multiline-union-type-aliases": "error",
+    "@borela-tech/naming-convention": "error",
     "@borela-tech/no-inline-object-types": "error",
     "@borela-tech/no-unnecessary-braces": "error",
     "@borela-tech/object-property-line-break": "error",
@@ -3443,32 +3745,6 @@ const typescriptRules = {
       { fixStyle: "separate-type-imports" }
     ],
     "@typescript-eslint/explicit-function-return-type": "error",
-    "@typescript-eslint/naming-convention": ["error", {
-      format: ["camelCase"],
-      leadingUnderscore: "allow",
-      selector: "default",
-      trailingUnderscore: "allow"
-    }, {
-      format: ["camelCase", "PascalCase"],
-      selector: "import"
-    }, {
-      format: ["camelCase", "UPPER_CASE"],
-      leadingUnderscore: "allow",
-      selector: "variable",
-      trailingUnderscore: "allow"
-    }, {
-      format: ["PascalCase"],
-      selector: "typeLike"
-    }, {
-      format: null,
-      selector: "property"
-    }, {
-      format: null,
-      selector: "objectLiteralProperty"
-    }, {
-      format: null,
-      selector: "objectLiteralMethod"
-    }],
     "@typescript-eslint/no-empty-function": "off",
     "@typescript-eslint/no-unused-vars": ["error", {
       argsIgnorePattern: "^_",
@@ -3594,7 +3870,6 @@ const unicornRules = {
     "unicorn/no-useless-promise-resolve-reject": "error",
     "unicorn/no-useless-spread": "error",
     "unicorn/no-useless-switch-case": "error",
-    "unicorn/no-useless-undefined": "error",
     "unicorn/number-literal-case": "error",
     "unicorn/numeric-separators-style": "error",
     "unicorn/prefer-array-find": "error",