@codeperfect/eslint-plugin 1.0.0

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

@@ -0,0 +1,183 @@
+import { SourceCode } from "eslint";
+import fs from "node:fs";
+import path from "node:path";
+import { requireTestCompanionRule } from "./rule";
+/** 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(process.cwd(), root);
+    fs.mkdirSync(baseDirectory, { recursive: true });
+    return fs.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) => {
+    fs.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: process.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)) {
+        fs.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/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 fs from \"node:fs\";\nimport path from \"node:path\";\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(process.cwd(), root);\n  fs.mkdirSync(baseDirectory, { recursive: true });\n  return fs.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  fs.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: process.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    fs.rmSync(directory, { force: true, recursive: true });\n  }\n};\n\nexport {\n  cleanupTemporaryDirectories,\n  createTemporaryFile,\n  createTemporaryPair,\n  runRule,\n};\n"]}

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

@@ -0,0 +1,28 @@
+import type { Rule } from "eslint";
+import { getOptions as getOptionsImpl } from "./require-test-companion-options";
+/** Normalized options state type. */
+type RequireTestCompanionState = ReturnType<typeof getOptionsImpl>;
+/**
+ * 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);
+ * ```
+ */
+declare const buildListenerForFilename: (context: Rule.RuleContext, filename: string, options: RequireTestCompanionState) => Rule.RuleListener;
+/**
+ * Normalize rule options for the listener.
+ * @param options Raw rule options.
+ * @returns Normalized rule options state.
+ * @example
+ * ```typescript
+ * const options = getOptions([]);
+ * ```
+ */
+declare const getOptions: (options: readonly unknown[]) => RequireTestCompanionState;
+export { buildListenerForFilename, getOptions };
+//# sourceMappingURL=require-test-companion-utilities.d.ts.map

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

@@ -0,0 +1,26 @@
+import { buildListenerForFilename as buildListenerForFilenameImpl } from "./require-test-companion-listeners";
+import { getOptions as getOptionsImpl } from "./require-test-companion-options";
+/**
+ * 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/testing/require-test-companion/rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule enforcing 1:1 test companions for TypeScript files. */
+declare const requireTestCompanionRule: Rule.RuleModule;
+export { requireTestCompanionRule };
+//# sourceMappingURL=rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/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"}

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

@@ -0,0 +1,57 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { buildListenerForFilename } from "./require-test-companion-listeners";
+import { getOptions } from "./require-test-companion-options";
+/** ESLint rule enforcing 1:1 test companions for TypeScript files. */
+const requireTestCompanionRule = {
+    create(context) {
+        return buildListenerForFilename(context, context.filename, getOptions(context.options));
+    },
+    meta: {
+        docs: createRuleDocumentation("require-test-companion", "Require a matching test file for each TypeScript file and vice versa."),
+        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.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    enforceIn: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                    ignorePatterns: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                    testSuffixes: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                items: { type: "string" },
+                                minItems: 1,
+                                type: "array",
+                            },
+                        ],
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+};
+export { requireTestCompanionRule };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+/** Type definition for rule data. */
+interface RequireTestCompanionOptions {
+    /** EnforceIn helper value. */
+    enforceIn?: string | string[];
+    /** IgnorePatterns helper value. */
+    ignorePatterns?: string | string[];
+    /** TestSuffixes helper value. */
+    testSuffixes?: string | string[];
+}
+export type { RequireTestCompanionOptions };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/testing/require-test-companion/types.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,UAAU,2BAA2B;IACnC,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE9B,mCAAmC;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEnC,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC;AAED,YAAY,EAAE,2BAA2B,EAAE,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9yZXF1aXJlLXRlc3QtY29tcGFuaW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgUmVxdWlyZVRlc3RDb21wYW5pb25PcHRpb25zIHtcbiAgLyoqIEVuZm9yY2VJbiBoZWxwZXIgdmFsdWUuICovXG4gIGVuZm9yY2VJbj86IHN0cmluZyB8IHN0cmluZ1tdO1xuXG4gIC8qKiBJZ25vcmVQYXR0ZXJucyBoZWxwZXIgdmFsdWUuICovXG4gIGlnbm9yZVBhdHRlcm5zPzogc3RyaW5nIHwgc3RyaW5nW107XG5cbiAgLyoqIFRlc3RTdWZmaXhlcyBoZWxwZXIgdmFsdWUuICovXG4gIHRlc3RTdWZmaXhlcz86IHN0cmluZyB8IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgdHlwZSB7IFJlcXVpcmVUZXN0Q29tcGFuaW9uT3B0aW9ucyB9O1xuIl19

package/dist/testing/single-act-statement/index.d.ts

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

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

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

package/dist/testing/single-act-statement/index.js

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { analyzeTestBlock, countActStatements } from "../aaa";
+const singleActStatementRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const actStatementCount = countActStatements(analysis);
+                if (actStatementCount <= 1) {
+                    return;
+                }
+                context.report({
+                    data: { count: String(actStatementCount) },
+                    messageId: "multipleActStatements",
+                    node: analysis.callExpression,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("single-act-statement", "Require the // Act section to contain a single top-level statement or declaration."),
+        messages: {
+            multipleActStatements: "Reduce the // Act section to a single top-level statement or variable declaration; found {{count}}.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { singleActStatementRule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZXN0aW5nL3NpbmdsZS1hY3Qtc3RhdGVtZW50L3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDMUUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGtCQUFrQixFQUFFLE1BQU0sUUFBUSxDQUFDO0FBRTlELE1BQU0sc0JBQXNCLEdBQW9CO0lBQzlDLE1BQU0sQ0FBQyxPQUF5QjtRQUM5QixPQUFPO1lBQ0wsY0FBYyxDQUFDLElBQUk7Z0JBQ2pCLE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDakQsSUFBSSxRQUFRLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztvQkFDeEIsT0FBTztnQkFDVCxDQUFDO2dCQUVELE1BQU0saUJBQWlCLEdBQUcsa0JBQWtCLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ3ZELElBQUksaUJBQWlCLElBQUksQ0FBQyxFQUFFLENBQUM7b0JBQzNCLE9BQU87Z0JBQ1QsQ0FBQztnQkFFRCxPQUFPLENBQUMsTUFBTSxDQUFDO29CQUNiLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLENBQUMsaUJBQWlCLENBQUMsRUFBRTtvQkFDMUMsU0FBUyxFQUFFLHVCQUF1QjtvQkFDbEMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxjQUFjO2lCQUM5QixDQUFDLENBQUM7WUFDTCxDQUFDO1NBQzBCLENBQUM7SUFDaEMsQ0FBQztJQUNELElBQUksRUFBRTtRQUNKLElBQUksRUFBRSx1QkFBdUIsQ0FDM0Isc0JBQXNCLEVBQ3RCLG9GQUFvRixDQUNyRjtRQUNELFFBQVEsRUFBRTtZQUNSLHFCQUFxQixFQUNuQixxR0FBcUc7U0FDeEc7UUFDRCxNQUFNLEVBQUUsRUFBRTtRQUNWLElBQUksRUFBRSxZQUFZO0tBQ25CO0NBQ0YsQ0FBQztBQUVGLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSdWxlIH0gZnJvbSBcImVzbGludFwiO1xuXG5pbXBvcnQgeyBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbiB9IGZyb20gXCIuLi8uLi9jdXN0b20tcnVsZS1kb2N1bWVudGF0aW9uXCI7XG5pbXBvcnQgeyBhbmFseXplVGVzdEJsb2NrLCBjb3VudEFjdFN0YXRlbWVudHMgfSBmcm9tIFwiLi4vYWFhXCI7XG5cbmNvbnN0IHNpbmdsZUFjdFN0YXRlbWVudFJ1bGU6IFJ1bGUuUnVsZU1vZHVsZSA9IHtcbiAgY3JlYXRlKGNvbnRleHQ6IFJ1bGUuUnVsZUNvbnRleHQpOiBSdWxlLlJ1bGVMaXN0ZW5lciB7XG4gICAgcmV0dXJuIHtcbiAgICAgIENhbGxFeHByZXNzaW9uKG5vZGUpOiB2b2lkIHtcbiAgICAgICAgY29uc3QgYW5hbHlzaXMgPSBhbmFseXplVGVzdEJsb2NrKGNvbnRleHQsIG5vZGUpO1xuICAgICAgICBpZiAoYW5hbHlzaXMgPT09IHZvaWQgMCkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnN0IGFjdFN0YXRlbWVudENvdW50ID0gY291bnRBY3RTdGF0ZW1lbnRzKGFuYWx5c2lzKTtcbiAgICAgICAgaWYgKGFjdFN0YXRlbWVudENvdW50IDw9IDEpIHtcbiAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBjb250ZXh0LnJlcG9ydCh7XG4gICAgICAgICAgZGF0YTogeyBjb3VudDogU3RyaW5nKGFjdFN0YXRlbWVudENvdW50KSB9LFxuICAgICAgICAgIG1lc3NhZ2VJZDogXCJtdWx0aXBsZUFjdFN0YXRlbWVudHNcIixcbiAgICAgICAgICBub2RlOiBhbmFseXNpcy5jYWxsRXhwcmVzc2lvbixcbiAgICAgICAgfSk7XG4gICAgICB9LFxuICAgIH0gc2F0aXNmaWVzIFJ1bGUuUnVsZUxpc3RlbmVyO1xuICB9LFxuICBtZXRhOiB7XG4gICAgZG9jczogY3JlYXRlUnVsZURvY3VtZW50YXRpb24oXG4gICAgICBcInNpbmdsZS1hY3Qtc3RhdGVtZW50XCIsXG4gICAgICBcIlJlcXVpcmUgdGhlIC8vIEFjdCBzZWN0aW9uIHRvIGNvbnRhaW4gYSBzaW5nbGUgdG9wLWxldmVsIHN0YXRlbWVudCBvciBkZWNsYXJhdGlvbi5cIixcbiAgICApLFxuICAgIG1lc3NhZ2VzOiB7XG4gICAgICBtdWx0aXBsZUFjdFN0YXRlbWVudHM6XG4gICAgICAgIFwiUmVkdWNlIHRoZSAvLyBBY3Qgc2VjdGlvbiB0byBhIHNpbmdsZSB0b3AtbGV2ZWwgc3RhdGVtZW50IG9yIHZhcmlhYmxlIGRlY2xhcmF0aW9uOyBmb3VuZCB7e2NvdW50fX0uXCIsXG4gICAgfSxcbiAgICBzY2hlbWE6IFtdLFxuICAgIHR5cGU6IFwic3VnZ2VzdGlvblwiLFxuICB9LFxufTtcblxuZXhwb3J0IHsgc2luZ2xlQWN0U3RhdGVtZW50UnVsZSB9O1xuIl19

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@codeperfect/eslint-plugin",
+  "version": "1.0.0",
+  "description": "Custom ESLint rules for TypeScript repositories",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "custom-rules",
+    "typescript",
+    "linting"
+  ],
+  "homepage": "https://github.com/codeperfect/eslint-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/codeperfect/eslint-plugin/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codeperfect/eslint-plugin.git"
+  },
+  "license": "MIT",
+  "author": "CodePerfect",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "\n# --------------- SCM --------------- #": "",
+    "commit": "npx --yes git-cz",
+    "prepare": "husky",
+    "\n# --------------- BUILDING --------------- #": "",
+    "build": "npm run clean && npm run compile",
+    "clean": "npx --yes rimraf dist",
+    "compile": "tsc -b -f ./tsconfig.build.json",
+    "pack": "npm pack --pack-destination dist",
+    "\n# --------------- LINTING --------------- #": "",
+    "\t• --------------- checking --------------- •": "",
+    "eslint": "npx --yes eslint --max-warnings=0",
+    "lint": "npm run lint:run",
+    "lint:run": "npm run prettier && npm run eslint",
+    "lint:staged": "npx --yes tsx scripts/lint-staged.ts",
+    "prettier": "npx --yes prettier --ignore-unknown --check .",
+    "\n\t• --------------- fixing --------------- •": "",
+    "eslint:fix": "npm run check:rules && npm run eslint -- --fix",
+    "lint:fix": "npm run prettier:write && npm run eslint:fix",
+    "prettier:write": "npm run prettier -- --write",
+    "\n\t• --------------- helpers --------------- •": "",
+    "check:rules": "npx --yes eslint-config-prettier eslint.config.ts",
+    "benchmark:rules": "npx --yes tsx src/benchmark-rules.ts",
+    "eslint:inspect": "npx --yes @eslint/config-inspector",
+    "\n# --------------- TESTING --------------- #": "",
+    "typecheck": "tsc --noEmit",
+    "typecheck:spec": "tsc -p tsconfig.spec.json --noEmit",
+    "validate": "npm run lint && npm run typecheck && npm run typecheck:spec && npm run test && npm run build && npm run pack",
+    "\n\t• --------------- unit --------------- •": "",
+    "tdd": "npx --yes vitest run --watch --silent=true --coverage.enabled=false",
+    "tdd:notify": "npm run tdd -- --notify",
+    "test": "npx --yes vitest run"
+  },
+  "dependencies": {
+    "minimatch": "^9.0.5"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "devDependencies": {
+    "@codeperfect/eslint-config": "file:../eslint-config/dist/codeperfect-eslint-config-1.0.0.tgz",
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@commitlint/cz-commitlint": "^20.4.1",
+    "@eslint/js": "^9.39.2",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^25.2.1",
+    "@typescript-eslint/rule-tester": "^8.46.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "chalk": "^5.6.2",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "lodash-es": "^4.17.23",
+    "memfs": "^4.56.11",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}