@sun-asterisk/sunlint 1.3.34 → 1.3.35

package/engines/arch-detect/rules/layered/layered-rules-collection.js

@@ -0,0 +1,445 @@
+"use strict";
+/**
+ * Layered Rules Collection
+ * Định nghĩa các rules còn lại (L007-L015) với cách tiếp cận đơn giản hơn
+ */
+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.L015InterfaceDefinitions = exports.L014Middleware = exports.L013ConfigLayer = exports.L012Validation = exports.L011ExceptionHandling = exports.L010MapperLayer = exports.L009DtoLayer = exports.L008FrameworkConfig = exports.L007ControllerThin = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+// L007: Controller is Thin
+const l007Rule = (0, base_rule_1.createRule)('L007', 'Controller is Thin', 'Xác nhận Controller không chứa business logic', enums_1.RuleCategory.QUALITY, 0.06, [enums_1.PatternType.LAYERED], { filePatterns: ['*Controller.*', '*Handler.*'] }, { tags: ['layered', 'quality', 'thin-controller'] });
+let L007ControllerThin = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l007Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L007ControllerThin = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l007Rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const violations = [];
+            const controllerFiles = context.files
+                .filter((f) => /controller/i.test(f.fileName) && !f.isTest)
+                .slice(0, 20);
+            const totalControllers = controllerFiles.length;
+            let thinControllers = 0;
+            for (const file of controllerFiles) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    // Check for business logic indicators
+                    const businessPatterns = [
+                        /for\s*\(/g,
+                        /while\s*\(/g,
+                        /calculate/gi,
+                        /process/gi,
+                        /validate.*\(/gi,
+                        /\.query\s*\(/g,
+                        /\.execute\s*\(/g,
+                    ];
+                    let hasBusinessLogic = false;
+                    for (const pattern of businessPatterns) {
+                        if (pattern.test(content)) {
+                            hasBusinessLogic = true;
+                            violations.push({
+                                type: 'fat_controller',
+                                severity: enums_1.Severity.INFO,
+                                path: file.relativePath,
+                                message: 'Controller may contain business logic',
+                                suggestion: 'Consider moving complex logic to service layer',
+                            });
+                            break;
+                        }
+                    }
+                    if (!hasBusinessLogic) {
+                        thinControllers++;
+                        matches.push({
+                            type: enums_1.MatchType.FILE,
+                            path: file.relativePath,
+                            matchedPattern: 'Thin controller',
+                        });
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+            const score = totalControllers > 0 ? thinControllers / totalControllers : 0.5;
+            return { matches, violations, score };
+        }
+    };
+    __setFunctionName(_classThis, "L007ControllerThin");
+    (() => {
+        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);
+        L007ControllerThin = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L007ControllerThin = _classThis;
+})();
+exports.L007ControllerThin = L007ControllerThin;
+// L008: Framework Configuration Exists
+const l008Rule = (0, base_rule_1.createRule)('L008', 'Framework Configuration Exists', 'Xác nhận có configuration files của framework', enums_1.RuleCategory.STRUCTURE, 0.05, [enums_1.PatternType.LAYERED], {
+    filePatterns: [
+        'application.properties',
+        'application.yml',
+        'application.yaml',
+        'appsettings.json',
+        'appsettings.*.json',
+        'web.config',
+        'config/*.php',
+        '.env',
+    ],
+}, { tags: ['layered', 'configuration'] });
+let L008FrameworkConfig = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l008Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L008FrameworkConfig = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l008Rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const configPatterns = [
+                /application\.(properties|ya?ml)$/i,
+                /appsettings(\.\w+)?\.json$/i,
+                /web\.config$/i,
+                /config\.php$/i,
+                /settings\.py$/i,
+                /\.env$/,
+            ];
+            for (const file of context.files) {
+                for (const pattern of configPatterns) {
+                    if (pattern.test(file.fileName)) {
+                        matches.push({
+                            type: enums_1.MatchType.CONFIG,
+                            path: file.relativePath,
+                            matchedPattern: 'Framework config',
+                        });
+                    }
+                }
+            }
+            return { matches, violations: [], score: matches.length > 0 ? 1 : 0 };
+        }
+    };
+    __setFunctionName(_classThis, "L008FrameworkConfig");
+    (() => {
+        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);
+        L008FrameworkConfig = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L008FrameworkConfig = _classThis;
+})();
+exports.L008FrameworkConfig = L008FrameworkConfig;
+// L009: DTO/Transfer Object Layer Exists
+const l009Rule = (0, base_rule_1.createRule)('L009', 'DTO/Transfer Object Layer Exists', 'Xác nhận có DTO layer để transfer data giữa layers', enums_1.RuleCategory.BONUS, 0.04, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['dtos', 'dto', 'transfer', 'requests', 'responses', 'contracts', 'payloads'],
+    filePatterns: ['*Dto.*', '*DTO.*', '*Request.*', '*Response.*', '*Payload.*'],
+}, { tags: ['layered', 'dto'] });
+let L009DtoLayer = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l009Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L009DtoLayer = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l009Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L009DtoLayer");
+    (() => {
+        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);
+        L009DtoLayer = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L009DtoLayer = _classThis;
+})();
+exports.L009DtoLayer = L009DtoLayer;
+// L010: Mapper/Converter Layer Exists
+const l010Rule = (0, base_rule_1.createRule)('L010', 'Mapper/Converter Layer Exists', 'Xác nhận có mapper để convert giữa Entity và DTO', enums_1.RuleCategory.BONUS, 0.02, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['mappers', 'converters', 'transformers', 'adapters'],
+    filePatterns: ['*Mapper.*', '*Converter.*', '*Transformer.*', '*Assembler.*'],
+}, { tags: ['layered', 'mapper'] });
+let L010MapperLayer = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l010Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L010MapperLayer = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l010Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L010MapperLayer");
+    (() => {
+        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);
+        L010MapperLayer = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L010MapperLayer = _classThis;
+})();
+exports.L010MapperLayer = L010MapperLayer;
+// L011: Exception/Error Handling Layer
+const l011Rule = (0, base_rule_1.createRule)('L011', 'Exception/Error Handling Layer', 'Xác nhận có centralized error handling', enums_1.RuleCategory.QUALITY, 0.03, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['exceptions', 'errors', 'handlers'],
+    filePatterns: ['*Exception.*', '*Error.*', '*ExceptionHandler.*', 'GlobalExceptionHandler.*'],
+    codePatterns: [
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@ControllerAdvice/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@ExceptionHandler/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Catch\s*\(/ },
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.PATTERN, pattern: /IExceptionHandler/ },
+    ],
+}, { tags: ['layered', 'error-handling'] });
+let L011ExceptionHandling = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l011Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L011ExceptionHandling = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l011Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L011ExceptionHandling");
+    (() => {
+        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);
+        L011ExceptionHandling = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L011ExceptionHandling = _classThis;
+})();
+exports.L011ExceptionHandling = L011ExceptionHandling;
+// L012: Validation Layer/Mechanism
+const l012Rule = (0, base_rule_1.createRule)('L012', 'Validation Layer/Mechanism', 'Xác nhận có validation mechanism', enums_1.RuleCategory.QUALITY, 0.03, [enums_1.PatternType.LAYERED], {
+    codePatterns: [
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Valid\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@NotNull\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@NotBlank\b/ },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.ANNOTATION,
+            pattern: /@IsString\s*\(/,
+        },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.ANNOTATION, pattern: /@IsEmail\s*\(/ },
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.ANNOTATION, pattern: /\[Required\]/ },
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.ANNOTATION, pattern: /\[StringLength/ },
+    ],
+}, { tags: ['layered', 'validation'] });
+let L012Validation = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l012Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L012Validation = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l012Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L012Validation");
+    (() => {
+        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);
+        L012Validation = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L012Validation = _classThis;
+})();
+exports.L012Validation = L012Validation;
+// L013: Configuration Layer
+const l013Rule = (0, base_rule_1.createRule)('L013', 'Configuration Layer', 'Xác nhận có configuration management riêng', enums_1.RuleCategory.STRUCTURE, 0.02, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['config', 'configuration', 'settings'],
+    filePatterns: ['*Config.*', '*Configuration.*', '*Settings.*', '*Options.*'],
+    codePatterns: [
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Configuration\b/ },
+        {
+            language: enums_1.Language.JAVA,
+            type: enums_1.CodePatternType.ANNOTATION,
+            pattern: /@ConfigurationProperties/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /ConfigModule\.forRoot/,
+        },
+    ],
+}, { tags: ['layered', 'configuration'] });
+let L013ConfigLayer = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l013Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L013ConfigLayer = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l013Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L013ConfigLayer");
+    (() => {
+        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);
+        L013ConfigLayer = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L013ConfigLayer = _classThis;
+})();
+exports.L013ConfigLayer = L013ConfigLayer;
+// L014: Middleware/Interceptor Layer
+const l014Rule = (0, base_rule_1.createRule)('L014', 'Middleware/Interceptor Layer', 'Xác nhận có middleware/interceptor cho cross-cutting concerns', enums_1.RuleCategory.QUALITY, 0.02, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['middlewares', 'middleware', 'interceptors', 'filters', 'pipes'],
+    filePatterns: ['*Middleware.*', '*Interceptor.*', '*Filter.*', '*Pipe.*'],
+    codePatterns: [
+        {
+            language: enums_1.Language.JAVA,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /implements\s+HandlerInterceptor/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /implements\s+NestInterceptor/,
+        },
+        {
+            language: enums_1.Language.JAVASCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /app\.use\s*\(\s*\(req,\s*res,\s*next\)/,
+        },
+    ],
+}, { tags: ['layered', 'middleware'] });
+let L014Middleware = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l014Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L014Middleware = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l014Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L014Middleware");
+    (() => {
+        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);
+        L014Middleware = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L014Middleware = _classThis;
+})();
+exports.L014Middleware = L014Middleware;
+// L015: Interface/Contract Definitions
+const l015Rule = (0, base_rule_1.createRule)('L015', 'Interface/Contract Definitions', 'Xác nhận có interface definitions cho dependency inversion', enums_1.RuleCategory.QUALITY, 0.03, [enums_1.PatternType.LAYERED], {
+    folderPatterns: ['interfaces', 'contracts', 'ports', 'abstractions'],
+    filePatterns: ['I*Service.*', 'I*Repository.*', '*Interface.*', '*Contract.*', '*Port.*'],
+    codePatterns: [
+        {
+            language: enums_1.Language.JAVA,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /public\s+interface\s+I?\w+Service/,
+        },
+        {
+            language: enums_1.Language.CSHARP,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /interface\s+I\w+(Service|Repository)/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /export\s+interface\s+I?\w+(Service|Repository)/,
+        },
+    ],
+}, { tags: ['layered', 'interface', 'dependency-inversion'] });
+let L015InterfaceDefinitions = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(l015Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L015InterfaceDefinitions = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = l015Rule;
+        }
+    };
+    __setFunctionName(_classThis, "L015InterfaceDefinitions");
+    (() => {
+        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);
+        L015InterfaceDefinitions = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L015InterfaceDefinitions = _classThis;
+})();
+exports.L015InterfaceDefinitions = L015InterfaceDefinitions;
+// All classes are exported inline with their declarations
+//# sourceMappingURL=layered-rules-collection.js.map

package/engines/arch-detect/rules/modular/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Modular Rules Index
+ * Export tất cả Modular Architecture rules (M001-M014)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./m001-feature-modules"), exports);
+__exportStar(require("./m002-core-module"), exports);
+__exportStar(require("./m003-module-declaration"), exports);
+__exportStar(require("./m004-public-api"), exports);
+__exportStar(require("./m005-no-deep-imports"), exports);
+__exportStar(require("./modular-rules-collection"), exports);
+//# sourceMappingURL=index.js.map