@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/engines/arch-detect/rules/modular/m004-public-api.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * M004: Public API Defined (Barrel Files)
+ * Xác nhận mỗi module có public API rõ ràng
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M004PublicApi = void 0;
+const enums_1 = require("../../types/enums");
+const file_scanner_1 = require("../../utils/file-scanner");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('M004', 'Public API Defined (Barrel Files)', 'Xác nhận mỗi module có public API rõ ràng (index.ts, public-api.ts, __init__.py, etc.)', enums_1.RuleCategory.STRUCTURE, 0.13, [enums_1.PatternType.MODULAR], {
+    filePatterns: [
+        'index.ts',
+        'index.js',
+        'public-api.ts',
+        'public_api.dart',
+        '__init__.py',
+        'mod.rs',
+    ],
+}, {
+    isKeyIndicator: true,
+    tags: ['modular', 'barrel', 'public-api'],
+});
+let M004PublicApi = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M004PublicApi = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            let modulesWithBarrel = 0;
+            let totalModules = 0;
+            // Find module containers
+            const moduleContainers = ['features', 'modules', 'packages', 'libs'];
+            const moduleDirs = [];
+            for (const container of moduleContainers) {
+                const found = file_scanner_1.FileScanner.findFoldersByPattern(context.directoryTree, new RegExp(`^(src/)?${container}$`, 'i'));
+                for (const dir of found) {
+                    for (const subDir of dir.subdirectories) {
+                        moduleDirs.push(subDir.relativePath);
+                        totalModules++;
+                    }
+                }
+            }
+            // Barrel file patterns
+            const barrelPatterns = [
+                'index.ts',
+                'index.js',
+                'index.tsx',
+                'index.jsx',
+                'public-api.ts',
+                'public_api.dart',
+                '__init__.py',
+                'mod.rs',
+            ];
+            // Check each module for barrel files
+            for (const moduleDir of moduleDirs) {
+                const hasBarrel = barrelPatterns.some((barrel) => context.files.some((f) => f.relativePath === `${moduleDir}/${barrel}` ||
+                    f.relativePath === `${moduleDir}/src/${barrel}`));
+                if (hasBarrel) {
+                    modulesWithBarrel++;
+                    matches.push({
+                        type: enums_1.MatchType.FILE,
+                        path: moduleDir,
+                        matchedPattern: 'Module with barrel file',
+                    });
+                }
+            }
+            // Also count standalone barrel files in likely module locations
+            const barrelFiles = context.files.filter((f) => barrelPatterns.includes(f.fileName) &&
+                !f.relativePath.includes('node_modules') &&
+                // Not at root level
+                f.relativePath.includes('/'));
+            // Add barrel files not in module directories
+            for (const file of barrelFiles) {
+                const alreadyMatched = matches.some((m) => file.relativePath.startsWith(m.path));
+                if (!alreadyMatched && matches.length < 15) {
+                    matches.push({
+                        type: enums_1.MatchType.FILE,
+                        path: file.relativePath,
+                        matchedPattern: 'Barrel file',
+                    });
+                }
+            }
+            // Calculate score
+            let score = 0;
+            if (totalModules > 0) {
+                const ratio = modulesWithBarrel / totalModules;
+                if (ratio >= 1)
+                    score = 1;
+                else if (ratio >= 0.8)
+                    score = 0.8;
+                else if (ratio >= 0.5)
+                    score = 0.5;
+                else
+                    score = ratio * 0.4;
+            }
+            else if (barrelFiles.length > 0) {
+                // No formal module structure but has barrel files
+                score = Math.min(barrelFiles.length * 0.1, 0.6);
+            }
+            return { matches, violations: [], score };
+        }
+        getMetadata(context, matches) {
+            const withBarrel = matches.filter((m) => m.matchedPattern === 'Module with barrel file').length;
+            const barrelFiles = matches.filter((m) => m.matchedPattern === 'Barrel file').length;
+            return {
+                ...super.getMetadata(context, matches),
+                modulesWithBarrel: withBarrel,
+                totalBarrelFiles: withBarrel + barrelFiles,
+            };
+        }
+    };
+    __setFunctionName(_classThis, "M004PublicApi");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        M004PublicApi = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M004PublicApi = _classThis;
+})();
+exports.M004PublicApi = M004PublicApi;
+exports.default = M004PublicApi;
+//# sourceMappingURL=m004-public-api.js.map

package/engines/arch-detect/rules/modular/m005-no-deep-imports.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * M005: No Deep Imports (Encapsulation)
+ * Xác nhận modules không import deep vào internal của module khác
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M005NoDeepImports = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('M005', 'No Deep Imports (Encapsulation)', 'Xác nhận modules không import deep vào internal của module khác', enums_1.RuleCategory.STRUCTURE, 0.1, [enums_1.PatternType.MODULAR], {}, {
+    tags: ['modular', 'encapsulation', 'imports'],
+});
+let M005NoDeepImports = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M005NoDeepImports = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const violations = [];
+            let deepImportCount = 0;
+            let validImportCount = 0;
+            // Identify module boundaries
+            const modulePaths = this.identifyModulePaths(context);
+            if (modulePaths.length < 2) {
+                // Not enough modules to check cross-module imports
+                return { matches, violations, score: 0.5 };
+            }
+            // Check imports in source files
+            const sourceFiles = context.files
+                .filter((f) => !f.isTest &&
+                !f.isConfig &&
+                (f.extension === '.ts' || f.extension === '.js' || f.extension === '.tsx'))
+                .slice(0, 50);
+            const importPattern = /import\s+.*\s+from\s+['"]([^'"]+)['"]/g;
+            for (const file of sourceFiles) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    const fileModulePath = this.getModulePath(file.relativePath, modulePaths);
+                    let match;
+                    while ((match = importPattern.exec(content)) !== null) {
+                        const importPath = match[1];
+                        // Skip external packages
+                        if (!importPath.startsWith('.') &&
+                            !importPath.startsWith('@app') &&
+                            !importPath.startsWith('@/')) {
+                            continue;
+                        }
+                        // Check if this is a cross-module import
+                        const targetModulePath = this.resolveImportToModule(importPath, file.relativePath, modulePaths);
+                        if (targetModulePath && targetModulePath !== fileModulePath) {
+                            // Cross-module import detected
+                            const isDeepImport = this.isDeepImport(importPath, targetModulePath);
+                            if (isDeepImport) {
+                                deepImportCount++;
+                                violations.push({
+                                    type: 'deep_import',
+                                    severity: enums_1.Severity.WARNING,
+                                    path: file.relativePath,
+                                    message: `Deep import into ${targetModulePath}: ${importPath}`,
+                                    suggestion: `Import from ${targetModulePath}/index instead`,
+                                });
+                            }
+                            else {
+                                validImportCount++;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+            // Add summary match
+            matches.push({
+                type: enums_1.MatchType.CODE,
+                path: '',
+                matchedPattern: `${validImportCount} valid, ${deepImportCount} deep imports`,
+            });
+            // Calculate score
+            let score = 1;
+            if (deepImportCount === 0)
+                score = 1;
+            else if (deepImportCount <= 5)
+                score = 0.7;
+            else if (deepImportCount <= 10)
+                score = 0.4;
+            else
+                score = 0.1;
+            return { matches, violations, score };
+        }
+        identifyModulePaths(context) {
+            const modulePaths = [];
+            const moduleContainers = ['features', 'modules', 'packages', 'libs'];
+            for (const file of context.files) {
+                for (const container of moduleContainers) {
+                    const regex = new RegExp(`^(src/)?${container}/([^/]+)`, 'i');
+                    const match = file.relativePath.match(regex);
+                    if (match) {
+                        const modulePath = `${match[1] || ''}${container}/${match[2]}`;
+                        if (!modulePaths.includes(modulePath)) {
+                            modulePaths.push(modulePath);
+                        }
+                    }
+                }
+            }
+            return modulePaths;
+        }
+        getModulePath(filePath, modulePaths) {
+            for (const modulePath of modulePaths) {
+                if (filePath.startsWith(modulePath)) {
+                    return modulePath;
+                }
+            }
+            return null;
+        }
+        resolveImportToModule(importPath, fromFilePath, modulePaths) {
+            // Handle relative imports
+            if (importPath.startsWith('.')) {
+                const parts = fromFilePath.split('/');
+                parts.pop(); // Remove filename
+                const importParts = importPath.split('/');
+                for (const part of importParts) {
+                    if (part === '..') {
+                        parts.pop();
+                    }
+                    else if (part !== '.') {
+                        parts.push(part);
+                    }
+                }
+                const resolvedPath = parts.join('/');
+                return this.getModulePath(resolvedPath, modulePaths);
+            }
+            // Handle alias imports (@app/users, @/features/users)
+            if (importPath.startsWith('@app/') || importPath.startsWith('@/')) {
+                const cleaned = importPath.replace(/^@(app)?\//, '');
+                return this.getModulePath(cleaned, modulePaths);
+            }
+            return null;
+        }
+        isDeepImport(importPath, targetModulePath) {
+            // A deep import goes beyond the module's public API (index file)
+            // Example:
+            // Valid: @app/users or @app/users/index
+            // Deep: @app/users/services/user.service
+            const cleanPath = importPath.replace(/^@(app)?\//, '').replace(/\/index$/, '');
+            // Count path segments beyond module
+            const moduleSegments = targetModulePath.split('/').length;
+            const importSegments = cleanPath.split('/').length;
+            // If import has more segments than module path, it's a deep import
+            return importSegments > moduleSegments;
+        }
+        getMetadata(context, matches) {
+            const statsMatch = matches.find((m) => m.matchedPattern?.includes('valid,'));
+            const stats = statsMatch?.matchedPattern?.split(', ') || [];
+            return {
+                ...super.getMetadata(context, matches),
+                validImports: parseInt(stats[0]?.split(' ')[0] || '0', 10),
+                deepImports: parseInt(stats[1]?.split(' ')[0] || '0', 10),
+            };
+        }
+    };
+    __setFunctionName(_classThis, "M005NoDeepImports");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        M005NoDeepImports = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M005NoDeepImports = _classThis;
+})();
+exports.M005NoDeepImports = M005NoDeepImports;
+exports.default = M005NoDeepImports;
+//# sourceMappingURL=m005-no-deep-imports.js.map