@codeperfect/eslint-plugin 1.0.0

package/dist/testing/require-aaa-sections/rule.js

@@ -0,0 +1,111 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { aaaPhaseOrder, analyzeTestBlock, getLineStartRange, getPhaseBoundaryComments, hasBlankLineBeforeComment, } from "../aaa";
+const requireAaaSectionsRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                reportMissingSections(context, analysis);
+                reportCodeBeforeArrange(context, analysis);
+                reportBlankLineSeparators(context, analysis);
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("require-aaa-sections", "Require strict // Arrange, // Act, and // Assert markers in supported test blocks."),
+        fixable: "code",
+        messages: {
+            blankLineBeforeSection: "Insert a blank line before the // {{section}} section comment.",
+            codeBeforeArrange: "Move setup statements below the first // Arrange section comment.",
+            missingSections: "Add the missing AAA section comments: {{sections}}.",
+        },
+        schema: [],
+        type: "layout",
+    },
+};
+function reportBlankLineSeparators(context, analysis) {
+    for (const sectionComment of getPhaseBoundaryComments(analysis)) {
+        if (hasBlankLineBeforeComment(analysis.sourceText, sectionComment.comment)) {
+            continue;
+        }
+        context.report({
+            data: { section: sectionComment.phases.join(" & ") },
+            fix: (fixer) => fixer.insertTextBeforeRange(getLineStartRange(analysis.sourceText, sectionComment.comment.loc.start.line), analysis.newline),
+            messageId: "blankLineBeforeSection",
+            node: sectionComment.comment,
+        });
+    }
+}
+function reportCodeBeforeArrange(context, analysis) {
+    const firstArrangeLine = analysis.sectionComments.find((sectionComment) => sectionComment.phases.includes("Arrange"))?.comment.loc.start.line;
+    if (firstArrangeLine === void 0) {
+        return;
+    }
+    const statementBeforeArrange = analysis.statements.find((statement) => statement.node.loc.start.line < firstArrangeLine);
+    if (statementBeforeArrange === void 0) {
+        return;
+    }
+    context.report({
+        messageId: "codeBeforeArrange",
+        node: statementBeforeArrange.node,
+    });
+}
+function reportMissingSections(context, analysis) {
+    const presentSections = new Set(analysis.sectionComments.flatMap((sectionComment) => sectionComment.phases));
+    const missingSections = ["Arrange", "Act", "Assert"].filter((phase) => !presentSections.has(phase));
+    if (missingSections.length === 0) {
+        return;
+    }
+    context.report({
+        data: { sections: missingSections.join(", ") },
+        fix: analysis.bodyLineCount >= 3
+            ? (fixer) => buildMissingSectionFixes(analysis, missingSections, fixer)
+            : null,
+        messageId: "missingSections",
+        node: analysis.callExpression,
+    });
+}
+function buildMissingSectionFixes(analysis, missingSections, fixer) {
+    if (analysis.statements.length === 0) {
+        return [];
+    }
+    const anchorMap = new Map();
+    const sourceLines = analysis.sourceText.split(/\r\n|\n/u);
+    const firstStatement = analysis.statements[0]?.node;
+    const middleStatement = analysis.statements[Math.min(analysis.statements.length - 1, Math.floor(analysis.statements.length / 2))]?.node;
+    const lastStatement = analysis.statements.at(-1)?.node;
+    for (const phase of missingSections) {
+        const anchorNode = phase === "Arrange"
+            ? firstStatement
+            : phase === "Act"
+                ? middleStatement
+                : lastStatement;
+        /* v8 ignore start -- guarded by the empty-statements early return above. */
+        if (anchorNode === void 0) {
+            continue;
+        }
+        /* v8 ignore stop */
+        const existing = anchorMap.get(anchorNode.range[0]) ?? [];
+        existing.push(phase);
+        anchorMap.set(anchorNode.range[0], existing);
+    }
+    return [...anchorMap.entries()].map(([offset, phases]) => {
+        const sortedPhases = phases.toSorted((left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right]);
+        const statementLine = analysis.sourceText
+            .slice(0, offset)
+            .split(/\r\n|\n/u).length;
+        /* v8 ignore start -- fixer anchors always point to real statement lines in analyzed test blocks. */
+        const previousLine = sourceLines[statementLine - 2] ?? "";
+        const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);
+        const needsLeadingBlankLine = sortedPhases.some((phase) => phase !== "Arrange") &&
+            previousLine.trim().length > 0;
+        const indentation = /^\s*/u.exec(sourceLines[statementLine - 1] ?? "")?.[0] ?? "";
+        /* v8 ignore stop */
+        return fixer.insertTextBeforeRange(lineStartRange, `${needsLeadingBlankLine ? analysis.newline : ""}${indentation}// ${sortedPhases.join(" & ")}${analysis.newline}`);
+    });
+}
+export { requireAaaSectionsRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/testing/require-aaa-sections/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { AaaPhase, TestBlockAnalysis } from \"../aaa\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport {\n  aaaPhaseOrder,\n  analyzeTestBlock,\n  getIndentationAtOffset,\n  getLineStartRange,\n  getPhaseBoundaryComments,\n  hasBlankLineBeforeComment,\n} from \"../aaa\";\n\nconst requireAaaSectionsRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      CallExpression(node): void {\n        const analysis = analyzeTestBlock(context, node);\n        if (analysis === void 0) {\n          return;\n        }\n\n        reportMissingSections(context, analysis);\n        reportCodeBeforeArrange(context, analysis);\n        reportBlankLineSeparators(context, analysis);\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"require-aaa-sections\",\n      \"Require strict // Arrange, // Act, and // Assert markers in supported test blocks.\",\n    ),\n    fixable: \"code\",\n    messages: {\n      blankLineBeforeSection:\n        \"Insert a blank line before the // {{section}} section comment.\",\n      codeBeforeArrange:\n        \"Move setup statements below the first // Arrange section comment.\",\n      missingSections: \"Add the missing AAA section comments: {{sections}}.\",\n    },\n    schema: [],\n    type: \"layout\",\n  },\n};\n\nfunction reportBlankLineSeparators(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  for (const sectionComment of getPhaseBoundaryComments(analysis)) {\n    if (\n      hasBlankLineBeforeComment(analysis.sourceText, sectionComment.comment)\n    ) {\n      continue;\n    }\n\n    context.report({\n      data: { section: sectionComment.phases.join(\" & \") },\n      fix: (fixer) =>\n        fixer.insertTextBeforeRange(\n          getLineStartRange(\n            analysis.sourceText,\n            sectionComment.comment.loc.start.line,\n          ),\n          analysis.newline,\n        ),\n      messageId: \"blankLineBeforeSection\",\n      node: sectionComment.comment,\n    });\n  }\n}\n\nfunction reportCodeBeforeArrange(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const firstArrangeLine = analysis.sectionComments.find((sectionComment) =>\n    sectionComment.phases.includes(\"Arrange\"),\n  )?.comment.loc.start.line;\n  if (firstArrangeLine === void 0) {\n    return;\n  }\n\n  const statementBeforeArrange = analysis.statements.find(\n    (statement) => statement.node.loc.start.line < firstArrangeLine,\n  );\n  if (statementBeforeArrange === void 0) {\n    return;\n  }\n\n  context.report({\n    messageId: \"codeBeforeArrange\",\n    node: statementBeforeArrange.node,\n  });\n}\n\nfunction reportMissingSections(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const presentSections = new Set(\n    analysis.sectionComments.flatMap((sectionComment) => sectionComment.phases),\n  );\n  const missingSections = ([\"Arrange\", \"Act\", \"Assert\"] as const).filter(\n    (phase) => !presentSections.has(phase),\n  );\n\n  if (missingSections.length === 0) {\n    return;\n  }\n\n  context.report({\n    data: { sections: missingSections.join(\", \") },\n    fix:\n      analysis.bodyLineCount >= 3\n        ? (fixer) => buildMissingSectionFixes(analysis, missingSections, fixer)\n        : null,\n    messageId: \"missingSections\",\n    node: analysis.callExpression,\n  });\n}\n\nfunction buildMissingSectionFixes(\n  analysis: TestBlockAnalysis,\n  missingSections: readonly AaaPhase[],\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  if (analysis.statements.length === 0) {\n    return [];\n  }\n\n  const anchorMap = new Map<number, AaaPhase[]>();\n  const sourceLines = analysis.sourceText.split(/\\r\\n|\\n/u);\n  const firstStatement = analysis.statements[0]?.node;\n  const middleStatement =\n    analysis.statements[\n      Math.min(\n        analysis.statements.length - 1,\n        Math.floor(analysis.statements.length / 2),\n      )\n    ]?.node;\n  const lastStatement = analysis.statements.at(-1)?.node;\n\n  for (const phase of missingSections) {\n    const anchorNode =\n      phase === \"Arrange\"\n        ? firstStatement\n        : phase === \"Act\"\n          ? middleStatement\n          : lastStatement;\n    /* v8 ignore start -- guarded by the empty-statements early return above. */\n    if (anchorNode === void 0) {\n      continue;\n    }\n    /* v8 ignore stop */\n\n    const existing = anchorMap.get(anchorNode.range[0]) ?? [];\n    existing.push(phase);\n    anchorMap.set(anchorNode.range[0], existing);\n  }\n\n  return [...anchorMap.entries()].map(([offset, phases]) => {\n    const sortedPhases = phases.toSorted(\n      (left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right],\n    );\n    const statementLine = analysis.sourceText\n      .slice(0, offset)\n      .split(/\\r\\n|\\n/u).length;\n    /* v8 ignore start -- fixer anchors always point to real statement lines in analyzed test blocks. */\n    const previousLine = sourceLines[statementLine - 2] ?? \"\";\n    const lineStartRange = getLineStartRange(\n      analysis.sourceText,\n      statementLine,\n    );\n    const needsLeadingBlankLine =\n      sortedPhases.some((phase) => phase !== \"Arrange\") &&\n      previousLine.trim().length > 0;\n    const indentation =\n      /^\\s*/u.exec(sourceLines[statementLine - 1] ?? \"\")?.[0] ?? \"\";\n    /* v8 ignore stop */\n\n    return fixer.insertTextBeforeRange(\n      lineStartRange,\n      `${needsLeadingBlankLine ? analysis.newline : \"\"}${indentation}// ${sortedPhases.join(\" & \")}${analysis.newline}`,\n    );\n  });\n}\n\nexport { requireAaaSectionsRule };\n"]}

package/dist/testing/require-act-result-capture/index.d.ts

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

package/dist/testing/require-act-result-capture/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/require-act-result-capture/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/require-act-result-capture/index.js

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

package/dist/testing/require-act-result-capture/rule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const requireActResultCaptureRule: Rule.RuleModule;
+export { requireActResultCaptureRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/testing/require-act-result-capture/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/require-act-result-capture/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,QAAA,MAAM,2BAA2B,EAAE,IAAI,CAAC,UAqCvC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/testing/require-act-result-capture/rule.js

@@ -0,0 +1,34 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { analyzeTestBlock, hasCapturableActResult } from "../aaa";
+const requireActResultCaptureRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                for (const statement of analysis.statements) {
+                    if (statement.phase !== "Act" ||
+                        !hasCapturableActResult(statement.node)) {
+                        continue;
+                    }
+                    context.report({
+                        messageId: "captureActResult",
+                        node: statement.node,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("require-act-result-capture", "Require non-void Act expressions to store the observed result before assertions."),
+        messages: {
+            captureActResult: "Capture the // Act result in a named variable before asserting on it.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { requireActResultCaptureRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/testing/require-test-companion/index.d.ts

@@ -0,0 +1,3 @@
+export { buildListenerForFilename, getOptions, } from "./require-test-companion-utilities";
+export { requireTestCompanionRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/require-test-companion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/require-test-companion/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,UAAU,GACX,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/require-test-companion/index.js

@@ -0,0 +1,3 @@
+export { buildListenerForFilename, getOptions, } from "./require-test-companion-utilities";
+export { requireTestCompanionRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9yZXF1aXJlLXRlc3QtY29tcGFuaW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCx3QkFBd0IsRUFDeEIsVUFBVSxHQUNYLE1BQU0sb0NBQW9DLENBQUM7QUFDNUMsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYnVpbGRMaXN0ZW5lckZvckZpbGVuYW1lLFxuICBnZXRPcHRpb25zLFxufSBmcm9tIFwiLi9yZXF1aXJlLXRlc3QtY29tcGFuaW9uLXV0aWxpdGllc1wiO1xuZXhwb3J0IHsgcmVxdWlyZVRlc3RDb21wYW5pb25SdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuIl19

package/dist/testing/require-test-companion/require-test-companion-listeners.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type { RequireTestCompanionState } from "./require-test-companion-options";
+/**
+ * Builds a listener for a specific filename.
+ * @param context Input context value.
+ * @param filename Input filename value.
+ * @param options Input options value.
+ * @returns Rule listener for the filename.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForFilename(context, filename, options);
+ * ```
+ */
+declare const buildListenerForFilename: (context: Rule.RuleContext, filename: string, options: RequireTestCompanionState) => Rule.RuleListener;
+export { buildListenerForFilename };
+//# sourceMappingURL=require-test-companion-listeners.d.ts.map

package/dist/testing/require-test-companion/require-test-companion-listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-test-companion-listeners.d.ts","sourceRoot":"","sources":["../../../src/testing/require-test-companion/require-test-companion-listeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAuLlF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,SAAS,IAAI,CAAC,WAAW,EACzB,UAAU,MAAM,EAChB,SAAS,yBAAyB,KACjC,IAAI,CAAC,YAuBP,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/testing/require-test-companion/require-test-companion-listeners.js

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isLintableFilename, isPathMatch, isTypeScriptFile, TYPESCRIPT_EXTENSION, } from "./require-test-companion-options";
+/**
+ * Gets the test suffix for a file name when present.
+ * @param basename Input basename value.
+ * @param testSuffixes Input testSuffixes value.
+ * @returns Matched test suffix when present.
+ * @example
+ * ```typescript
+ * const suffix = getTestSuffix("feature.spec.ts", ["spec"]);
+ * ```
+ */
+const getTestSuffix = (basename, testSuffixes) => testSuffixes.find((suffix) => basename.endsWith(`.${suffix}${TYPESCRIPT_EXTENSION}`));
+/**
+ * Checks for any test companion file in the directory.
+ * @param directory Input directory value.
+ * @param baseStem Input baseStem value.
+ * @param testSuffixes Input testSuffixes value.
+ * @returns True when any test companion exists.
+ * @example
+ * ```typescript
+ * const ok = hasAnyTestCompanion(dir, "feature", ["spec"]);
+ * ```
+ */
+const hasAnyTestCompanion = (directory, baseStem, testSuffixes) => testSuffixes.some((suffix) => fs.existsSync(path.join(directory, `${baseStem}.${suffix}.ts`)));
+/**
+ * Builds a listener that reports missing test companions.
+ * @param context Input context value.
+ * @param options Input options value.
+ * @returns Rule listener for missing tests.
+ * @example
+ * ```typescript
+ * const listener = buildMissingTestListener(context, options);
+ * ```
+ */
+const buildMissingTestListener = (context, options) => {
+    const { basename, directory, testSuffixes } = options;
+    const baseStem = basename.slice(0, -TYPESCRIPT_EXTENSION.length);
+    if (baseStem.length === 0) {
+        return {};
+    }
+    if (hasAnyTestCompanion(directory, baseStem, testSuffixes)) {
+        return {};
+    }
+    return {
+        Program(node) {
+            const testFiles = testSuffixes
+                .map((suffix) => `${baseStem}.${suffix}${TYPESCRIPT_EXTENSION}`)
+                .join(", ");
+            context.report({
+                data: { testFiles },
+                messageId: "missingTest",
+                node,
+            });
+        },
+    };
+};
+/**
+ * Builds a listener that reports missing source files.
+ * @param context Input context value.
+ * @param options Input options value.
+ * @returns Rule listener for missing sources.
+ * @example
+ * ```typescript
+ * const listener = buildMissingSourceListener(context, options);
+ * ```
+ */
+const buildMissingSourceListener = (context, options) => {
+    const { basename, directory, suffix } = options;
+    const sourceBasename = basename.slice(0, -`.${suffix}${TYPESCRIPT_EXTENSION}`.length);
+    if (sourceBasename.length === 0) {
+        return {};
+    }
+    const sourceFile = `${sourceBasename}${TYPESCRIPT_EXTENSION}`;
+    if (fs.existsSync(path.join(directory, sourceFile))) {
+        return {};
+    }
+    return {
+        Program(node) {
+            context.report({
+                data: { sourceFile },
+                messageId: "missingSource",
+                node,
+            });
+        },
+    };
+};
+/**
+ * Determines whether a file should be linted.
+ * @param filename Input filename value.
+ * @param options Input options value.
+ * @returns True when the file should be linted.
+ * @example
+ * ```typescript
+ * const ok = shouldLintFile(filename, options);
+ * ```
+ */
+const shouldLintFile = (filename, options) => {
+    const { enforceIn, ignorePatterns } = options;
+    if (!isLintableFilename(filename)) {
+        return false;
+    }
+    if (!isTypeScriptFile(filename)) {
+        return false;
+    }
+    if (!isPathMatch(filename, enforceIn)) {
+        return false;
+    }
+    return !isPathMatch(filename, ignorePatterns);
+};
+/**
+ * Builds a listener for a specific filename.
+ * @param context Input context value.
+ * @param filename Input filename value.
+ * @param options Input options value.
+ * @returns Rule listener for the filename.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForFilename(context, filename, options);
+ * ```
+ */
+const buildListenerForFilename = (context, filename, options) => {
+    if (!shouldLintFile(filename, options)) {
+        return {};
+    }
+    const basename = path.basename(filename);
+    const directory = path.dirname(filename);
+    const { testSuffixes } = options;
+    const testSuffix = getTestSuffix(basename, testSuffixes);
+    if (testSuffix !== void 0) {
+        return buildMissingSourceListener(context, {
+            basename,
+            directory,
+            suffix: testSuffix,
+        });
+    }
+    return buildMissingTestListener(context, {
+        basename,
+        directory,
+        testSuffixes,
+    });
+};
+export { buildListenerForFilename };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require-test-companion-listeners.js","sourceRoot":"","sources":["../../../src/testing/require-test-companion/require-test-companion-listeners.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\n\nimport type { RequireTestCompanionState } from \"./require-test-companion-options\";\n\nimport {\n  isLintableFilename,\n  isPathMatch,\n  isTypeScriptFile,\n  TYPESCRIPT_EXTENSION,\n} from \"./require-test-companion-options\";\n\n/** Type definition for rule data. */\ninterface MissingSourceListenerOptions {\n  /** Basename field value. */\n  basename: string;\n\n  /** Directory field value. */\n  directory: string;\n\n  /** Suffix field value. */\n  suffix: string;\n}\n\n/** Type definition for rule data. */\ninterface MissingTestListenerOptions {\n  /** Basename field value. */\n  basename: string;\n\n  /** Directory field value. */\n  directory: string;\n\n  /** TestSuffixes field value. */\n  testSuffixes: string[];\n}\n\n/**\n * Gets the test suffix for a file name when present.\n * @param basename Input basename value.\n * @param testSuffixes Input testSuffixes value.\n * @returns Matched test suffix when present.\n * @example\n * ```typescript\n * const suffix = getTestSuffix(\"feature.spec.ts\", [\"spec\"]);\n * ```\n */\nconst getTestSuffix = (\n  basename: string,\n  testSuffixes: string[],\n): string | undefined =>\n  testSuffixes.find((suffix) =>\n    basename.endsWith(`.${suffix}${TYPESCRIPT_EXTENSION}`),\n  );\n\n/**\n * Checks for any test companion file in the directory.\n * @param directory Input directory value.\n * @param baseStem Input baseStem value.\n * @param testSuffixes Input testSuffixes value.\n * @returns True when any test companion exists.\n * @example\n * ```typescript\n * const ok = hasAnyTestCompanion(dir, \"feature\", [\"spec\"]);\n * ```\n */\nconst hasAnyTestCompanion = (\n  directory: string,\n  baseStem: string,\n  testSuffixes: string[],\n): boolean =>\n  testSuffixes.some((suffix) =>\n    fs.existsSync(path.join(directory, `${baseStem}.${suffix}.ts`)),\n  );\n\n/**\n * Builds a listener that reports missing test companions.\n * @param context Input context value.\n * @param options Input options value.\n * @returns Rule listener for missing tests.\n * @example\n * ```typescript\n * const listener = buildMissingTestListener(context, options);\n * ```\n */\nconst buildMissingTestListener = (\n  context: Rule.RuleContext,\n  options: MissingTestListenerOptions,\n): Rule.RuleListener => {\n  const { basename, directory, testSuffixes } = options;\n  const baseStem = basename.slice(0, -TYPESCRIPT_EXTENSION.length);\n\n  if (baseStem.length === 0) {\n    return {};\n  }\n\n  if (hasAnyTestCompanion(directory, baseStem, testSuffixes)) {\n    return {};\n  }\n\n  return {\n    Program(node): void {\n      const testFiles = testSuffixes\n        .map((suffix) => `${baseStem}.${suffix}${TYPESCRIPT_EXTENSION}`)\n        .join(\", \");\n\n      context.report({\n        data: { testFiles },\n        messageId: \"missingTest\",\n        node,\n      });\n    },\n  };\n};\n\n/**\n * Builds a listener that reports missing source files.\n * @param context Input context value.\n * @param options Input options value.\n * @returns Rule listener for missing sources.\n * @example\n * ```typescript\n * const listener = buildMissingSourceListener(context, options);\n * ```\n */\nconst buildMissingSourceListener = (\n  context: Rule.RuleContext,\n  options: MissingSourceListenerOptions,\n): Rule.RuleListener => {\n  const { basename, directory, suffix } = options;\n  const sourceBasename = basename.slice(\n    0,\n    -`.${suffix}${TYPESCRIPT_EXTENSION}`.length,\n  );\n\n  if (sourceBasename.length === 0) {\n    return {};\n  }\n\n  const sourceFile = `${sourceBasename}${TYPESCRIPT_EXTENSION}`;\n\n  if (fs.existsSync(path.join(directory, sourceFile))) {\n    return {};\n  }\n\n  return {\n    Program(node): void {\n      context.report({\n        data: { sourceFile },\n        messageId: \"missingSource\",\n        node,\n      });\n    },\n  };\n};\n\n/**\n * Determines whether a file should be linted.\n * @param filename Input filename value.\n * @param options Input options value.\n * @returns True when the file should be linted.\n * @example\n * ```typescript\n * const ok = shouldLintFile(filename, options);\n * ```\n */\nconst shouldLintFile = (\n  filename: string,\n  options: RequireTestCompanionState,\n): boolean => {\n  const { enforceIn, ignorePatterns } = options;\n\n  if (!isLintableFilename(filename)) {\n    return false;\n  }\n\n  if (!isTypeScriptFile(filename)) {\n    return false;\n  }\n\n  if (!isPathMatch(filename, enforceIn)) {\n    return false;\n  }\n\n  return !isPathMatch(filename, ignorePatterns);\n};\n\n/**\n * Builds a listener for a specific filename.\n * @param context Input context value.\n * @param filename Input filename value.\n * @param options Input options value.\n * @returns Rule listener for the filename.\n * @example\n * ```typescript\n * const listener = buildListenerForFilename(context, filename, options);\n * ```\n */\nconst buildListenerForFilename = (\n  context: Rule.RuleContext,\n  filename: string,\n  options: RequireTestCompanionState,\n): Rule.RuleListener => {\n  if (!shouldLintFile(filename, options)) {\n    return {};\n  }\n\n  const basename = path.basename(filename);\n  const directory = path.dirname(filename);\n  const { testSuffixes } = options;\n  const testSuffix = getTestSuffix(basename, testSuffixes);\n\n  if (testSuffix !== void 0) {\n    return buildMissingSourceListener(context, {\n      basename,\n      directory,\n      suffix: testSuffix,\n    });\n  }\n\n  return buildMissingTestListener(context, {\n    basename,\n    directory,\n    testSuffixes,\n  });\n};\n\nexport { buildListenerForFilename };\n"]}

package/dist/testing/require-test-companion/require-test-companion-options.d.ts

@@ -0,0 +1,54 @@
+/** File extension used to detect TypeScript source files. */
+declare const TYPESCRIPT_EXTENSION = ".ts";
+/** Type definition for rule data. */
+interface RequireTestCompanionState {
+    /** EnforceIn field value. */
+    enforceIn: string[];
+    /** IgnorePatterns field value. */
+    ignorePatterns: string[];
+    /** TestSuffixes field value. */
+    testSuffixes: string[];
+}
+/**
+ * Checks isLintableFilename.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLintableFilename();
+ * ```
+ */
+declare const isLintableFilename: (filename: string) => boolean;
+/**
+ * Checks isTypeScriptFile.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isTypeScriptFile();
+ * ```
+ */
+declare const isTypeScriptFile: (filename: string) => boolean;
+/**
+ * Gets getOptions.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getOptions();
+ * ```
+ */
+declare const getOptions: (options: readonly unknown[]) => RequireTestCompanionState;
+/**
+ * Checks isPathMatch.
+ * @param filename Input filename value.
+ * @param patterns Input patterns value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isPathMatch();
+ * ```
+ */
+declare const isPathMatch: (filename: string, patterns: string[]) => boolean;
+export { getOptions, isLintableFilename, isPathMatch, isTypeScriptFile, type RequireTestCompanionState, TYPESCRIPT_EXTENSION, };
+//# sourceMappingURL=require-test-companion-options.d.ts.map

package/dist/testing/require-test-companion/require-test-companion-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-test-companion-options.d.ts","sourceRoot":"","sources":["../../../src/testing/require-test-companion/require-test-companion-options.ts"],"names":[],"mappings":"AAcA,6DAA6D;AAC7D,QAAA,MAAM,oBAAoB,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,UAAU,yBAAyB;IACjC,6BAA6B;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB,kCAAkC;IAClC,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB,gCAAgC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OACG,CAAC;AAEnD;;;;;;;;GAQG;AACH,QAAA,MAAM,gBAAgB,GAAI,UAAU,MAAM,KAAG,OAC2B,CAAC;AA+BzE;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,yBAcjD,CAAC;AA0BF;;;;;;;;;GASG;AACH,QAAA,MAAM,WAAW,GAAI,UAAU,MAAM,EAAE,UAAU,MAAM,EAAE,KAAG,OAc3D,CAAC;AAEF,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,KAAK,yBAAyB,EAC9B,oBAAoB,GACrB,CAAC"}

package/dist/testing/require-test-companion/require-test-companion-options.js

@@ -0,0 +1,112 @@
+import { minimatch } from "minimatch";
+import path from "node:path";
+/** Default value used by this module. */
+const DEFAULT_TEST_SUFFIXES = ["spec", "test"];
+/** Default value used by this module. */
+const DEFAULT_IGNORE_PATTERNS = ["/*.d.ts", "/index.ts"];
+/** Default folders where test companions are enforced. */
+const DEFAULT_ENFORCE_IN = ["src/**"];
+/** File extension used to detect TypeScript source files. */
+const TYPESCRIPT_EXTENSION = ".ts";
+/**
+ * Checks isLintableFilename.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLintableFilename();
+ * ```
+ */
+const isLintableFilename = (filename) => filename.length > 0 && path.isAbsolute(filename);
+/**
+ * Checks isTypeScriptFile.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isTypeScriptFile();
+ * ```
+ */
+const isTypeScriptFile = (filename) => filename.endsWith(TYPESCRIPT_EXTENSION) && !filename.endsWith(".d.ts");
+/**
+ * Normalizes a rule option into a string list.
+ * @param value Input value value.
+ * @param defaults Input defaults value.
+ * @returns Normalized list of strings.
+ * @example
+ * ```typescript
+ * const list = normalizeList("src/**", ["src/**"]);
+ * ```
+ */
+const normalizeList = (value, defaults) => {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length === 0 ? [] : [trimmed];
+    }
+    return [...defaults];
+};
+/**
+ * Gets getOptions.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getOptions();
+ * ```
+ */
+const getOptions = (options) => {
+    const rawOptions = options[0];
+    return {
+        enforceIn: normalizeList(rawOptions?.enforceIn, DEFAULT_ENFORCE_IN),
+        ignorePatterns: normalizeList(rawOptions?.ignorePatterns, DEFAULT_IGNORE_PATTERNS),
+        testSuffixes: normalizeList(rawOptions?.testSuffixes, DEFAULT_TEST_SUFFIXES),
+    };
+};
+/**
+ * Normalizes normalizeRelativePath.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeRelativePath();
+ * ```
+ */
+const normalizeRelativePath = (filename) => path.relative(process.cwd(), filename).split(path.sep).join("/");
+/**
+ * Normalizes normalizePattern.
+ * @param pattern Input pattern value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizePattern();
+ * ```
+ */
+const normalizePattern = (pattern) => pattern.startsWith("/") ? `**${pattern}` : pattern;
+/**
+ * Checks isPathMatch.
+ * @param filename Input filename value.
+ * @param patterns Input patterns value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isPathMatch();
+ * ```
+ */
+const isPathMatch = (filename, patterns) => {
+    if (patterns.length === 0) {
+        return false;
+    }
+    const relativePath = normalizeRelativePath(filename);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return false;
+    }
+    return patterns.some((pattern) => minimatch(relativePath, normalizePattern(pattern), { dot: true }));
+};
+export { getOptions, isLintableFilename, isPathMatch, isTypeScriptFile, TYPESCRIPT_EXTENSION, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require-test-companion-options.js","sourceRoot":"","sources":["../../../src/testing/require-test-companion/require-test-companion-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { minimatch } from \"minimatch\";\nimport path from \"node:path\";\n\nimport type { RequireTestCompanionOptions } from \"./types\";\n\n/** Default value used by this module. */\nconst DEFAULT_TEST_SUFFIXES = [\"spec\", \"test\"] as const;\n\n/** Default value used by this module. */\nconst DEFAULT_IGNORE_PATTERNS = [\"/*.d.ts\", \"/index.ts\"] as const;\n\n/** Default folders where test companions are enforced. */\nconst DEFAULT_ENFORCE_IN = [\"src/**\"] as const;\n\n/** File extension used to detect TypeScript source files. */\nconst TYPESCRIPT_EXTENSION = \".ts\";\n\n/** Type definition for rule data. */\ninterface RequireTestCompanionState {\n  /** EnforceIn field value. */\n  enforceIn: string[];\n\n  /** IgnorePatterns field value. */\n  ignorePatterns: string[];\n\n  /** TestSuffixes field value. */\n  testSuffixes: string[];\n}\n\n/**\n * Checks isLintableFilename.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isLintableFilename();\n * ```\n */\nconst isLintableFilename = (filename: string): boolean =>\n  filename.length > 0 && path.isAbsolute(filename);\n\n/**\n * Checks isTypeScriptFile.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isTypeScriptFile();\n * ```\n */\nconst isTypeScriptFile = (filename: string): boolean =>\n  filename.endsWith(TYPESCRIPT_EXTENSION) && !filename.endsWith(\".d.ts\");\n\n/**\n * Normalizes a rule option into a string list.\n * @param value Input value value.\n * @param defaults Input defaults value.\n * @returns Normalized list of strings.\n * @example\n * ```typescript\n * const list = normalizeList(\"src/**\", [\"src/**\"]);\n * ```\n */\nconst normalizeList = (\n  value: RequireTestCompanionOptions[keyof RequireTestCompanionOptions],\n  defaults: readonly string[],\n): string[] => {\n  if (Array.isArray(value)) {\n    return value\n      .filter((entry): entry is string => typeof entry === \"string\")\n      .map((entry) => entry.trim())\n      .filter((entry) => entry.length > 0);\n  }\n\n  if (typeof value === \"string\") {\n    const trimmed = value.trim();\n    return trimmed.length === 0 ? [] : [trimmed];\n  }\n\n  return [...defaults];\n};\n\n/**\n * Gets getOptions.\n * @param options Input options value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getOptions();\n * ```\n */\nconst getOptions = (options: readonly unknown[]): RequireTestCompanionState => {\n  const rawOptions = options[0] as RequireTestCompanionOptions | undefined;\n\n  return {\n    enforceIn: normalizeList(rawOptions?.enforceIn, DEFAULT_ENFORCE_IN),\n    ignorePatterns: normalizeList(\n      rawOptions?.ignorePatterns,\n      DEFAULT_IGNORE_PATTERNS,\n    ),\n    testSuffixes: normalizeList(\n      rawOptions?.testSuffixes,\n      DEFAULT_TEST_SUFFIXES,\n    ),\n  };\n};\n\n/**\n * Normalizes normalizeRelativePath.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeRelativePath();\n * ```\n */\nconst normalizeRelativePath = (filename: string): string =>\n  path.relative(process.cwd(), filename).split(path.sep).join(\"/\");\n\n/**\n * Normalizes normalizePattern.\n * @param pattern Input pattern value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizePattern();\n * ```\n */\nconst normalizePattern = (pattern: string): string =>\n  pattern.startsWith(\"/\") ? `**${pattern}` : pattern;\n\n/**\n * Checks isPathMatch.\n * @param filename Input filename value.\n * @param patterns Input patterns value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isPathMatch();\n * ```\n */\nconst isPathMatch = (filename: string, patterns: string[]): boolean => {\n  if (patterns.length === 0) {\n    return false;\n  }\n\n  const relativePath = normalizeRelativePath(filename);\n\n  if (relativePath.startsWith(\"..\") || path.isAbsolute(relativePath)) {\n    return false;\n  }\n\n  return patterns.some((pattern) =>\n    minimatch(relativePath, normalizePattern(pattern), { dot: true }),\n  );\n};\n\nexport {\n  getOptions,\n  isLintableFilename,\n  isPathMatch,\n  isTypeScriptFile,\n  type RequireTestCompanionState,\n  TYPESCRIPT_EXTENSION,\n};\n"]}

package/dist/testing/require-test-companion/require-test-companion-test-helpers.d.ts

@@ -0,0 +1,51 @@
+import type { RequireTestCompanionOptions } from "./types";
+/** Type definition for rule data. */
+interface RuleReport {
+    /** MessageId helper value. */
+    messageId: string | undefined;
+}
+/**
+ * Creates createTemporaryFile.
+ * @param root Input root value.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createTemporaryFile();
+ * ```
+ */
+declare const createTemporaryFile: (root: "src" | "tmp", filename: string) => string;
+/**
+ * Creates a temporary file pair for test/source combinations.
+ * @param root Input root value.
+ * @param first Input first value.
+ * @param second Input second value.
+ * @returns Tuple of created file paths.
+ * @throws {Error} When the file paths are missing.
+ * @example
+ * ```typescript
+ * const [source, test] = createTemporaryPair("tmp", "a.ts", "a.spec.ts");
+ * ```
+ */
+declare const createTemporaryPair: (root: "src" | "tmp", first: string, second: string) => [string, string];
+/**
+ * Runs the rule with the given options.
+ * @param filename Input filename value.
+ * @param options Input options value.
+ * @returns Collected rule reports.
+ * @example
+ * ```typescript
+ * const reports = runRule("/tmp/feature.ts");
+ * ```
+ */
+declare const runRule: (filename: string, options?: RequireTestCompanionOptions) => RuleReport[];
+/**
+ * Cleans up temporary directories created by tests.
+ * @example
+ * ```typescript
+ * cleanupTemporaryDirectories();
+ * ```
+ */
+declare const cleanupTemporaryDirectories: () => void;
+export { cleanupTemporaryDirectories, createTemporaryFile, createTemporaryPair, runRule, };
+//# sourceMappingURL=require-test-companion-test-helpers.d.ts.map

package/dist/testing/require-test-companion/require-test-companion-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-test-companion-test-helpers.d.ts","sourceRoot":"","sources":["../../../src/testing/require-test-companion/require-test-companion-test-helpers.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAU3D,qCAAqC;AACrC,UAAU,UAAU;IAClB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAgCD;;;;;;;;;GASG;AACH,QAAA,MAAM,mBAAmB,GAAI,MAAM,KAAK,GAAG,KAAK,EAAE,UAAU,MAAM,KAAG,MAMpE,CAAC;AAyBF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,mBAAmB,GACvB,MAAM,KAAK,GAAG,KAAK,EACnB,OAAO,MAAM,EACb,QAAQ,MAAM,KACb,CAAC,MAAM,EAAE,MAAM,CAOjB,CAAC;AA2EF;;;;;;;;;GASG;AACH,QAAA,MAAM,OAAO,GACX,UAAU,MAAM,EAChB,UAAU,2BAA2B,KACpC,UAAU,EAUZ,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,2BAA2B,QAAO,IAIvC,CAAC;AAEF,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,mBAAmB,EACnB,OAAO,GACR,CAAC"}