@codeperfect/eslint-plugin 2.4.0 → 2.5.0

package/dist/domain/core/no-multiple-declarators/rule-utilities.d.ts

@@ -0,0 +1,58 @@
+import type { Rule } from "eslint";
+import type { FixableVariableDeclarationNode, RangedVariableDeclaratorNode, SourceCodeAccess, VariableDeclarationNode, VariableDeclaratorNode } from "./types.js";
+/**
+ * Gets the source access wrapper from the ESLint context.
+ * @param context Rule execution context.
+ * @returns Source access helpers used by the fixer.
+ * @example
+ * ```typescript
+ * const sourceCode = getSourceCode(context);
+ * ```
+ */
+declare const getSourceCode: (context: Rule.RuleContext) => SourceCodeAccess;
+/**
+ * Reads the full source text for the active file.
+ * @param sourceCode Source access wrapper.
+ * @returns Full source text.
+ * @example
+ * ```typescript
+ * const sourceText = getSourceText(sourceCode);
+ * ```
+ */
+declare const getSourceText: (sourceCode: SourceCodeAccess) => string;
+/**
+ * Collects ranged declarators when every declarator exposes a range.
+ * @param declarations Declarators from the declaration node.
+ * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.
+ * @example
+ * ```typescript
+ * const ranged = getRangedDeclarations(node.declarations ?? []);
+ * ```
+ */
+declare const getRangedDeclarations: (declarations: readonly VariableDeclaratorNode[]) => readonly RangedVariableDeclaratorNode[] | undefined;
+/**
+ * Determines whether a declaration can be safely rewritten.
+ * @param node Declaration node to inspect.
+ * @param declarations Declarators within the declaration.
+ * @param sourceText Full source text.
+ * @returns Whether the declaration is safe to autofix.
+ * @example
+ * ```typescript
+ * const fixable = canFix(node, declarations, sourceText);
+ * ```
+ */
+declare const canFix: (node: VariableDeclarationNode, declarations: readonly VariableDeclaratorNode[], sourceText: string) => boolean;
+/**
+ * Converts declarators into separate declaration statements.
+ * @param node Fixable declaration node.
+ * @param declarations Declarators that should be split.
+ * @param sourceCode Source access wrapper.
+ * @returns Replacement text for the full declaration.
+ * @example
+ * ```typescript
+ * const replacement = buildReplacement(node, declarations, sourceCode);
+ * ```
+ */
+declare const buildReplacement: (node: FixableVariableDeclarationNode, declarations: readonly RangedVariableDeclaratorNode[], sourceCode: SourceCodeAccess) => string;
+export { buildReplacement, canFix, getRangedDeclarations, getSourceCode, getSourceText, };
+//# sourceMappingURL=rule-utilities.d.ts.map

package/dist/domain/core/no-multiple-declarators/rule-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EACV,8BAA8B,EAG9B,4BAA4B,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAejB;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,SAAS,IAAI,CAAC,WAAW,KAAG,gBACA,CAAC;AAEpD;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,YAAY,gBAAgB,KAAG,MACwB,CAAC;AA6I/E;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,cAAc,SAAS,sBAAsB,EAAE,KAC9C,SAAS,4BAA4B,EAAE,GAAG,SAY5C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,MAAM,GACV,MAAM,uBAAuB,EAC7B,cAAc,SAAS,sBAAsB,EAAE,EAC/C,YAAY,MAAM,KACjB,OAiBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,gBAAgB,GACpB,MAAM,8BAA8B,EACpC,cAAc,SAAS,4BAA4B,EAAE,EACrD,YAAY,gBAAgB,KAC3B,MAQF,CAAC;AAEF,OAAO,EACL,gBAAgB,EAChB,MAAM,EACN,qBAAqB,EACrB,aAAa,EACb,aAAa,GACd,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule-utilities.js

@@ -0,0 +1,204 @@
+import { hasFixData, hasRange } from "./types.js";
+/** Matches comment syntax between declarators. */
+const commentPattern = /\/\/|\/\*/u;
+/** Declaration kinds that can be safely split into standalone statements. */
+const fixableDeclarationKinds = new Set(["const", "let", "var"]);
+/** Loop parent types whose initializers cannot be safely split. */
+const loopParentTypes = new Set([
+    "ForAwaitOfStatement",
+    "ForInStatement",
+    "ForOfStatement",
+]);
+/**
+ * Gets the source access wrapper from the ESLint context.
+ * @param context Rule execution context.
+ * @returns Source access helpers used by the fixer.
+ * @example
+ * ```typescript
+ * const sourceCode = getSourceCode(context);
+ * ```
+ */
+const getSourceCode = (context) => context.sourceCode;
+/**
+ * Reads the full source text for the active file.
+ * @param sourceCode Source access wrapper.
+ * @returns Full source text.
+ * @example
+ * ```typescript
+ * const sourceText = getSourceText(sourceCode);
+ * ```
+ */
+const getSourceText = (sourceCode) => typeof sourceCode.text === "string" ? sourceCode.text : sourceCode.getText();
+/**
+ * Gets the line separator style used by the current source file.
+ * @param sourceText Full source text.
+ * @returns File-native line separator sequence.
+ * @example
+ * ```typescript
+ * const lineSeparator = getLineSeparator("const a = 1;\r\nconst b = 2;");
+ * ```
+ */
+const getLineSeparator = (sourceText) => sourceText.includes("\r\n") ? "\r\n" : "\n";
+/**
+ * Determines whether a declaration is used as a loop initializer.
+ * @param node Declaration node to inspect.
+ * @returns Whether the declaration is attached to a loop initializer.
+ * @example
+ * ```typescript
+ * const inLoop = isLoopInitializer(node);
+ * ```
+ */
+const isLoopInitializer = (node) => {
+    const { parent } = node;
+    if (parent?.type === "ForStatement") {
+        return parent.init === node;
+    }
+    if (parent !== void 0 && loopParentTypes.has(parent.type)) {
+        return parent.left === node;
+    }
+    return false;
+};
+/**
+ * Determines whether a declaration is wrapped in an export statement.
+ * @param node Declaration node to inspect.
+ * @returns Whether the declaration is directly exported.
+ * @example
+ * ```typescript
+ * const exported = isWrappedExport(node);
+ * ```
+ */
+const isWrappedExport = (node) => node.parent?.type === "ExportDefaultDeclaration" ||
+    node.parent?.type === "ExportNamedDeclaration";
+/**
+ * Determines whether a declaration is ambient in TypeScript source.
+ * @param node Declaration node to inspect.
+ * @returns Whether the declaration is marked with `declare`.
+ * @example
+ * ```typescript
+ * const ambient = isTypeScriptAmbientDeclaration(node);
+ * ```
+ */
+const isTypeScriptAmbientDeclaration = (node) => node.declare === true;
+/**
+ * Determines whether a declaration kind is safe to rewrite.
+ * @param node Declaration node to inspect.
+ * @returns Whether the declaration kind supports conservative split fixes.
+ * @example
+ * ```typescript
+ * const safeKind = hasFixableDeclarationKind(node);
+ * ```
+ */
+const hasFixableDeclarationKind = (node) => hasFixData(node) && fixableDeclarationKinds.has(node.kind);
+/**
+ * Gets the indentation for the line containing a declaration.
+ * @param sourceText Full source text.
+ * @param start Start offset of the declaration.
+ * @returns Leading indentation for the declaration line.
+ * @example
+ * ```typescript
+ * const indent = getLineIndent("const a = 1;", 0);
+ * ```
+ */
+const getLineIndent = (sourceText, start) => {
+    const lineStart = sourceText.lastIndexOf("\n", start - 1) + 1;
+    const linePrefix = sourceText.slice(lineStart, start);
+    let indentLength = 0;
+    while (indentLength < linePrefix.length) {
+        const currentCharacter = linePrefix[indentLength];
+        if (currentCharacter !== "\t" && currentCharacter !== " ") {
+            break;
+        }
+        indentLength += 1;
+    }
+    return linePrefix.slice(0, indentLength);
+};
+/**
+ * Detects whether comments appear between declarators.
+ * @param declarations Declarators from a single declaration statement.
+ * @param sourceText Full source text.
+ * @returns Whether comments appear between declarators.
+ * @example
+ * ```typescript
+ * const blocked = hasSeparatorComment(declarations, sourceText);
+ * ```
+ */
+const hasSeparatorComment = (declarations, sourceText) => {
+    for (const [index, declaration] of declarations.entries()) {
+        const nextDeclaration = declarations[index + 1];
+        if (nextDeclaration === void 0) {
+            break;
+        }
+        if (!hasRange(declaration) || !hasRange(nextDeclaration)) {
+            return true;
+        }
+        const separatorText = sourceText.slice(declaration.range[1], nextDeclaration.range[0]);
+        if (commentPattern.test(separatorText)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Collects ranged declarators when every declarator exposes a range.
+ * @param declarations Declarators from the declaration node.
+ * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.
+ * @example
+ * ```typescript
+ * const ranged = getRangedDeclarations(node.declarations ?? []);
+ * ```
+ */
+const getRangedDeclarations = (declarations) => {
+    const rangedDeclarations = [];
+    for (const declaration of declarations) {
+        if (!hasRange(declaration)) {
+            return void 0;
+        }
+        rangedDeclarations.push(declaration);
+    }
+    return rangedDeclarations;
+};
+/**
+ * Determines whether a declaration can be safely rewritten.
+ * @param node Declaration node to inspect.
+ * @param declarations Declarators within the declaration.
+ * @param sourceText Full source text.
+ * @returns Whether the declaration is safe to autofix.
+ * @example
+ * ```typescript
+ * const fixable = canFix(node, declarations, sourceText);
+ * ```
+ */
+const canFix = (node, declarations, sourceText) => {
+    if (!hasFixData(node)) {
+        return false;
+    }
+    if (!hasFixableDeclarationKind(node) ||
+        isTypeScriptAmbientDeclaration(node)) {
+        return false;
+    }
+    if (isLoopInitializer(node) || isWrappedExport(node)) {
+        return false;
+    }
+    return !hasSeparatorComment(declarations, sourceText);
+};
+/**
+ * Converts declarators into separate declaration statements.
+ * @param node Fixable declaration node.
+ * @param declarations Declarators that should be split.
+ * @param sourceCode Source access wrapper.
+ * @returns Replacement text for the full declaration.
+ * @example
+ * ```typescript
+ * const replacement = buildReplacement(node, declarations, sourceCode);
+ * ```
+ */
+const buildReplacement = (node, declarations, sourceCode) => {
+    const sourceText = getSourceText(sourceCode);
+    const indent = getLineIndent(sourceText, node.range[0]);
+    const lineSeparator = getLineSeparator(sourceText);
+    return declarations
+        .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)
+        .join(`${lineSeparator}${indent}`);
+};
+export { buildReplacement, canFix, getRangedDeclarations, getSourceCode, getSourceText, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-utilities.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  FixableVariableDeclarationNode,\n  ForInOrOfStatementNode,\n  ForStatementNode,\n  RangedVariableDeclaratorNode,\n  SourceCodeAccess,\n  VariableDeclarationNode,\n  VariableDeclaratorNode,\n} from \"./types\";\n\nimport { hasFixData, hasRange } from \"./types\";\n\n/** Matches comment syntax between declarators. */\nconst commentPattern = /\\/\\/|\\/\\*/u;\n/** Declaration kinds that can be safely split into standalone statements. */\nconst fixableDeclarationKinds = new Set([\"const\", \"let\", \"var\"]);\n/** Loop parent types whose initializers cannot be safely split. */\nconst loopParentTypes = new Set([\n  \"ForAwaitOfStatement\",\n  \"ForInStatement\",\n  \"ForOfStatement\",\n]);\n\n/**\n * Gets the source access wrapper from the ESLint context.\n * @param context Rule execution context.\n * @returns Source access helpers used by the fixer.\n * @example\n * ```typescript\n * const sourceCode = getSourceCode(context);\n * ```\n */\nconst getSourceCode = (context: Rule.RuleContext): SourceCodeAccess =>\n  context.sourceCode as unknown as SourceCodeAccess;\n\n/**\n * Reads the full source text for the active file.\n * @param sourceCode Source access wrapper.\n * @returns Full source text.\n * @example\n * ```typescript\n * const sourceText = getSourceText(sourceCode);\n * ```\n */\nconst getSourceText = (sourceCode: SourceCodeAccess): string =>\n  typeof sourceCode.text === \"string\" ? sourceCode.text : sourceCode.getText();\n\n/**\n * Gets the line separator style used by the current source file.\n * @param sourceText Full source text.\n * @returns File-native line separator sequence.\n * @example\n * ```typescript\n * const lineSeparator = getLineSeparator(\"const a = 1;\\r\\nconst b = 2;\");\n * ```\n */\nconst getLineSeparator = (sourceText: string): string =>\n  sourceText.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n\n/**\n * Determines whether a declaration is used as a loop initializer.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is attached to a loop initializer.\n * @example\n * ```typescript\n * const inLoop = isLoopInitializer(node);\n * ```\n */\nconst isLoopInitializer = (node: VariableDeclarationNode): boolean => {\n  const { parent } = node;\n\n  if (parent?.type === \"ForStatement\") {\n    return (parent as ForStatementNode).init === node;\n  }\n\n  if (parent !== void 0 && loopParentTypes.has(parent.type)) {\n    return (parent as ForInOrOfStatementNode).left === node;\n  }\n\n  return false;\n};\n\n/**\n * Determines whether a declaration is wrapped in an export statement.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is directly exported.\n * @example\n * ```typescript\n * const exported = isWrappedExport(node);\n * ```\n */\nconst isWrappedExport = (node: VariableDeclarationNode): boolean =>\n  node.parent?.type === \"ExportDefaultDeclaration\" ||\n  node.parent?.type === \"ExportNamedDeclaration\";\n\n/**\n * Determines whether a declaration is ambient in TypeScript source.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is marked with `declare`.\n * @example\n * ```typescript\n * const ambient = isTypeScriptAmbientDeclaration(node);\n * ```\n */\nconst isTypeScriptAmbientDeclaration = (\n  node: VariableDeclarationNode,\n): boolean => node.declare === true;\n\n/**\n * Determines whether a declaration kind is safe to rewrite.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration kind supports conservative split fixes.\n * @example\n * ```typescript\n * const safeKind = hasFixableDeclarationKind(node);\n * ```\n */\nconst hasFixableDeclarationKind = (node: VariableDeclarationNode): boolean =>\n  hasFixData(node) && fixableDeclarationKinds.has(node.kind);\n\n/**\n * Gets the indentation for the line containing a declaration.\n * @param sourceText Full source text.\n * @param start Start offset of the declaration.\n * @returns Leading indentation for the declaration line.\n * @example\n * ```typescript\n * const indent = getLineIndent(\"const a = 1;\", 0);\n * ```\n */\nconst getLineIndent = (sourceText: string, start: number): string => {\n  const lineStart = sourceText.lastIndexOf(\"\\n\", start - 1) + 1;\n  const linePrefix = sourceText.slice(lineStart, start);\n  let indentLength = 0;\n\n  while (indentLength < linePrefix.length) {\n    const currentCharacter = linePrefix[indentLength];\n\n    if (currentCharacter !== \"\\t\" && currentCharacter !== \" \") {\n      break;\n    }\n\n    indentLength += 1;\n  }\n\n  return linePrefix.slice(0, indentLength);\n};\n\n/**\n * Detects whether comments appear between declarators.\n * @param declarations Declarators from a single declaration statement.\n * @param sourceText Full source text.\n * @returns Whether comments appear between declarators.\n * @example\n * ```typescript\n * const blocked = hasSeparatorComment(declarations, sourceText);\n * ```\n */\nconst hasSeparatorComment = (\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  for (const [index, declaration] of declarations.entries()) {\n    const nextDeclaration = declarations[index + 1];\n\n    if (nextDeclaration === void 0) {\n      break;\n    }\n\n    if (!hasRange(declaration) || !hasRange(nextDeclaration)) {\n      return true;\n    }\n\n    const separatorText = sourceText.slice(\n      declaration.range[1],\n      nextDeclaration.range[0],\n    );\n\n    if (commentPattern.test(separatorText)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Collects ranged declarators when every declarator exposes a range.\n * @param declarations Declarators from the declaration node.\n * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.\n * @example\n * ```typescript\n * const ranged = getRangedDeclarations(node.declarations ?? []);\n * ```\n */\nconst getRangedDeclarations = (\n  declarations: readonly VariableDeclaratorNode[],\n): readonly RangedVariableDeclaratorNode[] | undefined => {\n  const rangedDeclarations: RangedVariableDeclaratorNode[] = [];\n\n  for (const declaration of declarations) {\n    if (!hasRange(declaration)) {\n      return void 0;\n    }\n\n    rangedDeclarations.push(declaration);\n  }\n\n  return rangedDeclarations;\n};\n\n/**\n * Determines whether a declaration can be safely rewritten.\n * @param node Declaration node to inspect.\n * @param declarations Declarators within the declaration.\n * @param sourceText Full source text.\n * @returns Whether the declaration is safe to autofix.\n * @example\n * ```typescript\n * const fixable = canFix(node, declarations, sourceText);\n * ```\n */\nconst canFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  if (!hasFixData(node)) {\n    return false;\n  }\n\n  if (\n    !hasFixableDeclarationKind(node) ||\n    isTypeScriptAmbientDeclaration(node)\n  ) {\n    return false;\n  }\n\n  if (isLoopInitializer(node) || isWrappedExport(node)) {\n    return false;\n  }\n\n  return !hasSeparatorComment(declarations, sourceText);\n};\n\n/**\n * Converts declarators into separate declaration statements.\n * @param node Fixable declaration node.\n * @param declarations Declarators that should be split.\n * @param sourceCode Source access wrapper.\n * @returns Replacement text for the full declaration.\n * @example\n * ```typescript\n * const replacement = buildReplacement(node, declarations, sourceCode);\n * ```\n */\nconst buildReplacement = (\n  node: FixableVariableDeclarationNode,\n  declarations: readonly RangedVariableDeclaratorNode[],\n  sourceCode: SourceCodeAccess,\n): string => {\n  const sourceText = getSourceText(sourceCode);\n  const indent = getLineIndent(sourceText, node.range[0]);\n  const lineSeparator = getLineSeparator(sourceText);\n\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`${lineSeparator}${indent}`);\n};\n\nexport {\n  buildReplacement,\n  canFix,\n  getRangedDeclarations,\n  getSourceCode,\n  getSourceText,\n};\n"]}

package/dist/domain/core/no-multiple-declarators/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA+UnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAuBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgFnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAqBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule.js

@@ -1,205 +1,5 @@
-import { hasFixData, hasRange } from "./types.js";
-/** Matches comment syntax between declarators. */
-const commentPattern = /\/\/|\/\*/u;
-/** Declaration kinds that can be safely split into standalone statements. */
-const fixableDeclarationKinds = new Set(["const", "let", "var"]);
-/** Loop parent types whose initializers cannot be safely split. */
-const loopParentTypes = new Set([
-    "ForAwaitOfStatement",
-    "ForInStatement",
-    "ForOfStatement",
-]);
-/**
- * Gets the source access wrapper from the ESLint context.
- * @param context Rule execution context.
- * @returns Source access helpers used by the fixer.
- * @example
- * ```typescript
- * const sourceCode = getSourceCode(context);
- * ```
- */
-const getSourceCode = (context) => context.sourceCode;
-/**
- * Reads the full source text for the active file.
- * @param sourceCode Source access wrapper.
- * @returns Full source text.
- * @example
- * ```typescript
- * const sourceText = getSourceText(sourceCode);
- * ```
- */
-const getSourceText = (sourceCode) => typeof sourceCode.text === "string" ? sourceCode.text : sourceCode.getText();
-/**
- * Gets the line separator style used by the current source file.
- * @param sourceText Full source text.
- * @returns File-native line separator sequence.
- * @example
- * ```typescript
- * const lineSeparator = getLineSeparator("const a = 1;\r\nconst b = 2;");
- * ```
- */
-const getLineSeparator = (sourceText) => sourceText.includes("\r\n") ? "\r\n" : "\n";
-/**
- * Determines whether a declaration is used as a loop initializer.
- * @param node Declaration node to inspect.
- * @returns Whether the declaration is attached to a loop initializer.
- * @example
- * ```typescript
- * const inLoop = isLoopInitializer(node);
- * ```
- */
-const isLoopInitializer = (node) => {
-    const { parent } = node;
-    if (parent?.type === "ForStatement") {
-        return parent.init === node;
-    }
-    if (parent !== void 0 && loopParentTypes.has(parent.type)) {
-        return parent.left === node;
-    }
-    return false;
-};
-/**
- * Determines whether a declaration is wrapped in an export statement.
- * @param node Declaration node to inspect.
- * @returns Whether the declaration is directly exported.
- * @example
- * ```typescript
- * const exported = isWrappedExport(node);
- * ```
- */
-const isWrappedExport = (node) => node.parent?.type === "ExportDefaultDeclaration" ||
-    node.parent?.type === "ExportNamedDeclaration";
-/**
- * Determines whether a declaration is ambient in TypeScript source.
- * @param node Declaration node to inspect.
- * @returns Whether the declaration is marked with `declare`.
- * @example
- * ```typescript
- * const ambient = isTypeScriptAmbientDeclaration(node);
- * ```
- */
-const isTypeScriptAmbientDeclaration = (node) => node.declare === true;
-/**
- * Determines whether a declaration kind is safe to rewrite.
- * @param node Declaration node to inspect.
- * @returns Whether the declaration kind supports conservative split fixes.
- * @example
- * ```typescript
- * const safeKind = hasFixableDeclarationKind(node);
- * ```
- */
-const hasFixableDeclarationKind = (node) => hasFixData(node) && fixableDeclarationKinds.has(node.kind);
-/**
- * Gets the indentation for the line containing a declaration.
- * @param sourceText Full source text.
- * @param start Start offset of the declaration.
- * @returns Leading indentation for the declaration line.
- * @example
- * ```typescript
- * const indent = getLineIndent("const a = 1;", 0);
- * ```
- */
-const getLineIndent = (sourceText, start) => {
-    const lineStart = sourceText.lastIndexOf("\n", start - 1) + 1;
-    const linePrefix = sourceText.slice(lineStart, start);
-    let indentLength = 0;
-    while (indentLength < linePrefix.length) {
-        const currentCharacter = linePrefix[indentLength];
-        if (currentCharacter !== "\t" && currentCharacter !== " ") {
-            break;
-        }
-        indentLength += 1;
-    }
-    return linePrefix.slice(0, indentLength);
-};
-/**
- * Detects whether comments appear between declarators.
- * @param declarations Declarators from a single declaration statement.
- * @param sourceText Full source text.
- * @returns Whether comments appear between declarators.
- * @example
- * ```typescript
- * const blocked = hasSeparatorComment(declarations, sourceText);
- * ```
- */
-const hasSeparatorComment = (declarations, sourceText) => {
-    for (const [index, declaration] of declarations.entries()) {
-        const nextDeclaration = declarations[index + 1];
-        if (nextDeclaration === void 0) {
-            break;
-        }
-        if (!hasRange(declaration) || !hasRange(nextDeclaration)) {
-            return true;
-        }
-        const separatorText = sourceText.slice(declaration.range[1], nextDeclaration.range[0]);
-        if (commentPattern.test(separatorText)) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Determines whether a declaration can be safely rewritten.
- * @param node Declaration node to inspect.
- * @param declarations Declarators within the declaration.
- * @param sourceText Full source text.
- * @returns Whether the declaration is safe to autofix.
- * @example
- * ```typescript
- * const fixable = canFix(node, declarations, sourceText);
- * ```
- */
-const canFix = (node, declarations, sourceText) => {
-    if (!hasFixData(node)) {
-        return false;
-    }
-    if (!hasFixableDeclarationKind(node) ||
-        isTypeScriptAmbientDeclaration(node)) {
-        return false;
-    }
-    if (isLoopInitializer(node) || isWrappedExport(node)) {
-        return false;
-    }
-    return !hasSeparatorComment(declarations, sourceText);
-};
-/**
- * Converts declarators into separate declaration statements.
- * @param node Fixable declaration node.
- * @param declarations Declarators that should be split.
- * @param sourceCode Source access wrapper.
- * @returns Replacement text for the full declaration.
- * @example
- * ```typescript
- * const replacement = buildReplacement(node, declarations, sourceCode);
- * ```
- */
-const buildReplacement = (node, declarations, sourceCode) => {
-    const sourceText = getSourceText(sourceCode);
-    const indent = getLineIndent(sourceText, node.range[0]);
-    const lineSeparator = getLineSeparator(sourceText);
-    return declarations
-        .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)
-        .join(`${lineSeparator}${indent}`);
-};
-/**
- * Collects ranged declarators when every declarator exposes a range.
- * @param declarations Declarators from the declaration node.
- * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.
- * @example
- * ```typescript
- * const ranged = getRangedDeclarations(node.declarations ?? []);
- * ```
- */
-const getRangedDeclarations = (declarations) => {
-    const rangedDeclarations = [];
-    for (const declaration of declarations) {
-        if (!hasRange(declaration)) {
-            return void 0;
-        }
-        rangedDeclarations.push(declaration);
-    }
-    return rangedDeclarations;
-};
+import { buildReplacement, canFix, getRangedDeclarations, getSourceCode, getSourceText, } from "./rule-utilities.js";
+import { hasFixData } from "./types.js";
 /**
  * Creates an autofix callback when the declaration can be rewritten safely.
  * @param node Declaration node to inspect.
@@ -239,20 +39,18 @@ const reportVariableDeclaration = (context, node) => {
     const sourceCode = getSourceCode(context);
     const fix = createDeclarationFix(node, declarations, sourceCode);
     context.report({
-        ...(fix === void 0 ? {} : { fix }),
+        ...(fix !== void 0 && { fix }),
         messageId: "singleDeclarator",
         node: node,
     });
 };
 /** ESLint rule implementation for single-declarator variable statements. */
 const noMultipleDeclaratorsRule = {
-    create(context) {
-        return {
-            VariableDeclaration: (node) => {
-                reportVariableDeclaration(context, node);
-            },
-        };
-    },
+    create: (context) => ({
+        VariableDeclaration: (node) => {
+            reportVariableDeclaration(context, node);
+        },
+    }),
     meta: {
         docs: {
             description: "Require variable declarations to contain exactly one declarator per statement.",
@@ -268,4 +66,4 @@ const noMultipleDeclaratorsRule = {
     },
 };
 export { noMultipleDeclaratorsRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  FixableVariableDeclarationNode,\n  ForInOrOfStatementNode,\n  ForStatementNode,\n  RangedVariableDeclaratorNode,\n  SourceCodeAccess,\n  VariableDeclarationNode,\n  VariableDeclaratorNode,\n} from \"./types\";\n\nimport { hasFixData, hasRange } from \"./types\";\n\n/** Matches comment syntax between declarators. */\nconst commentPattern = /\\/\\/|\\/\\*/u;\n/** Declaration kinds that can be safely split into standalone statements. */\nconst fixableDeclarationKinds = new Set([\"const\", \"let\", \"var\"]);\n/** Loop parent types whose initializers cannot be safely split. */\nconst loopParentTypes = new Set([\n  \"ForAwaitOfStatement\",\n  \"ForInStatement\",\n  \"ForOfStatement\",\n]);\n\n/**\n * Gets the source access wrapper from the ESLint context.\n * @param context Rule execution context.\n * @returns Source access helpers used by the fixer.\n * @example\n * ```typescript\n * const sourceCode = getSourceCode(context);\n * ```\n */\nconst getSourceCode = (context: Rule.RuleContext): SourceCodeAccess =>\n  context.sourceCode as unknown as SourceCodeAccess;\n\n/**\n * Reads the full source text for the active file.\n * @param sourceCode Source access wrapper.\n * @returns Full source text.\n * @example\n * ```typescript\n * const sourceText = getSourceText(sourceCode);\n * ```\n */\nconst getSourceText = (sourceCode: SourceCodeAccess): string =>\n  typeof sourceCode.text === \"string\" ? sourceCode.text : sourceCode.getText();\n\n/**\n * Gets the line separator style used by the current source file.\n * @param sourceText Full source text.\n * @returns File-native line separator sequence.\n * @example\n * ```typescript\n * const lineSeparator = getLineSeparator(\"const a = 1;\\r\\nconst b = 2;\");\n * ```\n */\nconst getLineSeparator = (sourceText: string): string =>\n  sourceText.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n\n/**\n * Determines whether a declaration is used as a loop initializer.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is attached to a loop initializer.\n * @example\n * ```typescript\n * const inLoop = isLoopInitializer(node);\n * ```\n */\nconst isLoopInitializer = (node: VariableDeclarationNode): boolean => {\n  const { parent } = node;\n\n  if (parent?.type === \"ForStatement\") {\n    return (parent as ForStatementNode).init === node;\n  }\n\n  if (parent !== void 0 && loopParentTypes.has(parent.type)) {\n    return (parent as ForInOrOfStatementNode).left === node;\n  }\n\n  return false;\n};\n\n/**\n * Determines whether a declaration is wrapped in an export statement.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is directly exported.\n * @example\n * ```typescript\n * const exported = isWrappedExport(node);\n * ```\n */\nconst isWrappedExport = (node: VariableDeclarationNode): boolean =>\n  node.parent?.type === \"ExportDefaultDeclaration\" ||\n  node.parent?.type === \"ExportNamedDeclaration\";\n\n/**\n * Determines whether a declaration is ambient in TypeScript source.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is marked with `declare`.\n * @example\n * ```typescript\n * const ambient = isTypeScriptAmbientDeclaration(node);\n * ```\n */\nconst isTypeScriptAmbientDeclaration = (\n  node: VariableDeclarationNode,\n): boolean => node.declare === true;\n\n/**\n * Determines whether a declaration kind is safe to rewrite.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration kind supports conservative split fixes.\n * @example\n * ```typescript\n * const safeKind = hasFixableDeclarationKind(node);\n * ```\n */\nconst hasFixableDeclarationKind = (node: VariableDeclarationNode): boolean =>\n  hasFixData(node) && fixableDeclarationKinds.has(node.kind);\n\n/**\n * Gets the indentation for the line containing a declaration.\n * @param sourceText Full source text.\n * @param start Start offset of the declaration.\n * @returns Leading indentation for the declaration line.\n * @example\n * ```typescript\n * const indent = getLineIndent(\"const a = 1;\", 0);\n * ```\n */\nconst getLineIndent = (sourceText: string, start: number): string => {\n  const lineStart = sourceText.lastIndexOf(\"\\n\", start - 1) + 1;\n  const linePrefix = sourceText.slice(lineStart, start);\n  let indentLength = 0;\n\n  while (indentLength < linePrefix.length) {\n    const currentCharacter = linePrefix[indentLength];\n\n    if (currentCharacter !== \"\\t\" && currentCharacter !== \" \") {\n      break;\n    }\n\n    indentLength += 1;\n  }\n\n  return linePrefix.slice(0, indentLength);\n};\n\n/**\n * Detects whether comments appear between declarators.\n * @param declarations Declarators from a single declaration statement.\n * @param sourceText Full source text.\n * @returns Whether comments appear between declarators.\n * @example\n * ```typescript\n * const blocked = hasSeparatorComment(declarations, sourceText);\n * ```\n */\nconst hasSeparatorComment = (\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  for (const [index, declaration] of declarations.entries()) {\n    const nextDeclaration = declarations[index + 1];\n\n    if (nextDeclaration === void 0) {\n      break;\n    }\n\n    if (!hasRange(declaration) || !hasRange(nextDeclaration)) {\n      return true;\n    }\n\n    const separatorText = sourceText.slice(\n      declaration.range[1],\n      nextDeclaration.range[0],\n    );\n\n    if (commentPattern.test(separatorText)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Determines whether a declaration can be safely rewritten.\n * @param node Declaration node to inspect.\n * @param declarations Declarators within the declaration.\n * @param sourceText Full source text.\n * @returns Whether the declaration is safe to autofix.\n * @example\n * ```typescript\n * const fixable = canFix(node, declarations, sourceText);\n * ```\n */\nconst canFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  if (!hasFixData(node)) {\n    return false;\n  }\n\n  if (\n    !hasFixableDeclarationKind(node) ||\n    isTypeScriptAmbientDeclaration(node)\n  ) {\n    return false;\n  }\n\n  if (isLoopInitializer(node) || isWrappedExport(node)) {\n    return false;\n  }\n\n  return !hasSeparatorComment(declarations, sourceText);\n};\n\n/**\n * Converts declarators into separate declaration statements.\n * @param node Fixable declaration node.\n * @param declarations Declarators that should be split.\n * @param sourceCode Source access wrapper.\n * @returns Replacement text for the full declaration.\n * @example\n * ```typescript\n * const replacement = buildReplacement(node, declarations, sourceCode);\n * ```\n */\nconst buildReplacement = (\n  node: FixableVariableDeclarationNode,\n  declarations: readonly RangedVariableDeclaratorNode[],\n  sourceCode: SourceCodeAccess,\n): string => {\n  const sourceText = getSourceText(sourceCode);\n  const indent = getLineIndent(sourceText, node.range[0]);\n  const lineSeparator = getLineSeparator(sourceText);\n\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`${lineSeparator}${indent}`);\n};\n\n/**\n * Collects ranged declarators when every declarator exposes a range.\n * @param declarations Declarators from the declaration node.\n * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.\n * @example\n * ```typescript\n * const ranged = getRangedDeclarations(node.declarations ?? []);\n * ```\n */\nconst getRangedDeclarations = (\n  declarations: readonly VariableDeclaratorNode[],\n): readonly RangedVariableDeclaratorNode[] | undefined => {\n  const rangedDeclarations: RangedVariableDeclaratorNode[] = [];\n\n  for (const declaration of declarations) {\n    if (!hasRange(declaration)) {\n      return void 0;\n    }\n\n    rangedDeclarations.push(declaration);\n  }\n\n  return rangedDeclarations;\n};\n\n/**\n * Creates an autofix callback when the declaration can be rewritten safely.\n * @param node Declaration node to inspect.\n * @param declarations Declarators from the declaration statement.\n * @param sourceCode Source access wrapper.\n * @returns Fix callback when the declaration is safe to split.\n * @example\n * ```typescript\n * const fix = createDeclarationFix(node, declarations, sourceCode);\n * ```\n */\nconst createDeclarationFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceCode: SourceCodeAccess,\n): ((fixer: Rule.RuleFixer) => Rule.Fix) | undefined => {\n  const sourceText = getSourceText(sourceCode);\n\n  if (!canFix(node, declarations, sourceText) || !hasFixData(node)) {\n    return void 0;\n  }\n\n  const rangedDeclarations = getRangedDeclarations(declarations);\n  if (rangedDeclarations === void 0) {\n    return void 0;\n  }\n\n  return (fixer: Rule.RuleFixer): Rule.Fix =>\n    fixer.replaceTextRange(\n      node.range,\n      buildReplacement(node, rangedDeclarations, sourceCode),\n    );\n};\n\n/**\n * Reports declarations that contain more than one declarator.\n * @param context Rule execution context.\n * @param node Declaration node to report.\n * @example\n * ```typescript\n * reportVariableDeclaration(context, node);\n * ```\n */\nconst reportVariableDeclaration = (\n  context: Rule.RuleContext,\n  node: VariableDeclarationNode,\n): void => {\n  const declarations = node.declarations ?? [];\n\n  if (declarations.length <= 1) {\n    return;\n  }\n\n  const sourceCode = getSourceCode(context);\n  const fix = createDeclarationFix(node, declarations, sourceCode);\n\n  context.report({\n    ...(fix === void 0 ? {} : { fix }),\n    messageId: \"singleDeclarator\",\n    node: node as unknown as Rule.Node,\n  });\n};\n\n/** ESLint rule implementation for single-declarator variable statements. */\nconst noMultipleDeclaratorsRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      VariableDeclaration: (node: Rule.Node): void => {\n        reportVariableDeclaration(context, node as VariableDeclarationNode);\n      },\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require variable declarations to contain exactly one declarator per statement.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-multiple-declarators.md\",\n    },\n    fixable: \"code\",\n    messages: {\n      singleDeclarator:\n        \"Declare exactly one variable per declaration statement.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { noMultipleDeclaratorsRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/core/no-multiple-declarators/types.js

@@ -34,8 +34,8 @@ function hasRange(node) {
 function isRange(value) {
     return (Array.isArray(value) &&
         value.length === 2 &&
-        value.every((part) => Number.isInteger(part) && part >= 0) &&
+        value.every((part) => Number.isSafeInteger(part) && part >= 0) &&
         value[0] <= value[1]);
 }
 export { hasFixData, hasRange };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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