@d3lm/lint-preset 1.0.0

package/dist/rules.js

@@ -0,0 +1,857 @@
+// src/rules/block-scoped-case.ts
+var leadingWhitespace = (line) => /^[ \t]*/.exec(line)?.[0].length ?? 0;
+var rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require case clauses to use block scope (braces)."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      missingBlock: "Case clause should be wrapped in a block (braces)."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      SwitchCase(node) {
+        const { consequent } = node;
+        if (consequent.length === 0) {
+          return;
+        }
+        if (consequent.length === 1 && consequent[0].type === "BlockStatement") {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "missingBlock",
+          fix(fixer) {
+            const caseKeyword = sourceCode.getFirstToken(node);
+            if (!caseKeyword) {
+              return [];
+            }
+            const colonToken = sourceCode.getTokenAfter(
+              node.test ? node.test : caseKeyword,
+              (token) => token.value === ":"
+            );
+            if (!colonToken) {
+              return [];
+            }
+            const lastConsequent = consequent.at(-1);
+            const lastToken = sourceCode.getLastToken(lastConsequent);
+            if (!lastToken) {
+              return [];
+            }
+            const caseIndent = " ".repeat(caseKeyword.loc.start.column);
+            const bodyIndent = caseIndent + "  ";
+            const text = sourceCode.getText();
+            const bodyText = text.slice(colonToken.range[1], lastToken.range[1]);
+            const lines = bodyText.split("\n");
+            const restLines = lines.slice(1);
+            const restIndents = restLines.filter((line) => line.trim() !== "").map((line) => leadingWhitespace(line));
+            const indentDelta = restIndents.length > 0 ? bodyIndent.length - Math.min(...restIndents) : 0;
+            const bodyLines = [];
+            const firstLine = lines[0].trim();
+            if (firstLine) {
+              bodyLines.push(bodyIndent + firstLine);
+            }
+            for (const line of restLines) {
+              if (line.trim() === "") {
+                bodyLines.push("");
+                continue;
+              }
+              const lead = leadingWhitespace(line);
+              const newIndent = Math.max(0, lead + indentDelta);
+              bodyLines.push(" ".repeat(newIndent) + line.slice(lead));
+            }
+            while (bodyLines.length > 0 && bodyLines[0] === "") {
+              bodyLines.shift();
+            }
+            while (bodyLines.length > 0 && bodyLines.at(-1) === "") {
+              bodyLines.pop();
+            }
+            const result = ` {
+${bodyLines.join("\n")}
+${caseIndent}}`;
+            return fixer.replaceTextRange([colonToken.range[1], lastToken.range[1]], result);
+          }
+        });
+      }
+    };
+  }
+};
+var block_scoped_case_default = rule;
+
+// src/rules/comment-preceding-blank-line.ts
+var rule2 = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Require a blank line before comments, with an exception for comments inside chained member-call expressions."
+    },
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowInObjects: {
+            type: "boolean"
+          },
+          allowInArrays: {
+            type: "boolean"
+          },
+          allowInInterfaces: {
+            type: "boolean"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingBlankLine: "Expected blank line before comment."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const options = context.options[0] ?? {};
+    const allowInObjects = options.allowInObjects ?? false;
+    const allowInArrays = options.allowInArrays ?? false;
+    const allowInInterfaces = options.allowInInterfaces ?? false;
+    function isChainedCallContext(comment) {
+      if (!comment.range) {
+        return false;
+      }
+      let current = sourceCode.getNodeByRangeIndex(comment.range[0]) ?? void 0;
+      while (current?.type === "CallExpression" || current?.type === "MemberExpression") {
+        if (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+    function isCommentAllowedByEnclosure(comment) {
+      if (!comment.range) {
+        return false;
+      }
+      const node = sourceCode.getNodeByRangeIndex(comment.range[0]);
+      if (!node) {
+        return false;
+      }
+      const type = node.type;
+      if (allowInObjects && (type === "ObjectExpression" || type === "ObjectPattern")) {
+        return true;
+      }
+      if (allowInArrays && (type === "ArrayExpression" || type === "ArrayPattern")) {
+        return true;
+      }
+      if (allowInInterfaces && (type === "TSInterfaceBody" || type === "TSTypeLiteral")) {
+        return true;
+      }
+      return false;
+    }
+    function isAtBlockStart(comment) {
+      const tokenBefore = sourceCode.getTokenBefore(comment, {
+        includeComments: false
+      });
+      if (!tokenBefore) {
+        return true;
+      }
+      return ["{", "(", "["].includes(tokenBefore.value);
+    }
+    return {
+      Program() {
+        const comments = sourceCode.getAllComments();
+        for (const comment of comments) {
+          if (!comment.loc || !comment.range) {
+            continue;
+          }
+          const commentLine = comment.loc.start.line;
+          if (commentLine <= 1) {
+            continue;
+          }
+          if (isAtBlockStart(comment)) {
+            continue;
+          }
+          if (isChainedCallContext(comment)) {
+            continue;
+          }
+          if (isCommentAllowedByEnclosure(comment)) {
+            continue;
+          }
+          const tokenBefore = sourceCode.getTokenBefore(comment, {
+            includeComments: true
+          });
+          if (!tokenBefore?.loc) {
+            continue;
+          }
+          const linesBetween = commentLine - tokenBefore.loc.end.line;
+          if (linesBetween >= 2) {
+            continue;
+          }
+          if (linesBetween === 0) {
+            continue;
+          }
+          const commentStart = comment.range[0];
+          const lineStart = sourceCode.getText().lastIndexOf("\n", commentStart - 1) + 1;
+          context.report({
+            loc: comment.loc,
+            messageId: "missingBlankLine",
+            fix(fixer) {
+              return fixer.insertTextBeforeRange([lineStart, lineStart], "\n");
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var comment_preceding_blank_line_default = rule2;
+
+// src/rules/comment-syntax.ts
+var URL_PATTERN = /\bhttps?:\/\//;
+var DIRECTIVE_PATTERN = /^\s*(?:eslint(?:-[a-z-]+)?\b|@ts-[a-z-]+|@(?:jsx|jsxFrag|jsxImportSource|jsxRuntime)\b|istanbul\s|c8\s|v8\s|prettier-ignore\b|stylelint-[a-z-]+|webpack[A-Z][a-zA-Z]*|#(?:region|endregion)\b|type\s*:)/;
+var TAG_PATTERN = /^\s*(?:TODO|FIXME|HACK|NOTE|BUG|XXX|SAFETY|WARNING|INFO|OPTIMIZE|REVIEW|PERF|DEPRECATED)\b/i;
+var FIRST_WORD_PATTERN = /^\s*([A-Za-z_$][\w$]*)/;
+var ALL_CAPS_WORD = /^[A-Z][A-Z0-9_]*$/;
+var JSDOC_TAG_LINE = /^\s*\*\s*@[A-Za-z]/;
+var SINGLE_LINE_JSDOC_TAG = /^@[A-Za-z][\w-]*$/;
+var PARAM_DESC_RE = /^@param\s+(?:\{[^}]*\}\s+)?(\S+)\s+(.*\S)\s*$/;
+var BLOCK_LINE_WITH_TEXT = /^(\s*\*)(\s*)(\S.*?)\s*$/;
+var BLOCK_LINE_EMPTY = /^\s*\*\s*$/;
+var CODE_FENCE_LINE = /^\s*\*\s*```/;
+var DEFAULT_LINE_ENDINGS = Object.freeze(["etc.", "...", "e.g.", "i.e."]);
+var DEFAULT_PARAGRAPH_ENDINGS = Object.freeze([".", "!", "?", ":", ";", "`", ")", "]", "}"]);
+var DEFAULT_OPTIONS = {
+  ignoredWords: /* @__PURE__ */ new Set(),
+  ignoredPatterns: [],
+  ignoreUrls: true,
+  ignoreDirectives: true,
+  line: {
+    requireLeadingSpace: true,
+    requireLowercase: true,
+    forbidTrailingPunctuation: true,
+    allowedEndings: DEFAULT_LINE_ENDINGS
+  },
+  block: {
+    requireCapital: true,
+    requireTrailingPunctuation: true,
+    enforceOpening: false,
+    enforceClosing: false,
+    requireSpaceAfterStar: true,
+    requireParagraphCapital: true,
+    paragraphEndings: DEFAULT_PARAGRAPH_ENDINGS,
+    requireJSDocSpacing: true,
+    enforceParamStyle: true
+  }
+};
+function isUpperCase(char) {
+  return char !== char.toLowerCase() && char === char.toUpperCase();
+}
+function isLowerCase(char) {
+  return char !== char.toUpperCase() && char === char.toLowerCase();
+}
+function isTrailingPunctuation(char) {
+  return char === "." || char === "!" || char === "?" || char === ";" || char === ":";
+}
+function isBlockEndingPunctuation(char) {
+  return char === "." || char === "!" || char === "?" || char === ";" || char === ":" || char === ")" || char === "]" || char === "}" || char === "`" || char === ">";
+}
+function indexOfLastNonSpace(value) {
+  for (let index = value.length - 1; index >= 0; index -= 1) {
+    const char = value.codePointAt(index);
+    if (char !== 32 && char !== 9 && char !== 10 && char !== 13) {
+      return index;
+    }
+  }
+  return -1;
+}
+function endsWithAny(value, endings) {
+  for (const ending of endings) {
+    if (value.endsWith(ending)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveOptions(raw) {
+  if (!raw || typeof raw !== "object") {
+    return DEFAULT_OPTIONS;
+  }
+  const input = raw;
+  const line = input.line ?? {};
+  const block = input.block ?? {};
+  const patterns = Array.isArray(input.ignoredPatterns) ? input.ignoredPatterns.map((source) => new RegExp(source)) : DEFAULT_OPTIONS.ignoredPatterns;
+  return {
+    ignoredWords: new Set(Array.isArray(input.ignoredWords) ? input.ignoredWords : []),
+    ignoredPatterns: patterns,
+    ignoreUrls: input.ignoreUrls ?? DEFAULT_OPTIONS.ignoreUrls,
+    ignoreDirectives: input.ignoreDirectives ?? DEFAULT_OPTIONS.ignoreDirectives,
+    line: { ...DEFAULT_OPTIONS.line, ...line },
+    block: { ...DEFAULT_OPTIONS.block, ...block }
+  };
+}
+function shouldSkipComment(value, options) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (options.ignoreDirectives && (DIRECTIVE_PATTERN.test(trimmed) || TAG_PATTERN.test(trimmed))) {
+    return true;
+  }
+  if (options.ignoreUrls && URL_PATTERN.test(trimmed)) {
+    return true;
+  }
+  for (const pattern of options.ignoredPatterns) {
+    if (pattern.test(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkLineComment(context, comment, options) {
+  const { line } = options;
+  const raw = comment.value;
+  const loc = comment.loc;
+  const range = comment.range;
+  if (!loc || !range) {
+    return;
+  }
+  const rangeStart = range[0];
+  if (line.requireLeadingSpace && raw.length > 0) {
+    const first = raw.codePointAt(0);
+    if (first !== 32 && first !== 47 && first !== 9) {
+      context.report({
+        loc,
+        messageId: "lineLeadingSpace",
+        fix: (fixer) => fixer.insertTextAfterRange([rangeStart, rangeStart + 2], " ")
+      });
+    }
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return;
+  }
+  const firstWordMatch = FIRST_WORD_PATTERN.exec(trimmed);
+  if (firstWordMatch && line.requireLowercase) {
+    const word = firstWordMatch[1];
+    const firstChar = word[0];
+    if (isUpperCase(firstChar) && !ALL_CAPS_WORD.test(word) && !options.ignoredWords.has(word)) {
+      context.report({
+        loc,
+        messageId: "lineLowercase",
+        fix: (fixer) => {
+          const offset = rangeStart + 2 + raw.indexOf(firstChar);
+          return fixer.replaceTextRange([offset, offset + 1], firstChar.toLowerCase());
+        }
+      });
+    }
+  }
+  if (line.forbidTrailingPunctuation && !endsWithAny(trimmed, line.allowedEndings)) {
+    const lastChar = trimmed.at(-1) ?? "";
+    if (isTrailingPunctuation(lastChar)) {
+      context.report({
+        loc,
+        messageId: "lineTrailingPunctuation",
+        fix: (fixer) => {
+          const offset = rangeStart + 2 + indexOfLastNonSpace(raw);
+          return fixer.removeRange([offset, offset + 1]);
+        }
+      });
+    }
+  }
+}
+function checkSingleLineBlock(context, comment, options) {
+  const { block } = options;
+  const raw = comment.value;
+  const loc = comment.loc;
+  const range = comment.range;
+  if (!loc || !range) {
+    return;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (raw.startsWith("*")) {
+    const inner = raw.slice(1).trim();
+    if (!inner) {
+      return;
+    }
+    if (SINGLE_LINE_JSDOC_TAG.test(inner)) {
+      return;
+    }
+    const sourceCode = context.sourceCode;
+    const sourceLine = sourceCode.lines[loc.start.line - 1] ?? "";
+    const prefix = sourceLine.slice(0, loc.start.column);
+    const canFix = /^\s*$/.test(prefix);
+    context.report({
+      loc,
+      messageId: "blockSingleLineJSDoc",
+      fix: canFix ? (fixer) => fixer.replaceTextRange(range, `/**
+${prefix} * ${inner}
+${prefix} */`) : void 0
+    });
+    return;
+  }
+  const rangeStart = range[0];
+  const firstWordMatch = FIRST_WORD_PATTERN.exec(trimmed);
+  if (firstWordMatch && block.requireCapital) {
+    const word = firstWordMatch[1];
+    const firstChar = word[0];
+    if (isLowerCase(firstChar) && !ALL_CAPS_WORD.test(word) && !options.ignoredWords.has(word)) {
+      context.report({
+        loc,
+        messageId: "blockCapital",
+        fix: (fixer) => {
+          const offset = rangeStart + 2 + raw.indexOf(firstChar);
+          return fixer.replaceTextRange([offset, offset + 1], firstChar.toUpperCase());
+        }
+      });
+    }
+  }
+  if (block.requireTrailingPunctuation) {
+    const lastChar = trimmed.at(-1) ?? "";
+    if (!isBlockEndingPunctuation(lastChar)) {
+      context.report({
+        loc,
+        messageId: "blockTrailingPunctuation",
+        fix: (fixer) => {
+          const offset = rangeStart + 2 + indexOfLastNonSpace(raw);
+          return fixer.insertTextAfterRange([offset, offset + 1], ".");
+        }
+      });
+    }
+  }
+}
+function offsetOfLine(comment, lines, lineIndex) {
+  const range = comment.range;
+  if (!range) {
+    return 0;
+  }
+  let offset = range[0] + 2;
+  for (let index = 0; index < lineIndex; index += 1) {
+    offset += lines[index].length + 1;
+  }
+  return offset;
+}
+function skipParagraphFirstWord(text, options) {
+  const match = FIRST_WORD_PATTERN.exec(text);
+  if (!match) {
+    return true;
+  }
+  const word = match[1];
+  return ALL_CAPS_WORD.test(word) || options.ignoredWords.has(word);
+}
+function reportParagraphEnding(context, comment, text, options) {
+  const { block } = options;
+  const loc = comment.loc;
+  if (!loc) {
+    return;
+  }
+  for (const ending of block.paragraphEndings) {
+    if (text.endsWith(ending)) {
+      return;
+    }
+  }
+  context.report({
+    loc,
+    messageId: "blockParagraphEnding",
+    data: { endings: `[${block.paragraphEndings.join(" ")}]` }
+  });
+}
+function checkParameterLine(context, comment, lines, lineIndex, text, starSegment, spaces) {
+  const loc = comment.loc;
+  if (!loc) {
+    return;
+  }
+  const match = PARAM_DESC_RE.exec(text);
+  if (!match) {
+    return;
+  }
+  const descPart = match[2];
+  const textStart = offsetOfLine(comment, lines, lineIndex) + starSegment.length + spaces.length;
+  if (!descPart.startsWith("- ")) {
+    const prefixMatch = /^@param\s+(?:\{[^}]*\}\s+)?\S+\s+/.exec(text);
+    if (!prefixMatch) {
+      return;
+    }
+    const descStartOffset = textStart + prefixMatch[0].length;
+    context.report({
+      loc,
+      messageId: "paramMissingDash",
+      fix: (fixer) => fixer.insertTextBeforeRange([descStartOffset, descStartOffset + 1], "- ")
+    });
+    return;
+  }
+  const description = descPart.slice(2).trim();
+  if (!description) {
+    return;
+  }
+  if (!description.endsWith(".")) {
+    const textEndOffset = textStart + text.length;
+    context.report({
+      loc,
+      messageId: "paramDescriptionPeriod",
+      fix: (fixer) => fixer.insertTextAfterRange([textEndOffset - 1, textEndOffset], ".")
+    });
+  }
+}
+function checkMultiLineBlock(context, comment, options) {
+  const { block } = options;
+  const loc = comment.loc;
+  const range = comment.range;
+  if (!loc || !range) {
+    return;
+  }
+  const lines = comment.value.split("\n");
+  const firstLine = lines[0];
+  const lastLine = lines.at(-1) ?? "";
+  if (block.enforceOpening) {
+    const opening = firstLine.trim();
+    if (opening !== "" && opening !== "*") {
+      context.report({ loc, messageId: "blockOpening" });
+      return;
+    }
+  }
+  if (block.enforceClosing) {
+    if (lastLine.trim() !== "") {
+      context.report({ loc, messageId: "blockClosing" });
+      return;
+    }
+    if (lines.length >= 3 && BLOCK_LINE_EMPTY.test(lines.at(-2) ?? "")) {
+      context.report({ loc, messageId: "blockEmptyLineBeforeClose" });
+    }
+  }
+  let insideCodeBlock = false;
+  let paragraphStart = true;
+  let previousText;
+  for (let index = 1; index < lines.length - 1; index += 1) {
+    const line = lines[index];
+    if (CODE_FENCE_LINE.test(line)) {
+      insideCodeBlock = !insideCodeBlock;
+      paragraphStart = true;
+      previousText = void 0;
+      continue;
+    }
+    if (insideCodeBlock) {
+      continue;
+    }
+    if (BLOCK_LINE_EMPTY.test(line)) {
+      if (previousText !== void 0 && block.requireParagraphCapital) {
+        reportParagraphEnding(context, comment, previousText, options);
+      }
+      paragraphStart = true;
+      previousText = void 0;
+      continue;
+    }
+    const match = BLOCK_LINE_WITH_TEXT.exec(line);
+    if (!match) {
+      continue;
+    }
+    const [, starSegment, spaces, text] = match;
+    if (block.requireSpaceAfterStar && spaces.length === 0) {
+      const lineOffset = offsetOfLine(comment, lines, index);
+      const starEnd = lineOffset + starSegment.length;
+      context.report({
+        loc,
+        messageId: "blockLineSpaceAfterStar",
+        fix: (fixer) => fixer.insertTextAfterRange([starEnd - 1, starEnd], " ")
+      });
+      continue;
+    }
+    if (block.requireJSDocSpacing && JSDOC_TAG_LINE.test(line) && previousText !== void 0) {
+      const previousLine = lines[index - 1];
+      if (!BLOCK_LINE_EMPTY.test(previousLine) && !JSDOC_TAG_LINE.test(previousLine)) {
+        context.report({ loc, messageId: "blockJSDocBlankLine" });
+      }
+    }
+    if (paragraphStart && block.requireParagraphCapital && !JSDOC_TAG_LINE.test(line)) {
+      const firstChar = text[0];
+      if (firstChar && isLowerCase(firstChar) && !skipParagraphFirstWord(text, options)) {
+        const lineOffset = offsetOfLine(comment, lines, index);
+        const charOffset = lineOffset + starSegment.length + spaces.length;
+        context.report({
+          loc,
+          messageId: "blockParagraphCapital",
+          fix: (fixer) => fixer.replaceTextRange([charOffset, charOffset + 1], firstChar.toUpperCase())
+        });
+      }
+    }
+    paragraphStart = false;
+    if (block.enforceParamStyle && /^@param\s/.test(text)) {
+      checkParameterLine(context, comment, lines, index, text, starSegment, spaces);
+      previousText = void 0;
+    } else {
+      previousText = text;
+    }
+  }
+  if (previousText !== void 0 && block.requireParagraphCapital) {
+    reportParagraphEnding(context, comment, previousText, options);
+  }
+}
+var messages = {
+  lineLeadingSpace: "Line comment should start with a space.",
+  lineLowercase: "Line comment should start with a lowercase letter.",
+  lineTrailingPunctuation: "Line comment should not end with punctuation.",
+  blockCapital: "Block comment should start with an uppercase letter.",
+  blockTrailingPunctuation: "Block comment should end with punctuation.",
+  blockSingleLineJSDoc: "JSDoc-style block comments (/** ... */) must span multiple lines.",
+  blockOpening: "Block comment should start with '/**\\n *' (or '/*\\n *').",
+  blockClosing: "Block comment should end with '\\n */'.",
+  blockEmptyLineBeforeClose: "Block comment should not end with an empty line.",
+  blockLineSpaceAfterStar: "Each line of a block comment requires a space after '*'.",
+  blockParagraphCapital: "Paragraph should start with an uppercase letter.",
+  blockParagraphEnding: "Paragraph should end with one of {{endings}}.",
+  blockJSDocBlankLine: "Insert a blank line before JSDoc tags.",
+  paramMissingDash: "@param should use ' - ' between name and description.",
+  paramDescriptionPeriod: "@param description should end with a period."
+};
+var rule3 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce comment casing, punctuation, and JSDoc/paragraph structure for line, single-line block, and multi-line block comments."
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          ignoredWords: {
+            type: "array",
+            items: { type: "string" },
+            uniqueItems: true
+          },
+          ignoredPatterns: {
+            type: "array",
+            items: { type: "string" },
+            uniqueItems: true
+          },
+          ignoreUrls: { type: "boolean" },
+          ignoreDirectives: { type: "boolean" },
+          line: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              requireLeadingSpace: { type: "boolean" },
+              requireLowercase: { type: "boolean" },
+              forbidTrailingPunctuation: { type: "boolean" },
+              allowedEndings: {
+                type: "array",
+                items: { type: "string" },
+                uniqueItems: true
+              }
+            }
+          },
+          block: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              requireCapital: { type: "boolean" },
+              requireTrailingPunctuation: { type: "boolean" },
+              enforceOpening: { type: "boolean" },
+              enforceClosing: { type: "boolean" },
+              requireSpaceAfterStar: { type: "boolean" },
+              requireParagraphCapital: { type: "boolean" },
+              paragraphEndings: {
+                type: "array",
+                items: { type: "string" },
+                uniqueItems: true
+              },
+              requireJSDocSpacing: { type: "boolean" },
+              enforceParamStyle: { type: "boolean" }
+            }
+          }
+        }
+      }
+    ],
+    messages
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const options = resolveOptions(context.options[0]);
+    return {
+      Program() {
+        const comments = sourceCode.getAllComments();
+        for (const comment of comments) {
+          if (shouldSkipComment(comment.value, options)) {
+            continue;
+          }
+          if (comment.type === "Line") {
+            checkLineComment(context, comment, options);
+            continue;
+          }
+          if (comment.value.includes("\n")) {
+            checkMultiLineBlock(context, comment, options);
+          } else {
+            checkSingleLineBlock(context, comment, options);
+          }
+        }
+      }
+    };
+  }
+};
+var comment_syntax_default = rule3;
+
+// src/rules/newline-around-multiline.ts
+function isAlwaysPadded(node) {
+  return node.type === "MethodDefinition" || node.type === "StaticBlock";
+}
+function isImportOrExport(node) {
+  if (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration") {
+    return true;
+  }
+  return node.type === "ExportNamedDeclaration" && !node.declaration;
+}
+var rule4 = {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Require blank lines around multiline statements, class methods, static blocks, and switch case bodies."
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      missingBlankBefore: "Expected blank line before this.",
+      missingBlankAfter: "Expected blank line after this."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    function checkBody(body, options = {}) {
+      for (let index = 0; index < body.length; index++) {
+        const node = body[index];
+        if (!node.loc || isImportOrExport(node)) {
+          continue;
+        }
+        const isMultiline = node.loc.start.line !== node.loc.end.line;
+        const forceByKind = options.alwaysPadMembers === true && isAlwaysPadded(node);
+        const needsPadding = isMultiline || forceByKind;
+        if (!needsPadding) {
+          continue;
+        }
+        if (index > 0) {
+          const previous = body[index - 1];
+          if (previous.loc && !isImportOrExport(previous)) {
+            const linesBetween = node.loc.start.line - previous.loc.end.line;
+            if (linesBetween < 2) {
+              context.report({
+                node,
+                messageId: "missingBlankBefore",
+                fix(fixer) {
+                  const previousToken = sourceCode.getLastToken(previous);
+                  if (!previousToken) {
+                    return null;
+                  }
+                  return fixer.insertTextAfter(previousToken, "\n");
+                }
+              });
+            }
+          }
+        }
+        if (index < body.length - 1) {
+          const next = body[index + 1];
+          if (next.loc && !isImportOrExport(next)) {
+            const linesBetween = next.loc.start.line - node.loc.end.line;
+            if (linesBetween < 2) {
+              context.report({
+                node,
+                messageId: "missingBlankAfter",
+                fix(fixer) {
+                  const lastToken = sourceCode.getLastToken(node);
+                  if (!lastToken) {
+                    return null;
+                  }
+                  return fixer.insertTextAfter(lastToken, "\n");
+                }
+              });
+            }
+          }
+        }
+      }
+    }
+    return {
+      Program(node) {
+        checkBody(node.body);
+      },
+      BlockStatement(node) {
+        checkBody(node.body);
+      },
+      StaticBlock(node) {
+        checkBody(node.body);
+      },
+      SwitchCase(node) {
+        checkBody(node.consequent);
+      },
+      ClassBody(node) {
+        checkBody(node.body, { alwaysPadMembers: true });
+      }
+    };
+  }
+};
+var newline_around_multiline_default = rule4;
+
+// src/rules/no-implicit-object-return.ts
+var rule5 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow returning an object literal from an arrow function concise body (e.g. `() => ({})`); require a block body with an explicit return."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      implicitObjectReturn: "Avoid returning an object literal directly from an arrow function; use a block body with an explicit return."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      ArrowFunctionExpression(node) {
+        const body = node.body;
+        if (!node.expression || body.type !== "ObjectExpression") {
+          return;
+        }
+        context.report({
+          node: body,
+          messageId: "implicitObjectReturn",
+          fix(fixer) {
+            const arrowToken = sourceCode.getTokenBefore(body, (token) => token.value === "=>");
+            const openParen = sourceCode.getTokenBefore(body);
+            const closeParen = sourceCode.getTokenAfter(body);
+            if (!arrowToken || openParen?.value !== "(" || closeParen?.value !== ")") {
+              return null;
+            }
+            const objectText = sourceCode.getText(body);
+            return fixer.replaceTextRange([arrowToken.range[1], closeParen.range[1]], ` { return ${objectText}; }`);
+          }
+        });
+      }
+    };
+  }
+};
+var no_implicit_object_return_default = rule5;
+
+// src/rules/index.ts
+var customRules = {
+  meta: {
+    name: "@d3lm/lint-preset-rules",
+    version: "0.1.0"
+  },
+  rules: {
+    "newline-around-multiline": newline_around_multiline_default,
+    "block-scoped-case": block_scoped_case_default,
+    "comment-syntax": comment_syntax_default,
+    "comment-preceding-blank-line": comment_preceding_blank_line_default,
+    "no-implicit-object-return": no_implicit_object_return_default
+  }
+};
+var rules_default = customRules;
+export {
+  customRules,
+  rules_default as default
+};
+//# sourceMappingURL=rules.js.map