@codeperfect/eslint-plugin 1.0.0 → 2.1.0

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

@@ -0,0 +1,235 @@
+import { mkdirSync, mkdtempSync } from "node:fs";
+import path from "node:path";
+import { cwd } from "node:process";
+/**
+ * Creates a temporary repo directory for test fixtures.
+ * @param root Root folder to create the temporary directory under.
+ * @returns The generated temporary directory path.
+ * @example
+ * ```typescript
+ * const directory = createRepoDirectory("tmp");
+ * ```
+ */
+const createRepoDirectory = (root) => {
+    const baseDirectory = path.join(cwd(), root);
+    mkdirSync(baseDirectory, { recursive: true });
+    return mkdtempSync(path.join(baseDirectory, "barrel-files-"));
+};
+/**
+ * Wraps statements in a program node for SourceCode construction.
+ * @param body Program body statements.
+ * @returns The AST program wrapper.
+ * @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 a string literal node for import and export statements.
+ * @param value Literal value to wrap.
+ * @returns The ESTree literal node.
+ * @example
+ * ```typescript
+ * const literal = createLiteral("./feature");
+ * ```
+ */
+const createLiteral = (value) => ({ raw: `'${value}'`, type: "Literal", value });
+/**
+ * Converts a raw symbol name into the ESTree shape used by the fixture factories.
+ * @param name Raw symbol text to encode in the AST node.
+ * @returns An ESTree Identifier carrying the supplied symbol text.
+ * @example
+ * ```typescript
+ * const identifier = createIdentifier("feature");
+ * ```
+ */
+const createIdentifier = (name) => ({ name, type: "Identifier" });
+/**
+ * Creates an export specifier node.
+ * @param localName Local identifier name.
+ * @param exportedName Exported identifier name.
+ * @returns The ESTree export specifier.
+ * @example
+ * ```typescript
+ * const specifier = createExportSpecifier("feature");
+ * ```
+ */
+const createExportSpecifier = (localName, exportedName = localName) => ({
+    exported: createIdentifier(exportedName),
+    local: createIdentifier(localName),
+    type: "ExportSpecifier",
+});
+/**
+ * Creates an import specifier node.
+ * @param localName Local identifier name.
+ * @param importedName Imported identifier name.
+ * @returns The ESTree import specifier.
+ * @example
+ * ```typescript
+ * const specifier = createImportSpecifier("feature");
+ * ```
+ */
+const createImportSpecifier = (localName, importedName = localName) => ({
+    imported: createIdentifier(importedName),
+    local: createIdentifier(localName),
+    type: "ImportSpecifier",
+});
+/**
+ * Creates an import default specifier node.
+ * @param localName Local identifier name.
+ * @returns The ESTree default import specifier.
+ * @example
+ * ```typescript
+ * const specifier = createImportDefaultSpecifier("feature");
+ * ```
+ */
+const createImportDefaultSpecifier = (localName) => ({
+    local: createIdentifier(localName),
+    type: "ImportDefaultSpecifier",
+});
+/**
+ * Creates an import declaration for fixture programs.
+ * @param specifiers Import specifiers to include.
+ * @returns The ESTree import declaration.
+ * @example
+ * ```typescript
+ * const declaration = createImportDeclaration();
+ * ```
+ */
+const createImportDeclaration = (specifiers = []) => ({
+    attributes: [],
+    source: createLiteral("./feature"),
+    specifiers,
+    type: "ImportDeclaration",
+});
+/**
+ * Creates an export-all declaration for fixture programs.
+ * @returns The ESTree export-all declaration.
+ * @example
+ * ```typescript
+ * const declaration = createExportAll();
+ * ```
+ */
+const createExportAll = () => ({
+    attributes: [],
+    exported: createIdentifier("all"),
+    source: createLiteral("./feature"),
+    type: "ExportAllDeclaration",
+});
+/**
+ * Creates an export-from declaration for fixture programs.
+ * @returns The ESTree named export declaration.
+ * @example
+ * ```typescript
+ * const declaration = createExportNamedFrom();
+ * ```
+ */
+const createExportNamedFrom = () => ({
+    attributes: [],
+    source: createLiteral("./feature"),
+    specifiers: [],
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates an export declaration with an inline variable declaration.
+ * @returns The ESTree named export declaration.
+ * @example
+ * ```typescript
+ * const declaration = createExportWithDeclaration();
+ * ```
+ */
+const createExportWithDeclaration = () => {
+    const declaration = {
+        declarations: [],
+        kind: "const",
+        type: "VariableDeclaration",
+    };
+    return {
+        attributes: [],
+        declaration,
+        specifiers: [],
+        type: "ExportNamedDeclaration",
+    };
+};
+/**
+ * Creates an exported interface declaration for tests.
+ * @returns The exported interface declaration node.
+ * @example
+ * ```typescript
+ * const declaration = createExportInterfaceDeclaration();
+ * ```
+ */
+const createExportInterfaceDeclaration = () => ({
+    declaration: {
+        body: { body: [], type: "TSInterfaceBody" },
+        id: createIdentifier("Feature"),
+        type: "TSInterfaceDeclaration",
+    },
+    specifiers: [],
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates an exported type alias declaration for tests.
+ * @returns The exported type alias declaration node.
+ * @example
+ * ```typescript
+ * const declaration = createExportTypeAliasDeclaration();
+ * ```
+ */
+const createExportTypeAliasDeclaration = () => ({
+    declaration: {
+        id: createIdentifier("Feature"),
+        type: "TSTypeAliasDeclaration",
+        typeAnnotation: { type: "TSStringKeyword" },
+    },
+    specifiers: [],
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates a named export without a source value.
+ * @param specifiers Export specifiers to include.
+ * @returns The ESTree named export declaration.
+ * @example
+ * ```typescript
+ * const declaration = createExportWithoutSource();
+ * ```
+ */
+const createExportWithoutSource = (specifiers = []) => ({
+    attributes: [],
+    specifiers,
+    type: "ExportNamedDeclaration",
+});
+/**
+ * Creates a default export declaration for an identifier.
+ * @param name Identifier to export.
+ * @returns The ESTree default export declaration.
+ * @example
+ * ```typescript
+ * const declaration = createExportDefaultIdentifier("feature");
+ * ```
+ */
+const createExportDefaultIdentifier = (name) => ({
+    declaration: createIdentifier(name),
+    type: "ExportDefaultDeclaration",
+});
+/**
+ * Collects statements into a program body.
+ * @param statements Statements to include in the body.
+ * @returns The program body array.
+ * @example
+ * ```typescript
+ * const body = createBody();
+ * ```
+ */
+const createBody = (...statements) => statements;
+export { createBody, createExportAll, createExportDefaultIdentifier, createExportInterfaceDeclaration, createExportNamedFrom, createExportSpecifier, createExportTypeAliasDeclaration, createExportWithDeclaration, createExportWithoutSource, createImportDeclaration, createImportDefaultSpecifier, createImportSpecifier, createProgram, createRepoDirectory, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/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 { mkdirSync, mkdtempSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { cwd } from \"node:process\";\n\n/**\n * Creates a temporary repo directory for test fixtures.\n * @param root Root folder to create the temporary directory under.\n * @returns The generated temporary directory path.\n * @example\n * ```typescript\n * const directory = createRepoDirectory(\"tmp\");\n * ```\n */\nconst createRepoDirectory = (root: \"src\" | \"tmp\"): string => {\n  const baseDirectory = path.join(cwd(), root);\n  mkdirSync(baseDirectory, { recursive: true });\n  return mkdtempSync(path.join(baseDirectory, \"barrel-files-\"));\n};\n\n/**\n * Wraps statements in a program node for SourceCode construction.\n * @param body Program body statements.\n * @returns The AST program wrapper.\n * @example\n * ```typescript\n * const program = createProgram([]);\n * ```\n */\nconst createProgram = (body: ESTree.Program[\"body\"]): AST.Program => ({\n  body,\n  comments: [],\n  loc: { end: { column: 0, line: 1 }, start: { column: 0, line: 1 } },\n  range: [0, 0],\n  sourceType: \"module\",\n  tokens: [],\n  type: \"Program\",\n});\n\n/**\n * Creates a string literal node for import and export statements.\n * @param value Literal value to wrap.\n * @returns The ESTree literal node.\n * @example\n * ```typescript\n * const literal = createLiteral(\"./feature\");\n * ```\n */\nconst createLiteral = (value: string): ESTree.Literal =>\n  ({ raw: `'${value}'`, type: \"Literal\", value }) satisfies ESTree.Literal;\n\n/**\n * Converts a raw symbol name into the ESTree shape used by the fixture factories.\n * @param name Raw symbol text to encode in the AST node.\n * @returns An ESTree Identifier carrying the supplied symbol text.\n * @example\n * ```typescript\n * const identifier = createIdentifier(\"feature\");\n * ```\n */\nconst createIdentifier = (name: string): ESTree.Identifier =>\n  ({ name, type: \"Identifier\" }) satisfies ESTree.Identifier;\n\n/**\n * Creates an export specifier node.\n * @param localName Local identifier name.\n * @param exportedName Exported identifier name.\n * @returns The ESTree export specifier.\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 import specifier node.\n * @param localName Local identifier name.\n * @param importedName Imported identifier name.\n * @returns The ESTree import specifier.\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 import default specifier node.\n * @param localName Local identifier name.\n * @returns The ESTree default import specifier.\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 fixture programs.\n * @param specifiers Import specifiers to include.\n * @returns The ESTree import declaration.\n * @example\n * ```typescript\n * const declaration = createImportDeclaration();\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 fixture programs.\n * @returns The ESTree export-all declaration.\n * @example\n * ```typescript\n * const declaration = 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 an export-from declaration for fixture programs.\n * @returns The ESTree named export declaration.\n * @example\n * ```typescript\n * const declaration = 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 an export declaration with an inline variable declaration.\n * @returns The ESTree named export declaration.\n * @example\n * ```typescript\n * const declaration = 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 an exported interface declaration for tests.\n * @returns The exported interface declaration node.\n * @example\n * ```typescript\n * const declaration = createExportInterfaceDeclaration();\n * ```\n */\nconst createExportInterfaceDeclaration = (): ESTree.Program[\"body\"][number] =>\n  ({\n    declaration: {\n      body: { body: [], type: \"TSInterfaceBody\" },\n      id: createIdentifier(\"Feature\"),\n      type: \"TSInterfaceDeclaration\",\n    },\n    specifiers: [],\n    type: \"ExportNamedDeclaration\",\n  }) as unknown as ESTree.Program[\"body\"][number];\n\n/**\n * Creates an exported type alias declaration for tests.\n * @returns The exported type alias declaration node.\n * @example\n * ```typescript\n * const declaration = createExportTypeAliasDeclaration();\n * ```\n */\nconst createExportTypeAliasDeclaration = (): ESTree.Program[\"body\"][number] =>\n  ({\n    declaration: {\n      id: createIdentifier(\"Feature\"),\n      type: \"TSTypeAliasDeclaration\",\n      typeAnnotation: { type: \"TSStringKeyword\" },\n    },\n    specifiers: [],\n    type: \"ExportNamedDeclaration\",\n  }) as unknown as ESTree.Program[\"body\"][number];\n\n/**\n * Creates a named export without a source value.\n * @param specifiers Export specifiers to include.\n * @returns The ESTree named export declaration.\n * @example\n * ```typescript\n * const declaration = createExportWithoutSource();\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 declaration for an identifier.\n * @param name Identifier to export.\n * @returns The ESTree default export declaration.\n * @example\n * ```typescript\n * const declaration = 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.\n * @param statements Statements to include in the body.\n * @returns The program body array.\n * @example\n * ```typescript\n * const body = createBody();\n * ```\n */\nconst createBody = (\n  ...statements: ESTree.Program[\"body\"][number][]\n): ESTree.Program[\"body\"] => statements;\n\nexport {\n  createBody,\n  createExportAll,\n  createExportDefaultIdentifier,\n  createExportInterfaceDeclaration,\n  createExportNamedFrom,\n  createExportSpecifier,\n  createExportTypeAliasDeclaration,\n  createExportWithDeclaration,\n  createExportWithoutSource,\n  createImportDeclaration,\n  createImportDefaultSpecifier,\n  createImportSpecifier,\n  createProgram,\n  createRepoDirectory,\n};\n"]}

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

@@ -0,0 +1,19 @@
+/** Type definition for rule data. */
+interface BarrelFilesExportsOnlyOptions {
+    /** AllowedBarrelNames helper value. */
+    allowedBarrelNames?: string[];
+}
+/** Type definition for rule data. */
+interface ConsistentBarrelFilesOptions {
+    /** AllowedNames helper value. */
+    allowedNames?: string[];
+    /** Enforce helper value. */
+    enforce?: boolean;
+}
+/** Type definition for rule data. */
+interface NoReexportsOutsideBarrelsOptions {
+    /** AllowedBarrelNames helper value. */
+    allowedBarrelNames?: string[];
+}
+export type { BarrelFilesExportsOnlyOptions, ConsistentBarrelFilesOptions, NoReexportsOutsideBarrelsOptions, };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/types.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,UAAU,6BAA6B;IACrC,uCAAuC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,qCAAqC;AACrC,UAAU,4BAA4B;IACpC,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qCAAqC;AACrC,UAAU,gCAAgC;IACxC,uCAAuC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,YAAY,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,gCAAgC,GACjC,CAAC"}

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

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

package/dist/{architecture → domain/architecture}/index.d.ts

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

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

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

package/dist/domain/architecture/index.js

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

package/dist/{core → domain/core}/index.d.ts

@@ -1,3 +1,3 @@
-export { noMultipleDeclaratorsRule } from "./no-multiple-declarators";
-export { preferInterfaceTypesRule } from "./prefer-interface-types";
+export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/domain/core/index.js

@@ -0,0 +1,3 @@
+export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnNcIjtcbmV4cG9ydCB7IHByZWZlckludGVyZmFjZVR5cGVzUnVsZSB9IGZyb20gXCIuL3ByZWZlci1pbnRlcmZhY2UtdHlwZXNcIjtcbiJdfQ==

package/dist/domain/core/no-multiple-declarators/index.d.ts

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

package/dist/domain/core/no-multiple-declarators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/core/no-multiple-declarators/index.js

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

package/dist/domain/core/no-multiple-declarators/rule-test-helpers.d.ts

@@ -0,0 +1,101 @@
+import type { Rule } from "eslint";
+import type { Range } from "./types.js";
+/** Options that shape the mock ESLint source access used by the tests. */
+interface ContextOptions {
+    /** Omits the raw `text` property to exercise the `getText()` fallback path. */
+    omitText?: boolean;
+}
+/** Input used to build a mock variable declaration node. */
+interface CreateVariableDeclarationInput {
+    /** Individual declarator source fragments in declaration order. */
+    declaratorTexts: readonly string[];
+    /** Declaration keyword such as `const` or `let`. */
+    kind: string;
+    /** Full file source used to resolve node ranges. */
+    sourceText: string;
+    /** Exact statement text that contains the declaration. */
+    statementText: string;
+}
+/** Mock ESTree node shape required by the rule tests. */
+interface MockNode {
+    /** Variable declarators belonging to a declaration statement. */
+    declarations?: MockNode[];
+    /** Loop initializer reference used by `ForStatement` parents. */
+    init?: MockNode | null;
+    /** Declaration keyword such as `const` or `let`. */
+    kind?: string;
+    /** Loop left-hand reference used by `for...of` and `for...in` parents. */
+    left?: MockNode;
+    /** Parent node used by the rule to inspect surrounding syntax. */
+    parent?: MockNode;
+    /** Source range used by the autofix logic. */
+    range?: Range;
+    /** ESTree node type. */
+    type: string;
+}
+/** Captured report metadata asserted by the unit tests. */
+interface ReportEntry {
+    /** Fix callback captured from the rule report descriptor. */
+    fix: null | Rule.ReportFixer | undefined;
+    /** Message identifier reported by the rule. */
+    messageId: string | undefined;
+    /** Node type captured from the report descriptor. */
+    nodeType: string | undefined;
+}
+/** Captured reports and mock context returned from `createContext`. */
+interface RuleContextState {
+    /** Mock rule context passed into the rule under test. */
+    context: Rule.RuleContext;
+    /** Reports captured during rule execution. */
+    reports: ReportEntry[];
+}
+/**
+ * Builds a mock ESLint context for the rule tests.
+ * @param sourceText Full source text used by the mock source code object.
+ * @param options Options that tweak the mock source code shape.
+ * @returns The mock context and captured reports.
+ * @example Create a context with the default source text access.
+ * ```typescript
+ * const { context, reports } = createContext("const value = 1;");
+ * ```
+ */
+declare const createContext: (sourceText: string, options?: ContextOptions) => RuleContextState;
+/**
+ * Builds a mock variable declaration node with stable source ranges.
+ * @param input Source fragments used to build the declaration node.
+ * @param input.declaratorTexts Individual declarator source fragments.
+ * @param input.kind Declaration keyword such as `const` or `let`.
+ * @param input.sourceText Full file source used to resolve ranges.
+ * @param input.statementText Exact statement text containing the declaration.
+ * @returns A mock variable declaration node with linked declarator parents.
+ * @example Build a declaration with two declarators.
+ * ```typescript
+ * const declaration = createVariableDeclaration({
+ *   declaratorTexts: ["first = 1", "second = 2"],
+ *   kind: "const",
+ *   sourceText: "const first = 1, second = 2;",
+ *   statementText: "const first = 1, second = 2;",
+ * });
+ * ```
+ */
+declare const createVariableDeclaration: ({ declaratorTexts, kind, sourceText, statementText, }: CreateVariableDeclarationInput) => MockNode;
+/**
+ * Executes the rule listener for a variable declaration node.
+ * @param context Rule execution context.
+ * @param node Declaration node passed to the rule listener.
+ * @example Execute the rule against a mock declaration.
+ * ```typescript
+ * const state = createContext("const first = 1, second = 2;");
+ * const declaration = createVariableDeclaration({
+ *   declaratorTexts: ["first = 1", "second = 2"],
+ *   kind: "const",
+ *   sourceText: "const first = 1, second = 2;",
+ *   statementText: "const first = 1, second = 2;",
+ * });
+ * runRule(state.context, declaration);
+ * ```
+ */
+declare const runRule: (context: Rule.RuleContext, node: MockNode) => void;
+export { createContext, createVariableDeclaration, runRule };
+export type { MockNode };
+//# sourceMappingURL=rule-test-helpers.d.ts.map

package/dist/domain/core/no-multiple-declarators/rule-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIrC,0EAA0E;AAC1E,UAAU,cAAc;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,4DAA4D;AAC5D,UAAU,8BAA8B;IACtC,mEAAmE;IACnE,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,yDAAyD;AACzD,UAAU,QAAQ;IAChB,iEAAiE;IACjE,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC1B,iEAAiE;IACjE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACvB,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,kEAAkE;IAClE,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,2DAA2D;AAC3D,UAAU,WAAW;IACnB,6DAA6D;IAC7D,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;IACzC,+CAA+C;IAC/C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,qDAAqD;IACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,uEAAuE;AACvE,UAAU,gBAAgB;IACxB,yDAAyD;IACzD,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GACjB,YAAY,MAAM,EAClB,UAAU,cAAc,KACvB,gBA8BF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,yBAAyB,GAAI,uDAKhC,8BAA8B,KAAG,QAgCnC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,OAAO,GAAI,SAAS,IAAI,CAAC,WAAW,EAAE,MAAM,QAAQ,KAAG,IAO5D,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,OAAO,EAAE,CAAC;AAC7D,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule-test-helpers.js

@@ -0,0 +1,108 @@
+import { noMultipleDeclaratorsRule } from "./rule.js";
+/**
+ * Builds a mock ESLint context for the rule tests.
+ * @param sourceText Full source text used by the mock source code object.
+ * @param options Options that tweak the mock source code shape.
+ * @returns The mock context and captured reports.
+ * @example Create a context with the default source text access.
+ * ```typescript
+ * const { context, reports } = createContext("const value = 1;");
+ * ```
+ */
+const createContext = (sourceText, options) => {
+    const reports = [];
+    const sourceCode = {
+        getText: (node) => {
+            if (node?.range === void 0) {
+                return sourceText;
+            }
+            return sourceText.slice(node.range[0], node.range[1]);
+        },
+        ...(options?.omitText === true ? {} : { text: sourceText }),
+    };
+    const context = {
+        id: "no-multiple-declarators",
+        options: [],
+        report: (descriptor) => {
+            const messageId = "messageId" in descriptor ? descriptor.messageId : void 0;
+            const node = "node" in descriptor ? descriptor.node : void 0;
+            reports.push({
+                fix: descriptor.fix,
+                messageId,
+                nodeType: node?.type,
+            });
+        },
+        sourceCode,
+    };
+    return { context, reports };
+};
+/**
+ * Builds a mock variable declaration node with stable source ranges.
+ * @param input Source fragments used to build the declaration node.
+ * @param input.declaratorTexts Individual declarator source fragments.
+ * @param input.kind Declaration keyword such as `const` or `let`.
+ * @param input.sourceText Full file source used to resolve ranges.
+ * @param input.statementText Exact statement text containing the declaration.
+ * @returns A mock variable declaration node with linked declarator parents.
+ * @example Build a declaration with two declarators.
+ * ```typescript
+ * const declaration = createVariableDeclaration({
+ *   declaratorTexts: ["first = 1", "second = 2"],
+ *   kind: "const",
+ *   sourceText: "const first = 1, second = 2;",
+ *   statementText: "const first = 1, second = 2;",
+ * });
+ * ```
+ */
+const createVariableDeclaration = ({ declaratorTexts, kind, sourceText, statementText, }) => {
+    const statementOffset = sourceText.indexOf(statementText);
+    const statementRange = [
+        statementOffset + statementText.indexOf(kind),
+        statementOffset + statementText.length,
+    ];
+    let [searchStart] = statementRange;
+    const declarations = declaratorTexts.map((declaratorText) => {
+        const start = sourceText.indexOf(declaratorText, searchStart);
+        const range = [start, start + declaratorText.length];
+        const declaration = {
+            range,
+            type: "VariableDeclarator",
+        };
+        const [, rangeEnd] = range;
+        searchStart = rangeEnd;
+        return declaration;
+    });
+    const declarationNode = {
+        declarations,
+        kind,
+        range: statementRange,
+        type: "VariableDeclaration",
+    };
+    for (const declaration of declarations) {
+        declaration.parent = declarationNode;
+    }
+    return declarationNode;
+};
+/**
+ * Executes the rule listener for a variable declaration node.
+ * @param context Rule execution context.
+ * @param node Declaration node passed to the rule listener.
+ * @example Execute the rule against a mock declaration.
+ * ```typescript
+ * const state = createContext("const first = 1, second = 2;");
+ * const declaration = createVariableDeclaration({
+ *   declaratorTexts: ["first = 1", "second = 2"],
+ *   kind: "const",
+ *   sourceText: "const first = 1, second = 2;",
+ *   statementText: "const first = 1, second = 2;",
+ * });
+ * runRule(state.context, declaration);
+ * ```
+ */
+const runRule = (context, node) => {
+    const listeners = noMultipleDeclaratorsRule.create(context);
+    const listener = listeners.VariableDeclaration;
+    listener?.(node);
+};
+export { createContext, createVariableDeclaration, runRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { Range } from \"./types\";\r\n\r\nimport { noMultipleDeclaratorsRule } from \"./rule\";\r\n\r\n/** Options that shape the mock ESLint source access used by the tests. */\r\ninterface ContextOptions {\r\n  /** Omits the raw `text` property to exercise the `getText()` fallback path. */\r\n  omitText?: boolean;\r\n}\r\n\r\n/** Input used to build a mock variable declaration node. */\r\ninterface CreateVariableDeclarationInput {\r\n  /** Individual declarator source fragments in declaration order. */\r\n  declaratorTexts: readonly string[];\r\n  /** Declaration keyword such as `const` or `let`. */\r\n  kind: string;\r\n  /** Full file source used to resolve node ranges. */\r\n  sourceText: string;\r\n  /** Exact statement text that contains the declaration. */\r\n  statementText: string;\r\n}\r\n\r\n/** Mock ESTree node shape required by the rule tests. */\r\ninterface MockNode {\r\n  /** Variable declarators belonging to a declaration statement. */\r\n  declarations?: MockNode[];\r\n  /** Loop initializer reference used by `ForStatement` parents. */\r\n  init?: MockNode | null;\r\n  /** Declaration keyword such as `const` or `let`. */\r\n  kind?: string;\r\n  /** Loop left-hand reference used by `for...of` and `for...in` parents. */\r\n  left?: MockNode;\r\n  /** Parent node used by the rule to inspect surrounding syntax. */\r\n  parent?: MockNode;\r\n  /** Source range used by the autofix logic. */\r\n  range?: Range;\r\n  /** ESTree node type. */\r\n  type: string;\r\n}\r\n\r\n/** Captured report metadata asserted by the unit tests. */\r\ninterface ReportEntry {\r\n  /** Fix callback captured from the rule report descriptor. */\r\n  fix: null | Rule.ReportFixer | undefined;\r\n  /** Message identifier reported by the rule. */\r\n  messageId: string | undefined;\r\n  /** Node type captured from the report descriptor. */\r\n  nodeType: string | undefined;\r\n}\r\n\r\n/** Captured reports and mock context returned from `createContext`. */\r\ninterface RuleContextState {\r\n  /** Mock rule context passed into the rule under test. */\r\n  context: Rule.RuleContext;\r\n  /** Reports captured during rule execution. */\r\n  reports: ReportEntry[];\r\n}\r\n\r\n/**\r\n * Builds a mock ESLint context for the rule tests.\r\n * @param sourceText Full source text used by the mock source code object.\r\n * @param options Options that tweak the mock source code shape.\r\n * @returns The mock context and captured reports.\r\n * @example Create a context with the default source text access.\r\n * ```typescript\r\n * const { context, reports } = createContext(\"const value = 1;\");\r\n * ```\r\n */\r\nconst createContext = (\r\n  sourceText: string,\r\n  options?: ContextOptions,\r\n): RuleContextState => {\r\n  const reports: ReportEntry[] = [];\r\n  const sourceCode = {\r\n    getText: (node?: MockNode): string => {\r\n      if (node?.range === void 0) {\r\n        return sourceText;\r\n      }\r\n\r\n      return sourceText.slice(node.range[0], node.range[1]);\r\n    },\r\n    ...(options?.omitText === true ? {} : { text: sourceText }),\r\n  };\r\n  const context: Rule.RuleContext = {\r\n    id: \"no-multiple-declarators\",\r\n    options: [],\r\n    report: (descriptor: Rule.ReportDescriptor): void => {\r\n      const messageId =\r\n        \"messageId\" in descriptor ? descriptor.messageId : void 0;\r\n      const node = \"node\" in descriptor ? descriptor.node : void 0;\r\n\r\n      reports.push({\r\n        fix: descriptor.fix,\r\n        messageId,\r\n        nodeType: node?.type,\r\n      });\r\n    },\r\n    sourceCode,\r\n  } as unknown as Rule.RuleContext;\r\n\r\n  return { context, reports };\r\n};\r\n\r\n/**\r\n * Builds a mock variable declaration node with stable source ranges.\r\n * @param input Source fragments used to build the declaration node.\r\n * @param input.declaratorTexts Individual declarator source fragments.\r\n * @param input.kind Declaration keyword such as `const` or `let`.\r\n * @param input.sourceText Full file source used to resolve ranges.\r\n * @param input.statementText Exact statement text containing the declaration.\r\n * @returns A mock variable declaration node with linked declarator parents.\r\n * @example Build a declaration with two declarators.\r\n * ```typescript\r\n * const declaration = createVariableDeclaration({\r\n *   declaratorTexts: [\"first = 1\", \"second = 2\"],\r\n *   kind: \"const\",\r\n *   sourceText: \"const first = 1, second = 2;\",\r\n *   statementText: \"const first = 1, second = 2;\",\r\n * });\r\n * ```\r\n */\r\nconst createVariableDeclaration = ({\r\n  declaratorTexts,\r\n  kind,\r\n  sourceText,\r\n  statementText,\r\n}: CreateVariableDeclarationInput): MockNode => {\r\n  const statementOffset = sourceText.indexOf(statementText);\r\n  const statementRange: Range = [\r\n    statementOffset + statementText.indexOf(kind),\r\n    statementOffset + statementText.length,\r\n  ];\r\n  let [searchStart] = statementRange;\r\n  const declarations = declaratorTexts.map((declaratorText) => {\r\n    const start = sourceText.indexOf(declaratorText, searchStart);\r\n    const range: Range = [start, start + declaratorText.length];\r\n    const declaration: MockNode = {\r\n      range,\r\n      type: \"VariableDeclarator\",\r\n    };\r\n    const [, rangeEnd] = range;\r\n\r\n    searchStart = rangeEnd;\r\n\r\n    return declaration;\r\n  });\r\n  const declarationNode: MockNode = {\r\n    declarations,\r\n    kind,\r\n    range: statementRange,\r\n    type: \"VariableDeclaration\",\r\n  };\r\n\r\n  for (const declaration of declarations) {\r\n    declaration.parent = declarationNode;\r\n  }\r\n\r\n  return declarationNode;\r\n};\r\n\r\n/**\r\n * Executes the rule listener for a variable declaration node.\r\n * @param context Rule execution context.\r\n * @param node Declaration node passed to the rule listener.\r\n * @example Execute the rule against a mock declaration.\r\n * ```typescript\r\n * const state = createContext(\"const first = 1, second = 2;\");\r\n * const declaration = createVariableDeclaration({\r\n *   declaratorTexts: [\"first = 1\", \"second = 2\"],\r\n *   kind: \"const\",\r\n *   sourceText: \"const first = 1, second = 2;\",\r\n *   statementText: \"const first = 1, second = 2;\",\r\n * });\r\n * runRule(state.context, declaration);\r\n * ```\r\n */\r\nconst runRule = (context: Rule.RuleContext, node: MockNode): void => {\r\n  const listeners = noMultipleDeclaratorsRule.create(context);\r\n  const listener = listeners.VariableDeclaration as\r\n    | ((value: Rule.Node) => void)\r\n    | undefined;\r\n\r\n  listener?.(node as unknown as Rule.Node);\r\n};\r\n\r\nexport { createContext, createVariableDeclaration, runRule };\r\nexport type { MockNode };\r\n"]}

package/dist/{core → domain/core}/no-multiple-declarators/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** ESLint rule implementation for single-declarator variable statements. */
 declare const noMultipleDeclaratorsRule: Rule.RuleModule;
 export { noMultipleDeclaratorsRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/core/no-multiple-declarators/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiRnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAuBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule.fixes.d.ts

@@ -0,0 +1,35 @@
+import type { Rule } from "eslint";
+/** Report shape used by fix collection helpers. */
+interface FixReportEntry {
+    /** Fix helper value captured from a rule report. */
+    fix?: null | Rule.ReportFixer | undefined;
+}
+/** Suite name used by the fix-focused no-multiple-declarators tests. */
+declare const ruleFixesSuiteName = "no-multiple-declarators rule fixes";
+/**
+ * Collects concrete fixes from captured report entries.
+ * @param reports Captured rule reports to evaluate.
+ * @returns All concrete fixes produced by the report callbacks.
+ * @example Collect fixes from a captured report array.
+ * ```typescript
+ * const fixes = getFixes([
+ *   { fix: () => ({ range: [0, 0], text: "const value = 1;" }) },
+ * ]);
+ * ```
+ */
+declare const getFixes: (reports: readonly FixReportEntry[]) => Rule.Fix[];
+/**
+ * Applies fixes to source text from the end of the file toward the start.
+ * @param sourceText Original source text.
+ * @param fixes Concrete fixes that should be applied.
+ * @returns Source text with the fixes applied.
+ * @example Apply a replacement fix to source text.
+ * ```typescript
+ * const output = applyFixes("const first = 1, second = 2;", [
+ *   { range: [0, 26], text: "const first = 1;\nconst second = 2;" },
+ * ]);
+ * ```
+ */
+declare const applyFixes: (sourceText: string, fixes: readonly Rule.Fix[]) => string;
+export { applyFixes, getFixes, ruleFixesSuiteName };
+//# sourceMappingURL=rule.fixes.d.ts.map

package/dist/domain/core/no-multiple-declarators/rule.fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,mDAAmD;AACnD,UAAU,cAAc;IACtB,oDAAoD;IACpD,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;CAC3C;AAKD,wEAAwE;AACxE,QAAA,MAAM,kBAAkB,uCAAuC,CAAC;AA6ChE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,QAAQ,GAAI,SAAS,SAAS,cAAc,EAAE,KAAG,IAAI,CAAC,GAAG,EAiB9D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,UAAU,GAAI,YAAY,MAAM,EAAE,OAAO,SAAS,IAAI,CAAC,GAAG,EAAE,KAAG,MAgBpE,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC"}