@codeperfect/eslint-plugin 2.0.0 → 2.2.0

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

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
+import { cwd } from "node:process";
 import { isLintableFilename, isPathMatch, isTypeScriptFile, TYPESCRIPT_EXTENSION, } from "./require-test-companion-options.js";
 /**
  * Gets the test suffix for a file name when present.
@@ -12,50 +13,6 @@ import { isLintableFilename, isPathMatch, isTypeScriptFile, TYPESCRIPT_EXTENSION
  * ```
  */
 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.
@@ -90,13 +47,14 @@ const buildMissingSourceListener = (context, options) => {
  * Determines whether a file should be linted.
  * @param filename Input filename value.
  * @param options Input options value.
+ * @param baseDirectory Input baseDirectory value.
  * @returns True when the file should be linted.
  * @example
  * ```typescript
  * const ok = shouldLintFile(filename, options);
  * ```
  */
-const shouldLintFile = (filename, options) => {
+const shouldLintFile = (filename, options, baseDirectory) => {
     const { enforceIn, ignorePatterns } = options;
     if (!isLintableFilename(filename)) {
         return false;
@@ -104,42 +62,39 @@ const shouldLintFile = (filename, options) => {
     if (!isTypeScriptFile(filename)) {
         return false;
     }
-    if (!isPathMatch(filename, enforceIn)) {
+    if (!isPathMatch(filename, enforceIn, baseDirectory)) {
         return false;
     }
-    return !isPathMatch(filename, ignorePatterns);
+    return !isPathMatch(filename, ignorePatterns, baseDirectory);
 };
 /**
  * Builds a listener for a specific filename.
  * @param context Input context value.
  * @param filename Input filename value.
  * @param options Input options value.
+ * @param baseDirectory Input baseDirectory value.
  * @returns Rule listener for the filename.
  * @example
  * ```typescript
  * const listener = buildListenerForFilename(context, filename, options);
  * ```
  */
-const buildListenerForFilename = (context, filename, options) => {
-    if (!shouldLintFile(filename, options)) {
+const buildListenerForFilename = (context, filename, options, baseDirectory = cwd()) => {
+    if (!shouldLintFile(filename, options, baseDirectory)) {
         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,
-        });
+    if (testSuffix === void 0) {
+        return {};
     }
-    return buildMissingTestListener(context, {
+    return buildMissingSourceListener(context, {
         directory,
         fileBasename,
-        testSuffixes,
+        suffix: testSuffix,
     });
 };
 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"]}
+//# 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\";\nimport { cwd } from \"node:process\";\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/**\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 * 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 * @param baseDirectory Input baseDirectory 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  baseDirectory: string,\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, baseDirectory)) {\n    return false;\n  }\n\n  return !isPathMatch(filename, ignorePatterns, baseDirectory);\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 * @param baseDirectory Input baseDirectory 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  baseDirectory: string = cwd(),\n): Rule.RuleListener => {\n  if (!shouldLintFile(filename, options, baseDirectory)) {\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 {};\n  }\n\n  return buildMissingSourceListener(context, {\n    directory,\n    fileBasename,\n    suffix: testSuffix,\n  });\n};\n\nexport { buildListenerForFilename };\n"]}

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

@@ -43,12 +43,13 @@ declare const getOptions: (options: readonly unknown[]) => RequireTestCompanionS
  * Checks isPathMatch.
  * @param filename Input filename value.
  * @param patterns Input patterns value.
+ * @param baseDirectory Input baseDirectory value.
  * @returns Return value output.
  * @example
  * ```typescript
  * isPathMatch();
  * ```
  */
-declare const isPathMatch: (filename: string, patterns: string[]) => boolean;
+declare const isPathMatch: (filename: string, patterns: string[], baseDirectory: string) => boolean;
 export { getOptions, isLintableFilename, isPathMatch, isTypeScriptFile, type RequireTestCompanionState, TYPESCRIPT_EXTENSION, };
 //# sourceMappingURL=require-test-companion-options.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"require-test-companion-options.d.ts","sourceRoot":"","sources":["../../../../src/domain/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;AA6BF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,WAAW,GACf,UAAU,MAAM,EAChB,UAAU,MAAM,EAAE,EAClB,eAAe,MAAM,KACpB,OAcF,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

@@ -1,6 +1,5 @@
 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. */
@@ -72,13 +71,14 @@ const getOptions = (options) => {
 /**
  * Normalizes normalizeRelativePath.
  * @param filename Input filename value.
+ * @param baseDirectory Input baseDirectory value.
  * @returns Return value output.
  * @example
  * ```typescript
  * normalizeRelativePath();
  * ```
  */
-const normalizeRelativePath = (filename) => path.relative(cwd(), filename).split(path.sep).join("/");
+const normalizeRelativePath = (filename, baseDirectory) => path.relative(baseDirectory, filename).split(path.sep).join("/");
 /**
  * Normalizes normalizePattern.
  * @param pattern Input pattern value.
@@ -93,21 +93,22 @@ const normalizePattern = (pattern) => pattern.startsWith("/") ? `**${pattern}` :
  * Checks isPathMatch.
  * @param filename Input filename value.
  * @param patterns Input patterns value.
+ * @param baseDirectory Input baseDirectory value.
  * @returns Return value output.
  * @example
  * ```typescript
  * isPathMatch();
  * ```
  */
-const isPathMatch = (filename, patterns) => {
+const isPathMatch = (filename, patterns, baseDirectory) => {
     if (patterns.length === 0) {
         return false;
     }
-    const relativePath = normalizeRelativePath(filename);
+    const relativePath = normalizeRelativePath(filename, baseDirectory);
     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"]}
+//# 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\";\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 * @param baseDirectory Input baseDirectory value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeRelativePath();\n * ```\n */\nconst normalizeRelativePath = (\n  filename: string,\n  baseDirectory: string,\n): string => path.relative(baseDirectory, 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 * @param baseDirectory Input baseDirectory value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isPathMatch();\n * ```\n */\nconst isPathMatch = (\n  filename: string,\n  patterns: string[],\n  baseDirectory: string,\n): boolean => {\n  if (patterns.length === 0) {\n    return false;\n  }\n\n  const relativePath = normalizeRelativePath(filename, baseDirectory);\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/domain/testing/require-test-companion/rule.d.ts.map

@@ -1 +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"}
+{"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;AAOnC,sEAAsE;AACtE,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UAqFpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -1,25 +1,40 @@
-import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { cwd } from "node:process";
 import { buildListenerForFilename } from "./require-test-companion-listeners.js";
 import { getOptions } from "./require-test-companion-options.js";
 /** ESLint rule enforcing 1:1 test companions for TypeScript files. */
 const requireTestCompanionRule = {
     create(context) {
-        return buildListenerForFilename(context, context.filename, getOptions(context.options));
+        return buildListenerForFilename(context, context.filename, getOptions(context.options), typeof context.cwd === "string" ? context.cwd : cwd());
     },
     meta: {
-        docs: createRuleDocumentation("require-test-companion", "Require a matching test file for each TypeScript file and vice versa."),
+        defaultOptions: [
+            {
+                enforceIn: ["src/**"],
+                ignorePatterns: ["/*.d.ts", "/index.ts"],
+                testSuffixes: ["spec", "test"],
+            },
+        ],
+        docs: {
+            description: "Require each test file to have a matching TypeScript source file.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/require-test-companion.md",
+        },
         messages: {
-            missingSource: "Test file requires a matching source file '{{sourceFile}}' in the same folder.",
-            missingTest: "Source file requires a matching test file ({{testFiles}}) in the same folder.",
+            missingSource: "Test file requires a matching source file '{{sourceFile}}' in the same folder. If this test file is orphaned, move its tests to the correct companion file or delete this orphan file.",
         },
         schema: [
             {
                 additionalProperties: false,
                 properties: {
                     enforceIn: {
+                        description: "Glob patterns that define where test files must have matching source companions.",
                         oneOf: [
-                            { type: "string" },
                             {
+                                description: "A single glob pattern.",
+                                type: "string",
+                            },
+                            {
+                                description: "A list of glob patterns.",
                                 items: { type: "string" },
                                 minItems: 1,
                                 type: "array",
@@ -27,9 +42,14 @@ const requireTestCompanionRule = {
                         ],
                     },
                     ignorePatterns: {
+                        description: "Glob patterns that should be excluded from test-to-source companion checks.",
                         oneOf: [
-                            { type: "string" },
                             {
+                                description: "A single ignore glob pattern.",
+                                type: "string",
+                            },
+                            {
+                                description: "A list of ignore glob patterns.",
                                 items: { type: "string" },
                                 minItems: 1,
                                 type: "array",
@@ -37,9 +57,14 @@ const requireTestCompanionRule = {
                         ],
                     },
                     testSuffixes: {
+                        description: "Filename suffixes that are recognized as valid test companions.",
                         oneOf: [
-                            { type: "string" },
                             {
+                                description: "A single test filename suffix.",
+                                type: "string",
+                            },
+                            {
+                                description: "A list of test filename suffixes.",
                                 items: { type: "string" },
                                 minItems: 1,
                                 type: "array",
@@ -54,4 +79,4 @@ const requireTestCompanionRule = {
     },
 };
 export { requireTestCompanionRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/single-act-statement/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/single-act-statement/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,sEAAsE;AACtE,QAAA,MAAM,sBAAsB,EAAE,IAAI,CAAC,UAkClC,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/single-act-statement/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQnC,sEAAsE;AACtE,QAAA,MAAM,sBAAsB,EAAE,IAAI,CAAC,UAuClC,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/domain/testing/single-act-statement/rule.js

@@ -1,5 +1,5 @@
-import { createRuleDocumentation } from "../../custom-rule-documentation.js";
-import { analyzeTestBlock, countActStatements } from "../aaa/index.js";
+import { analyzeTestBlock } from "../aaa/analyzer.analysis.js";
+import { countActStatements, getActTopLevelStatements, } from "../aaa/analyzer.analysis.helpers.js";
 /** Requires the Act phase to contain a single top-level statement. */
 const singleActStatementRule = {
     create(context) {
@@ -13,16 +13,22 @@ const singleActStatementRule = {
                 if (actStatementCount <= 1) {
                     return;
                 }
+                const actStatements = getActTopLevelStatements(analysis);
+                const firstExcessActStatement = actStatements.at(1)?.node;
                 context.report({
                     data: { count: String(actStatementCount) },
                     messageId: "multipleActStatements",
-                    node: analysis.callExpression,
+                    node: firstExcessActStatement ?? analysis.callExpression,
                 });
             },
         };
     },
     meta: {
-        docs: createRuleDocumentation("single-act-statement", "Require the // Act section to contain a single top-level statement or declaration."),
+        docs: {
+            description: "Require the // Act section to contain a single top-level statement or declaration.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/single-act-statement.md",
+        },
         messages: {
             multipleActStatements: "Reduce the // Act section to a single top-level statement or variable declaration; found {{count}}.",
         },
@@ -31,4 +37,4 @@ const singleActStatementRule = {
     },
 };
 export { singleActStatementRule };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9zaW5nbGUtYWN0LXN0YXRlbWVudC9ydWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzFFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUU5RCxzRUFBc0U7QUFDdEUsTUFBTSxzQkFBc0IsR0FBb0I7SUFDOUMsTUFBTSxDQUFDLE9BQXlCO1FBQzlCLE9BQU87WUFDTCxjQUFjLENBQUMsSUFBSTtnQkFDakIsTUFBTSxRQUFRLEdBQUcsZ0JBQWdCLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO2dCQUNqRCxJQUFJLFFBQVEsS0FBSyxLQUFLLENBQUMsRUFBRSxDQUFDO29CQUN4QixPQUFPO2dCQUNULENBQUM7Z0JBRUQsTUFBTSxpQkFBaUIsR0FBRyxrQkFBa0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDdkQsSUFBSSxpQkFBaUIsSUFBSSxDQUFDLEVBQUUsQ0FBQztvQkFDM0IsT0FBTztnQkFDVCxDQUFDO2dCQUVELE9BQU8sQ0FBQyxNQUFNLENBQUM7b0JBQ2IsSUFBSSxFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFO29CQUMxQyxTQUFTLEVBQUUsdUJBQXVCO29CQUNsQyxJQUFJLEVBQUUsUUFBUSxDQUFDLGNBQWM7aUJBQzlCLENBQUMsQ0FBQztZQUNMLENBQUM7U0FDMEIsQ0FBQztJQUNoQyxDQUFDO0lBQ0QsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLHVCQUF1QixDQUMzQixzQkFBc0IsRUFDdEIsb0ZBQW9GLENBQ3JGO1FBQ0QsUUFBUSxFQUFFO1lBQ1IscUJBQXFCLEVBQ25CLHFHQUFxRztTQUN4RztRQUNELE1BQU0sRUFBRSxFQUFFO1FBQ1YsSUFBSSxFQUFFLFlBQVk7S0FDbkI7Q0FDRixDQUFDO0FBRUYsT0FBTyxFQUFFLHNCQUFzQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbmltcG9ydCB7IGNyZWF0ZVJ1bGVEb2N1bWVudGF0aW9uIH0gZnJvbSBcIi4uLy4uL2N1c3RvbS1ydWxlLWRvY3VtZW50YXRpb25cIjtcbmltcG9ydCB7IGFuYWx5emVUZXN0QmxvY2ssIGNvdW50QWN0U3RhdGVtZW50cyB9IGZyb20gXCIuLi9hYWFcIjtcblxuLyoqIFJlcXVpcmVzIHRoZSBBY3QgcGhhc2UgdG8gY29udGFpbiBhIHNpbmdsZSB0b3AtbGV2ZWwgc3RhdGVtZW50LiAqL1xuY29uc3Qgc2luZ2xlQWN0U3RhdGVtZW50UnVsZTogUnVsZS5SdWxlTW9kdWxlID0ge1xuICBjcmVhdGUoY29udGV4dDogUnVsZS5SdWxlQ29udGV4dCk6IFJ1bGUuUnVsZUxpc3RlbmVyIHtcbiAgICByZXR1cm4ge1xuICAgICAgQ2FsbEV4cHJlc3Npb24obm9kZSk6IHZvaWQge1xuICAgICAgICBjb25zdCBhbmFseXNpcyA9IGFuYWx5emVUZXN0QmxvY2soY29udGV4dCwgbm9kZSk7XG4gICAgICAgIGlmIChhbmFseXNpcyA9PT0gdm9pZCAwKSB7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgY29uc3QgYWN0U3RhdGVtZW50Q291bnQgPSBjb3VudEFjdFN0YXRlbWVudHMoYW5hbHlzaXMpO1xuICAgICAgICBpZiAoYWN0U3RhdGVtZW50Q291bnQgPD0gMSkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnRleHQucmVwb3J0KHtcbiAgICAgICAgICBkYXRhOiB7IGNvdW50OiBTdHJpbmcoYWN0U3RhdGVtZW50Q291bnQpIH0sXG4gICAgICAgICAgbWVzc2FnZUlkOiBcIm11bHRpcGxlQWN0U3RhdGVtZW50c1wiLFxuICAgICAgICAgIG5vZGU6IGFuYWx5c2lzLmNhbGxFeHByZXNzaW9uLFxuICAgICAgICB9KTtcbiAgICAgIH0sXG4gICAgfSBzYXRpc2ZpZXMgUnVsZS5SdWxlTGlzdGVuZXI7XG4gIH0sXG4gIG1ldGE6IHtcbiAgICBkb2NzOiBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbihcbiAgICAgIFwic2luZ2xlLWFjdC1zdGF0ZW1lbnRcIixcbiAgICAgIFwiUmVxdWlyZSB0aGUgLy8gQWN0IHNlY3Rpb24gdG8gY29udGFpbiBhIHNpbmdsZSB0b3AtbGV2ZWwgc3RhdGVtZW50IG9yIGRlY2xhcmF0aW9uLlwiLFxuICAgICksXG4gICAgbWVzc2FnZXM6IHtcbiAgICAgIG11bHRpcGxlQWN0U3RhdGVtZW50czpcbiAgICAgICAgXCJSZWR1Y2UgdGhlIC8vIEFjdCBzZWN0aW9uIHRvIGEgc2luZ2xlIHRvcC1sZXZlbCBzdGF0ZW1lbnQgb3IgdmFyaWFibGUgZGVjbGFyYXRpb247IGZvdW5kIHt7Y291bnR9fS5cIixcbiAgICB9LFxuICAgIHNjaGVtYTogW10sXG4gICAgdHlwZTogXCJzdWdnZXN0aW9uXCIsXG4gIH0sXG59O1xuXG5leHBvcnQgeyBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlIH07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9zaW5nbGUtYWN0LXN0YXRlbWVudC9ydWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzVELE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsd0JBQXdCLEdBQ3pCLE1BQU0sa0NBQWtDLENBQUM7QUFFMUMsc0VBQXNFO0FBQ3RFLE1BQU0sc0JBQXNCLEdBQW9CO0lBQzlDLE1BQU0sQ0FBQyxPQUF5QjtRQUM5QixPQUFPO1lBQ0wsY0FBYyxDQUFDLElBQUk7Z0JBQ2pCLE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDakQsSUFBSSxRQUFRLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztvQkFDeEIsT0FBTztnQkFDVCxDQUFDO2dCQUVELE1BQU0saUJBQWlCLEdBQUcsa0JBQWtCLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ3ZELElBQUksaUJBQWlCLElBQUksQ0FBQyxFQUFFLENBQUM7b0JBQzNCLE9BQU87Z0JBQ1QsQ0FBQztnQkFFRCxNQUFNLGFBQWEsR0FBRyx3QkFBd0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDekQsTUFBTSx1QkFBdUIsR0FBRyxhQUFhLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQztnQkFFMUQsT0FBTyxDQUFDLE1BQU0sQ0FBQztvQkFDYixJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDLGlCQUFpQixDQUFDLEVBQUU7b0JBQzFDLFNBQVMsRUFBRSx1QkFBdUI7b0JBQ2xDLElBQUksRUFBRSx1QkFBdUIsSUFBSSxRQUFRLENBQUMsY0FBYztpQkFDekQsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztTQUMwQixDQUFDO0lBQ2hDLENBQUM7SUFDRCxJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUU7WUFDSixXQUFXLEVBQ1Qsb0ZBQW9GO1lBQ3RGLFdBQVcsRUFBRSxLQUFLO1lBQ2xCLEdBQUcsRUFBRSx1RkFBdUY7U0FDN0Y7UUFDRCxRQUFRLEVBQUU7WUFDUixxQkFBcUIsRUFDbkIscUdBQXFHO1NBQ3hHO1FBQ0QsTUFBTSxFQUFFLEVBQUU7UUFDVixJQUFJLEVBQUUsWUFBWTtLQUNuQjtDQUNGLENBQUM7QUFFRixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUnVsZSB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHsgYW5hbHl6ZVRlc3RCbG9jayB9IGZyb20gXCIuLi9hYWEvYW5hbHl6ZXIuYW5hbHlzaXNcIjtcbmltcG9ydCB7XG4gIGNvdW50QWN0U3RhdGVtZW50cyxcbiAgZ2V0QWN0VG9wTGV2ZWxTdGF0ZW1lbnRzLFxufSBmcm9tIFwiLi4vYWFhL2FuYWx5emVyLmFuYWx5c2lzLmhlbHBlcnNcIjtcblxuLyoqIFJlcXVpcmVzIHRoZSBBY3QgcGhhc2UgdG8gY29udGFpbiBhIHNpbmdsZSB0b3AtbGV2ZWwgc3RhdGVtZW50LiAqL1xuY29uc3Qgc2luZ2xlQWN0U3RhdGVtZW50UnVsZTogUnVsZS5SdWxlTW9kdWxlID0ge1xuICBjcmVhdGUoY29udGV4dDogUnVsZS5SdWxlQ29udGV4dCk6IFJ1bGUuUnVsZUxpc3RlbmVyIHtcbiAgICByZXR1cm4ge1xuICAgICAgQ2FsbEV4cHJlc3Npb24obm9kZSk6IHZvaWQge1xuICAgICAgICBjb25zdCBhbmFseXNpcyA9IGFuYWx5emVUZXN0QmxvY2soY29udGV4dCwgbm9kZSk7XG4gICAgICAgIGlmIChhbmFseXNpcyA9PT0gdm9pZCAwKSB7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgY29uc3QgYWN0U3RhdGVtZW50Q291bnQgPSBjb3VudEFjdFN0YXRlbWVudHMoYW5hbHlzaXMpO1xuICAgICAgICBpZiAoYWN0U3RhdGVtZW50Q291bnQgPD0gMSkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnN0IGFjdFN0YXRlbWVudHMgPSBnZXRBY3RUb3BMZXZlbFN0YXRlbWVudHMoYW5hbHlzaXMpO1xuICAgICAgICBjb25zdCBmaXJzdEV4Y2Vzc0FjdFN0YXRlbWVudCA9IGFjdFN0YXRlbWVudHMuYXQoMSk/Lm5vZGU7XG5cbiAgICAgICAgY29udGV4dC5yZXBvcnQoe1xuICAgICAgICAgIGRhdGE6IHsgY291bnQ6IFN0cmluZyhhY3RTdGF0ZW1lbnRDb3VudCkgfSxcbiAgICAgICAgICBtZXNzYWdlSWQ6IFwibXVsdGlwbGVBY3RTdGF0ZW1lbnRzXCIsXG4gICAgICAgICAgbm9kZTogZmlyc3RFeGNlc3NBY3RTdGF0ZW1lbnQgPz8gYW5hbHlzaXMuY2FsbEV4cHJlc3Npb24sXG4gICAgICAgIH0pO1xuICAgICAgfSxcbiAgICB9IHNhdGlzZmllcyBSdWxlLlJ1bGVMaXN0ZW5lcjtcbiAgfSxcbiAgbWV0YToge1xuICAgIGRvY3M6IHtcbiAgICAgIGRlc2NyaXB0aW9uOlxuICAgICAgICBcIlJlcXVpcmUgdGhlIC8vIEFjdCBzZWN0aW9uIHRvIGNvbnRhaW4gYSBzaW5nbGUgdG9wLWxldmVsIHN0YXRlbWVudCBvciBkZWNsYXJhdGlvbi5cIixcbiAgICAgIHJlY29tbWVuZGVkOiBmYWxzZSxcbiAgICAgIHVybDogXCJodHRwczovL2dpdGh1Yi5jb20vcGFybG90aS9lc2xpbnQtcGx1Z2luL2Jsb2IvbWFpbi9kb2NzL3J1bGVzL3NpbmdsZS1hY3Qtc3RhdGVtZW50Lm1kXCIsXG4gICAgfSxcbiAgICBtZXNzYWdlczoge1xuICAgICAgbXVsdGlwbGVBY3RTdGF0ZW1lbnRzOlxuICAgICAgICBcIlJlZHVjZSB0aGUgLy8gQWN0IHNlY3Rpb24gdG8gYSBzaW5nbGUgdG9wLWxldmVsIHN0YXRlbWVudCBvciB2YXJpYWJsZSBkZWNsYXJhdGlvbjsgZm91bmQge3tjb3VudH19LlwiLFxuICAgIH0sXG4gICAgc2NoZW1hOiBbXSxcbiAgICB0eXBlOiBcInN1Z2dlc3Rpb25cIixcbiAgfSxcbn07XG5cbmV4cG9ydCB7IHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUgfTtcbiJdfQ==

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, preferInterfaceTypesRule, preferViMockedImportRule, preferVitestIncrementalCastsRule, requireAaaSectionsRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
 export type { CustomRuleEntry } from "./application/index.js";
 export { aaa, all, architecture, codeperfectPlugin, core, customRules, documentation, testing, } from "./infrastructure/index.js";
 export type { CodeperfectPreset } from "./infrastructure/index.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,uBAAuB,EACvB,kCAAkC,EAClC,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,wBAAwB,EACxB,gCAAgC,EAChC,sBAAsB,EACtB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,GAAG,EACH,GAAG,EACH,YAAY,EACZ,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,aAAa,EACb,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,kCAAkC,EAClC,yBAAyB,EACzB,6BAA6B,EAC7B,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,GAAG,EACH,GAAG,EACH,YAAY,EACZ,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,aAAa,EACb,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,3 +1,3 @@
-export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, preferInterfaceTypesRule, preferViMockedImportRule, preferVitestIncrementalCastsRule, requireAaaSectionsRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
 export { aaa, all, architecture, codeperfectPlugin, core, customRules, documentation, testing, } from "./infrastructure/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qix1QkFBdUIsRUFDdkIsa0NBQWtDLEVBQ2xDLHlCQUF5QixFQUN6Qiw2QkFBNkIsRUFDN0Isd0JBQXdCLEVBQ3hCLHdCQUF3QixFQUN4QixnQ0FBZ0MsRUFDaEMsc0JBQXNCLEVBQ3RCLDJCQUEyQixFQUMzQiwwQkFBMEIsRUFDMUIsd0JBQXdCLEVBQ3hCLHNCQUFzQixFQUN0QixtQkFBbUIsR0FDcEIsTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUNMLEdBQUcsRUFDSCxHQUFHLEVBQ0gsWUFBWSxFQUNaLGlCQUFpQixFQUNqQixJQUFJLEVBQ0osV0FBVyxFQUNYLGFBQWEsRUFDYixPQUFPLEdBQ1IsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcbiAgZW5mb3JjZUFhYVBoYXNlUHVyaXR5UnVsZSxcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gIG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxuICBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUsXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcbiAgcHJlZmVyVml0ZXN0SW5jcmVtZW50YWxDYXN0c1J1bGUsXG4gIHJlcXVpcmVBYWFTZWN0aW9uc1J1bGUsXG4gIHJlcXVpcmVBY3RSZXN1bHRDYXB0dXJlUnVsZSxcbiAgcmVxdWlyZUV4YW1wbGVMYW5ndWFnZVJ1bGUsXG4gIHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSxcbiAgc2luZ2xlQWN0U3RhdGVtZW50UnVsZSxcbiAgc2luZ2xlTGluZUpzZG9jUnVsZSxcbn0gZnJvbSBcIi4vYXBwbGljYXRpb25cIjtcbmV4cG9ydCB0eXBlIHsgQ3VzdG9tUnVsZUVudHJ5IH0gZnJvbSBcIi4vYXBwbGljYXRpb25cIjtcbmV4cG9ydCB7XG4gIGFhYSxcbiAgYWxsLFxuICBhcmNoaXRlY3R1cmUsXG4gIGNvZGVwZXJmZWN0UGx1Z2luLFxuICBjb3JlLFxuICBjdXN0b21SdWxlcyxcbiAgZG9jdW1lbnRhdGlvbixcbiAgdGVzdGluZyxcbn0gZnJvbSBcIi4vaW5mcmFzdHJ1Y3R1cmVcIjtcbmV4cG9ydCB0eXBlIHsgQ29kZXBlcmZlY3RQcmVzZXQgfSBmcm9tIFwiLi9pbmZyYXN0cnVjdHVyZVwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLG1CQUFtQixFQUNuQix3QkFBd0IsRUFDeEIsd0JBQXdCLEVBQ3hCLDJCQUEyQixFQUMzQiwwQkFBMEIsRUFDMUIsd0JBQXdCLEVBQ3hCLHNCQUFzQixFQUN0QixtQkFBbUIsR0FDcEIsTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUNMLEdBQUcsRUFDSCxHQUFHLEVBQ0gsWUFBWSxFQUNaLGlCQUFpQixFQUNqQixJQUFJLEVBQ0osV0FBVyxFQUNYLGFBQWEsRUFDYixPQUFPLEdBQ1IsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gIG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxuICBub1VudXNlZEV4cG9ydHNSdWxlLFxuICBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUsXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcbiAgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxuICByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSxcbiAgcmVxdWlyZVRlc3RDb21wYW5pb25SdWxlLFxuICBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlLFxuICBzaW5nbGVMaW5lSnNkb2NSdWxlLFxufSBmcm9tIFwiLi9hcHBsaWNhdGlvblwiO1xuZXhwb3J0IHR5cGUgeyBDdXN0b21SdWxlRW50cnkgfSBmcm9tIFwiLi9hcHBsaWNhdGlvblwiO1xuZXhwb3J0IHtcbiAgYWFhLFxuICBhbGwsXG4gIGFyY2hpdGVjdHVyZSxcbiAgY29kZXBlcmZlY3RQbHVnaW4sXG4gIGNvcmUsXG4gIGN1c3RvbVJ1bGVzLFxuICBkb2N1bWVudGF0aW9uLFxuICB0ZXN0aW5nLFxufSBmcm9tIFwiLi9pbmZyYXN0cnVjdHVyZVwiO1xuZXhwb3J0IHR5cGUgeyBDb2RlcGVyZmVjdFByZXNldCB9IGZyb20gXCIuL2luZnJhc3RydWN0dXJlXCI7XG4iXX0=

package/dist/infrastructure/codeperfect-plugin.d.ts

@@ -4,15 +4,15 @@ declare const codeperfectRules: {
     readonly "assert-actual-expected-names": Rule.RuleModule;
     readonly "barrel-files-exports-only": Rule.RuleModule;
     readonly "consistent-barrel-files": Rule.RuleModule;
-    readonly "enforce-aaa-phase-purity": Rule.RuleModule;
     readonly "enforce-aaa-structure": Rule.RuleModule;
+    readonly "no-import-export-aliases": Rule.RuleModule;
+    readonly "no-import-export-extensions": Rule.RuleModule;
     readonly "no-interface-member-docs": Rule.RuleModule;
     readonly "no-multiple-declarators": Rule.RuleModule;
     readonly "no-reexports-outside-barrels": Rule.RuleModule;
+    readonly "no-unused-exports": Rule.RuleModule;
     readonly "prefer-interface-types": Rule.RuleModule;
     readonly "prefer-vi-mocked-import": Rule.RuleModule;
-    readonly "prefer-vitest-incremental-casts": Rule.RuleModule;
-    readonly "require-aaa-sections": Rule.RuleModule;
     readonly "require-act-result-capture": Rule.RuleModule;
     readonly "require-example-language": Rule.RuleModule;
     readonly "require-test-companion": Rule.RuleModule;
@@ -28,15 +28,15 @@ declare const codeperfectPlugin: {
         readonly "assert-actual-expected-names": Rule.RuleModule;
         readonly "barrel-files-exports-only": Rule.RuleModule;
         readonly "consistent-barrel-files": Rule.RuleModule;
-        readonly "enforce-aaa-phase-purity": Rule.RuleModule;
         readonly "enforce-aaa-structure": Rule.RuleModule;
+        readonly "no-import-export-aliases": Rule.RuleModule;
+        readonly "no-import-export-extensions": Rule.RuleModule;
         readonly "no-interface-member-docs": Rule.RuleModule;
         readonly "no-multiple-declarators": Rule.RuleModule;
         readonly "no-reexports-outside-barrels": Rule.RuleModule;
+        readonly "no-unused-exports": Rule.RuleModule;
         readonly "prefer-interface-types": Rule.RuleModule;
         readonly "prefer-vi-mocked-import": Rule.RuleModule;
-        readonly "prefer-vitest-incremental-casts": Rule.RuleModule;
-        readonly "require-aaa-sections": Rule.RuleModule;
         readonly "require-act-result-capture": Rule.RuleModule;
         readonly "require-example-language": Rule.RuleModule;
         readonly "require-test-companion": Rule.RuleModule;

package/dist/infrastructure/codeperfect-plugin.js

@@ -1,18 +1,18 @@
-import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, preferInterfaceTypesRule, preferViMockedImportRule, preferVitestIncrementalCastsRule, requireAaaSectionsRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../application/index.js";
+import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../application/index.js";
 /** Rule registry exposed by the package plugin. */
 const codeperfectRules = {
     "assert-actual-expected-names": assertActualExpectedNamesRule,
     "barrel-files-exports-only": barrelFilesExportsOnlyRule,
     "consistent-barrel-files": consistentBarrelFilesRule,
-    "enforce-aaa-phase-purity": enforceAaaPhasePurityRule,
     "enforce-aaa-structure": enforceAaaStructureRule,
+    "no-import-export-aliases": noImportExportAliasesRule,
+    "no-import-export-extensions": noImportExportExtensionsRule,
     "no-interface-member-docs": noInterfaceMemberDocumentationRule,
     "no-multiple-declarators": noMultipleDeclaratorsRule,
     "no-reexports-outside-barrels": noReexportsOutsideBarrelsRule,
+    "no-unused-exports": noUnusedExportsRule,
     "prefer-interface-types": preferInterfaceTypesRule,
     "prefer-vi-mocked-import": preferViMockedImportRule,
-    "prefer-vitest-incremental-casts": preferVitestIncrementalCastsRule,
-    "require-aaa-sections": requireAaaSectionsRule,
     "require-act-result-capture": requireActResultCaptureRule,
     "require-example-language": requireExampleLanguageRule,
     "require-test-companion": requireTestCompanionRule,
@@ -27,4 +27,4 @@ const codeperfectPlugin = {
     rules: codeperfectRules,
 };
 export { codeperfectPlugin, codeperfectRules };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/infrastructure/presets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,gEAAgE;AAChE,KAAK,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;AA6FlE,oDAAoD;AACpD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,sDAAsD;AACtD,QAAA,MAAM,YAAY,mBAAsC,CAAC;AAEzD,sCAAsC;AACtC,QAAA,MAAM,IAAI,mBAA8B,CAAC;AAEzC,+CAA+C;AAC/C,QAAA,MAAM,aAAa,mBAAuC,CAAC;AAE3D,yCAAyC;AACzC,QAAA,MAAM,OAAO,mBAAiC,CAAC;AAE/C,sDAAsD;AACtD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,gEAAgE;AAChE,KAAK,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;AA6GlE,oDAAoD;AACpD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,sDAAsD;AACtD,QAAA,MAAM,YAAY,mBAAsC,CAAC;AAEzD,sCAAsC;AACtC,QAAA,MAAM,IAAI,mBAA8B,CAAC;AAEzC,+CAA+C;AAC/C,QAAA,MAAM,aAAa,mBAAuC,CAAC;AAE3D,yCAAyC;AACzC,QAAA,MAAM,OAAO,mBAAiC,CAAC;AAE/C,sDAAsD;AACtD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}