@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

@@ -0,0 +1,95 @@
+/** Suite name used by the fix-focused no-multiple-declarators tests. */
+const ruleFixesSuiteName = "no-multiple-declarators rule fixes";
+/**
+ * Creates a minimal fixer object for unit tests.
+ * @returns A fixer compatible with ESLint rule fix callbacks.
+ * @example Create a fixer for a captured report callback.
+ * ```typescript
+ * const fixer = createFixer();
+ * ```
+ */
+const createFixer = () => ({
+    insertTextAfter: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextAfterRange: (range, text) => ({ range, text }),
+    insertTextBefore: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextBeforeRange: (range, text) => ({ range, text }),
+    remove: (syntaxElement) => {
+        void syntaxElement;
+        return { range: [0, 0], text: "" };
+    },
+    removeRange: (range) => ({ range, text: "" }),
+    replaceText: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    replaceTextRange: (range, text) => ({ range, text }),
+});
+/**
+ * Determines whether a fix result is iterable.
+ * @param fixResult Fix result returned by an ESLint rule fixer.
+ * @returns Whether the fix result can be iterated.
+ * @example Check an iterable fix result.
+ * ```typescript
+ * const iterable = isFixIterable([{ range: [0, 0], text: "value" }]);
+ * ```
+ */
+const isFixIterable = (fixResult) => Symbol.iterator in fixResult;
+/**
+ * Collects concrete fixes from captured report entries.
+ * @param reports Captured rule reports to evaluate.
+ * @returns All concrete fixes produced by the report callbacks.
+ * @example Collect fixes from a captured report array.
+ * ```typescript
+ * const fixes = getFixes([
+ *   { fix: () => ({ range: [0, 0], text: "const value = 1;" }) },
+ * ]);
+ * ```
+ */
+const getFixes = (reports) => {
+    const fixer = createFixer();
+    const fixes = [];
+    for (const report of reports) {
+        const fixResult = report.fix?.(fixer) ?? void 0;
+        if (fixResult !== void 0) {
+            if (isFixIterable(fixResult)) {
+                fixes.push(...fixResult);
+            }
+            else {
+                fixes.push(fixResult);
+            }
+        }
+    }
+    return fixes;
+};
+/**
+ * Applies fixes to source text from the end of the file toward the start.
+ * @param sourceText Original source text.
+ * @param fixes Concrete fixes that should be applied.
+ * @returns Source text with the fixes applied.
+ * @example Apply a replacement fix to source text.
+ * ```typescript
+ * const output = applyFixes("const first = 1, second = 2;", [
+ *   { range: [0, 26], text: "const first = 1;\nconst second = 2;" },
+ * ]);
+ * ```
+ */
+const applyFixes = (sourceText, fixes) => {
+    const sortedFixes = fixes.toSorted((left, right) => right.range[0] - left.range[0]);
+    let output = sourceText;
+    for (const fix of sortedFixes) {
+        output = [
+            output.slice(0, fix.range[0]),
+            fix.text,
+            output.slice(fix.range[1]),
+        ].join("");
+    }
+    return output;
+};
+export { applyFixes, getFixes, ruleFixesSuiteName };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.fixes.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.fixes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\n/** Report shape used by fix collection helpers. */\r\ninterface FixReportEntry {\r\n  /** Fix helper value captured from a rule report. */\r\n  fix?: null | Rule.ReportFixer | undefined;\r\n}\r\n\r\n/** Result returned by a rule fixer callback. */\r\ntype FixResult = Exclude<ReturnType<Rule.ReportFixer>, null>;\r\n\r\n/** Suite name used by the fix-focused no-multiple-declarators tests. */\r\nconst ruleFixesSuiteName = \"no-multiple-declarators rule fixes\";\r\n\r\n/**\r\n * Creates a minimal fixer object for unit tests.\r\n * @returns A fixer compatible with ESLint rule fix callbacks.\r\n * @example Create a fixer for a captured report callback.\r\n * ```typescript\r\n * const fixer = createFixer();\r\n * ```\r\n */\r\nconst createFixer = (): Parameters<Rule.ReportFixer>[0] => ({\r\n  insertTextAfter: (syntaxElement, text): Rule.Fix => {\r\n    void syntaxElement;\r\n    return { range: [0, 0], text };\r\n  },\r\n  insertTextAfterRange: (range, text): Rule.Fix => ({ range, text }),\r\n  insertTextBefore: (syntaxElement, text): Rule.Fix => {\r\n    void syntaxElement;\r\n    return { range: [0, 0], text };\r\n  },\r\n  insertTextBeforeRange: (range, text): Rule.Fix => ({ range, text }),\r\n  remove: (syntaxElement): Rule.Fix => {\r\n    void syntaxElement;\r\n    return { range: [0, 0], text: \"\" };\r\n  },\r\n  removeRange: (range): Rule.Fix => ({ range, text: \"\" }),\r\n  replaceText: (syntaxElement, text): Rule.Fix => {\r\n    void syntaxElement;\r\n    return { range: [0, 0], text };\r\n  },\r\n  replaceTextRange: (range, text): Rule.Fix => ({ range, text }),\r\n});\r\n\r\n/**\r\n * Determines whether a fix result is iterable.\r\n * @param fixResult Fix result returned by an ESLint rule fixer.\r\n * @returns Whether the fix result can be iterated.\r\n * @example Check an iterable fix result.\r\n * ```typescript\r\n * const iterable = isFixIterable([{ range: [0, 0], text: \"value\" }]);\r\n * ```\r\n */\r\nconst isFixIterable = (fixResult: FixResult): fixResult is Iterable<Rule.Fix> =>\r\n  Symbol.iterator in fixResult;\r\n\r\n/**\r\n * Collects concrete fixes from captured report entries.\r\n * @param reports Captured rule reports to evaluate.\r\n * @returns All concrete fixes produced by the report callbacks.\r\n * @example Collect fixes from a captured report array.\r\n * ```typescript\r\n * const fixes = getFixes([\r\n *   { fix: () => ({ range: [0, 0], text: \"const value = 1;\" }) },\r\n * ]);\r\n * ```\r\n */\r\nconst getFixes = (reports: readonly FixReportEntry[]): Rule.Fix[] => {\r\n  const fixer = createFixer();\r\n  const fixes: Rule.Fix[] = [];\r\n\r\n  for (const report of reports) {\r\n    const fixResult = report.fix?.(fixer) ?? void 0;\r\n\r\n    if (fixResult !== void 0) {\r\n      if (isFixIterable(fixResult)) {\r\n        fixes.push(...fixResult);\r\n      } else {\r\n        fixes.push(fixResult);\r\n      }\r\n    }\r\n  }\r\n\r\n  return fixes;\r\n};\r\n\r\n/**\r\n * Applies fixes to source text from the end of the file toward the start.\r\n * @param sourceText Original source text.\r\n * @param fixes Concrete fixes that should be applied.\r\n * @returns Source text with the fixes applied.\r\n * @example Apply a replacement fix to source text.\r\n * ```typescript\r\n * const output = applyFixes(\"const first = 1, second = 2;\", [\r\n *   { range: [0, 26], text: \"const first = 1;\\nconst second = 2;\" },\r\n * ]);\r\n * ```\r\n */\r\nconst applyFixes = (sourceText: string, fixes: readonly Rule.Fix[]): string => {\r\n  const sortedFixes = fixes.toSorted(\r\n    (left, right) => right.range[0] - left.range[0],\r\n  );\r\n\r\n  let output = sourceText;\r\n\r\n  for (const fix of sortedFixes) {\r\n    output = [\r\n      output.slice(0, fix.range[0]),\r\n      fix.text,\r\n      output.slice(fix.range[1]),\r\n    ].join(\"\");\r\n  }\r\n\r\n  return output;\r\n};\r\n\r\nexport { applyFixes, getFixes, ruleFixesSuiteName };\r\n"]}

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

@@ -0,0 +1,4 @@
+/** Suite name used by the guardrail-focused no-multiple-declarators tests. */
+declare const ruleGuardrailsSuiteName = "no-multiple-declarators rule guardrails";
+export { ruleGuardrailsSuiteName };
+//# sourceMappingURL=rule.guardrails.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.guardrails.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.guardrails.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,QAAA,MAAM,uBAAuB,4CAA4C,CAAC;AAE1E,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -0,0 +1,4 @@
+/** Suite name used by the guardrail-focused no-multiple-declarators tests. */
+const ruleGuardrailsSuiteName = "no-multiple-declarators rule guardrails";
+export { ruleGuardrailsSuiteName };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5ndWFyZHJhaWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi9jb3JlL25vLW11bHRpcGxlLWRlY2xhcmF0b3JzL3J1bGUuZ3VhcmRyYWlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4RUFBOEU7QUFDOUUsTUFBTSx1QkFBdUIsR0FBRyx5Q0FBeUMsQ0FBQztBQUUxRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBTdWl0ZSBuYW1lIHVzZWQgYnkgdGhlIGd1YXJkcmFpbC1mb2N1c2VkIG5vLW11bHRpcGxlLWRlY2xhcmF0b3JzIHRlc3RzLiAqL1xyXG5jb25zdCBydWxlR3VhcmRyYWlsc1N1aXRlTmFtZSA9IFwibm8tbXVsdGlwbGUtZGVjbGFyYXRvcnMgcnVsZSBndWFyZHJhaWxzXCI7XHJcblxyXG5leHBvcnQgeyBydWxlR3VhcmRyYWlsc1N1aXRlTmFtZSB9O1xyXG4iXX0=

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

@@ -0,0 +1,219 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { hasFixData, hasRange } from "./types.js";
+/** Matches comment syntax between declarators. */
+const commentPattern = /\/\/|\/\*/u;
+/** Loop parent types whose initializers cannot be safely split. */
+const loopParentTypes = new Set(["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();
+/**
+ * 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";
+/**
+ * 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);
+    return linePrefix.replace(/[^\t ].*$/u, "");
+};
+/**
+ * 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 (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]);
+    return declarations
+        .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)
+        .join(`\n${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;
+};
+/**
+ * Creates an autofix callback when the declaration can be rewritten safely.
+ * @param node Declaration node to inspect.
+ * @param declarations Declarators from the declaration statement.
+ * @param sourceCode Source access wrapper.
+ * @returns Fix callback when the declaration is safe to split.
+ * @example
+ * ```typescript
+ * const fix = createDeclarationFix(node, declarations, sourceCode);
+ * ```
+ */
+const createDeclarationFix = (node, declarations, sourceCode) => {
+    const sourceText = getSourceText(sourceCode);
+    if (!canFix(node, declarations, sourceText) || !hasFixData(node)) {
+        return void 0;
+    }
+    const rangedDeclarations = getRangedDeclarations(declarations);
+    if (rangedDeclarations === void 0) {
+        return void 0;
+    }
+    return (fixer) => fixer.replaceTextRange(node.range, buildReplacement(node, rangedDeclarations, sourceCode));
+};
+/**
+ * Reports declarations that contain more than one declarator.
+ * @param context Rule execution context.
+ * @param node Declaration node to report.
+ * @example
+ * ```typescript
+ * reportVariableDeclaration(context, node);
+ * ```
+ */
+const reportVariableDeclaration = (context, node) => {
+    const declarations = node.declarations ?? [];
+    if (declarations.length <= 1) {
+        return;
+    }
+    const sourceCode = getSourceCode(context);
+    const fix = createDeclarationFix(node, declarations, sourceCode);
+    context.report({
+        ...(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);
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("no-multiple-declarators", "Require variable declarations to contain exactly one declarator per statement."),
+        fixable: "code",
+        messages: {
+            singleDeclarator: "Declare exactly one variable per declaration statement.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { noMultipleDeclaratorsRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/C,kDAAkD;AAClD,MAAM,cAAc,GAAG,YAAY,CAAC;AAEpC,mEAAmE;AACnE,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,aAAa,GAAG,CAAC,OAAyB,EAAoB,EAAE,CACpE,OAAO,CAAC,UAAyC,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,aAAa,GAAG,CAAC,UAA4B,EAAU,EAAE,CAC7D,OAAO,UAAU,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;AAE/E;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CAAC,IAA6B,EAAW,EAAE;IACnE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAExB,IAAI,MAAM,EAAE,IAAI,KAAK,cAAc,EAAE,CAAC;QACpC,OAAQ,MAA2B,CAAC,IAAI,KAAK,IAAI,CAAC;IACpD,CAAC;IAED,IAAI,MAAM,KAAK,KAAK,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1D,OAAQ,MAAiC,CAAC,IAAI,KAAK,IAAI,CAAC;IAC1D,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,eAAe,GAAG,CAAC,IAA6B,EAAW,EAAE,CACjE,IAAI,CAAC,MAAM,EAAE,IAAI,KAAK,0BAA0B;IAChD,IAAI,CAAC,MAAM,EAAE,IAAI,KAAK,wBAAwB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,aAAa,GAAG,CAAC,UAAkB,EAAE,KAAa,EAAU,EAAE;IAClE,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC9D,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAEtD,OAAO,UAAU,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;AAC9C,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,mBAAmB,GAAG,CAC1B,YAA+C,EAC/C,UAAkB,EACT,EAAE;IACX,KAAK,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;QAC1D,MAAM,eAAe,GAAG,YAAY,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAEhD,IAAI,eAAe,KAAK,KAAK,CAAC,EAAE,CAAC;YAC/B,MAAM;QACR,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CACpC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EACpB,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CACzB,CAAC;QAEF,IAAI,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,GAAG,CACb,IAA6B,EAC7B,YAA+C,EAC/C,UAAkB,EACT,EAAE;IACX,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,iBAAiB,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,CAAC,mBAAmB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,gBAAgB,GAAG,CACvB,IAAoC,EACpC,YAAqD,EACrD,UAA4B,EACpB,EAAE;IACV,MAAM,UAAU,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAExD,OAAO,YAAY;SAChB,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC;SACxE,IAAI,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC;AACzB,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAAG,CAC5B,YAA+C,EACM,EAAE;IACvD,MAAM,kBAAkB,GAAmC,EAAE,CAAC;IAE9D,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3B,OAAO,KAAK,CAAC,CAAC;QAChB,CAAC;QAED,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;IAED,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,oBAAoB,GAAG,CAC3B,IAA6B,EAC7B,YAA+C,EAC/C,UAA4B,EACuB,EAAE;IACrD,MAAM,UAAU,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;IAE7C,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACjE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAAC;IAC/D,IAAI,kBAAkB,KAAK,KAAK,CAAC,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,OAAO,CAAC,KAAqB,EAAY,EAAE,CACzC,KAAK,CAAC,gBAAgB,CACpB,IAAI,CAAC,KAAK,EACV,gBAAgB,CAAC,IAAI,EAAE,kBAAkB,EAAE,UAAU,CAAC,CACvD,CAAC;AACN,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,yBAAyB,GAAG,CAChC,OAAyB,EACzB,IAA6B,EACvB,EAAE;IACR,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC;IAE7C,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO;IACT,CAAC;IAED,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,GAAG,GAAG,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAEjE,OAAO,CAAC,MAAM,CAAC;QACb,GAAG,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC;QAClC,SAAS,EAAE,kBAAkB;QAC7B,IAAI,EAAE,IAA4B;KACnC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,4EAA4E;AAC5E,MAAM,yBAAyB,GAAoB;IACjD,MAAM,CAAC,OAAyB;QAC9B,OAAO;YACL,mBAAmB,EAAE,CAAC,IAAe,EAAQ,EAAE;gBAC7C,yBAAyB,CAAC,OAAO,EAAE,IAA+B,CAAC,CAAC;YACtE,CAAC;SACF,CAAC;IACJ,CAAC;IACD,IAAI,EAAE;QACJ,IAAI,EAAE,uBAAuB,CAC3B,yBAAyB,EACzB,gFAAgF,CACjF;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACR,gBAAgB,EACd,yDAAyD;SAC5D;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACnB;CACF,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC","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 { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport { hasFixData, hasRange } from \"./types\";\n\n/** Matches comment syntax between declarators. */\nconst commentPattern = /\\/\\/|\\/\\*/u;\n\n/** Loop parent types whose initializers cannot be safely split. */\nconst loopParentTypes = new Set([\"ForInStatement\", \"ForOfStatement\"]);\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 * 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 * 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\n  return linePrefix.replace(/[^\\t ].*$/u, \"\");\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 (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\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`\\n${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: createRuleDocumentation(\n      \"no-multiple-declarators\",\n      \"Require variable declarations to contain exactly one declarator per statement.\",\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"]}

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

@@ -0,0 +1,4 @@
+/** Companion marker for the mocked-types spec. */
+declare const noMultipleDeclaratorsRuleMockedTypes = true;
+export { noMultipleDeclaratorsRuleMockedTypes };
+//# sourceMappingURL=rule.mocked-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.mocked-types.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.mocked-types.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,QAAA,MAAM,oCAAoC,OAAO,CAAC;AAElD,OAAO,EAAE,oCAAoC,EAAE,CAAC"}

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

@@ -0,0 +1,4 @@
+/** Companion marker for the mocked-types spec. */
+const noMultipleDeclaratorsRuleMockedTypes = true;
+export { noMultipleDeclaratorsRuleMockedTypes };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5tb2NrZWQtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnMvcnVsZS5tb2NrZWQtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0RBQWtEO0FBQ2xELE1BQU0sb0NBQW9DLEdBQUcsSUFBSSxDQUFDO0FBRWxELE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIENvbXBhbmlvbiBtYXJrZXIgZm9yIHRoZSBtb2NrZWQtdHlwZXMgc3BlYy4gKi9cclxuY29uc3Qgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZU1vY2tlZFR5cGVzID0gdHJ1ZTtcclxuXHJcbmV4cG9ydCB7IG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGVNb2NrZWRUeXBlcyB9O1xyXG4iXX0=

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

@@ -0,0 +1,77 @@
+/** Provides the minimal node shape used by the rule. */
+interface BaseNode {
+    /** Parent node used to inspect surrounding syntax. */
+    parent?: BaseNode;
+    /** Source range used by autofix logic. */
+    range?: Range;
+    /** ESTree node type. */
+    type: string;
+}
+/** Represents a declaration that can be rewritten by the fixer. */
+interface FixableVariableDeclarationNode extends VariableDeclarationNode {
+    /** Confirmed declaration keyword. */
+    kind: string;
+    /** Confirmed source range for the full declaration. */
+    range: Range;
+}
+/** Represents a `for...in` or `for...of` statement. */
+interface ForInOrOfStatementNode extends BaseNode {
+    /** Left-hand initializer of the loop. */
+    left?: BaseNode;
+}
+/** Represents a classic `for` statement. */
+interface ForStatementNode extends BaseNode {
+    /** Initializer section of the loop. */
+    init?: BaseNode | null;
+}
+/** Represents a source range within the original file. */
+type Range = [number, number];
+/** Represents a node whose range has been confirmed. */
+interface RangedNode extends BaseNode {
+    /** Confirmed source range for the node. */
+    range: Range;
+}
+/** Represents a declarator whose range has been confirmed. */
+interface RangedVariableDeclaratorNode extends VariableDeclaratorNode {
+    /** Confirmed source range for the declarator. */
+    range: Range;
+}
+/** Exposes the source access methods used by the rule. */
+interface SourceCodeAccess {
+    /** Returns the source text for a node or the full file when omitted. */
+    getText: (node?: BaseNode) => string;
+    /** Raw source text when available from ESLint. */
+    text?: string;
+}
+/** Represents a variable declaration statement. */
+interface VariableDeclarationNode extends BaseNode {
+    /** Individual declarators contained in the declaration. */
+    declarations?: VariableDeclaratorNode[];
+    /** Declaration kind such as `const`, `let`, or `var`. */
+    kind?: string;
+}
+/** Represents a single variable declarator. */
+type VariableDeclaratorNode = BaseNode;
+/**
+ * Determines whether a declaration contains the data needed for autofix.
+ * @param node Declaration to validate.
+ * @returns Whether the declaration exposes both `kind` and `range`.
+ * @example
+ * ```typescript
+ * const fixable = hasFixData({ kind: "const", range: [0, 5], type: "VariableDeclaration" });
+ * ```
+ */
+declare function hasFixData(node: VariableDeclarationNode): node is FixableVariableDeclarationNode;
+/**
+ * Determines whether a node has a complete range.
+ * @param node Node to validate.
+ * @returns Whether the node exposes a valid two-item range.
+ * @example
+ * ```typescript
+ * const ranged = hasRange({ range: [0, 1], type: "Identifier" });
+ * ```
+ */
+declare function hasRange(node: BaseNode | undefined): node is RangedNode;
+export { hasFixData, hasRange };
+export type { FixableVariableDeclarationNode, ForInOrOfStatementNode, ForStatementNode, Range, RangedVariableDeclaratorNode, SourceCodeAccess, VariableDeclarationNode, VariableDeclaratorNode, };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/types.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,UAAU,QAAQ;IAChB,sDAAsD;IACtD,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,mEAAmE;AACnE,UAAU,8BAA+B,SAAQ,uBAAuB;IACtE,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,KAAK,EAAE,KAAK,CAAC;CACd;AAED,uDAAuD;AACvD,UAAU,sBAAuB,SAAQ,QAAQ;IAC/C,yCAAyC;IACzC,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED,4CAA4C;AAC5C,UAAU,gBAAiB,SAAQ,QAAQ;IACzC,uCAAuC;IACvC,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CACxB;AAED,0DAA0D;AAC1D,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9B,wDAAwD;AACxD,UAAU,UAAW,SAAQ,QAAQ;IACnC,2CAA2C;IAC3C,KAAK,EAAE,KAAK,CAAC;CACd;AAED,8DAA8D;AAC9D,UAAU,4BAA6B,SAAQ,sBAAsB;IACnE,iDAAiD;IACjD,KAAK,EAAE,KAAK,CAAC;CACd;AAED,0DAA0D;AAC1D,UAAU,gBAAgB;IACxB,wEAAwE;IACxE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,MAAM,CAAC;IACrC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,mDAAmD;AACnD,UAAU,uBAAwB,SAAQ,QAAQ;IAChD,2DAA2D;IAC3D,YAAY,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACxC,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,+CAA+C;AAC/C,KAAK,sBAAsB,GAAG,QAAQ,CAAC;AAEvC;;;;;;;;GAQG;AACH,iBAAS,UAAU,CACjB,IAAI,EAAE,uBAAuB,GAC5B,IAAI,IAAI,8BAA8B,CAExC;AAED;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,IAAI,UAAU,CAEhE;AAeD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;AAChC,YAAY,EACV,8BAA8B,EAC9B,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,EACL,4BAA4B,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,GACvB,CAAC"}

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

@@ -0,0 +1,38 @@
+/**
+ * Determines whether a declaration contains the data needed for autofix.
+ * @param node Declaration to validate.
+ * @returns Whether the declaration exposes both `kind` and `range`.
+ * @example
+ * ```typescript
+ * const fixable = hasFixData({ kind: "const", range: [0, 5], type: "VariableDeclaration" });
+ * ```
+ */
+function hasFixData(node) {
+    return hasRange(node) && "kind" in node && typeof node.kind === "string";
+}
+/**
+ * Determines whether a node has a complete range.
+ * @param node Node to validate.
+ * @returns Whether the node exposes a valid two-item range.
+ * @example
+ * ```typescript
+ * const ranged = hasRange({ range: [0, 1], type: "Identifier" });
+ * ```
+ */
+function hasRange(node) {
+    return isRange(node?.range);
+}
+/**
+ * Checks whether a value is a complete source range.
+ * @param value Candidate range value.
+ * @returns Whether the value is a valid source range tuple.
+ * @example
+ * ```typescript
+ * const validRange = isRange([0, 1]);
+ * ```
+ */
+function isRange(value) {
+    return Array.isArray(value);
+}
+export { hasFixData, hasRange };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/core/prefer-interface-types/index.d.ts

@@ -0,0 +1,2 @@
+export { preferInterfaceTypesRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/core/prefer-interface-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/core/prefer-interface-types/index.js

@@ -0,0 +1,2 @@
+export { preferInterfaceTypesRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvcHJlZmVyLWludGVyZmFjZS10eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUgfSBmcm9tIFwiLi9ydWxlXCI7XG4iXX0=

package/dist/domain/core/prefer-interface-types/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA4LnC,2EAA2E;AAC3E,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UA6BpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}