@futdevpro/dynamo-eslint 1.15.28 → 1.20.3

package/build/plugin/rules/import/import-order.js

@@ -1,155 +1,155 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: { description: 'Validate import ordering based on Dynamo conventions' },
-        schema: [],
-        messages: {
-            misordered: 'Import statements should be grouped and ordered by convention.',
-            forbiddenNpmPackages: 'Import from "*/../NPM-packages/*" is forbidden. Use "@futdevpro/*" instead.',
-            missingEmptyLine: 'Missing empty line between import groups.',
-            extraEmptyLine: 'Extra empty line detected.',
-        },
-        fixable: 'code',
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const filename = context.filename;
-        function getImportGroup(importNode) {
-            const source = importNode.source.value;
-            // Check for forbidden patterns first
-            if (source.includes('/NPM-packages/')) {
-                return 'non-futdevpro'; // Will be flagged as error
-            }
-            if (source.endsWith('.js')) {
-                return 'non-futdevpro'; // Will be flagged as error
-            }
-            // FutDevPro packages
-            if (source.startsWith('@futdevpro/')) {
-                return 'futdevpro';
-            }
-            // Same module (relative imports with specific patterns)
-            if (source.startsWith('./') || source.startsWith('../')) {
-                const pathParts = source.split('/');
-                const upLevels = pathParts.filter(part => part === '..').length;
-                // Same module: up to 3 ".." and starts with "_", or less than 2 ".."
-                if (upLevels <= 2 || (upLevels <= 3 && pathParts.some(part => part.startsWith('_')))) {
-                    return 'same-module';
-                }
-                // Other modules
-                return 'other-modules';
-            }
-            // Non-FutDevPro packages
-            return 'non-futdevpro';
-        }
-        function validateImportDeclaration(importNode) {
-            const source = importNode.source.value;
-            // Check for forbidden patterns
-            if (source.includes('/NPM-packages/')) {
-                context.report({
-                    node: importNode.source,
-                    messageId: 'forbiddenNpmPackages',
-                    fix(fixer) {
-                        // Replace NPM-packages path with @futdevpro equivalent
-                        const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
-                        return fixer.replaceText(importNode.source, `'${newSource}'`);
-                    },
-                });
-            }
-        }
-        function validateImportOrdering(importNodes) {
-            if (importNodes.length === 0)
-                return;
-            // Group imports
-            const groups = [
-                { type: 'non-futdevpro', imports: [] },
-                { type: 'futdevpro', imports: [] },
-                { type: 'other-modules', imports: [] },
-                { type: 'same-module', imports: [] },
-            ];
-            importNodes.forEach(importNode => {
-                const groupType = getImportGroup(importNode);
-                const group = groups.find(g => g.type === groupType);
-                if (group) {
-                    group.imports.push(importNode);
-                }
-            });
-            // Remove empty groups
-            const nonEmptyGroups = groups.filter(group => group.imports.length > 0);
-            // Check if imports are in correct order and detect violations
-            let needsReordering = false;
-            let currentGroupIndex = 0;
-            for (let i = 0; i < importNodes.length; i++) {
-                const importNode = importNodes[i];
-                const expectedGroupType = getImportGroup(importNode);
-                const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
-                if (expectedGroupIndex < currentGroupIndex) {
-                    needsReordering = true;
-                }
-                currentGroupIndex = expectedGroupIndex;
-            }
-            // Check empty lines between groups
-            let needsEmptyLineFix = false;
-            for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
-                const currentGroup = nonEmptyGroups[i];
-                const nextGroup = nonEmptyGroups[i + 1];
-                const lastImportOfCurrentGroup = currentGroup.imports[currentGroup.imports.length - 1];
-                const firstImportOfNextGroup = nextGroup.imports[0];
-                const lines = sourceCode.getLines();
-                const lastImportLine = lastImportOfCurrentGroup.loc?.end.line || 0;
-                const firstImportLine = firstImportOfNextGroup.loc?.start.line || 0;
-                if (firstImportLine - lastImportLine < 2) {
-                    needsEmptyLineFix = true;
-                }
-            }
-            // If any violations are detected, provide a comprehensive fix
-            if (needsReordering || needsEmptyLineFix) {
-                context.report({
-                    node: importNodes[0],
-                    messageId: 'misordered',
-                    fix(fixer) {
-                        // Sort imports within each group alphabetically
-                        nonEmptyGroups.forEach(group => {
-                            group.imports.sort((a, b) => {
-                                const aSource = a.source.value;
-                                const bSource = b.source.value;
-                                return aSource.localeCompare(bSource);
-                            });
-                        });
-                        // Build the corrected import section
-                        const correctedImports = [];
-                        nonEmptyGroups.forEach((group, groupIndex) => {
-                            group.imports.forEach(importNode => {
-                                const importText = sourceCode.getText(importNode);
-                                correctedImports.push(importText);
-                            });
-                            // Add empty line between groups (except after the last group)
-                            if (groupIndex < nonEmptyGroups.length - 1) {
-                                correctedImports.push('');
-                            }
-                        });
-                        // Calculate the range to replace (from first import to last import)
-                        const firstImport = importNodes[0];
-                        const lastImport = importNodes[importNodes.length - 1];
-                        const startRange = firstImport.range[0];
-                        const endRange = lastImport.range[1];
-                        // Replace the entire import section
-                        return fixer.replaceTextRange([startRange, endRange], correctedImports.join('\n'));
-                    },
-                });
-            }
-        }
-        return {
-            Program(node) {
-                const importNodes = node.body.filter((statement) => statement.type === 'ImportDeclaration');
-                // Validate individual import declarations
-                importNodes.forEach(validateImportDeclaration);
-                // Validate import ordering
-                validateImportOrdering(importNodes);
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Validate import ordering based on Dynamo conventions' },
+        schema: [],
+        messages: {
+            misordered: 'Import statements should be grouped and ordered by convention.',
+            forbiddenNpmPackages: 'Import from "*/../NPM-packages/*" is forbidden. Use "@futdevpro/*" instead.',
+            missingEmptyLine: 'Missing empty line between import groups.',
+            extraEmptyLine: 'Extra empty line detected.',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const filename = context.filename;
+        function getImportGroup(importNode) {
+            const source = importNode.source.value;
+            // Check for forbidden patterns first
+            if (source.includes('/NPM-packages/')) {
+                return 'non-futdevpro'; // Will be flagged as error
+            }
+            if (source.endsWith('.js')) {
+                return 'non-futdevpro'; // Will be flagged as error
+            }
+            // FutDevPro packages
+            if (source.startsWith('@futdevpro/')) {
+                return 'futdevpro';
+            }
+            // Same module (relative imports with specific patterns)
+            if (source.startsWith('./') || source.startsWith('../')) {
+                const pathParts = source.split('/');
+                const upLevels = pathParts.filter(part => part === '..').length;
+                // Same module: up to 3 ".." and starts with "_", or less than 2 ".."
+                if (upLevels <= 2 || (upLevels <= 3 && pathParts.some(part => part.startsWith('_')))) {
+                    return 'same-module';
+                }
+                // Other modules
+                return 'other-modules';
+            }
+            // Non-FutDevPro packages
+            return 'non-futdevpro';
+        }
+        function validateImportDeclaration(importNode) {
+            const source = importNode.source.value;
+            // Check for forbidden patterns
+            if (source.includes('/NPM-packages/')) {
+                context.report({
+                    node: importNode.source,
+                    messageId: 'forbiddenNpmPackages',
+                    fix(fixer) {
+                        // Replace NPM-packages path with @futdevpro equivalent
+                        const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
+                        return fixer.replaceText(importNode.source, `'${newSource}'`);
+                    },
+                });
+            }
+        }
+        function validateImportOrdering(importNodes) {
+            if (importNodes.length === 0)
+                return;
+            // Group imports
+            const groups = [
+                { type: 'non-futdevpro', imports: [] },
+                { type: 'futdevpro', imports: [] },
+                { type: 'other-modules', imports: [] },
+                { type: 'same-module', imports: [] },
+            ];
+            importNodes.forEach(importNode => {
+                const groupType = getImportGroup(importNode);
+                const group = groups.find(g => g.type === groupType);
+                if (group) {
+                    group.imports.push(importNode);
+                }
+            });
+            // Remove empty groups
+            const nonEmptyGroups = groups.filter(group => group.imports.length > 0);
+            // Check if imports are in correct order and detect violations
+            let needsReordering = false;
+            let currentGroupIndex = 0;
+            for (let i = 0; i < importNodes.length; i++) {
+                const importNode = importNodes[i];
+                const expectedGroupType = getImportGroup(importNode);
+                const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
+                if (expectedGroupIndex < currentGroupIndex) {
+                    needsReordering = true;
+                }
+                currentGroupIndex = expectedGroupIndex;
+            }
+            // Check empty lines between groups
+            let needsEmptyLineFix = false;
+            for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
+                const currentGroup = nonEmptyGroups[i];
+                const nextGroup = nonEmptyGroups[i + 1];
+                const lastImportOfCurrentGroup = currentGroup.imports[currentGroup.imports.length - 1];
+                const firstImportOfNextGroup = nextGroup.imports[0];
+                const lines = sourceCode.getLines();
+                const lastImportLine = lastImportOfCurrentGroup.loc?.end.line || 0;
+                const firstImportLine = firstImportOfNextGroup.loc?.start.line || 0;
+                if (firstImportLine - lastImportLine < 2) {
+                    needsEmptyLineFix = true;
+                }
+            }
+            // If any violations are detected, provide a comprehensive fix
+            if (needsReordering || needsEmptyLineFix) {
+                context.report({
+                    node: importNodes[0],
+                    messageId: 'misordered',
+                    fix(fixer) {
+                        // Sort imports within each group alphabetically
+                        nonEmptyGroups.forEach(group => {
+                            group.imports.sort((a, b) => {
+                                const aSource = a.source.value;
+                                const bSource = b.source.value;
+                                return aSource.localeCompare(bSource);
+                            });
+                        });
+                        // Build the corrected import section
+                        const correctedImports = [];
+                        nonEmptyGroups.forEach((group, groupIndex) => {
+                            group.imports.forEach(importNode => {
+                                const importText = sourceCode.getText(importNode);
+                                correctedImports.push(importText);
+                            });
+                            // Add empty line between groups (except after the last group)
+                            if (groupIndex < nonEmptyGroups.length - 1) {
+                                correctedImports.push('');
+                            }
+                        });
+                        // Calculate the range to replace (from first import to last import)
+                        const firstImport = importNodes[0];
+                        const lastImport = importNodes[importNodes.length - 1];
+                        const startRange = firstImport.range[0];
+                        const endRange = lastImport.range[1];
+                        // Replace the entire import section
+                        return fixer.replaceTextRange([startRange, endRange], correctedImports.join('\n'));
+                    },
+                });
+            }
+        }
+        return {
+            Program(node) {
+                const importNodes = node.body.filter((statement) => statement.type === 'ImportDeclaration');
+                // Validate individual import declarations
+                importNodes.forEach(validateImportDeclaration);
+                // Validate import ordering
+                validateImportOrdering(importNodes);
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=import-order.js.map

package/build/plugin/rules/import/no-import-type.d.ts

@@ -1,4 +1,4 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=no-import-type.d.ts.map

package/build/plugin/rules/import/no-import-type.js

@@ -1,46 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: { description: 'Forbid use of "import type" syntax' },
-        schema: [],
-        messages: {
-            forbiddenImportType: 'Use of "import type" is forbidden.',
-        },
-        fixable: 'code',
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        return {
-            ImportDeclaration(node) {
-                try {
-                    // Check for import type usage
-                    if (node.importKind === 'type') {
-                        context.report({
-                            node,
-                            messageId: 'forbiddenImportType',
-                            fix(fixer) {
-                                try {
-                                    // Remove 'type' keyword
-                                    const importText = sourceCode.getText(node);
-                                    const newImportText = importText.replace(/import\s+type\s+/, 'import ');
-                                    return fixer.replaceText(node, newImportText);
-                                }
-                                catch (fixError) {
-                                    console.error('[no-import-type] Error in fix function:', fixError);
-                                    return null;
-                                }
-                            },
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('[no-import-type] Error in ImportDeclaration visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Forbid use of "import type" syntax' },
+        schema: [],
+        messages: {
+            forbiddenImportType: 'Use of "import type" is forbidden.',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            ImportDeclaration(node) {
+                try {
+                    // Check for import type usage
+                    if (node.importKind === 'type') {
+                        context.report({
+                            node,
+                            messageId: 'forbiddenImportType',
+                            fix(fixer) {
+                                try {
+                                    // Remove 'type' keyword
+                                    const importText = sourceCode.getText(node);
+                                    const newImportText = importText.replace(/import\s+type\s+/, 'import ');
+                                    return fixer.replaceText(node, newImportText);
+                                }
+                                catch (fixError) {
+                                    console.error('[no-import-type] Error in fix function:', fixError);
+                                    return null;
+                                }
+                            },
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[no-import-type] Error in ImportDeclaration visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=no-import-type.js.map

package/build/plugin/rules/import/no-js-import.d.ts

@@ -1,4 +1,4 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=no-js-import.d.ts.map

package/build/plugin/rules/import/no-js-import.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: { description: 'Forbid imports with ".js" extension' },
-        schema: [],
-        messages: {
-            forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
-        },
-        fixable: 'code',
-    },
-    create(context) {
-        // List of allowed packages that can use .js extension
-        const allowedJsPackages = [
-            'discord.js',
-        ];
-        return {
-            ImportDeclaration(node) {
-                try {
-                    const source = node.source?.value;
-                    if (source && source.endsWith('.js')) {
-                        // Check if the import is from an allowed package
-                        const isAllowedPackage = allowedJsPackages.some((pkg) => source.includes(pkg) || source.startsWith(pkg));
-                        if (!isAllowedPackage) {
-                            context.report({
-                                node: node.source,
-                                messageId: 'forbiddenJsExtension',
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('[no-js-import] Error in ImportDeclaration visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Forbid imports with ".js" extension' },
+        schema: [],
+        messages: {
+            forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        // List of allowed packages that can use .js extension
+        const allowedJsPackages = [
+            'discord.js',
+        ];
+        return {
+            ImportDeclaration(node) {
+                try {
+                    const source = node.source?.value;
+                    if (source && source.endsWith('.js')) {
+                        // Check if the import is from an allowed package
+                        const isAllowedPackage = allowedJsPackages.some((pkg) => source.includes(pkg) || source.startsWith(pkg));
+                        if (!isAllowedPackage) {
+                            context.report({
+                                node: node.source,
+                                messageId: 'forbiddenJsExtension',
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('[no-js-import] Error in ImportDeclaration visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=no-js-import.js.map

package/build/plugin/rules/naming-patterns.d.ts

@@ -1,8 +1,8 @@
-import { Rule } from 'eslint';
-/**
- * Naming-patterns szabály (CCAP-megerősített): 7 al-ellenőrzés a CCAP "naming/*" review-kből.
- * Minden al-ellenőrzés külön-külön kapcsolható a `checks` schema option-nel.
- */
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+/**
+ * Naming-patterns szabály (CCAP-megerősített): 7 al-ellenőrzés a CCAP "naming/*" review-kből.
+ * Minden al-ellenőrzés külön-külön kapcsolható a `checks` schema option-nel.
+ */
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=naming-patterns.d.ts.map