@codeperfect/eslint-plugin 2.1.0 → 2.2.0

package/dist/domain/architecture/consistent-barrel-files/no-import-export-aliases-rule.js

@@ -0,0 +1,247 @@
+/**
+ * Adds all identifier names introduced by one binding pattern.
+ * @param pattern Binding pattern to inspect.
+ * @param boundNames Destination set.
+ * @example
+ * ```typescript
+ * addPatternBoundNames(variable.id, names);
+ * ```
+ */
+const addPatternBoundNames = (pattern, boundNames) => {
+    if (pattern.type === "Identifier") {
+        boundNames.add(pattern.name);
+        return;
+    }
+    if (pattern.type === "RestElement") {
+        addPatternBoundNames(pattern.argument, boundNames);
+        return;
+    }
+    if (pattern.type === "AssignmentPattern") {
+        addPatternBoundNames(pattern.left, boundNames);
+        return;
+    }
+    if (pattern.type === "ObjectPattern") {
+        for (const property of pattern.properties) {
+            if (property.type === "Property") {
+                addPatternBoundNames(property.value, boundNames);
+            }
+            if (property.type === "RestElement") {
+                addPatternBoundNames(property.argument, boundNames);
+            }
+        }
+        return;
+    }
+    if (pattern.type === "ArrayPattern") {
+        for (const element of pattern.elements) {
+            if (element !== null) {
+                addPatternBoundNames(element, boundNames);
+            }
+        }
+    }
+};
+/**
+ * Adds one declaration identifier name when present.
+ * @param declaration Declaration that may bind an identifier.
+ * @param boundNames Destination set.
+ * @example
+ * ```typescript
+ * addDeclarationIdentifierBoundName(declaration, names);
+ * ```
+ */
+const addDeclarationIdentifierBoundName = (declaration, boundNames) => {
+    if (declaration.id !== null && declaration.id !== void 0) {
+        addPatternBoundNames(declaration.id, boundNames);
+    }
+};
+/**
+ * Adds bound variable names from one variable declaration.
+ * @param declaration Variable declaration to inspect.
+ * @param boundNames Destination set.
+ * @example
+ * ```typescript
+ * addVariableBoundNames(declaration, names);
+ * ```
+ */
+const addVariableBoundNames = (declaration, boundNames) => {
+    for (const variable of declaration.declarations) {
+        addPatternBoundNames(variable.id, boundNames);
+    }
+};
+/**
+ * Collects bound names available for collision detection.
+ * @param body Program body statements.
+ * @returns Bound names in the file.
+ * @example
+ * ```typescript
+ * const names = collectBoundNames(program.body);
+ * ```
+ */
+const collectBoundNames = (body) => {
+    const boundNames = new Set();
+    for (const statement of body) {
+        if (statement.type === "ImportDeclaration") {
+            const declarationImportKind = statement.importKind;
+            for (const specifier of statement.specifiers) {
+                const specifierImportKind = specifier.importKind;
+                const isTypeOnly = declarationImportKind === "type" || specifierImportKind === "type";
+                if (!isTypeOnly) {
+                    boundNames.add(specifier.local.name);
+                }
+            }
+        }
+        if (statement.type === "VariableDeclaration") {
+            addVariableBoundNames(statement, boundNames);
+        }
+        if (statement.type === "FunctionDeclaration") {
+            addDeclarationIdentifierBoundName(statement, boundNames);
+        }
+        if (statement.type === "ClassDeclaration") {
+            addDeclarationIdentifierBoundName(statement, boundNames);
+        }
+        if (statement.type === "ExportNamedDeclaration" &&
+            statement.declaration !== null &&
+            statement.declaration !== void 0 &&
+            statement.declaration.type === "VariableDeclaration") {
+            addVariableBoundNames(statement.declaration, boundNames);
+        }
+        if (statement.type === "ExportNamedDeclaration" &&
+            statement.declaration !== null &&
+            statement.declaration !== void 0 &&
+            statement.declaration.type === "FunctionDeclaration") {
+            addDeclarationIdentifierBoundName(statement.declaration, boundNames);
+        }
+        if (statement.type === "ExportNamedDeclaration" &&
+            statement.declaration !== null &&
+            statement.declaration !== void 0 &&
+            statement.declaration.type === "ClassDeclaration") {
+            addDeclarationIdentifierBoundName(statement.declaration, boundNames);
+        }
+        if (statement.type === "ExportDefaultDeclaration" &&
+            statement.declaration.type === "FunctionDeclaration") {
+            addDeclarationIdentifierBoundName(statement.declaration, boundNames);
+        }
+        if (statement.type === "ExportDefaultDeclaration" &&
+            statement.declaration.type === "ClassDeclaration") {
+            addDeclarationIdentifierBoundName(statement.declaration, boundNames);
+        }
+    }
+    return boundNames;
+};
+/**
+ * Collects aliased named import specifiers from one import declaration.
+ * @param declaration Import declaration to inspect.
+ * @returns Aliased import specifier candidates.
+ * @example
+ * ```typescript
+ * const candidates = collectImportAliasCandidates(declaration);
+ * ```
+ */
+const collectImportAliasCandidates = (declaration) => {
+    const candidates = [];
+    const declarationImportKind = declaration.importKind;
+    for (const specifier of declaration.specifiers) {
+        const specifierImportKind = specifier.importKind;
+        const isTypeOnly = declarationImportKind === "type" || specifierImportKind === "type";
+        if (!isTypeOnly &&
+            specifier.type === "ImportSpecifier" &&
+            specifier.imported.type === "Identifier" &&
+            specifier.local.name !== specifier.imported.name) {
+            candidates.push({
+                originalName: specifier.imported.name,
+                specifier,
+            });
+        }
+    }
+    return candidates;
+};
+/**
+ * Collects aliased named export specifiers from one export declaration.
+ * @param declaration Export declaration to inspect.
+ * @returns Aliased export specifier candidates.
+ * @example
+ * ```typescript
+ * const candidates = collectExportAliasCandidates(declaration);
+ * ```
+ */
+const collectExportAliasCandidates = (declaration) => {
+    const candidates = [];
+    const declarationExportKind = declaration.exportKind;
+    for (const specifier of declaration.specifiers) {
+        const specifierExportKind = specifier.exportKind;
+        const isTypeOnly = declarationExportKind === "type" || specifierExportKind === "type";
+        if (!isTypeOnly &&
+            specifier.local.type === "Identifier" &&
+            specifier.exported.type === "Identifier" &&
+            specifier.local.name !== specifier.exported.name) {
+            candidates.push({
+                originalName: specifier.local.name,
+                specifier,
+            });
+        }
+    }
+    return candidates;
+};
+/**
+ * Collects aliased import/export named specifiers.
+ * @param body Program body statements.
+ * @returns Aliased named import/export specifiers.
+ * @example
+ * ```typescript
+ * const candidates = collectAliasedSpecifiers(program.body);
+ * ```
+ */
+const collectAliasedSpecifiers = (body) => {
+    const candidates = [];
+    for (const statement of body) {
+        if (statement.type === "ImportDeclaration") {
+            candidates.push(...collectImportAliasCandidates(statement));
+        }
+        if (statement.type === "ExportNamedDeclaration") {
+            candidates.push(...collectExportAliasCandidates(statement));
+        }
+    }
+    return candidates;
+};
+/**
+ * Builds a listener for this rule.
+ * @param context Rule execution context.
+ * @returns Listener for import/export alias checks.
+ * @example
+ * ```typescript
+ * const listener = buildListener(context);
+ * ```
+ */
+const buildListener = (context) => ({
+    Program(node) {
+        const boundNames = collectBoundNames(node.body);
+        const aliasedSpecifiers = collectAliasedSpecifiers(node.body);
+        for (const candidate of aliasedSpecifiers) {
+            if (!boundNames.has(candidate.originalName)) {
+                context.report({
+                    messageId: "aliasNotAllowed",
+                    node: candidate.specifier,
+                });
+            }
+        }
+    },
+});
+/** ESLint rule that forbids aliased import/export names unless required by same-file name collisions. */
+const noImportExportAliasesRule = {
+    create(context) {
+        return buildListener(context);
+    },
+    meta: {
+        docs: {
+            description: "Forbid aliased import/export names unless the original name is already bound in the same file.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-aliases.md",
+        },
+        messages: {
+            aliasNotAllowed: "Avoid aliased import/export names unless the original name is already bound in this file.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { noImportExportAliasesRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-import-export-aliases-rule.js","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/no-import-export-aliases-rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\n/** Tracks one aliased specifier candidate in a program. */\ninterface AliasedSpecifierCandidate {\n  /** Identifier name before aliasing (e.g. A in A as B). */\n  originalName: string;\n\n  /** Specifier node to report when aliasing is not allowed. */\n  specifier: ESTree.ExportSpecifier | ESTree.ImportSpecifier;\n}\n\n/** Minimal declaration shape that may carry an identifier binding. */\ninterface DeclarationWithIdentifier {\n  /** Declaration identifier if one exists. */\n  id?: ESTree.Pattern | null;\n}\n\n/** Optional export-kind carrier shape used for type-only checks. */\ninterface ExportKindCarrier {\n  /** ESTree-compatible export kind value. */\n  exportKind?: \"type\" | \"value\";\n}\n\n/** Optional import-kind carrier shape used for type-only checks. */\ninterface ImportKindCarrier {\n  /** ESTree-compatible import kind value. */\n  importKind?: \"type\" | \"value\";\n}\n\n/**\n * Adds all identifier names introduced by one binding pattern.\n * @param pattern Binding pattern to inspect.\n * @param boundNames Destination set.\n * @example\n * ```typescript\n * addPatternBoundNames(variable.id, names);\n * ```\n */\nconst addPatternBoundNames = (\n  pattern: ESTree.Pattern,\n  boundNames: Set<string>,\n): void => {\n  if (pattern.type === \"Identifier\") {\n    boundNames.add(pattern.name);\n    return;\n  }\n\n  if (pattern.type === \"RestElement\") {\n    addPatternBoundNames(pattern.argument, boundNames);\n    return;\n  }\n\n  if (pattern.type === \"AssignmentPattern\") {\n    addPatternBoundNames(pattern.left, boundNames);\n    return;\n  }\n\n  if (pattern.type === \"ObjectPattern\") {\n    for (const property of pattern.properties) {\n      if (property.type === \"Property\") {\n        addPatternBoundNames(property.value, boundNames);\n      }\n\n      if (property.type === \"RestElement\") {\n        addPatternBoundNames(property.argument, boundNames);\n      }\n    }\n\n    return;\n  }\n\n  if (pattern.type === \"ArrayPattern\") {\n    for (const element of pattern.elements) {\n      if (element !== null) {\n        addPatternBoundNames(element, boundNames);\n      }\n    }\n  }\n};\n\n/**\n * Adds one declaration identifier name when present.\n * @param declaration Declaration that may bind an identifier.\n * @param boundNames Destination set.\n * @example\n * ```typescript\n * addDeclarationIdentifierBoundName(declaration, names);\n * ```\n */\nconst addDeclarationIdentifierBoundName = (\n  declaration: DeclarationWithIdentifier,\n  boundNames: Set<string>,\n): void => {\n  if (declaration.id !== null && declaration.id !== void 0) {\n    addPatternBoundNames(declaration.id, boundNames);\n  }\n};\n\n/**\n * Adds bound variable names from one variable declaration.\n * @param declaration Variable declaration to inspect.\n * @param boundNames Destination set.\n * @example\n * ```typescript\n * addVariableBoundNames(declaration, names);\n * ```\n */\nconst addVariableBoundNames = (\n  declaration: ESTree.VariableDeclaration,\n  boundNames: Set<string>,\n): void => {\n  for (const variable of declaration.declarations) {\n    addPatternBoundNames(variable.id, boundNames);\n  }\n};\n\n/**\n * Collects bound names available for collision detection.\n * @param body Program body statements.\n * @returns Bound names in the file.\n * @example\n * ```typescript\n * const names = collectBoundNames(program.body);\n * ```\n */\nconst collectBoundNames = (body: ESTree.Program[\"body\"]): Set<string> => {\n  const boundNames = new Set<string>();\n\n  for (const statement of body) {\n    if (statement.type === \"ImportDeclaration\") {\n      const declarationImportKind = (statement as ImportKindCarrier).importKind;\n\n      for (const specifier of statement.specifiers) {\n        const specifierImportKind = (specifier as ImportKindCarrier).importKind;\n        const isTypeOnly =\n          declarationImportKind === \"type\" || specifierImportKind === \"type\";\n\n        if (!isTypeOnly) {\n          boundNames.add(specifier.local.name);\n        }\n      }\n    }\n\n    if (statement.type === \"VariableDeclaration\") {\n      addVariableBoundNames(statement, boundNames);\n    }\n\n    if (statement.type === \"FunctionDeclaration\") {\n      addDeclarationIdentifierBoundName(statement, boundNames);\n    }\n\n    if (statement.type === \"ClassDeclaration\") {\n      addDeclarationIdentifierBoundName(statement, boundNames);\n    }\n\n    if (\n      statement.type === \"ExportNamedDeclaration\" &&\n      statement.declaration !== null &&\n      statement.declaration !== void 0 &&\n      statement.declaration.type === \"VariableDeclaration\"\n    ) {\n      addVariableBoundNames(statement.declaration, boundNames);\n    }\n\n    if (\n      statement.type === \"ExportNamedDeclaration\" &&\n      statement.declaration !== null &&\n      statement.declaration !== void 0 &&\n      statement.declaration.type === \"FunctionDeclaration\"\n    ) {\n      addDeclarationIdentifierBoundName(statement.declaration, boundNames);\n    }\n\n    if (\n      statement.type === \"ExportNamedDeclaration\" &&\n      statement.declaration !== null &&\n      statement.declaration !== void 0 &&\n      statement.declaration.type === \"ClassDeclaration\"\n    ) {\n      addDeclarationIdentifierBoundName(statement.declaration, boundNames);\n    }\n\n    if (\n      statement.type === \"ExportDefaultDeclaration\" &&\n      statement.declaration.type === \"FunctionDeclaration\"\n    ) {\n      addDeclarationIdentifierBoundName(statement.declaration, boundNames);\n    }\n\n    if (\n      statement.type === \"ExportDefaultDeclaration\" &&\n      statement.declaration.type === \"ClassDeclaration\"\n    ) {\n      addDeclarationIdentifierBoundName(statement.declaration, boundNames);\n    }\n  }\n\n  return boundNames;\n};\n\n/**\n * Collects aliased named import specifiers from one import declaration.\n * @param declaration Import declaration to inspect.\n * @returns Aliased import specifier candidates.\n * @example\n * ```typescript\n * const candidates = collectImportAliasCandidates(declaration);\n * ```\n */\nconst collectImportAliasCandidates = (\n  declaration: ESTree.ImportDeclaration,\n): AliasedSpecifierCandidate[] => {\n  const candidates: AliasedSpecifierCandidate[] = [];\n  const declarationImportKind = (declaration as ImportKindCarrier).importKind;\n\n  for (const specifier of declaration.specifiers) {\n    const specifierImportKind = (specifier as ImportKindCarrier).importKind;\n    const isTypeOnly =\n      declarationImportKind === \"type\" || specifierImportKind === \"type\";\n\n    if (\n      !isTypeOnly &&\n      specifier.type === \"ImportSpecifier\" &&\n      specifier.imported.type === \"Identifier\" &&\n      specifier.local.name !== specifier.imported.name\n    ) {\n      candidates.push({\n        originalName: specifier.imported.name,\n        specifier,\n      });\n    }\n  }\n\n  return candidates;\n};\n\n/**\n * Collects aliased named export specifiers from one export declaration.\n * @param declaration Export declaration to inspect.\n * @returns Aliased export specifier candidates.\n * @example\n * ```typescript\n * const candidates = collectExportAliasCandidates(declaration);\n * ```\n */\nconst collectExportAliasCandidates = (\n  declaration: ESTree.ExportNamedDeclaration,\n): AliasedSpecifierCandidate[] => {\n  const candidates: AliasedSpecifierCandidate[] = [];\n  const declarationExportKind = (declaration as ExportKindCarrier).exportKind;\n\n  for (const specifier of declaration.specifiers) {\n    const specifierExportKind = (specifier as ExportKindCarrier).exportKind;\n    const isTypeOnly =\n      declarationExportKind === \"type\" || specifierExportKind === \"type\";\n\n    if (\n      !isTypeOnly &&\n      specifier.local.type === \"Identifier\" &&\n      specifier.exported.type === \"Identifier\" &&\n      specifier.local.name !== specifier.exported.name\n    ) {\n      candidates.push({\n        originalName: specifier.local.name,\n        specifier,\n      });\n    }\n  }\n\n  return candidates;\n};\n\n/**\n * Collects aliased import/export named specifiers.\n * @param body Program body statements.\n * @returns Aliased named import/export specifiers.\n * @example\n * ```typescript\n * const candidates = collectAliasedSpecifiers(program.body);\n * ```\n */\nconst collectAliasedSpecifiers = (\n  body: ESTree.Program[\"body\"],\n): AliasedSpecifierCandidate[] => {\n  const candidates: AliasedSpecifierCandidate[] = [];\n\n  for (const statement of body) {\n    if (statement.type === \"ImportDeclaration\") {\n      candidates.push(...collectImportAliasCandidates(statement));\n    }\n\n    if (statement.type === \"ExportNamedDeclaration\") {\n      candidates.push(...collectExportAliasCandidates(statement));\n    }\n  }\n\n  return candidates;\n};\n\n/**\n * Builds a listener for this rule.\n * @param context Rule execution context.\n * @returns Listener for import/export alias checks.\n * @example\n * ```typescript\n * const listener = buildListener(context);\n * ```\n */\nconst buildListener = (context: Rule.RuleContext): Rule.RuleListener => ({\n  Program(node: ESTree.Program): void {\n    const boundNames = collectBoundNames(node.body);\n    const aliasedSpecifiers = collectAliasedSpecifiers(node.body);\n\n    for (const candidate of aliasedSpecifiers) {\n      if (!boundNames.has(candidate.originalName)) {\n        context.report({\n          messageId: \"aliasNotAllowed\",\n          node: candidate.specifier,\n        });\n      }\n    }\n  },\n});\n\n/** ESLint rule that forbids aliased import/export names unless required by same-file name collisions. */\nconst noImportExportAliasesRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return buildListener(context);\n  },\n  meta: {\n    docs: {\n      description:\n        \"Forbid aliased import/export names unless the original name is already bound in the same file.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-aliases.md\",\n    },\n    messages: {\n      aliasNotAllowed:\n        \"Avoid aliased import/export names unless the original name is already bound in this file.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { noImportExportAliasesRule };\n"]}

package/dist/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule that forbids import/export module specifiers with explicit file extensions. */
+declare const noImportExportExtensionsRule: Rule.RuleModule;
+export { noImportExportExtensionsRule };
+//# sourceMappingURL=no-import-export-extensions-rule.d.ts.map

package/dist/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-import-export-extensions-rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgJnC,8FAA8F;AAC9F,QAAA,MAAM,4BAA4B,EAAE,IAAI,CAAC,UA4BxC,CAAC;AAEF,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.js

@@ -0,0 +1,136 @@
+/** Set of disallowed module-specifier file extensions. */
+const disallowedExtensions = new Set([
+    ".cjs",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".mts",
+    ".ts",
+    ".tsx",
+]);
+/**
+ * Gets the trailing extension from a module specifier string.
+ * @param source Module specifier text.
+ * @returns File extension including the leading dot when present.
+ * @example
+ * ```typescript
+ * const extension = getTrailingExtension("./feature.ts");
+ * ```
+ */
+const getSpecifierEndIndex = (source) => {
+    const queryIndex = source.indexOf("?");
+    const hashIndex = source.indexOf("#");
+    const endIndexCandidates = [queryIndex, hashIndex].filter((index) => index >= 0);
+    return endIndexCandidates.length === 0
+        ? source.length
+        : Math.min(...endIndexCandidates);
+};
+/**
+ * Gets the trailing extension from a module specifier string.
+ * @param source Module specifier text.
+ * @returns File extension including the leading dot when present.
+ * @example
+ * ```typescript
+ * const extension = getTrailingExtension("./feature.ts");
+ * ```
+ */
+const getTrailingExtension = (source) => {
+    const endIndex = getSpecifierEndIndex(source);
+    const cleanedSource = source.slice(0, endIndex);
+    const lastSlashIndex = Math.max(cleanedSource.lastIndexOf("/"), cleanedSource.lastIndexOf("\\"));
+    const basename = cleanedSource.slice(lastSlashIndex + 1);
+    const dotIndex = basename.lastIndexOf(".");
+    if (dotIndex <= 0) {
+        return void 0;
+    }
+    return basename.slice(dotIndex).toLowerCase();
+};
+/**
+ * Checks whether a source literal should be reported.
+ * @param sourceLiteral Source literal node.
+ * @returns True when the source includes a disallowed file extension.
+ * @example
+ * ```typescript
+ * const forbidden = hasDisallowedExtension(sourceLiteral);
+ * ```
+ */
+const hasDisallowedExtension = (sourceLiteral) => {
+    if (typeof sourceLiteral.value !== "string") {
+        return false;
+    }
+    const extension = getTrailingExtension(sourceLiteral.value);
+    return extension !== void 0 && disallowedExtensions.has(extension);
+};
+/**
+ * Reports a statement when it references a source with disallowed extension.
+ * @param context Rule execution context.
+ * @param statement Statement that may include a source literal.
+ * @example
+ * ```typescript
+ * reportWhenSourceHasExtension(context, statement);
+ * ```
+ */
+const reportWhenSourceHasExtension = (context, statement) => {
+    const sourceLiteral = statement.source;
+    if (sourceLiteral === null || sourceLiteral === void 0) {
+        return;
+    }
+    if (!hasDisallowedExtension(sourceLiteral)) {
+        return;
+    }
+    context.report({
+        messageId: "unexpectedExtension",
+        node: sourceLiteral,
+    });
+};
+/**
+ * Narrows one program statement to the source-bearing declarations this rule inspects.
+ * @param statement Program statement node.
+ * @returns Source-bearing declaration when supported.
+ * @example
+ * ```typescript
+ * const declaration = asSourceDeclaration(statement);
+ * ```
+ */
+const asSourceDeclaration = (statement) => {
+    if (statement.type === "ExportAllDeclaration") {
+        return statement;
+    }
+    if (statement.type === "ExportNamedDeclaration") {
+        return statement;
+    }
+    if (statement.type === "ImportDeclaration") {
+        return statement;
+    }
+    return void 0;
+};
+/** ESLint rule that forbids import/export module specifiers with explicit file extensions. */
+const noImportExportExtensionsRule = {
+    create(context) {
+        return {
+            Program(node) {
+                for (const statement of node.body) {
+                    const declaration = asSourceDeclaration(statement);
+                    if (declaration !== void 0) {
+                        reportWhenSourceHasExtension(context, declaration);
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Forbid explicit file extensions in import/export module specifiers.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-extensions.md",
+        },
+        messages: {
+            unexpectedExtension: "Avoid file extensions in import/export module specifiers.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { noImportExportExtensionsRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-import-export-extensions-rule.js","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\nimport type * as ESTree from \"estree\";\r\n\r\n/** Set of disallowed module-specifier file extensions. */\r\nconst disallowedExtensions = new Set([\r\n  \".cjs\",\r\n  \".cts\",\r\n  \".js\",\r\n  \".jsx\",\r\n  \".mjs\",\r\n  \".mts\",\r\n  \".ts\",\r\n  \".tsx\",\r\n]);\r\n\r\n/**\r\n * Gets the trailing extension from a module specifier string.\r\n * @param source Module specifier text.\r\n * @returns File extension including the leading dot when present.\r\n * @example\r\n * ```typescript\r\n * const extension = getTrailingExtension(\"./feature.ts\");\r\n * ```\r\n */\r\nconst getSpecifierEndIndex = (source: string): number => {\r\n  const queryIndex = source.indexOf(\"?\");\r\n  const hashIndex = source.indexOf(\"#\");\r\n  const endIndexCandidates = [queryIndex, hashIndex].filter(\r\n    (index) => index >= 0,\r\n  );\r\n\r\n  return endIndexCandidates.length === 0\r\n    ? source.length\r\n    : Math.min(...endIndexCandidates);\r\n};\r\n\r\n/**\r\n * Gets the trailing extension from a module specifier string.\r\n * @param source Module specifier text.\r\n * @returns File extension including the leading dot when present.\r\n * @example\r\n * ```typescript\r\n * const extension = getTrailingExtension(\"./feature.ts\");\r\n * ```\r\n */\r\nconst getTrailingExtension = (source: string): string | undefined => {\r\n  const endIndex = getSpecifierEndIndex(source);\r\n  const cleanedSource = source.slice(0, endIndex);\r\n  const lastSlashIndex = Math.max(\r\n    cleanedSource.lastIndexOf(\"/\"),\r\n    cleanedSource.lastIndexOf(\"\\\\\"),\r\n  );\r\n  const basename = cleanedSource.slice(lastSlashIndex + 1);\r\n  const dotIndex = basename.lastIndexOf(\".\");\r\n\r\n  if (dotIndex <= 0) {\r\n    return void 0;\r\n  }\r\n\r\n  return basename.slice(dotIndex).toLowerCase();\r\n};\r\n\r\n/**\r\n * Checks whether a source literal should be reported.\r\n * @param sourceLiteral Source literal node.\r\n * @returns True when the source includes a disallowed file extension.\r\n * @example\r\n * ```typescript\r\n * const forbidden = hasDisallowedExtension(sourceLiteral);\r\n * ```\r\n */\r\nconst hasDisallowedExtension = (sourceLiteral: ESTree.Literal): boolean => {\r\n  if (typeof sourceLiteral.value !== \"string\") {\r\n    return false;\r\n  }\r\n\r\n  const extension = getTrailingExtension(sourceLiteral.value);\r\n\r\n  return extension !== void 0 && disallowedExtensions.has(extension);\r\n};\r\n\r\n/**\r\n * Reports a statement when it references a source with disallowed extension.\r\n * @param context Rule execution context.\r\n * @param statement Statement that may include a source literal.\r\n * @example\r\n * ```typescript\r\n * reportWhenSourceHasExtension(context, statement);\r\n * ```\r\n */\r\nconst reportWhenSourceHasExtension = (\r\n  context: Rule.RuleContext,\r\n  statement:\r\n    | ESTree.ExportAllDeclaration\r\n    | ESTree.ExportNamedDeclaration\r\n    | ESTree.ImportDeclaration,\r\n): void => {\r\n  const sourceLiteral = statement.source;\r\n\r\n  if (sourceLiteral === null || sourceLiteral === void 0) {\r\n    return;\r\n  }\r\n\r\n  if (!hasDisallowedExtension(sourceLiteral)) {\r\n    return;\r\n  }\r\n\r\n  context.report({\r\n    messageId: \"unexpectedExtension\",\r\n    node: sourceLiteral,\r\n  });\r\n};\r\n\r\n/**\r\n * Narrows one program statement to the source-bearing declarations this rule inspects.\r\n * @param statement Program statement node.\r\n * @returns Source-bearing declaration when supported.\r\n * @example\r\n * ```typescript\r\n * const declaration = asSourceDeclaration(statement);\r\n * ```\r\n */\r\nconst asSourceDeclaration = (\r\n  statement: ESTree.Program[\"body\"][number],\r\n):\r\n  | ESTree.ExportAllDeclaration\r\n  | ESTree.ExportNamedDeclaration\r\n  | ESTree.ImportDeclaration\r\n  | undefined => {\r\n  if (statement.type === \"ExportAllDeclaration\") {\r\n    return statement;\r\n  }\r\n\r\n  if (statement.type === \"ExportNamedDeclaration\") {\r\n    return statement;\r\n  }\r\n\r\n  if (statement.type === \"ImportDeclaration\") {\r\n    return statement;\r\n  }\r\n\r\n  return void 0;\r\n};\r\n\r\n/** ESLint rule that forbids import/export module specifiers with explicit file extensions. */\r\nconst noImportExportExtensionsRule: Rule.RuleModule = {\r\n  create(context: Rule.RuleContext): Rule.RuleListener {\r\n    return {\r\n      Program(node: ESTree.Program): void {\r\n        for (const statement of node.body) {\r\n          const declaration = asSourceDeclaration(statement);\r\n\r\n          if (declaration !== void 0) {\r\n            reportWhenSourceHasExtension(context, declaration);\r\n          }\r\n        }\r\n      },\r\n    };\r\n  },\r\n  meta: {\r\n    docs: {\r\n      description:\r\n        \"Forbid explicit file extensions in import/export module specifiers.\",\r\n      recommended: false,\r\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-extensions.md\",\r\n    },\r\n    messages: {\r\n      unexpectedExtension:\r\n        \"Avoid file extensions in import/export module specifiers.\",\r\n    },\r\n    schema: [],\r\n    type: \"problem\",\r\n  },\r\n};\r\n\r\nexport { noImportExportExtensionsRule };\r\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQnC;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA8CrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQnC;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA6CrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

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

@@ -33,7 +33,6 @@ const consistentBarrelFilesRule = {
                     allowedNames: {
                         description: "Allowed barrel basenames that the rule recognizes in each folder.",
                         items: { type: "string" },
-                        minItems: 1,
                         type: "array",
                     },
                     enforce: {
@@ -48,4 +47,4 @@ const consistentBarrelFilesRule = {
     },
 };
 export { consistentBarrelFilesRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/architecture/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/domain/architecture/index.js

@@ -1,2 +1,3 @@
-export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noReexportsOutsideBarrelsRule, } from "./consistent-barrel-files/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2FyY2hpdGVjdHVyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsMEJBQTBCLEVBQzFCLHlCQUF5QixFQUN6Qiw2QkFBNkIsR0FDOUIsTUFBTSwyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGJhcnJlbEZpbGVzRXhwb3J0c09ubHlSdWxlLFxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxuICBub1JlZXhwb3J0c091dHNpZGVCYXJyZWxzUnVsZSxcbn0gZnJvbSBcIi4vY29uc2lzdGVudC1iYXJyZWwtZmlsZXNcIjtcbiJdfQ==
+export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noImportExportAliasesRule, noImportExportExtensionsRule, noReexportsOutsideBarrelsRule, } from "./consistent-barrel-files/index.js";
+export { noUnusedExportsRule } from "./no-unused-exports/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2FyY2hpdGVjdHVyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsMEJBQTBCLEVBQzFCLHlCQUF5QixFQUN6Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLDZCQUE2QixHQUM5QixNQUFNLDJCQUEyQixDQUFDO0FBQ25DLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXG4gIGNvbnNpc3RlbnRCYXJyZWxGaWxlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxufSBmcm9tIFwiLi9jb25zaXN0ZW50LWJhcnJlbC1maWxlc1wiO1xuZXhwb3J0IHsgbm9VbnVzZWRFeHBvcnRzUnVsZSB9IGZyb20gXCIuL25vLXVudXNlZC1leHBvcnRzXCI7XG4iXX0=

package/dist/domain/architecture/no-unused-exports/index.d.ts

@@ -0,0 +1,3 @@
+export { noUnusedExportsRule } from "./rule.js";
+export type { NoUnusedExportsOptions } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/architecture/no-unused-exports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAC7C,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC"}

package/dist/domain/architecture/no-unused-exports/index.js

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

package/dist/domain/architecture/no-unused-exports/no-unused-exports-options.d.ts

@@ -0,0 +1,50 @@
+import type { NoUnusedExportsState } from "./types.js";
+/** Default public API files where exported symbols are intentionally exposed. */
+export declare const DEFAULT_PUBLIC_API_FILES: readonly ["**/src/index.ts", "**/__tests__/**/*.ts"];
+/** Default glob patterns used to classify test files. */
+export declare const DEFAULT_TEST_FILE_PATTERNS: readonly ["**/*.{test,spec,e2e}.ts", "**/__tests__/**/*.ts"];
+/**
+ * Checks whether one file path is lintable.
+ * @param filename Input filename.
+ * @returns True when the path is absolute and matches source-file scope.
+ * @example
+ * ```typescript
+ * const ok = isLintableFilename("/repo/src/feature.ts");
+ * ```
+ */
+export declare const isLintableFilename: (filename: string) => boolean;
+/**
+ * Builds normalized options from raw rule options.
+ * @param options Raw rule options.
+ * @returns Normalized options state.
+ * @example
+ * ```typescript
+ * const state = getOptions([{}]);
+ * ```
+ */
+export declare const getOptions: (options: readonly unknown[]) => NoUnusedExportsState;
+/**
+ * Checks whether one file defines a public API export surface.
+ * @param filename Absolute filename.
+ * @param state Normalized options.
+ * @param repoRoot Absolute repository root.
+ * @returns True when the file is a public API file.
+ * @example
+ * ```typescript
+ * const publicApiFile = isPublicApiFile("/repo/src/index.ts", state, "/repo");
+ * ```
+ */
+export declare const isPublicApiFile: (filename: string, state: NoUnusedExportsState, repoRoot: string) => boolean;
+/**
+ * Checks whether one file should be treated as a test file.
+ * @param filename Absolute filename.
+ * @param state Normalized options.
+ * @param repoRoot Absolute repository root.
+ * @returns True when the file path matches a test pattern.
+ * @example
+ * ```typescript
+ * const testFile = isTestFile("/repo/tests/e2e/demo.ts", state, "/repo");
+ * ```
+ */
+export declare const isTestFile: (filename: string, state: NoUnusedExportsState, repoRoot: string) => boolean;
+//# sourceMappingURL=no-unused-exports-options.d.ts.map

package/dist/domain/architecture/no-unused-exports/no-unused-exports-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-exports-options.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-options.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAA0B,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE5E,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,sDAG3B,CAAC;AAEX,yDAAyD;AACzD,eAAO,MAAM,0BAA0B,8DAG7B,CAAC;AAiBX;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OAUrD,CAAC;AA4BF;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GACrB,SAAS,SAAS,OAAO,EAAE,KAC1B,oBAaF,CAAC;AAwDF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,KACf,OAAsE,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,EAChB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,KACf,OAAwE,CAAC"}