@codeperfect/eslint-plugin 1.0.0

package/dist/architecture/consistent-barrel-files/test-helpers.js

@@ -0,0 +1,229 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Creates a temporary repo directory under the given root.
+ * @param root Root folder for temp files.
+ * @returns The generated directory path.
+ * @example
+ * ```typescript
+ * const directory = createRepoDirectory("tmp");
+ * ```
+ */
+const createRepoDirectory = (root) => {
+    const baseDirectory = path.join(process.cwd(), root);
+    fs.mkdirSync(baseDirectory, { recursive: true });
+    return fs.mkdtempSync(path.join(baseDirectory, "barrel-files-"));
+};
+/**
+ * Creates a program wrapper around the supplied AST body.
+ * @param body Program body statements.
+ * @returns The AST program.
+ * @example
+ * ```typescript
+ * const program = createProgram([]);
+ * ```
+ */
+const createProgram = (body) => ({
+    body,
+    comments: [],
+    loc: {
+        end: { column: 0, line: 1 },
+        start: { column: 0, line: 1 },
+    },
+    range: [0, 0],
+    sourceType: "module",
+    tokens: [],
+    type: "Program",
+});
+/**
+ * Creates an ESTree literal node.
+ * @param value Literal string to wrap.
+ * @returns The literal node.
+ * @example
+ * ```typescript
+ * const literal = createLiteral("./feature");
+ * ```
+ */
+const createLiteral = (value) => ({
+    raw: `'${value}'`,
+    type: "Literal",
+    value,
+});
+/**
+ * Creates an ESTree identifier node.
+ * @param name Identifier to create.
+ * @returns The identifier node.
+ * @example
+ * ```typescript
+ * const id = createIdentifier("all");
+ * ```
+ */
+const createIdentifier = (name) => ({ name, type: "Identifier" });
+/**
+ * Creates an ESTree export specifier.
+ * @param localName Local identifier name.
+ * @param exportedName Exported identifier name.
+ * @returns Export specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createExportSpecifier("feature");
+ * ```
+ */
+const createExportSpecifier = (localName, exportedName = localName) => ({
+    exported: createIdentifier(exportedName),
+    local: createIdentifier(localName),
+    type: "ExportSpecifier",
+});
+/**
+ * Creates an ESTree import specifier.
+ * @param localName Local identifier name.
+ * @param importedName Imported identifier name.
+ * @returns Import specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createImportSpecifier("feature");
+ * ```
+ */
+const createImportSpecifier = (localName, importedName = localName) => ({
+    imported: createIdentifier(importedName),
+    local: createIdentifier(localName),
+    type: "ImportSpecifier",
+});
+/**
+ * Creates an ESTree import default specifier.
+ * @param localName Local identifier name.
+ * @returns Import default specifier node.
+ * @example
+ * ```typescript
+ * const specifier = createImportDefaultSpecifier("feature");
+ * ```
+ */
+const createImportDefaultSpecifier = (localName) => ({
+    local: createIdentifier(localName),
+    type: "ImportDefaultSpecifier",
+});
+/**
+ * Creates an import declaration for test fixtures.
+ * @param specifiers Specifiers to include.
+ * @returns Import declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createImportDeclaration([createImportSpecifier("feature")]);
+ * ```
+ */
+const createImportDeclaration = (specifiers = []) => ({
+    attributes: [],
+    source: createLiteral("./feature"),
+    specifiers,
+    type: "ImportDeclaration",
+});
+/**
+ * Creates an export-all declaration for test fixtures.
+ * @returns The export-all declaration node.
+ * @example
+ * ```typescript
+ * const node = createExportAll();
+ * ```
+ */
+const createExportAll = () => ({
+    attributes: [],
+    exported: createIdentifier("all"),
+    source: createLiteral("./feature"),
+    type: "ExportAllDeclaration",
+});
+/**
+ * Creates a named export-from declaration for test fixtures.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportNamedFrom();
+ * ```
+ */
+const createExportNamedFrom = () => ({
+    attributes: [],
+    source: createLiteral("./feature"),
+    specifiers: [],
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates a named export with a local declaration.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportWithDeclaration();
+ * ```
+ */
+const createExportWithDeclaration = () => {
+    const declaration = {
+        declarations: [],
+        kind: "const",
+        type: "VariableDeclaration",
+    };
+    return {
+        attributes: [],
+        declaration,
+        specifiers: [],
+        type: "ExportNamedDeclaration",
+    };
+};
+/**
+ * Creates a named export without a source value.
+ * @param specifiers Export specifiers to include.
+ * @returns Export declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportWithoutSource([createExportSpecifier("feature")]);
+ * ```
+ */
+const createExportWithoutSource = (specifiers = []) => ({
+    attributes: [],
+    specifiers,
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates a default export for an identifier.
+ * @param name Identifier to export.
+ * @returns Export default declaration node for tests.
+ * @example
+ * ```typescript
+ * const node = createExportDefaultIdentifier("feature");
+ * ```
+ */
+const createExportDefaultIdentifier = (name) => ({
+    declaration: createIdentifier(name),
+    type: "ExportDefaultDeclaration",
+});
+/**
+ * Collects statements into a program body array.
+ * @param statements Statements to include in the program.
+ * @returns The program body array.
+ * @example
+ * ```typescript
+ * const body = createBody(createImportDeclaration());
+ * ```
+ */
+const createBody = (...statements) => statements;
+/**
+ * Writes a barrel file to the given path.
+ * @param filePath Path for the barrel file.
+ * @example
+ * ```typescript
+ * writeBarrel("/tmp/index.ts");
+ * ```
+ */
+const writeBarrel = (filePath) => {
+    fs.writeFileSync(filePath, "export * from './feature';", "utf8");
+};
+/**
+ * Writes a feature file to the given path.
+ * @param filePath Path for the feature file.
+ * @example
+ * ```typescript
+ * writeFeature("/tmp/feature.ts");
+ * ```
+ */
+const writeFeature = (filePath) => {
+    fs.writeFileSync(filePath, "export const feature = 1;", "utf8");
+};
+export { createBody, createExportAll, createExportDefaultIdentifier, createExportNamedFrom, createExportSpecifier, createExportWithDeclaration, createExportWithoutSource, createImportDeclaration, createImportDefaultSpecifier, createImportSpecifier, createProgram, createRepoDirectory, writeBarrel, writeFeature, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AST } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Creates a temporary repo directory under the given root.\n * @param root Root folder for temp files.\n * @returns The generated directory path.\n * @example\n * ```typescript\n * const directory = createRepoDirectory(\"tmp\");\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, \"barrel-files-\"));\n};\n\n/**\n * Creates a program wrapper around the supplied AST body.\n * @param body Program body statements.\n * @returns The AST program.\n * @example\n * ```typescript\n * const program = createProgram([]);\n * ```\n */\nconst createProgram = (body: ESTree.Program[\"body\"]): 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 an ESTree literal node.\n * @param value Literal string to wrap.\n * @returns The literal node.\n * @example\n * ```typescript\n * const literal = createLiteral(\"./feature\");\n * ```\n */\nconst createLiteral = (value: string): ESTree.Literal =>\n  ({\n    raw: `'${value}'`,\n    type: \"Literal\",\n    value,\n  }) satisfies ESTree.Literal;\n\n/**\n * Creates an ESTree identifier node.\n * @param name Identifier to create.\n * @returns The identifier node.\n * @example\n * ```typescript\n * const id = createIdentifier(\"all\");\n * ```\n */\nconst createIdentifier = (name: string): ESTree.Identifier =>\n  ({ name, type: \"Identifier\" }) satisfies ESTree.Identifier;\n\n/**\n * Creates an ESTree export specifier.\n * @param localName Local identifier name.\n * @param exportedName Exported identifier name.\n * @returns Export specifier node.\n * @example\n * ```typescript\n * const specifier = createExportSpecifier(\"feature\");\n * ```\n */\nconst createExportSpecifier = (\n  localName: string,\n  exportedName = localName,\n): ESTree.ExportSpecifier =>\n  ({\n    exported: createIdentifier(exportedName),\n    local: createIdentifier(localName),\n    type: \"ExportSpecifier\",\n  }) satisfies ESTree.ExportSpecifier;\n\n/**\n * Creates an ESTree import specifier.\n * @param localName Local identifier name.\n * @param importedName Imported identifier name.\n * @returns Import specifier node.\n * @example\n * ```typescript\n * const specifier = createImportSpecifier(\"feature\");\n * ```\n */\nconst createImportSpecifier = (\n  localName: string,\n  importedName = localName,\n): ESTree.ImportSpecifier =>\n  ({\n    imported: createIdentifier(importedName),\n    local: createIdentifier(localName),\n    type: \"ImportSpecifier\",\n  }) satisfies ESTree.ImportSpecifier;\n\n/**\n * Creates an ESTree import default specifier.\n * @param localName Local identifier name.\n * @returns Import default specifier node.\n * @example\n * ```typescript\n * const specifier = createImportDefaultSpecifier(\"feature\");\n * ```\n */\nconst createImportDefaultSpecifier = (\n  localName: string,\n): ESTree.ImportDefaultSpecifier =>\n  ({\n    local: createIdentifier(localName),\n    type: \"ImportDefaultSpecifier\",\n  }) satisfies ESTree.ImportDefaultSpecifier;\n\n/**\n * Creates an import declaration for test fixtures.\n * @param specifiers Specifiers to include.\n * @returns Import declaration node for tests.\n * @example\n * ```typescript\n * const node = createImportDeclaration([createImportSpecifier(\"feature\")]);\n * ```\n */\nconst createImportDeclaration = (\n  specifiers: ESTree.ImportDeclaration[\"specifiers\"] = [],\n): ESTree.ImportDeclaration =>\n  ({\n    attributes: [],\n    source: createLiteral(\"./feature\"),\n    specifiers,\n    type: \"ImportDeclaration\",\n  }) satisfies ESTree.ImportDeclaration;\n\n/**\n * Creates an export-all declaration for test fixtures.\n * @returns The export-all declaration node.\n * @example\n * ```typescript\n * const node = createExportAll();\n * ```\n */\nconst createExportAll = (): ESTree.ExportAllDeclaration =>\n  ({\n    attributes: [],\n    exported: createIdentifier(\"all\"),\n    source: createLiteral(\"./feature\"),\n    type: \"ExportAllDeclaration\",\n  }) satisfies ESTree.ExportAllDeclaration;\n\n/**\n * Creates a named export-from declaration for test fixtures.\n * @returns Export declaration node for tests.\n * @example\n * ```typescript\n * const node = createExportNamedFrom();\n * ```\n */\nconst createExportNamedFrom = (): ESTree.ExportNamedDeclaration =>\n  ({\n    attributes: [],\n    source: createLiteral(\"./feature\"),\n    specifiers: [],\n    type: \"ExportNamedDeclaration\",\n  }) satisfies ESTree.ExportNamedDeclaration;\n\n/**\n * Creates a named export with a local declaration.\n * @returns Export declaration node for tests.\n * @example\n * ```typescript\n * const node = createExportWithDeclaration();\n * ```\n */\nconst createExportWithDeclaration = (): ESTree.ExportNamedDeclaration => {\n  const declaration = {\n    declarations: [],\n    kind: \"const\",\n    type: \"VariableDeclaration\",\n  } satisfies ESTree.VariableDeclaration;\n\n  return {\n    attributes: [],\n    declaration,\n    specifiers: [],\n    type: \"ExportNamedDeclaration\",\n  } satisfies ESTree.ExportNamedDeclaration;\n};\n\n/**\n * Creates a named export without a source value.\n * @param specifiers Export specifiers to include.\n * @returns Export declaration node for tests.\n * @example\n * ```typescript\n * const node = createExportWithoutSource([createExportSpecifier(\"feature\")]);\n * ```\n */\nconst createExportWithoutSource = (\n  specifiers: ESTree.ExportSpecifier[] = [],\n): ESTree.ExportNamedDeclaration =>\n  ({\n    attributes: [],\n    specifiers,\n    type: \"ExportNamedDeclaration\",\n  }) satisfies ESTree.ExportNamedDeclaration;\n\n/**\n * Creates a default export for an identifier.\n * @param name Identifier to export.\n * @returns Export default declaration node for tests.\n * @example\n * ```typescript\n * const node = createExportDefaultIdentifier(\"feature\");\n * ```\n */\nconst createExportDefaultIdentifier = (\n  name: string,\n): ESTree.ExportDefaultDeclaration =>\n  ({\n    declaration: createIdentifier(name),\n    type: \"ExportDefaultDeclaration\",\n  }) satisfies ESTree.ExportDefaultDeclaration;\n\n/**\n * Collects statements into a program body array.\n * @param statements Statements to include in the program.\n * @returns The program body array.\n * @example\n * ```typescript\n * const body = createBody(createImportDeclaration());\n * ```\n */\nconst createBody = (\n  ...statements: ESTree.Program[\"body\"][number][]\n): ESTree.Program[\"body\"] => statements;\n\n/**\n * Writes a barrel file to the given path.\n * @param filePath Path for the barrel file.\n * @example\n * ```typescript\n * writeBarrel(\"/tmp/index.ts\");\n * ```\n */\nconst writeBarrel = (filePath: string): void => {\n  fs.writeFileSync(filePath, \"export * from './feature';\", \"utf8\");\n};\n\n/**\n * Writes a feature file to the given path.\n * @param filePath Path for the feature file.\n * @example\n * ```typescript\n * writeFeature(\"/tmp/feature.ts\");\n * ```\n */\nconst writeFeature = (filePath: string): void => {\n  fs.writeFileSync(filePath, \"export const feature = 1;\", \"utf8\");\n};\n\nexport {\n  createBody,\n  createExportAll,\n  createExportDefaultIdentifier,\n  createExportNamedFrom,\n  createExportSpecifier,\n  createExportWithDeclaration,\n  createExportWithoutSource,\n  createImportDeclaration,\n  createImportDefaultSpecifier,\n  createImportSpecifier,\n  createProgram,\n  createRepoDirectory,\n  writeBarrel,\n  writeFeature,\n};\n"]}

package/dist/architecture/consistent-barrel-files/types.d.ts

@@ -0,0 +1,25 @@
+/** Type definition for rule data. */
+interface BarrelFilesExportsOnlyOptions {
+    /** Folders helper value. */
+    folders?: string | string[];
+    /** Names helper value. */
+    names?: string | string[];
+}
+/** Type definition for rule data. */
+interface ConsistentBarrelFilesOptions {
+    /** Enforce helper value. */
+    enforce?: boolean;
+    /** Folders helper value. */
+    folders?: string | string[];
+    /** Names helper value. */
+    names?: string | string[];
+}
+/** Type definition for rule data. */
+interface NoReexportsOutsideBarrelsOptions {
+    /** Folders helper value. */
+    folders?: string | string[];
+    /** Names helper value. */
+    names?: string | string[];
+}
+export type { BarrelFilesExportsOnlyOptions, ConsistentBarrelFilesOptions, NoReexportsOutsideBarrelsOptions, };
+//# sourceMappingURL=types.d.ts.map

package/dist/architecture/consistent-barrel-files/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/architecture/consistent-barrel-files/types.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,UAAU,6BAA6B;IACrC,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5B,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,4BAA4B;IACpC,4BAA4B;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5B,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,gCAAgC;IACxC,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5B,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B;AAED,YAAY,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,gCAAgC,GACjC,CAAC"}

package/dist/architecture/consistent-barrel-files/types.js

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

package/dist/architecture/index.d.ts

@@ -0,0 +1,2 @@
+export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noReexportsOutsideBarrelsRule, } from "./consistent-barrel-files";
+//# sourceMappingURL=index.d.ts.map

package/dist/architecture/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/architecture/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,2BAA2B,CAAC"}

package/dist/architecture/index.js

@@ -0,0 +1,2 @@
+export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noReexportsOutsideBarrelsRule, } from "./consistent-barrel-files";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXJjaGl0ZWN0dXJlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLDZCQUE2QixHQUM5QixNQUFNLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXG4gIGNvbnNpc3RlbnRCYXJyZWxGaWxlc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxufSBmcm9tIFwiLi9jb25zaXN0ZW50LWJhcnJlbC1maWxlc1wiO1xuIl19

package/dist/benchmark-rules.d.ts

@@ -0,0 +1,83 @@
+/** Shape of a benchmark case. */
+interface BenchmarkCase {
+    /** Source code passed to ESLint. */
+    code: string;
+    /** Filename used for the lint run. */
+    filename: string;
+    /** Rule id inside the internal plugin. */
+    ruleName: string;
+}
+/** Summary returned by a benchmark run. */
+interface BenchmarkSummary {
+    /** Elapsed milliseconds across all iterations. */
+    elapsedMilliseconds: number;
+    /** Iteration count used by the run. */
+    iterations: number;
+    /** Rule name under test. */
+    ruleName: string;
+}
+/** Benchmark cases covering the heavier package-owned rules. */
+declare const benchmarkCases: readonly [{
+    readonly code: string;
+    readonly filename: "src/features.ts";
+    readonly ruleName: "prefer-interface-types";
+}, {
+    readonly code: string;
+    readonly filename: "src/docs.ts";
+    readonly ruleName: "require-example-language";
+}, {
+    readonly code: string;
+    readonly filename: "src/example.spec.ts";
+    readonly ruleName: "prefer-vi-mocked-import";
+}, {
+    readonly code: string;
+    readonly filename: "src/index.ts";
+    readonly ruleName: "consistent-barrel-files";
+}];
+/**
+ * Formats a benchmark summary for console output.
+ * @param summary Summary to format.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const line = formatBenchmarkSummary({
+ *   elapsedMilliseconds: 10,
+ *   iterations: 1,
+ *   ruleName: "prefer-interface-types",
+ * });
+ * ```
+ */
+declare function formatBenchmarkSummary(summary: BenchmarkSummary): string;
+/**
+ * Runs the benchmark command and prints each summary.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @example
+ * ```typescript
+ * main(1);
+ * ```
+ */
+declare function main(iterationsOverride?: number): void;
+/**
+ * Runs a benchmark case and returns the elapsed milliseconds.
+ * @param benchmarkCase Benchmark definition.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const summary = runBenchmark(benchmarkCases[0], 1);
+ * ```
+ */
+declare function runBenchmark(benchmarkCase: BenchmarkCase, iterationsOverride?: number): BenchmarkSummary;
+/**
+ * Runs all benchmark cases and returns their summaries.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const summaries = runBenchmarks(1);
+ * ```
+ */
+declare function runBenchmarks(iterationsOverride?: number): BenchmarkSummary[];
+export { benchmarkCases, formatBenchmarkSummary, main, runBenchmark, runBenchmarks, };
+export type { BenchmarkCase, BenchmarkSummary };
+//# sourceMappingURL=benchmark-rules.d.ts.map

package/dist/benchmark-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark-rules.d.ts","sourceRoot":"","sources":["../src/benchmark-rules.ts"],"names":[],"mappings":"AAcA,iCAAiC;AACjC,UAAU,aAAa;IACrB,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IAEb,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IAEjB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,2CAA2C;AAC3C,UAAU,gBAAgB;IACxB,kDAAkD;IAClD,mBAAmB,EAAE,MAAM,CAAC;IAE5B,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IAEnB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAYD,gEAAgE;AAChE,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;EAwC6C,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,iBAAS,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAEjE;AAgCD;;;;;;;GAOG;AACH,iBAAS,IAAI,CAAC,kBAAkB,SAAa,GAAG,IAAI,CAInD;AAED;;;;;;;;;GASG;AACH,iBAAS,YAAY,CACnB,aAAa,EAAE,aAAa,EAC5B,kBAAkB,SAAa,GAC9B,gBAAgB,CAiClB;AAED;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,kBAAkB,SAAa,GAAG,gBAAgB,EAAE,CAI1E;AAqBD,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,IAAI,EACJ,YAAY,EACZ,aAAa,GACd,CAAC;AACF,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/benchmark-rules.js

@@ -0,0 +1,175 @@
+import { Linter } from "eslint";
+import { performance } from "node:perf_hooks";
+import { pathToFileURL } from "node:url";
+import { parser } from "typescript-eslint";
+import { consistentBarrelFilesRule, preferInterfaceTypesRule, preferViMockedImportRule, requireExampleLanguageRule, } from "./rules";
+/** Iteration count for each benchmark case. */
+const iterations = 25;
+/** Shared TypeScript language options for benchmark runs. */
+const languageOptions = {
+    ecmaVersion: 2022,
+    parser,
+    sourceType: "module",
+};
+/** Benchmark cases covering the heavier package-owned rules. */
+const benchmarkCases = [
+    {
+        code: Array.from({ length: 200 }, (_unused, index) => {
+            return `export interface Feature${index} { value: string }`;
+        }).join("\n"),
+        filename: "src/features.ts",
+        ruleName: "prefer-interface-types",
+    },
+    {
+        code: Array.from({ length: 150 }, (_unused, index) => {
+            return [
+                "/**",
+                ` * @example feature${index}()`,
+                " * ```typescript",
+                ` * feature${index}();`,
+                " * ```",
+                " */",
+                `export function feature${index}(): void {}`,
+            ].join("\n");
+        }).join("\n"),
+        filename: "src/docs.ts",
+        ruleName: "require-example-language",
+    },
+    {
+        code: Array.from({ length: 100 }, (_unused, index) => {
+            return [
+                `const mockedFeature${index} = vi.fn();`,
+                `vi.mock("./feature-${index}", () => ({ feature${index}: mockedFeature${index} }));`,
+            ].join("\n");
+        }).join("\n"),
+        filename: "src/example.spec.ts",
+        ruleName: "prefer-vi-mocked-import",
+    },
+    {
+        code: Array.from({ length: 150 }, (_unused, index) => {
+            return `export * from "./feature-${index}";`;
+        }).join("\n"),
+        filename: "src/index.ts",
+        ruleName: "consistent-barrel-files",
+    },
+];
+/**
+ * Formats a benchmark summary for console output.
+ * @param summary Summary to format.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const line = formatBenchmarkSummary({
+ *   elapsedMilliseconds: 10,
+ *   iterations: 1,
+ *   ruleName: "prefer-interface-types",
+ * });
+ * ```
+ */
+function formatBenchmarkSummary(summary) {
+    return `${summary.ruleName}: ${summary.elapsedMilliseconds}ms total for ${summary.iterations} iterations`;
+}
+/**
+ * Resolves the rule module used for a benchmark case.
+ * @param ruleName Internal rule name.
+ * @returns Return value output.
+ * @throws {TypeError} When the benchmark case references an unsupported rule.
+ * @example
+ * ```typescript
+ * const rule = getRuleModule("prefer-interface-types");
+ * ```
+ */
+function getRuleModule(ruleName) {
+    switch (ruleName) {
+        case "consistent-barrel-files": {
+            return consistentBarrelFilesRule;
+        }
+        case "prefer-interface-types": {
+            return preferInterfaceTypesRule;
+        }
+        case "prefer-vi-mocked-import": {
+            return preferViMockedImportRule;
+        }
+        case "require-example-language": {
+            return requireExampleLanguageRule;
+        }
+        default: {
+            throw new TypeError(`Unsupported benchmark rule: ${ruleName}`);
+        }
+    }
+}
+/**
+ * Runs the benchmark command and prints each summary.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @example
+ * ```typescript
+ * main(1);
+ * ```
+ */
+function main(iterationsOverride = iterations) {
+    for (const summary of runBenchmarks(iterationsOverride)) {
+        process.stdout.write(`${formatBenchmarkSummary(summary)}\n`);
+    }
+}
+/**
+ * Runs a benchmark case and returns the elapsed milliseconds.
+ * @param benchmarkCase Benchmark definition.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const summary = runBenchmark(benchmarkCases[0], 1);
+ * ```
+ */
+function runBenchmark(benchmarkCase, iterationsOverride = iterations) {
+    const linter = new Linter({ configType: "flat" });
+    const pluginRules = Object.fromEntries([
+        [benchmarkCase.ruleName, getRuleModule(benchmarkCase.ruleName)],
+    ]);
+    const start = performance.now();
+    for (let iteration = 0; iteration < iterationsOverride; iteration += 1) {
+        void linter.verify(benchmarkCase.code, [
+            {
+                files: ["**/*.ts"],
+                languageOptions,
+                plugins: {
+                    codeperfect: {
+                        rules: pluginRules,
+                    },
+                },
+                rules: {
+                    [`codeperfect/${benchmarkCase.ruleName}`]: "error",
+                },
+            },
+        ], benchmarkCase.filename);
+    }
+    return {
+        elapsedMilliseconds: Number((performance.now() - start).toFixed(2)),
+        iterations: iterationsOverride,
+        ruleName: benchmarkCase.ruleName,
+    };
+}
+/**
+ * Runs all benchmark cases and returns their summaries.
+ * @param iterationsOverride Optional iteration count used by the run.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const summaries = runBenchmarks(1);
+ * ```
+ */
+function runBenchmarks(iterationsOverride = iterations) {
+    return benchmarkCases.map((benchmarkCase) => runBenchmark(benchmarkCase, iterationsOverride));
+}
+/** Current CLI entry file when invoked from the terminal. */
+const [, currentEntry] = process.argv;
+/** Iteration count used by the CLI entry point. */
+const cliIterations = Number(process.env["BENCHMARK_RULE_ITERATIONS"] ?? iterations);
+if (currentEntry !== void 0 &&
+    import.meta.url === pathToFileURL(currentEntry).href) {
+    main(Number.isNaN(cliIterations) || cliIterations < 1
+        ? iterations
+        : cliIterations);
+}
+export { benchmarkCases, formatBenchmarkSummary, main, runBenchmark, runBenchmarks, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"benchmark-rules.js","sourceRoot":"","sources":["../src/benchmark-rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,SAAS,CAAC;AA0BjB,+CAA+C;AAC/C,MAAM,UAAU,GAAG,EAAE,CAAC;AAEtB,6DAA6D;AAC7D,MAAM,eAAe,GAAG;IACtB,WAAW,EAAE,IAAI;IACjB,MAAM;IACN,UAAU,EAAE,QAAQ;CACZ,CAAC;AAEX,gEAAgE;AAChE,MAAM,cAAc,GAAG;IACrB;QACE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACnD,OAAO,2BAA2B,KAAK,oBAAoB,CAAC;QAC9D,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACb,QAAQ,EAAE,iBAAiB;QAC3B,QAAQ,EAAE,wBAAwB;KACnC;IACD;QACE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACnD,OAAO;gBACL,KAAK;gBACL,sBAAsB,KAAK,IAAI;gBAC/B,kBAAkB;gBAClB,aAAa,KAAK,KAAK;gBACvB,QAAQ;gBACR,KAAK;gBACL,0BAA0B,KAAK,aAAa;aAC7C,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACb,QAAQ,EAAE,aAAa;QACvB,QAAQ,EAAE,0BAA0B;KACrC;IACD;QACE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACnD,OAAO;gBACL,sBAAsB,KAAK,aAAa;gBACxC,sBAAsB,KAAK,sBAAsB,KAAK,kBAAkB,KAAK,OAAO;aACrF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACb,QAAQ,EAAE,qBAAqB;QAC/B,QAAQ,EAAE,yBAAyB;KACpC;IACD;QACE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACnD,OAAO,4BAA4B,KAAK,IAAI,CAAC;QAC/C,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACb,QAAQ,EAAE,cAAc;QACxB,QAAQ,EAAE,yBAAyB;KACpC;CAC8D,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,SAAS,sBAAsB,CAAC,OAAyB;IACvD,OAAO,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,mBAAmB,gBAAgB,OAAO,CAAC,UAAU,aAAa,CAAC;AAC5G,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,aAAa,CAAC,QAAmC;IACxD,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,yBAAyB,CAAC,CAAC,CAAC;YAC/B,OAAO,yBAAyB,CAAC;QACnC,CAAC;QACD,KAAK,wBAAwB,CAAC,CAAC,CAAC;YAC9B,OAAO,wBAAwB,CAAC;QAClC,CAAC;QACD,KAAK,yBAAyB,CAAC,CAAC,CAAC;YAC/B,OAAO,wBAAwB,CAAC;QAClC,CAAC;QACD,KAAK,0BAA0B,CAAC,CAAC,CAAC;YAChC,OAAO,0BAA0B,CAAC;QACpC,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,IAAI,SAAS,CAAC,+BAA+B,QAAQ,EAAE,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,IAAI,CAAC,kBAAkB,GAAG,UAAU;IAC3C,KAAK,MAAM,OAAO,IAAI,aAAa,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACxD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,sBAAsB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,YAAY,CACnB,aAA4B,EAC5B,kBAAkB,GAAG,UAAU;IAE/B,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACrC,CAAC,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;KAChE,CAAoC,CAAC;IACtC,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAEhC,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,kBAAkB,EAAE,SAAS,IAAI,CAAC,EAAE,CAAC;QACvE,KAAK,MAAM,CAAC,MAAM,CAChB,aAAa,CAAC,IAAI,EAClB;YACE;gBACE,KAAK,EAAE,CAAC,SAAS,CAAC;gBAClB,eAAe;gBACf,OAAO,EAAE;oBACP,WAAW,EAAE;wBACX,KAAK,EAAE,WAAW;qBACnB;iBACF;gBACD,KAAK,EAAE;oBACL,CAAC,eAAe,aAAa,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO;iBACnD;aACF;SACF,EACD,aAAa,CAAC,QAAQ,CACvB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,mBAAmB,EAAE,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnE,UAAU,EAAE,kBAAkB;QAC9B,QAAQ,EAAE,aAAa,CAAC,QAAQ;KACjC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,kBAAkB,GAAG,UAAU;IACpD,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAC1C,YAAY,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAChD,CAAC;AACJ,CAAC;AAED,6DAA6D;AAC7D,MAAM,CAAC,EAAE,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;AAEtC,mDAAmD;AACnD,MAAM,aAAa,GAAG,MAAM,CAC1B,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,IAAI,UAAU,CACvD,CAAC;AAEF,IACE,YAAY,KAAK,KAAK,CAAC;IACvB,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,aAAa,CAAC,YAAY,CAAC,CAAC,IAAI,EACpD,CAAC;IACD,IAAI,CACF,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,aAAa,GAAG,CAAC;QAC9C,CAAC,CAAC,UAAU;QACZ,CAAC,CAAC,aAAa,CAClB,CAAC;AACJ,CAAC;AAED,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,IAAI,EACJ,YAAY,EACZ,aAAa,GACd,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { Linter } from \"eslint\";\nimport { performance } from \"node:perf_hooks\";\nimport { pathToFileURL } from \"node:url\";\nimport { parser } from \"typescript-eslint\";\n\nimport {\n  consistentBarrelFilesRule,\n  preferInterfaceTypesRule,\n  preferViMockedImportRule,\n  requireExampleLanguageRule,\n} from \"./rules\";\n\n/** Shape of a benchmark case. */\ninterface BenchmarkCase {\n  /** Source code passed to ESLint. */\n  code: string;\n\n  /** Filename used for the lint run. */\n  filename: string;\n\n  /** Rule id inside the internal plugin. */\n  ruleName: string;\n}\n\n/** Summary returned by a benchmark run. */\ninterface BenchmarkSummary {\n  /** Elapsed milliseconds across all iterations. */\n  elapsedMilliseconds: number;\n\n  /** Iteration count used by the run. */\n  iterations: number;\n\n  /** Rule name under test. */\n  ruleName: string;\n}\n\n/** Iteration count for each benchmark case. */\nconst iterations = 25;\n\n/** Shared TypeScript language options for benchmark runs. */\nconst languageOptions = {\n  ecmaVersion: 2022,\n  parser,\n  sourceType: \"module\",\n} as const;\n\n/** Benchmark cases covering the heavier package-owned rules. */\nconst benchmarkCases = [\n  {\n    code: Array.from({ length: 200 }, (_unused, index) => {\n      return `export interface Feature${index} { value: string }`;\n    }).join(\"\\n\"),\n    filename: \"src/features.ts\",\n    ruleName: \"prefer-interface-types\",\n  },\n  {\n    code: Array.from({ length: 150 }, (_unused, index) => {\n      return [\n        \"/**\",\n        ` * @example feature${index}()`,\n        \" * ```typescript\",\n        ` * feature${index}();`,\n        \" * ```\",\n        \" */\",\n        `export function feature${index}(): void {}`,\n      ].join(\"\\n\");\n    }).join(\"\\n\"),\n    filename: \"src/docs.ts\",\n    ruleName: \"require-example-language\",\n  },\n  {\n    code: Array.from({ length: 100 }, (_unused, index) => {\n      return [\n        `const mockedFeature${index} = vi.fn();`,\n        `vi.mock(\"./feature-${index}\", () => ({ feature${index}: mockedFeature${index} }));`,\n      ].join(\"\\n\");\n    }).join(\"\\n\"),\n    filename: \"src/example.spec.ts\",\n    ruleName: \"prefer-vi-mocked-import\",\n  },\n  {\n    code: Array.from({ length: 150 }, (_unused, index) => {\n      return `export * from \"./feature-${index}\";`;\n    }).join(\"\\n\"),\n    filename: \"src/index.ts\",\n    ruleName: \"consistent-barrel-files\",\n  },\n] as const satisfies readonly [BenchmarkCase, ...BenchmarkCase[]];\n\n/**\n * Formats a benchmark summary for console output.\n * @param summary Summary to format.\n * @returns Return value output.\n * @example\n * ```typescript\n * const line = formatBenchmarkSummary({\n *   elapsedMilliseconds: 10,\n *   iterations: 1,\n *   ruleName: \"prefer-interface-types\",\n * });\n * ```\n */\nfunction formatBenchmarkSummary(summary: BenchmarkSummary): string {\n  return `${summary.ruleName}: ${summary.elapsedMilliseconds}ms total for ${summary.iterations} iterations`;\n}\n\n/**\n * Resolves the rule module used for a benchmark case.\n * @param ruleName Internal rule name.\n * @returns Return value output.\n * @throws {TypeError} When the benchmark case references an unsupported rule.\n * @example\n * ```typescript\n * const rule = getRuleModule(\"prefer-interface-types\");\n * ```\n */\nfunction getRuleModule(ruleName: BenchmarkCase[\"ruleName\"]): Rule.RuleModule {\n  switch (ruleName) {\n    case \"consistent-barrel-files\": {\n      return consistentBarrelFilesRule;\n    }\n    case \"prefer-interface-types\": {\n      return preferInterfaceTypesRule;\n    }\n    case \"prefer-vi-mocked-import\": {\n      return preferViMockedImportRule;\n    }\n    case \"require-example-language\": {\n      return requireExampleLanguageRule;\n    }\n    default: {\n      throw new TypeError(`Unsupported benchmark rule: ${ruleName}`);\n    }\n  }\n}\n\n/**\n * Runs the benchmark command and prints each summary.\n * @param iterationsOverride Optional iteration count used by the run.\n * @example\n * ```typescript\n * main(1);\n * ```\n */\nfunction main(iterationsOverride = iterations): void {\n  for (const summary of runBenchmarks(iterationsOverride)) {\n    process.stdout.write(`${formatBenchmarkSummary(summary)}\\n`);\n  }\n}\n\n/**\n * Runs a benchmark case and returns the elapsed milliseconds.\n * @param benchmarkCase Benchmark definition.\n * @param iterationsOverride Optional iteration count used by the run.\n * @returns Return value output.\n * @example\n * ```typescript\n * const summary = runBenchmark(benchmarkCases[0], 1);\n * ```\n */\nfunction runBenchmark(\n  benchmarkCase: BenchmarkCase,\n  iterationsOverride = iterations,\n): BenchmarkSummary {\n  const linter = new Linter({ configType: \"flat\" });\n  const pluginRules = Object.fromEntries([\n    [benchmarkCase.ruleName, getRuleModule(benchmarkCase.ruleName)],\n  ]) as Record<string, Rule.RuleModule>;\n  const start = performance.now();\n\n  for (let iteration = 0; iteration < iterationsOverride; iteration += 1) {\n    void linter.verify(\n      benchmarkCase.code,\n      [\n        {\n          files: [\"**/*.ts\"],\n          languageOptions,\n          plugins: {\n            codeperfect: {\n              rules: pluginRules,\n            },\n          },\n          rules: {\n            [`codeperfect/${benchmarkCase.ruleName}`]: \"error\",\n          },\n        },\n      ],\n      benchmarkCase.filename,\n    );\n  }\n\n  return {\n    elapsedMilliseconds: Number((performance.now() - start).toFixed(2)),\n    iterations: iterationsOverride,\n    ruleName: benchmarkCase.ruleName,\n  };\n}\n\n/**\n * Runs all benchmark cases and returns their summaries.\n * @param iterationsOverride Optional iteration count used by the run.\n * @returns Return value output.\n * @example\n * ```typescript\n * const summaries = runBenchmarks(1);\n * ```\n */\nfunction runBenchmarks(iterationsOverride = iterations): BenchmarkSummary[] {\n  return benchmarkCases.map((benchmarkCase) =>\n    runBenchmark(benchmarkCase, iterationsOverride),\n  );\n}\n\n/** Current CLI entry file when invoked from the terminal. */\nconst [, currentEntry] = process.argv;\n\n/** Iteration count used by the CLI entry point. */\nconst cliIterations = Number(\n  process.env[\"BENCHMARK_RULE_ITERATIONS\"] ?? iterations,\n);\n\nif (\n  currentEntry !== void 0 &&\n  import.meta.url === pathToFileURL(currentEntry).href\n) {\n  main(\n    Number.isNaN(cliIterations) || cliIterations < 1\n      ? iterations\n      : cliIterations,\n  );\n}\n\nexport {\n  benchmarkCases,\n  formatBenchmarkSummary,\n  main,\n  runBenchmark,\n  runBenchmarks,\n};\nexport type { BenchmarkCase, BenchmarkSummary };\n"]}

package/dist/codeperfect-plugin.d.ts

@@ -0,0 +1,46 @@
+import type { Rule } from "eslint";
+/** Rule registry exposed by the package plugin. */
+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-interface-member-docs": Rule.RuleModule;
+    readonly "no-multiple-declarators": Rule.RuleModule;
+    readonly "no-reexports-outside-barrels": Rule.RuleModule;
+    readonly "prefer-interface-types": Rule.RuleModule;
+    readonly "prefer-vi-mocked-import": 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;
+    readonly "single-act-statement": Rule.RuleModule;
+    readonly "single-line-jsdoc": Rule.RuleModule;
+};
+/** ESLint plugin object exported by the package. */
+declare const codeperfectPlugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        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-interface-member-docs": Rule.RuleModule;
+        readonly "no-multiple-declarators": Rule.RuleModule;
+        readonly "no-reexports-outside-barrels": Rule.RuleModule;
+        readonly "prefer-interface-types": Rule.RuleModule;
+        readonly "prefer-vi-mocked-import": 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;
+        readonly "single-act-statement": Rule.RuleModule;
+        readonly "single-line-jsdoc": Rule.RuleModule;
+    };
+};
+export { codeperfectPlugin, codeperfectRules };
+//# sourceMappingURL=codeperfect-plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codeperfect-plugin.d.ts","sourceRoot":"","sources":["../src/codeperfect-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,IAAI,EAAE,MAAM,QAAQ,CAAC;AAqB3C,mDAAmD;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAiB8B,CAAC;AAErD,oDAAoD;AACpD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;CAKkC,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}