@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/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/domain/testing/require-test-companion/index.js

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

package/dist/{testing → domain/testing}/require-test-companion/require-test-companion-listeners.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { RequireTestCompanionState } from "./require-test-companion-options";
+import type { RequireTestCompanionState } from "./require-test-companion-options.js";
 /**
  * Builds a listener for a specific filename.
  * @param context Input context value.

package/dist/domain/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/domain/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/domain/testing/require-test-companion/require-test-companion-listeners.js

@@ -0,0 +1,145 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { isLintableFilename, isPathMatch, isTypeScriptFile, TYPESCRIPT_EXTENSION, } from "./require-test-companion-options.js";
+/**
+ * Gets the test suffix for a file name when present.
+ * @param fileBasename 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 = (fileBasename, testSuffixes) => testSuffixes.find((suffix) => fileBasename.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) => 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 { directory, fileBasename, testSuffixes } = options;
+    const baseStem = fileBasename.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 { directory, fileBasename, suffix } = options;
+    const sourceBasename = fileBasename.slice(0, -`.${suffix}${TYPESCRIPT_EXTENSION}`.length);
+    if (sourceBasename.length === 0) {
+        return {};
+    }
+    const sourceFile = `${sourceBasename}${TYPESCRIPT_EXTENSION}`;
+    if (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 fileBasename = path.basename(filename);
+    const directory = path.dirname(filename);
+    const { testSuffixes } = options;
+    const testSuffix = getTestSuffix(fileBasename, testSuffixes);
+    if (testSuffix !== void 0) {
+        return buildMissingSourceListener(context, {
+            directory,
+            fileBasename,
+            suffix: testSuffix,
+        });
+    }
+    return buildMissingTestListener(context, {
+        directory,
+        fileBasename,
+        testSuffixes,
+    });
+};
+export { buildListenerForFilename };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require-test-companion-listeners.js","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/require-test-companion-listeners.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { existsSync } 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  /** Directory field value. */\n  directory: string;\n\n  /** Basename field value. */\n  fileBasename: string;\n\n  /** Suffix field value. */\n  suffix: string;\n}\n\n/** Type definition for rule data. */\ninterface MissingTestListenerOptions {\n  /** Directory field value. */\n  directory: string;\n\n  /** Basename field value. */\n  fileBasename: 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 fileBasename 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  fileBasename: string,\n  testSuffixes: string[],\n): string | undefined =>\n  testSuffixes.find((suffix) =>\n    fileBasename.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    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 { directory, fileBasename, testSuffixes } = options;\n  const baseStem = fileBasename.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 { directory, fileBasename, suffix } = options;\n  const sourceBasename = fileBasename.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 (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 fileBasename = path.basename(filename);\n  const directory = path.dirname(filename);\n  const { testSuffixes } = options;\n  const testSuffix = getTestSuffix(fileBasename, testSuffixes);\n\n  if (testSuffix !== void 0) {\n    return buildMissingSourceListener(context, {\n      directory,\n      fileBasename,\n      suffix: testSuffix,\n    });\n  }\n\n  return buildMissingTestListener(context, {\n    directory,\n    fileBasename,\n    testSuffixes,\n  });\n};\n\nexport { buildListenerForFilename };\n"]}

package/dist/domain/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/domain/testing/require-test-companion/require-test-companion-options.ts"],"names":[],"mappings":"AAeA,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/domain/testing/require-test-companion/require-test-companion-options.js

@@ -0,0 +1,113 @@
+import { minimatch } from "minimatch";
+import path from "node:path";
+import { cwd } from "node:process";
+/** 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(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/domain/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\";\nimport { cwd } from \"node:process\";\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(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 → domain/testing}/require-test-companion/require-test-companion-test-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { RequireTestCompanionOptions } from "./types";
+import type { RequireTestCompanionOptions } from "./types.js";
 /** Type definition for rule data. */
 interface RuleReport {
     /** MessageId helper value. */

package/dist/domain/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/domain/testing/require-test-companion/require-test-companion-test-helpers.ts"],"names":[],"mappings":"AAOA,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"}

package/dist/domain/testing/require-test-companion/require-test-companion-test-helpers.js

@@ -0,0 +1,184 @@
+import { SourceCode } from "eslint";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { cwd } from "node:process";
+import { requireTestCompanionRule } from "./rule.js";
+/** Tracks temporary directories so tests can clean them up. */
+const temporaryDirectories = [];
+/**
+ * Creates createRepoDirectory.
+ * @param root Input root value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createRepoDirectory();
+ * ```
+ */
+const createRepoDirectory = (root) => {
+    const baseDirectory = path.join(cwd(), root);
+    mkdirSync(baseDirectory, { recursive: true });
+    return mkdtempSync(path.join(baseDirectory, "test-companion-"));
+};
+/**
+ * Writes a simple TypeScript file at the provided path.
+ * @param filePath Input filePath value.
+ * @example
+ * ```typescript
+ * writeFile("/tmp/feature.ts");
+ * ```
+ */
+const writeFile = (filePath) => {
+    writeFileSync(filePath, "export const value = 1;", "utf8");
+};
+/**
+ * Creates createTemporaryFile.
+ * @param root Input root value.
+ * @param filename Input filename value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createTemporaryFile();
+ * ```
+ */
+const createTemporaryFile = (root, filename) => {
+    const directory = createRepoDirectory(root);
+    temporaryDirectories.push(directory);
+    const filePath = path.join(directory, filename);
+    writeFile(filePath);
+    return filePath;
+};
+/**
+ * Creates multiple temporary files under the given root.
+ * @param root Input root value.
+ * @param filenames Input filenames value.
+ * @returns Paths to the created files.
+ * @example
+ * ```typescript
+ * const paths = createTemporaryFiles("tmp", ["a.ts", "b.ts"]);
+ * ```
+ */
+const createTemporaryFiles = (root, filenames) => {
+    const directory = createRepoDirectory(root);
+    temporaryDirectories.push(directory);
+    return filenames.map((filename) => {
+        const filePath = path.join(directory, filename);
+        writeFile(filePath);
+        return filePath;
+    });
+};
+/**
+ * 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");
+ * ```
+ */
+const createTemporaryPair = (root, first, second) => {
+    const [firstPath, secondPath] = createTemporaryFiles(root, [
+        first,
+        second,
+    ]);
+    return [firstPath, secondPath];
+};
+/**
+ * Creates createProgramAst.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createProgramAst();
+ * ```
+ */
+const createProgramAst = () => ({
+    body: [],
+    comments: [],
+    loc: {
+        end: { column: 0, line: 1 },
+        start: { column: 0, line: 1 },
+    },
+    range: [0, 0],
+    sourceType: "module",
+    tokens: [],
+    type: "Program",
+});
+/**
+ * Creates a rule context for the given filename.
+ * @param filename Input filename value.
+ * @param reports Input reports value.
+ * @param sourceCode Input sourceCode value.
+ * @returns Rule context for tests.
+ * @example
+ * ```typescript
+ * const context = createRuleContext(file, reports, sourceCode);
+ * ```
+ */
+const createRuleContext = (filename, reports, sourceCode) => ({
+    cwd: cwd(),
+    filename,
+    id: "require-test-companion",
+    languageOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+    },
+    options: [],
+    parserOptions: {},
+    parserPath: void 0,
+    physicalFilename: filename,
+    report: (report) => {
+        const { messageId } = report;
+        reports.push({ messageId });
+    },
+    settings: {},
+    sourceCode,
+});
+/**
+ * Runs the rule listeners for a context.
+ * @param context Input context value.
+ * @example
+ * ```typescript
+ * runListeners(context);
+ * ```
+ */
+const runListeners = (context) => {
+    const listeners = requireTestCompanionRule.create(context);
+    const programNode = context.sourceCode.ast;
+    const programListener = listeners.Program;
+    programListener?.(programNode);
+};
+/**
+ * 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");
+ * ```
+ */
+const runRule = (filename, options) => {
+    const reports = [];
+    const programAst = createProgramAst();
+    const sourceCode = new SourceCode("", programAst);
+    const context = createRuleContext(filename, reports, sourceCode);
+    context.options = options === void 0 ? [] : [options];
+    runListeners(context);
+    return reports;
+};
+/**
+ * Cleans up temporary directories created by tests.
+ * @example
+ * ```typescript
+ * cleanupTemporaryDirectories();
+ * ```
+ */
+const cleanupTemporaryDirectories = () => {
+    for (const directory of temporaryDirectories.splice(0)) {
+        rmSync(directory, { force: true, recursive: true });
+    }
+};
+export { cleanupTemporaryDirectories, createTemporaryFile, createTemporaryPair, runRule, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require-test-companion-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/require-test-companion-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST, Rule } from \"eslint\";\n\nimport { SourceCode } from \"eslint\";\nimport { mkdirSync, mkdtempSync, rmSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { cwd } from \"node:process\";\n\nimport type { RequireTestCompanionOptions } from \"./types\";\n\nimport { requireTestCompanionRule } from \"./rule\";\n\n/** Type definition for rule data. */\ninterface ReportDescriptorWithMessageId {\n  /** MessageId field value. */\n  messageId?: string;\n}\n\n/** Type definition for rule data. */\ninterface RuleReport {\n  /** MessageId helper value. */\n  messageId: string | undefined;\n}\n\n/** Tracks temporary directories so tests can clean them up. */\nconst temporaryDirectories: string[] = [];\n\n/**\n * Creates createRepoDirectory.\n * @param root Input root value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createRepoDirectory();\n * ```\n */\nconst createRepoDirectory = (root: \"src\" | \"tmp\"): string => {\n  const baseDirectory = path.join(cwd(), root);\n  mkdirSync(baseDirectory, { recursive: true });\n  return mkdtempSync(path.join(baseDirectory, \"test-companion-\"));\n};\n\n/**\n * Writes a simple TypeScript file at the provided path.\n * @param filePath Input filePath value.\n * @example\n * ```typescript\n * writeFile(\"/tmp/feature.ts\");\n * ```\n */\nconst writeFile = (filePath: string): void => {\n  writeFileSync(filePath, \"export const value = 1;\", \"utf8\");\n};\n\n/**\n * Creates createTemporaryFile.\n * @param root Input root value.\n * @param filename Input filename value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createTemporaryFile();\n * ```\n */\nconst createTemporaryFile = (root: \"src\" | \"tmp\", filename: string): string => {\n  const directory = createRepoDirectory(root);\n  temporaryDirectories.push(directory);\n  const filePath = path.join(directory, filename);\n  writeFile(filePath);\n  return filePath;\n};\n\n/**\n * Creates multiple temporary files under the given root.\n * @param root Input root value.\n * @param filenames Input filenames value.\n * @returns Paths to the created files.\n * @example\n * ```typescript\n * const paths = createTemporaryFiles(\"tmp\", [\"a.ts\", \"b.ts\"]);\n * ```\n */\nconst createTemporaryFiles = (\n  root: \"src\" | \"tmp\",\n  filenames: string[],\n): string[] => {\n  const directory = createRepoDirectory(root);\n  temporaryDirectories.push(directory);\n  return filenames.map((filename) => {\n    const filePath = path.join(directory, filename);\n    writeFile(filePath);\n    return filePath;\n  });\n};\n\n/**\n * Creates a temporary file pair for test/source combinations.\n * @param root Input root value.\n * @param first Input first value.\n * @param second Input second value.\n * @returns Tuple of created file paths.\n * @throws {Error} When the file paths are missing.\n * @example\n * ```typescript\n * const [source, test] = createTemporaryPair(\"tmp\", \"a.ts\", \"a.spec.ts\");\n * ```\n */\nconst createTemporaryPair = (\n  root: \"src\" | \"tmp\",\n  first: string,\n  second: string,\n): [string, string] => {\n  const [firstPath, secondPath] = createTemporaryFiles(root, [\n    first,\n    second,\n  ]) as [string, string];\n\n  return [firstPath, secondPath];\n};\n\n/**\n * Creates createProgramAst.\n * @returns Return value output.\n * @example\n * ```typescript\n * createProgramAst();\n * ```\n */\nconst createProgramAst = (): AST.Program => ({\n  body: [],\n  comments: [],\n  loc: {\n    end: { column: 0, line: 1 },\n    start: { column: 0, line: 1 },\n  },\n  range: [0, 0],\n  sourceType: \"module\",\n  tokens: [],\n  type: \"Program\",\n});\n\n/**\n * Creates a rule context for the given filename.\n * @param filename Input filename value.\n * @param reports Input reports value.\n * @param sourceCode Input sourceCode value.\n * @returns Rule context for tests.\n * @example\n * ```typescript\n * const context = createRuleContext(file, reports, sourceCode);\n * ```\n */\nconst createRuleContext = (\n  filename: string,\n  reports: RuleReport[],\n  sourceCode: SourceCode,\n): Rule.RuleContext =>\n  ({\n    cwd: cwd(),\n    filename,\n    id: \"require-test-companion\",\n    languageOptions: {\n      ecmaVersion: \"latest\",\n      sourceType: \"module\",\n    },\n    options: [],\n    parserOptions: {},\n    parserPath: void 0,\n    physicalFilename: filename,\n    report: (report: Rule.ReportDescriptor): void => {\n      const { messageId } = report as ReportDescriptorWithMessageId;\n      reports.push({ messageId });\n    },\n    settings: {},\n    sourceCode,\n  }) as unknown as Rule.RuleContext;\n\n/**\n * Runs the rule listeners for a context.\n * @param context Input context value.\n * @example\n * ```typescript\n * runListeners(context);\n * ```\n */\nconst runListeners = (context: Rule.RuleContext): void => {\n  const listeners = requireTestCompanionRule.create(context);\n  const programNode = context.sourceCode.ast;\n  const programListener = listeners.Program;\n\n  programListener?.(programNode);\n};\n\n/**\n * Runs the rule with the given options.\n * @param filename Input filename value.\n * @param options Input options value.\n * @returns Collected rule reports.\n * @example\n * ```typescript\n * const reports = runRule(\"/tmp/feature.ts\");\n * ```\n */\nconst runRule = (\n  filename: string,\n  options?: RequireTestCompanionOptions,\n): RuleReport[] => {\n  const reports: RuleReport[] = [];\n  const programAst = createProgramAst();\n  const sourceCode = new SourceCode(\"\", programAst);\n  const context = createRuleContext(filename, reports, sourceCode);\n  context.options = options === void 0 ? [] : [options];\n\n  runListeners(context);\n\n  return reports;\n};\n\n/**\n * Cleans up temporary directories created by tests.\n * @example\n * ```typescript\n * cleanupTemporaryDirectories();\n * ```\n */\nconst cleanupTemporaryDirectories = (): void => {\n  for (const directory of temporaryDirectories.splice(0)) {\n    rmSync(directory, { force: true, recursive: true });\n  }\n};\n\nexport {\n  cleanupTemporaryDirectories,\n  createTemporaryFile,\n  createTemporaryPair,\n  runRule,\n};\n"]}

package/dist/{testing → domain/testing}/require-test-companion/require-test-companion-utilities.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import { getOptions as getOptionsImpl } from "./require-test-companion-options";
+import { getOptions as getOptionsImpl } from "./require-test-companion-options.js";
 /** Normalized options state type. */
 type RequireTestCompanionState = ReturnType<typeof getOptionsImpl>;
 /**

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

@@ -0,0 +1 @@
+{"version":3,"file":"require-test-companion-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/require-test-companion-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEhF,qCAAqC;AACrC,KAAK,yBAAyB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAEnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,SAAS,IAAI,CAAC,WAAW,EACzB,UAAU,MAAM,EAChB,SAAS,yBAAyB,KACjC,IAAI,CAAC,YACkD,CAAC;AAE3D;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,yBACzB,CAAC;AAE1B,OAAO,EAAE,wBAAwB,EAAE,UAAU,EAAE,CAAC"}

package/dist/domain/testing/require-test-companion/require-test-companion-utilities.js

@@ -0,0 +1,26 @@
+import { buildListenerForFilename as buildListenerForFilenameImpl } from "./require-test-companion-listeners.js";
+import { getOptions as getOptionsImpl } from "./require-test-companion-options.js";
+/**
+ * Build a rule listener for a source filename.
+ * @param context Rule execution context.
+ * @param filename Source file path.
+ * @param options Normalized rule options state.
+ * @returns Rule listener for the file.
+ * @example
+ * ```typescript
+ * const listener = buildListenerForFilename(context, filename, options);
+ * ```
+ */
+const buildListenerForFilename = (context, filename, options) => buildListenerForFilenameImpl(context, filename, options);
+/**
+ * Normalize rule options for the listener.
+ * @param options Raw rule options.
+ * @returns Normalized rule options state.
+ * @example
+ * ```typescript
+ * const options = getOptions([]);
+ * ```
+ */
+const getOptions = (options) => getOptionsImpl(options);
+export { buildListenerForFilename, getOptions };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC,sEAAsE;AACtE,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UA2DpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}