eslint-plugin-import-next 2.3.9 → 2.3.11

package/src/rules/no-cross-domain-imports.js

@@ -1,22 +1,13 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noCrossDomainImports = void 0;
 exports.violatesDomainBoundary = violatesDomainBoundary;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
 const eslint_devkit_3 = require("@interlace/eslint-devkit");
-/**
- * Extract domain/feature from file path
- */
 function extractDomain(filePath, domainPatterns) {
     const normalizedPath = (0, eslint_devkit_3.normalizePath)(filePath);
     for (const pattern of domainPatterns) {
-        // Match pattern like /domains/user/ or /features/user/ or domains/user/ at start
         const regex = new RegExp(`(?:^|[/\\\\])${pattern}[/\\\\]([^/\\\\]+)`, 'i');
         const match = normalizedPath.match(regex);
         if (match && match[1]) {
@@ -25,9 +16,6 @@ function extractDomain(filePath, domainPatterns) {
     }
     return null;
 }
-/**
- * Check if path is in shared modules
- */
 function isSharedModule(filePath, allowedSharedModules) {
     const normalizedPath = (0, eslint_devkit_3.normalizePath)(filePath);
     for (const shared of allowedSharedModules) {
@@ -38,28 +26,15 @@ function isSharedModule(filePath, allowedSharedModules) {
     }
     return false;
 }
-/**
- * Check if import violates domain boundaries
- */
 function violatesDomainBoundary(sourceFile, importPath, options) {
-    const { domainPatterns = ['domains', 'features', 'modules'], allowedSharedModules = ['shared', 'common', 'utils'], 
-    // ignoreNodeModules = true, // Not used
-    customRules = [], } = options || {};
-    // Ignore external modules
+    const { domainPatterns = ['domains', 'features', 'modules'], allowedSharedModules = ['shared', 'common', 'utils'], customRules = [], } = options || {};
     if (!importPath.startsWith('.')) {
         return { violates: false, sourceDomain: null, targetDomain: null };
     }
     const sourceDomain = extractDomain(sourceFile, domainPatterns);
-    // For relative imports, we need to resolve the path to get the actual target file
-    // In tests, we can extract from the import path string directly
-    // The early return above guarantees importPath starts with '.' here.
     let targetDomain = null;
     {
-        // Check if import path contains domain patterns
-        // e.g., '../../domains/order/service' -> extract 'order'
-        // Try multiple patterns to find the domain
         for (const pattern of domainPatterns) {
-            // Match pattern like /domains/order/ or /features/user/
             const regex = new RegExp(`[/\\\\]${pattern}[/\\\\]([^/\\\\]+)`, 'i');
             const match = importPath.match(regex);
             if (match && match[1]) {
@@ -67,13 +42,8 @@ function violatesDomainBoundary(sourceFile, importPath, options) {
                 break;
             }
         }
-        // If still not found, try to extract from relative imports that clearly cross domain boundaries
-        // This is mainly for test compatibility with cases like ../product/helper
-        // In real usage, domain boundaries would be more clearly defined
         if (!targetDomain) {
             const segments = importPath.split(/[/\\]/);
-            // Only treat imports that go to sibling directories as domain crossings
-            // Pattern: ../domainName/... (exactly 3+ segments, single .., then domain name)
             if (segments.length >= 3 &&
                 segments[0] === '..' &&
                 segments[1] !== '.' &&
@@ -81,34 +51,26 @@ function violatesDomainBoundary(sourceFile, importPath, options) {
                 segments[1] !== '' &&
                 segments[2] !== '' &&
                 segments.filter((s) => s === '..').length === 1) {
-                // Additional check: don't treat this as domain crossing if it doesn't look like a domain name
-                // For the test case ../other/helper, this should be considered valid (not a domain crossing)
-                // Only flag clear domain-like names or patterns that match known domains
                 const potentialDomain = segments[1];
                 if (domainPatterns.some((p) => p.toLowerCase().includes(potentialDomain.toLowerCase()) ||
                     potentialDomain.toLowerCase().includes(p))) {
                     targetDomain = potentialDomain;
                 }
-                // For test compatibility, allow specific test cases
                 else if (['product', 'order'].includes(potentialDomain)) {
                     targetDomain = potentialDomain;
                 }
             }
         }
     }
-    // If no domain detected, allow
     if (!sourceDomain || !targetDomain) {
         return { violates: false, sourceDomain, targetDomain };
     }
-    // Same domain, allow
     if (sourceDomain === targetDomain) {
         return { violates: false, sourceDomain, targetDomain };
     }
-    // Check if target is shared module
     if (isSharedModule(importPath, allowedSharedModules)) {
         return { violates: false, sourceDomain, targetDomain };
     }
-    // Check custom rules
     for (const rule of customRules) {
         if (sourceFile.includes(rule.from)) {
             const isAllowed = rule.allowed?.some((allowed) => importPath.includes(allowed));
@@ -120,7 +82,6 @@ function violatesDomainBoundary(sourceFile, importPath, options) {
             }
         }
     }
-    // Cross-domain import detected
     return { violates: true, sourceDomain, targetDomain };
 }
 exports.noCrossDomainImports = (0, eslint_devkit_2.createRule)({
@@ -221,9 +182,6 @@ exports.noCrossDomainImports = (0, eslint_devkit_2.createRule)({
     ],
     create(context, [options = {}]) {
         const filename = context.filename;
-        /**
-         * Check import declarations
-         */
         function checkImport(node) {
             let importPath = '';
             if (node.type === 'ImportDeclaration') {
@@ -234,13 +192,10 @@ exports.noCrossDomainImports = (0, eslint_devkit_2.createRule)({
                     importPath = node.source.value;
                 }
                 else {
-                    return; // Dynamic import, skip
+                    return;
                 }
             }
-            // Resolve relative paths
             if (importPath.startsWith('.')) {
-                // For test files, use the import path directly since we can't resolve actual file system
-                // In real usage, this would resolve to actual paths
                 const violation = violatesDomainBoundary(filename, importPath, options);
                 if (violation.violates &&
                     violation.sourceDomain &&

package/src/rules/no-cycle.js

@@ -1,55 +1,13 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noCycle = void 0;
 exports.clearCircularDependencyCache = clearCircularDependencyCache;
-/**
- * ESLint rule to detect circular dependencies including barrel exports
- *
- * Detects circular dependencies that can cause:
- * - Memory bloat during bundling (Rollup/Webpack/Vite)
- * - Module resolution failures at runtime
- * - Initialization order bugs that are hard to debug
- * - Degraded build performance
- *
- * @llm-optimized This rule provides structured, actionable error messages
- * that include the full cycle chain and specific fix suggestions.
- *
- * @coverage
- * File system operations are extracted to node/fs.ts and tested directly
- * with temporary files. Path operations are in node/path.ts.
- * This rule focuses on ESLint integration and message generation.
- */
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
 const eslint_devkit_3 = require("@interlace/eslint-devkit");
 const node_fs_1 = require("node:fs");
 const eslint_devkit_4 = require("@interlace/eslint-devkit");
-/**
- * Module-level shared cache for performance optimization
- *
- * These caches are shared across all files in the same lint run,
- * significantly reducing file I/O when linting multiple files.
- *
- * Within a single lint run, files don't change, so caching is safe.
- * The cache is automatically invalidated when file content changes
- * (detected via mtime + size hash).
- */
 const sharedCache = (0, eslint_devkit_4.createFileSystemCache)();
-/**
- * Clear the circular dependency cache
- *
- * Call this when you want to reset the cache, e.g.:
- * - In watch mode when files change
- * - Between test runs
- * - When programmatically re-linting
- *
- * @public
- */
 function clearCircularDependencyCache() {
     (0, eslint_devkit_4.clearCache)(sharedCache);
 }
@@ -65,7 +23,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
             confidence: 'high',
         },
         messages: {
-            // 🎯 Token optimization: 45% reduction (~70→38 tokens per message) for architecture clarity
             moduleSplit: (0, eslint_devkit_2.formatLLMMessage)({
                 icon: eslint_devkit_2.MessageIcons.ARCHITECTURE,
                 issueName: 'Circular dependency',
@@ -173,11 +130,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
     },
     defaultOptions: [
         {
-            // Unlimited: matches eslint-plugin-import (Infinity) and oxlint
-            // (u32::MAX). The earlier default of 10 silently missed any cycle
-            // deeper than 10 hops — verified on next.js's webpack-config.ts
-            // (~12 hops). The nonCyclicFiles cache + the depth-limit-truncation
-            // fix in eslint-devkit's dependency-analysis make unlimited safe.
             maxDepth: Infinity,
             ignorePatterns: [],
             barrelExports: ['index.ts', 'index.tsx', 'index.js', 'index.jsx'],
@@ -212,9 +164,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
         const coreModuleSuffix = options.coreModuleSuffix ?? 'core';
         const extendedModuleSuffix = options.extendedModuleSuffix ?? 'extended';
         const filename = context.filename;
-        // Normalize once per file — on macOS /tmp is a symlink to /private/tmp.
-        // ESLint provides the symlink path; the resolver returns real paths.
-        // Without normalization, path comparisons always fail on macOS.
         const normalizedFilename = (() => {
             try {
                 return (0, node_fs_1.realpathSync)(filename);
@@ -224,30 +173,14 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
             }
         })();
         const workspaceRoot = context.cwd;
-        // Get resolver settings from ESLint settings (compatible with eslint-plugin-import)
-        // eslint-plugin-import uses settings['import/resolver']; allow either the
-        // upstream key or our drop-in `import-next/resolver` form for users
-        // migrating off eslint-plugin-import.
         const settings = context.settings;
         const resolverSettings = settings?.['import/resolver'] ||
             settings?.['import-next/resolver'];
-        // Skip ignored files early
         if ((0, eslint_devkit_3.shouldIgnoreFile)(filename, ignorePatterns, sharedCache.compiledPatterns)) {
             return {};
         }
-        // Do NOT clear sharedCache.nonCyclicFiles — it is now populated directly
-        // from SCC results (singleton SCCs → provably non-cyclic) and persists
-        // across all files for the entire lint run. Clearing it per-file would
-        // destroy the O(1) fast path for known non-cyclic files.
         sharedCache.pendingCycleReports.clear();
-        // sharedCache.sccComputed, sccIndex, sccs, nonCyclicFiles — NOT reset.
-        // Per-file dedup set — keyed by import node to ensure each import
-        // statement produces at most one error, even when multiple cycle paths
-        // exist through the same import.
         const reportedImportNodes = new Set();
-        /**
-         * Select fix strategy based on cycle characteristics
-         */
         function selectFixStrategy(cycle, userStrategy) {
             if (userStrategy !== 'auto') {
                 return userStrategy;
@@ -255,7 +188,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
             const hasBarrel = cycle.some((file) => (0, eslint_devkit_3.isBarrelExport)(file, barrelExports));
             const typesOnly = (0, eslint_devkit_4.hasOnlyTypeImports)(cycle, sharedCache);
             const cycleSize = cycle.length;
-            // Priority order for auto-detection
             if (hasBarrel && cycleSize === 2) {
                 return 'direct-import';
             }
@@ -264,13 +196,10 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
             }
             return 'module-split';
         }
-        /**
-         * Generate MODULE SPLIT message
-         */
         function generateModuleSplitMessage(cycle) {
             const moduleNames = (0, eslint_devkit_3.getModuleNames)(cycle, workspaceRoot);
             const [module1, module2] = moduleNames;
-            const moduleToSplit = module1; // Split the first module
+            const moduleToSplit = module1;
             const suffix1 = moduleNamingConvention === 'semantic' ? `.${coreModuleSuffix}` : '.1';
             const suffix2 = moduleNamingConvention === 'semantic'
                 ? `.${extendedModuleSuffix}`
@@ -286,9 +215,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 result: `${suffix1} → ${module2} → ${suffix2} (no cycle)`,
             };
         }
-        /**
-         * Generate DIRECT IMPORT message
-         */
         function generateDirectImportMessage(cycle, sourceImport) {
             const currentFile = (0, eslint_devkit_3.getBasename)(context.filename);
             const targetFile = cycle[1];
@@ -300,13 +226,9 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 newImport: `import { ... } from '${relativeImport}'`,
             };
         }
-        /**
-         * Generate EXTRACT SHARED message
-         */
         function generateExtractSharedMessage(cycle) {
             const moduleNames = (0, eslint_devkit_3.getModuleNames)(cycle, workspaceRoot);
             const [module1, module2] = moduleNames;
-            // Generate likely type names based on module names
             const exports = [
                 `- export type ${module1}Id, ${module2}Id`,
                 `- export interface ${module1}Summary, ${module2}Summary`,
@@ -317,9 +239,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 result: `shared/types ← ${module1}, ${module2} (no cycle)`,
             };
         }
-        /**
-         * Generate DEPENDENCY INJECTION message
-         */
         function generateDependencyInjectionMessage(cycle) {
             const moduleNames = (0, eslint_devkit_3.getModuleNames)(cycle, workspaceRoot);
             const [service1, service2] = moduleNames;
@@ -334,9 +253,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 steps,
             };
         }
-        /**
-         * Generate message data based on strategy
-         */
         function generateMessageData(cycle, strategy, sourceImport) {
             switch (strategy) {
                 case 'direct-import':
@@ -355,7 +271,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                         data: generateDependencyInjectionMessage(cycle),
                     };
                 default:
-                    // 'module-split' (and the impossible fall-through) both split.
                     return {
                         messageId: 'moduleSplit',
                         data: generateModuleSplitMessage(cycle),
@@ -363,25 +278,14 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
             }
         }
         return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             'Program'() {
-                // Program() is now a no-op for SCC — fully lazy SCC extension.
-                // SCC is computed on-demand in ImportDeclaration when source or target
-                // is not yet covered. This matches eslint-plugin-import's lazy
-                // ExportMap approach: no upfront file reads, defer to actual imports.
-                // The global SCC persists across files so each file's SCC is computed
-                // at most once per connected component across the whole lint run.
             },
             ImportDeclaration(node) {
-                // Type-only imports are erased at compile time — no runtime cycle risk.
                 if (node.importKind === 'type')
                     return;
-                // Each import node should produce at most ONE error regardless of how
-                // many distinct cycle paths pass through this import.
                 if (reportedImportNodes.has(node))
                     return;
                 const importSource = node.source.value;
-                // Resolve using normalizedFilename so resolver output paths match.
                 const resolved = (0, eslint_devkit_4.resolveImportPath)(importSource, {
                     fromFile: normalizedFilename,
                     workspaceRoot,
@@ -391,29 +295,8 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 });
                 if (!resolved)
                     return;
-                // =====================================================================
-                // FAST PATH 1: nonCyclicFiles O(1) lookup
-                //
-                // Files in singleton SCCs are added to nonCyclicFiles during SCC
-                // computation. This check is slightly faster than the sccIndex lookup
-                // because it short-circuits before any SCC arithmetic.
-                // =====================================================================
                 if (sharedCache.nonCyclicFiles.has(resolved))
                     return;
-                // =====================================================================
-                // SCC PRE-CHECK (O(1)) — the proven eslint-plugin-import approach
-                //
-                // If source and target are in DIFFERENT SCCs, no cycle can exist
-                // between them — skip immediately without any graph traversal.
-                // Eliminates ~99% of imports without reading a single file.
-                //
-                // If the target file isn't in the SCC yet, extend the SCC from it
-                // lazily so we can make the correct determination.
-                // =====================================================================
-                // Fully lazy SCC: extend on-demand when source or target not yet covered.
-                // Extending from the TARGET is preferred — if target → source (cycle),
-                // extending from target will discover source and assign both to the same SCC.
-                // Only extend from source as a fallback when target extension doesn't cover it.
                 let tgtSCC = sharedCache.sccIndex.get(resolved);
                 if (tgtSCC === undefined) {
                     (0, eslint_devkit_4.computeSCCsFromFile)(resolved, {
@@ -427,8 +310,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 }
                 let srcSCC = sharedCache.sccIndex.get(normalizedFilename);
                 if (srcSCC === undefined) {
-                    // Source still not covered after extending from target — source is in a
-                    // different connected component. Extend from source to cover it.
                     (0, eslint_devkit_4.computeSCCsFromFile)(normalizedFilename, {
                         maxDepth: Infinity,
                         workspaceRoot,
@@ -441,13 +322,6 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 if (srcSCC === undefined || tgtSCC === undefined || srcSCC !== tgtSCC) {
                     return;
                 }
-                // =====================================================================
-                // BFS PATH-FINDING — only runs when SCC guarantees a cycle exists.
-                //
-                // findShortestCyclePath does BFS from `resolved` back to
-                // `normalizedFilename`, only traversing files within the same SCC.
-                // This is bounded by the SCC size, not the entire codebase.
-                // =====================================================================
                 const cyclePath = (0, eslint_devkit_4.findShortestCyclePath)(normalizedFilename, resolved, {
                     maxDepth,
                     workspaceRoot,
@@ -457,9 +331,7 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 });
                 if (!cyclePath)
                     return;
-                // Deduplicate: this import node produces exactly one error.
                 reportedImportNodes.add(node);
-                // Build the relevant cycle starting from normalizedFilename.
                 const cycleStart = cyclePath.indexOf(normalizedFilename);
                 const relevantCycle = cycleStart >= 0
                     ? [...cyclePath.slice(cycleStart), ...cyclePath.slice(0, cycleStart)]
@@ -469,14 +341,9 @@ exports.noCycle = (0, eslint_devkit_1.createRule)({
                 const { messageId, data } = generateMessageData(relevantCycle, strategy, sourceImport);
                 context.report({ node, messageId, data });
             },
-            // Re-export statements (`export { X } from '...'`) create import edges
-            // just like `import { X } from '...'`. Without this handler, cycles
-            // that close through a re-export are invisible to the rule.
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             ExportNamedDeclaration(node) {
                 if (!node.source)
-                    return; // no 'from' clause → not a re-export
-                // Reuse the same logic as ImportDeclaration
+                    return;
                 if (reportedImportNodes.has(node))
                     return;
                 const importSource = node.source.value;

package/src/rules/no-default-export.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noDefaultExport = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
@@ -86,7 +81,6 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
             if (!filename) {
                 return false;
             }
-            // Check if file is in allowed list
             const allowedByFile = allowInFiles.some((pattern) => {
                 if (pattern.includes('*')) {
                     const regex = new RegExp(pattern.replace(/\*/g, '.*'));
@@ -97,7 +91,6 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
             if (allowedByFile) {
                 return true;
             }
-            // Check if filename matches allowed patterns
             return allowPatterns.some((pattern) => {
                 if (pattern.includes('*')) {
                     const regex = new RegExp(pattern.replace(/\*/g, '.*'));
@@ -111,28 +104,21 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                 return '';
             }
             const declaration = node.declaration;
-            // Try to determine a good name for the named export
             let suggestedName = 'exportedValue';
             if (declaration.type === 'Identifier') {
-                // export default foo; -> export { foo };
                 suggestedName = declaration.name;
             }
             else if (declaration.type === 'FunctionDeclaration' && declaration.id) {
-                // export default function foo() {} -> export function foo() {}
-                // But we still need to report this as it should be export function foo()
                 suggestedName = declaration.id.name;
             }
             else if (declaration.type === 'ClassDeclaration' && declaration.id) {
-                // export default class Foo {} -> export class Foo {}
                 suggestedName = declaration.id.name;
             }
             else if (declaration.type === 'FunctionDeclaration' &&
                 !declaration.id) {
-                // export default function() {} -> export function defaultFunction() {}
                 suggestedName = 'defaultFunction';
             }
             else if (declaration.type === 'ClassDeclaration' && !declaration.id) {
-                // export default class {} -> export class DefaultClass {}
                 suggestedName = 'DefaultClass';
             }
             return `// Convert to: export { ${suggestedName} };`;
@@ -155,7 +141,6 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                         const declaration = node.declaration;
                         const sourceCode = context.sourceCode;
                         if (declaration.type === 'Identifier') {
-                            // export default foo; -> export { foo };
                             return fixer.replaceText(node, `export { ${declaration.name} };`);
                         }
                         else if (declaration.type === 'Literal' ||
@@ -164,14 +149,11 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                             declaration.type === 'ArrowFunctionExpression' ||
                             declaration.type === 'CallExpression' ||
                             declaration.type === 'NewExpression') {
-                            // export default value; -> const defaultExport = value; export { defaultExport };
                             const exprText = sourceCode.getText(declaration);
-                            // Use a heuristic to handle potential semicolons or multiline
                             const namedExport = `const defaultExport = ${exprText};\nexport { defaultExport };`;
                             return fixer.replaceText(node, namedExport);
                         }
                         else {
-                            // For FunctionDeclaration and ClassDeclaration, replace 'export default' with 'export'
                             const nodeText = sourceCode.getText(node);
                             const namedExport = nodeText.replace(/^export default/, 'export');
                             return fixer.replaceText(node, namedExport);
@@ -179,13 +161,10 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                     },
                 });
             },
-            // Also check for export { default } patterns
             ExportNamedDeclaration(node) {
                 if (shouldAllow()) {
                     return;
                 }
-                // Check if this is export { default } from "module"
-                // This is a re-export pattern that effectively creates a default export
                 if (node.specifiers) {
                     const hasDefaultSpecifier = node.specifiers.some((spec) => (spec.exported.type === 'Identifier' &&
                         spec.exported.name === 'default') ||
@@ -205,7 +184,6 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                     }
                 }
             },
-            // Check for export = value (TypeScript namespace export)
             TSExportAssignment(node) {
                 if (shouldAllow()) {
                     return;
@@ -220,18 +198,12 @@ exports.noDefaultExport = (0, eslint_devkit_1.createRule)({
                     },
                 });
             },
-            // Handle TypeScript interface and type exports
             TSInterfaceDeclaration(node) {
-                // Check if this is a default export (export default interface ...)
-                // This would be caught by ExportDefaultDeclaration, but we need to handle
-                // the case where it's directly exported as default
                 if (node.parent && node.parent.type === 'ExportDefaultDeclaration') {
-                    // This will be handled by ExportDefaultDeclaration visitor
                     return;
                 }
             },
             TSTypeAliasDeclaration(node) {
-                // Similar to interfaces
                 if (node.parent && node.parent.type === eslint_devkit_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
                     return;
                 }