@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/build/plugin/rules/require-test-description-prefix.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=require-test-description-prefix.d.ts.map

package/build/plugin/rules/require-test-description-prefix.js

@@ -1,136 +1,136 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Require "| " prefix in test descriptions',
-            recommended: true,
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    prefix: {
-                        type: 'string',
-                        default: '| ',
-                    },
-                    testFunctions: {
-                        type: 'array',
-                        items: {
-                            type: 'string',
-                        },
-                        default: ['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'],
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            missingPrefix: 'Test description must start with "{{prefix}}"',
-            wrongPrefix: 'Test description must start with "{{prefix}}" but found "{{found}}"',
-        },
-        fixable: 'code',
-    },
-    create(context) {
-        const options = context.options[0] || {};
-        const prefix = options.prefix || '| ';
-        const testFunctions = options.testFunctions ||
-            ['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'];
-        /**
-         * Check if a CallExpression is a test function
-         */
-        function isTestFunction(node) {
-            try {
-                return node.type === 'CallExpression' &&
-                    node.callee &&
-                    node.callee.name &&
-                    testFunctions.includes(node.callee.name);
-            }
-            catch (error) {
-                console.error('[require-test-description-prefix] Error in isTestFunction:', error);
-                return false;
-            }
-        }
-        /**
-         * Check if a string has the correct prefix
-         */
-        function hasCorrectPrefix(description) {
-            try {
-                return typeof description === 'string' && description.startsWith(prefix);
-            }
-            catch (error) {
-                console.error('[require-test-description-prefix] Error in hasCorrectPrefix:', error);
-                return false;
-            }
-        }
-        /**
-         * Get the actual prefix found in the string
-         */
-        function getFoundPrefix(description) {
-            try {
-                if (typeof description !== 'string' || description.length === 0) {
-                    return '';
-                }
-                // Find the first non-alphanumeric character or end of string
-                const match = description.match(/^[^a-zA-Z0-9]*/);
-                return match ? match[0] : '';
-            }
-            catch (error) {
-                console.error('[require-test-description-prefix] Error in getFoundPrefix:', error);
-                return '';
-            }
-        }
-        /**
-         * Check and report on test function calls
-         */
-        function checkTestFunction(node) {
-            try {
-                if (!isTestFunction(node)) {
-                    return;
-                }
-                // Check if there are arguments
-                if (!node.arguments || node.arguments.length === 0) {
-                    return;
-                }
-                const firstArg = node.arguments[0];
-                // Only check string literals
-                if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') {
-                    return;
-                }
-                const description = firstArg.value;
-                if (!hasCorrectPrefix(description)) {
-                    const foundPrefix = getFoundPrefix(description);
-                    context.report({
-                        node: firstArg,
-                        messageId: foundPrefix ? 'wrongPrefix' : 'missingPrefix',
-                        data: {
-                            prefix,
-                            found: foundPrefix,
-                        },
-                        fix(fixer) {
-                            try {
-                                const newText = `${prefix}${description}`;
-                                return fixer.replaceText(firstArg, `'${newText}'`);
-                            }
-                            catch (fixError) {
-                                console.error('[require-test-description-prefix] Error in fix function:', fixError);
-                                return null;
-                            }
-                        },
-                    });
-                }
-            }
-            catch (error) {
-                console.error('[require-test-description-prefix] Error in checkTestFunction:', error);
-            }
-        }
-        return {
-            CallExpression(node) {
-                checkTestFunction(node);
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require "| " prefix in test descriptions',
+            recommended: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefix: {
+                        type: 'string',
+                        default: '| ',
+                    },
+                    testFunctions: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        default: ['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingPrefix: 'Test description must start with "{{prefix}}"',
+            wrongPrefix: 'Test description must start with "{{prefix}}" but found "{{found}}"',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const options = context.options[0] || {};
+        const prefix = options.prefix || '| ';
+        const testFunctions = options.testFunctions ||
+            ['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'];
+        /**
+         * Check if a CallExpression is a test function
+         */
+        function isTestFunction(node) {
+            try {
+                return node.type === 'CallExpression' &&
+                    node.callee &&
+                    node.callee.name &&
+                    testFunctions.includes(node.callee.name);
+            }
+            catch (error) {
+                console.error('[require-test-description-prefix] Error in isTestFunction:', error);
+                return false;
+            }
+        }
+        /**
+         * Check if a string has the correct prefix
+         */
+        function hasCorrectPrefix(description) {
+            try {
+                return typeof description === 'string' && description.startsWith(prefix);
+            }
+            catch (error) {
+                console.error('[require-test-description-prefix] Error in hasCorrectPrefix:', error);
+                return false;
+            }
+        }
+        /**
+         * Get the actual prefix found in the string
+         */
+        function getFoundPrefix(description) {
+            try {
+                if (typeof description !== 'string' || description.length === 0) {
+                    return '';
+                }
+                // Find the first non-alphanumeric character or end of string
+                const match = description.match(/^[^a-zA-Z0-9]*/);
+                return match ? match[0] : '';
+            }
+            catch (error) {
+                console.error('[require-test-description-prefix] Error in getFoundPrefix:', error);
+                return '';
+            }
+        }
+        /**
+         * Check and report on test function calls
+         */
+        function checkTestFunction(node) {
+            try {
+                if (!isTestFunction(node)) {
+                    return;
+                }
+                // Check if there are arguments
+                if (!node.arguments || node.arguments.length === 0) {
+                    return;
+                }
+                const firstArg = node.arguments[0];
+                // Only check string literals
+                if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') {
+                    return;
+                }
+                const description = firstArg.value;
+                if (!hasCorrectPrefix(description)) {
+                    const foundPrefix = getFoundPrefix(description);
+                    context.report({
+                        node: firstArg,
+                        messageId: foundPrefix ? 'wrongPrefix' : 'missingPrefix',
+                        data: {
+                            prefix,
+                            found: foundPrefix,
+                        },
+                        fix(fixer) {
+                            try {
+                                const newText = `${prefix}${description}`;
+                                return fixer.replaceText(firstArg, `'${newText}'`);
+                            }
+                            catch (fixError) {
+                                console.error('[require-test-description-prefix] Error in fix function:', fixError);
+                                return null;
+                            }
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                console.error('[require-test-description-prefix] Error in checkTestFunction:', error);
+            }
+        }
+        return {
+            CallExpression(node) {
+                checkTestFunction(node);
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=require-test-description-prefix.js.map

package/build/plugin/rules/ts/data-model-extends.d.ts

@@ -1,9 +1,9 @@
-import { Rule } from 'eslint';
-/**
- * Data-model-extends szabály: `*.data-model.ts` osztályoknak `DyFM_Metadata`-t (vagy bármely `DyFM_*`-ot)
- * kell kiterjeszteniük, és tilos párhuzamos dátum mezőket definiálni.
- * CCAP "data-model-extends" review ESLint AST-portja.
- */
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+/**
+ * Data-model-extends szabály: `*.data-model.ts` osztályoknak `DyFM_Metadata`-t (vagy bármely `DyFM_*`-ot)
+ * kell kiterjeszteniük, és tilos párhuzamos dátum mezőket definiálni.
+ * CCAP "data-model-extends" review ESLint AST-portja.
+ */
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=data-model-extends.d.ts.map

package/build/plugin/rules/ts/data-model-extends.js

@@ -1,95 +1,95 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Parallel date field nevek – ezeket egy DataModel sem tartalmazhatja,
- * mert a `DyFM_Metadata` `__created` / `__updated` mezőit kell használni.
- */
-const PARALLEL_DATE_FIELD_NAMES = new Set([
-    'firstRegisteredAt',
-    'lastSeenAt',
-    'createdAt',
-    'updatedAt',
-    'registeredAt',
-    'seenAt',
-    'modifiedAt',
-    'lastModified',
-    'lastUpdated',
-    'dateCreated',
-    'dateUpdated',
-]);
-/**
- * Data-model-extends szabály: `*.data-model.ts` osztályoknak `DyFM_Metadata`-t (vagy bármely `DyFM_*`-ot)
- * kell kiterjeszteniük, és tilos párhuzamos dátum mezőket definiálni.
- * CCAP "data-model-extends" review ESLint AST-portja.
- */
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: '`*.data-model.ts` classes must extend `DyFM_*`; no parallel date fields allowed.',
-            recommended: true,
-        },
-        schema: [],
-        messages: {
-            missingExtends: '`{{className}}` nem terjeszti ki a `DyFM_Metadata`-t (vagy `DyFM_*` base-t). '
-                + 'DataModel osztálynak `extends DyFM_Metadata` szükséges.',
-            parallelDateField: 'Párhuzamos dátum mező `{{fieldName}}` tilos. '
-                + 'Használd a `DyFM_Metadata`-ból örökölt `__created` / `__updated` mezőket.',
-        },
-    },
-    create(context) {
-        const filename = context.filename ?? '';
-        if (!filename.endsWith('.data-model.ts')) {
-            return {};
-        }
-        return {
-            ClassDeclaration(node) {
-                try {
-                    const superClass = node.superClass;
-                    let extendsName = null;
-                    if (superClass && superClass.type === 'Identifier') {
-                        extendsName = superClass.name;
-                    }
-                    else if (superClass
-                        && superClass.type === 'MemberExpression'
-                        && superClass.property
-                        && superClass.property.name) {
-                        extendsName = superClass.property.name;
-                    }
-                    const isDyFmExtends = extendsName !== null && extendsName.startsWith('DyFM_');
-                    if (!isDyFmExtends) {
-                        const className = (node.id && node.id.name) ? node.id.name : 'anonymous';
-                        context.report({
-                            node: node.id ?? node,
-                            messageId: 'missingExtends',
-                            data: { className: className },
-                        });
-                    }
-                    const body = node.body;
-                    if (!body || !Array.isArray(body.body)) {
-                        return;
-                    }
-                    for (const member of body.body) {
-                        if (member.type !== 'PropertyDefinition') {
-                            continue;
-                        }
-                        const key = member.key;
-                        const fieldName = (key && key.type === 'Identifier' && key.name) ? key.name : null;
-                        if (fieldName !== null && PARALLEL_DATE_FIELD_NAMES.has(fieldName)) {
-                            context.report({
-                                node: member,
-                                messageId: 'parallelDateField',
-                                data: { fieldName: fieldName },
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('[data-model-extends] Error in ClassDeclaration visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Parallel date field nevek – ezeket egy DataModel sem tartalmazhatja,
+ * mert a `DyFM_Metadata` `__created` / `__updated` mezőit kell használni.
+ */
+const PARALLEL_DATE_FIELD_NAMES = new Set([
+    'firstRegisteredAt',
+    'lastSeenAt',
+    'createdAt',
+    'updatedAt',
+    'registeredAt',
+    'seenAt',
+    'modifiedAt',
+    'lastModified',
+    'lastUpdated',
+    'dateCreated',
+    'dateUpdated',
+]);
+/**
+ * Data-model-extends szabály: `*.data-model.ts` osztályoknak `DyFM_Metadata`-t (vagy bármely `DyFM_*`-ot)
+ * kell kiterjeszteniük, és tilos párhuzamos dátum mezőket definiálni.
+ * CCAP "data-model-extends" review ESLint AST-portja.
+ */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '`*.data-model.ts` classes must extend `DyFM_*`; no parallel date fields allowed.',
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            missingExtends: '`{{className}}` nem terjeszti ki a `DyFM_Metadata`-t (vagy `DyFM_*` base-t). '
+                + 'DataModel osztálynak `extends DyFM_Metadata` szükséges.',
+            parallelDateField: 'Párhuzamos dátum mező `{{fieldName}}` tilos. '
+                + 'Használd a `DyFM_Metadata`-ból örökölt `__created` / `__updated` mezőket.',
+        },
+    },
+    create(context) {
+        const filename = context.filename ?? '';
+        if (!filename.endsWith('.data-model.ts')) {
+            return {};
+        }
+        return {
+            ClassDeclaration(node) {
+                try {
+                    const superClass = node.superClass;
+                    let extendsName = null;
+                    if (superClass && superClass.type === 'Identifier') {
+                        extendsName = superClass.name;
+                    }
+                    else if (superClass
+                        && superClass.type === 'MemberExpression'
+                        && superClass.property
+                        && superClass.property.name) {
+                        extendsName = superClass.property.name;
+                    }
+                    const isDyFmExtends = extendsName !== null && extendsName.startsWith('DyFM_');
+                    if (!isDyFmExtends) {
+                        const className = (node.id && node.id.name) ? node.id.name : 'anonymous';
+                        context.report({
+                            node: node.id ?? node,
+                            messageId: 'missingExtends',
+                            data: { className: className },
+                        });
+                    }
+                    const body = node.body;
+                    if (!body || !Array.isArray(body.body)) {
+                        return;
+                    }
+                    for (const member of body.body) {
+                        if (member.type !== 'PropertyDefinition') {
+                            continue;
+                        }
+                        const key = member.key;
+                        const fieldName = (key && key.type === 'Identifier' && key.name) ? key.name : null;
+                        if (fieldName !== null && PARALLEL_DATE_FIELD_NAMES.has(fieldName)) {
+                            context.report({
+                                node: member,
+                                messageId: 'parallelDateField',
+                                data: { fieldName: fieldName },
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('[data-model-extends] Error in ClassDeclaration visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=data-model-extends.js.map

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

@@ -1,9 +1,9 @@
-import { Rule } from 'eslint';
-/**
- * No-any-type szabály: `any` típus annotáció tilos.
- * CCAP "no-any-type" review ESLint AST-portja.
- * Lefedi a `: any`, `<any>`, `as any`, `Array<any>`, `Promise<any>` eseteket egyaránt.
- */
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+/**
+ * No-any-type szabály: `any` típus annotáció tilos.
+ * CCAP "no-any-type" review ESLint AST-portja.
+ * Lefedi a `: any`, `<any>`, `as any`, `Array<any>`, `Promise<any>` eseteket egyaránt.
+ */
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=no-any-type.d.ts.map

package/build/plugin/rules/ts/no-any-type.js

@@ -1,37 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * No-any-type szabály: `any` típus annotáció tilos.
- * CCAP "no-any-type" review ESLint AST-portja.
- * Lefedi a `: any`, `<any>`, `as any`, `Array<any>`, `Promise<any>` eseteket egyaránt.
- */
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Forbid `any` type annotation in TypeScript files.',
-            recommended: true,
-        },
-        schema: [],
-        messages: {
-            noAny: '`any` típus tilos. Adj meg konkrét típust vagy használj `unknown`-t.',
-        },
-    },
-    create(context) {
-        return {
-            TSAnyKeyword(node) {
-                try {
-                    context.report({
-                        node: node,
-                        messageId: 'noAny',
-                    });
-                }
-                catch (error) {
-                    console.error('[no-any-type] Error in TSAnyKeyword visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * No-any-type szabály: `any` típus annotáció tilos.
+ * CCAP "no-any-type" review ESLint AST-portja.
+ * Lefedi a `: any`, `<any>`, `as any`, `Array<any>`, `Promise<any>` eseteket egyaránt.
+ */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Forbid `any` type annotation in TypeScript files.',
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            noAny: '`any` típus tilos. Adj meg konkrét típust vagy használj `unknown`-t.',
+        },
+    },
+    create(context) {
+        return {
+            TSAnyKeyword(node) {
+                try {
+                    context.report({
+                        node: node,
+                        messageId: 'noAny',
+                    });
+                }
+                catch (error) {
+                    console.error('[no-any-type] Error in TSAnyKeyword visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=no-any-type.js.map

package/build/plugin/rules/ts/no-as-cast.d.ts

@@ -1,9 +1,9 @@
-import { Rule } from 'eslint';
-/**
- * No-as-cast szabály: TypeScript `as` type cast tilos.
- * CCAP "no-as-cast" review ESLint AST-portja.
- * Megjegyzés: az `as const` kifejezést megengedjük (immutable literal-ként standard).
- */
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+/**
+ * No-as-cast szabály: TypeScript `as` type cast tilos.
+ * CCAP "no-as-cast" review ESLint AST-portja.
+ * Megjegyzés: az `as const` kifejezést megengedjük (immutable literal-ként standard).
+ */
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=no-as-cast.d.ts.map