@sun-asterisk/sunlint 1.3.33 → 1.3.35

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

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * Modular Rules Collection
+ * Định nghĩa các rules còn lại (M006-M014)
+ */
+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.M014FeatureFlags = exports.M013ModuleDocumentation = exports.M012SharedState = exports.M011TestingIsolation = exports.M010BoundaryEnforcement = exports.M009ModuleCommunication = exports.M008ConsistentStructure = exports.M007LazyLoading = exports.M006ModuleIndependence = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+// M006: Module Independence (Low Coupling)
+const m006Rule = (0, base_rule_1.createRule)('M006', 'Module Independence (Low Coupling)', 'Xác nhận modules có coupling thấp với nhau', enums_1.RuleCategory.QUALITY, 0.08, [enums_1.PatternType.MODULAR], {}, { tags: ['modular', 'coupling'] });
+let M006ModuleIndependence = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m006Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M006ModuleIndependence = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m006Rule;
+        }
+        async customDetection(_context) {
+            // Simplified: Check if modules don't have too many cross-dependencies
+            const matches = [];
+            matches.push({
+                type: enums_1.MatchType.CODE,
+                path: '',
+                matchedPattern: 'Module independence check',
+            });
+            return { matches, violations: [], score: 0.5 };
+        }
+    };
+    __setFunctionName(_classThis, "M006ModuleIndependence");
+    (() => {
+        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);
+        M006ModuleIndependence = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M006ModuleIndependence = _classThis;
+})();
+exports.M006ModuleIndependence = M006ModuleIndependence;
+// M007: Lazy Loading / Dynamic Loading
+const m007Rule = (0, base_rule_1.createRule)('M007', 'Lazy Loading / Dynamic Loading', 'Xác nhận có cơ chế lazy loading modules', enums_1.RuleCategory.STRUCTURE, 0.06, [enums_1.PatternType.MODULAR], {
+    codePatterns: [
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /loadChildren:\s*\(\)\s*=>\s*import\s*\(/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /React\.lazy\s*\(\s*\(\)\s*=>\s*import\s*\(/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /\(\)\s*=>\s*import\s*\(['"]['"]\.\/.*['"]\)/,
+        },
+        {
+            language: enums_1.Language.JAVASCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /forwardRef\s*\(\s*\(\)\s*=>/,
+        },
+    ],
+}, { tags: ['modular', 'lazy-loading', 'performance'] });
+let M007LazyLoading = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m007Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M007LazyLoading = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m007Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M007LazyLoading");
+    (() => {
+        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);
+        M007LazyLoading = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M007LazyLoading = _classThis;
+})();
+exports.M007LazyLoading = M007LazyLoading;
+// M008: Consistent Module Structure
+const m008Rule = (0, base_rule_1.createRule)('M008', 'Consistent Module Structure', 'Xác nhận các modules có cấu trúc nhất quán', enums_1.RuleCategory.QUALITY, 0.04, [enums_1.PatternType.MODULAR], {}, { tags: ['modular', 'consistency'] });
+let M008ConsistentStructure = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m008Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M008ConsistentStructure = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m008Rule;
+        }
+        async customDetection(_context) {
+            const matches = [];
+            matches.push({
+                type: enums_1.MatchType.FOLDER,
+                path: '',
+                matchedPattern: 'Module structure consistency check',
+            });
+            return { matches, violations: [], score: 0.5 };
+        }
+    };
+    __setFunctionName(_classThis, "M008ConsistentStructure");
+    (() => {
+        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);
+        M008ConsistentStructure = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M008ConsistentStructure = _classThis;
+})();
+exports.M008ConsistentStructure = M008ConsistentStructure;
+// M009: Module Communication Pattern
+const m009Rule = (0, base_rule_1.createRule)('M009', 'Module Communication Pattern', 'Xác nhận modules communicate đúng cách (events, shared services)', enums_1.RuleCategory.STRUCTURE, 0.05, [enums_1.PatternType.MODULAR], {
+    codePatterns: [
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /EventEmitter/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /Subject</ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /@Output\s*\(\)/ },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /@MessagePattern\s*\(/,
+        },
+    ],
+}, { tags: ['modular', 'communication', 'events'] });
+let M009ModuleCommunication = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m009Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M009ModuleCommunication = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m009Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M009ModuleCommunication");
+    (() => {
+        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);
+        M009ModuleCommunication = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M009ModuleCommunication = _classThis;
+})();
+exports.M009ModuleCommunication = M009ModuleCommunication;
+// M010: Module Boundary Enforcement
+const m010Rule = (0, base_rule_1.createRule)('M010', 'Module Boundary Enforcement', 'Xác nhận module boundaries được enforce bằng tooling', enums_1.RuleCategory.QUALITY, 0.05, [enums_1.PatternType.MODULAR], {
+    configPatterns: [
+        { filePattern: 'nx.json' },
+        { filePattern: '.eslintrc*', contains: 'enforce-module-boundaries' },
+        { filePattern: '.eslintrc*', contains: 'no-restricted-paths' },
+        { filePattern: 'tsconfig*.json', contains: 'paths' },
+    ],
+}, { tags: ['modular', 'boundary', 'tooling'] });
+let M010BoundaryEnforcement = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m010Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M010BoundaryEnforcement = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m010Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M010BoundaryEnforcement");
+    (() => {
+        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);
+        M010BoundaryEnforcement = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M010BoundaryEnforcement = _classThis;
+})();
+exports.M010BoundaryEnforcement = M010BoundaryEnforcement;
+// M011: Module Testing Isolation
+const m011Rule = (0, base_rule_1.createRule)('M011', 'Module Testing Isolation', 'Xác nhận mỗi module có tests riêng', enums_1.RuleCategory.QUALITY, 0.02, [enums_1.PatternType.MODULAR], {
+    filePatterns: ['*.spec.ts', '*.test.ts', '__tests__/*'],
+}, { tags: ['modular', 'testing'] });
+let M011TestingIsolation = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m011Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M011TestingIsolation = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m011Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M011TestingIsolation");
+    (() => {
+        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);
+        M011TestingIsolation = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M011TestingIsolation = _classThis;
+})();
+exports.M011TestingIsolation = M011TestingIsolation;
+// M012: Shared State Management
+const m012Rule = (0, base_rule_1.createRule)('M012', 'Shared State Management', 'Xác nhận shared state được quản lý đúng cách', enums_1.RuleCategory.STRUCTURE, 0.03, [enums_1.PatternType.MODULAR], {
+    codePatterns: [
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /createStore/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /configureStore/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /@ngrx\/store/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /BehaviorSubject/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.PATTERN, pattern: /defineStore/ },
+    ],
+}, { tags: ['modular', 'state-management'] });
+let M012SharedState = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m012Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M012SharedState = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m012Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M012SharedState");
+    (() => {
+        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);
+        M012SharedState = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M012SharedState = _classThis;
+})();
+exports.M012SharedState = M012SharedState;
+// M013: Module Documentation
+const m013Rule = (0, base_rule_1.createRule)('M013', 'Module Documentation', 'Xác nhận modules có documentation', enums_1.RuleCategory.QUALITY, 0.01, [enums_1.PatternType.MODULAR], {
+    filePatterns: ['README.md', 'CHANGELOG.md'],
+}, { tags: ['modular', 'documentation'] });
+let M013ModuleDocumentation = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m013Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M013ModuleDocumentation = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m013Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M013ModuleDocumentation");
+    (() => {
+        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);
+        M013ModuleDocumentation = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M013ModuleDocumentation = _classThis;
+})();
+exports.M013ModuleDocumentation = M013ModuleDocumentation;
+// M014: Feature Flag/Toggle Support
+const m014Rule = (0, base_rule_1.createRule)('M014', 'Feature Flag/Toggle Support', 'Xác nhận có feature flag mechanism cho modules', enums_1.RuleCategory.BONUS, 0.01, [enums_1.PatternType.MODULAR], {
+    codePatterns: [
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { language: 'all', type: enums_1.CodePatternType.PATTERN, pattern: /featureFlag/i },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { language: 'all', type: enums_1.CodePatternType.PATTERN, pattern: /isEnabled\s*\(/ },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { language: 'all', type: enums_1.CodePatternType.PATTERN, pattern: /toggleFeature/i },
+    ],
+    configPatterns: [{ filePattern: '*feature*flag*' }],
+}, { tags: ['modular', 'feature-flags'] });
+let M014FeatureFlags = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(m014Rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M014FeatureFlags = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = m014Rule;
+        }
+    };
+    __setFunctionName(_classThis, "M014FeatureFlags");
+    (() => {
+        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);
+        M014FeatureFlags = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M014FeatureFlags = _classThis;
+})();
+exports.M014FeatureFlags = M014FeatureFlags;
+// All classes are exported inline with their declarations
+//# sourceMappingURL=modular-rules-collection.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Presentation Rules Index
+ * Export tất cả Presentation (MVVM/VIPER) rules (PR001-PR016)
+ */
+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("./pr001-view-layer"), exports);
+__exportStar(require("./pr002-presentation-logic"), exports);
+__exportStar(require("./pr004-data-binding"), exports);
+__exportStar(require("./pr006-router-layer"), exports);
+__exportStar(require("./pr007-interactor-layer"), exports);
+__exportStar(require("./presentation-rules-collection"), exports);
+//# sourceMappingURL=index.js.map

package/engines/arch-detect/rules/presentation/pr001-view-layer.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * PR001: View Layer Exists
+ * Xác nhận có tầng View tách biệt
+ */
+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.PR001ViewLayer = 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)('PR001', 'View Layer Exists', 'Xác nhận có tầng View tách biệt (Views, Screens, Pages, Components)', enums_1.RuleCategory.CORE, 0.08, [enums_1.PatternType.PRESENTATION, enums_1.PatternType.MVVM, enums_1.PatternType.VIPER], {
+    folderPatterns: ['views', 'screens', 'pages', 'ui', 'presentation', 'View', 'Screens'],
+    filePatterns: [
+        '*View.*',
+        '*Screen.*',
+        '*Page.*',
+        '*Activity.*',
+        '*Fragment.*',
+        '*ViewController.*',
+        '*Component.*',
+    ],
+    codePatterns: [
+        // Android
+        {
+            language: enums_1.Language.KOTLIN,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+Activity\s*:\s*AppCompatActivity/,
+        },
+        {
+            language: enums_1.Language.KOTLIN,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+Fragment\s*:\s*Fragment/,
+        },
+        { language: enums_1.Language.KOTLIN, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Composable\s+fun/ },
+        // iOS
+        {
+            language: enums_1.Language.SWIFT,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+ViewController\s*:\s*UIViewController/,
+        },
+        {
+            language: enums_1.Language.SWIFT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /struct\s+\w+View\s*:\s*View/,
+        },
+        // Flutter
+        {
+            language: enums_1.Language.DART,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+\s+extends\s+StatefulWidget/,
+        },
+        {
+            language: enums_1.Language.DART,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+\s+extends\s+StatelessWidget/,
+        },
+        // React/Vue
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /function\s+\w+\s*\([^)]*\)\s*:\s*JSX\.Element/,
+        },
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.ANNOTATION,
+            pattern: /@Component\s*\(/,
+        },
+        // WPF
+        {
+            language: enums_1.Language.CSHARP,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /partial\s+class\s+\w+\s*:\s*Window/,
+        },
+    ],
+}, {
+    tags: ['presentation', 'view', 'ui'],
+});
+let PR001ViewLayer = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var PR001ViewLayer = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            let hasFolders = false;
+            let hasFiles = false;
+            let hasCode = false;
+            // Check for view folders
+            const viewFolders = ['views', 'screens', 'pages', 'ui', 'presentation', 'components'];
+            for (const folder of viewFolders) {
+                const found = context.files.some((f) => f.relativePath.toLowerCase().includes(`/${folder}/`) ||
+                    f.relativePath.toLowerCase().startsWith(`${folder}/`));
+                if (found) {
+                    matches.push({
+                        type: enums_1.MatchType.FOLDER,
+                        path: folder,
+                        matchedPattern: 'View folder',
+                    });
+                    hasFolders = true;
+                }
+            }
+            // Check for view files
+            const viewFiles = context.files.filter((f) => /View\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
+                /Screen\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
+                /Page\.(ts|tsx|js|jsx|swift|kt|dart)$/i.test(f.fileName) ||
+                /Activity\.(kt|java)$/i.test(f.fileName) ||
+                /Fragment\.(kt|java)$/i.test(f.fileName) ||
+                /ViewController\.swift$/i.test(f.fileName) ||
+                /\.vue$/i.test(f.fileName));
+            if (viewFiles.length > 0) {
+                for (const file of viewFiles.slice(0, 5)) {
+                    matches.push({
+                        type: enums_1.MatchType.FILE,
+                        path: file.relativePath,
+                        matchedPattern: 'View file',
+                    });
+                }
+                hasFiles = true;
+            }
+            // Check for code patterns
+            const sourceFiles = context.files
+                .filter((f) => !f.isTest && !f.isConfig && f.language)
+                .slice(0, 50);
+            const codePatterns = [
+                /@Composable\s+fun/,
+                /struct\s+\w+View\s*:\s*View/,
+                /class\s+\w+ViewController/,
+                /extends\s+(StatefulWidget|StatelessWidget)/,
+                /<template>/,
+            ];
+            for (const file of sourceFiles) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    for (const pattern of codePatterns) {
+                        if (pattern.test(content)) {
+                            hasCode = true;
+                            matches.push({
+                                type: enums_1.MatchType.CODE,
+                                path: file.relativePath,
+                                matchedPattern: 'View pattern',
+                            });
+                            break;
+                        }
+                    }
+                    if (hasCode && matches.length >= 10)
+                        break;
+                }
+                catch {
+                    // Skip
+                }
+            }
+            // Calculate score
+            let score = 0;
+            if (hasFolders && hasFiles)
+                score = 1;
+            else if (hasFiles)
+                score = 0.7;
+            else if (hasCode)
+                score = 0.6;
+            else if (hasFolders)
+                score = 0.4;
+            return { matches, violations: [], score };
+        }
+    };
+    __setFunctionName(_classThis, "PR001ViewLayer");
+    (() => {
+        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);
+        PR001ViewLayer = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return PR001ViewLayer = _classThis;
+})();
+exports.PR001ViewLayer = PR001ViewLayer;
+exports.default = PR001ViewLayer;
+//# sourceMappingURL=pr001-view-layer.js.map