@dereekb/nestjs 13.11.14 → 13.11.16

package/eslint/index.esm.js

@@ -46,67 +46,65 @@ function _unsupported_iterable_to_array(o, minLen) {
 /**
  * Extracts the decorator name from a decorator node.
  *
+ * @param decorator - The decorator AST node.
+ * @returns The decorator name, or empty string if unrecognized.
+ *
  * @example
  * ```
  * // Returns 'Injectable' for both:
  * // @Injectable()
  * // @Injectable
  * ```
- *
- * @param decorator - The decorator AST node
- * @returns The decorator name, or empty string if unrecognized
  */ function getDecoratorName(decorator) {
     var expression = decorator.expression;
+    var name = '';
     if (expression.type === 'CallExpression') {
         if (expression.callee.type === 'Identifier') {
-            return expression.callee.name;
-        }
-        if (expression.callee.type === 'MemberExpression' && expression.callee.property.type === 'Identifier') {
-            return expression.callee.property.name;
+            name = expression.callee.name;
+        } else if (expression.callee.type === 'MemberExpression' && expression.callee.property.type === 'Identifier') {
+            name = expression.callee.property.name;
         }
+    } else if (expression.type === 'Identifier') {
+        name = expression.name;
     }
-    if (expression.type === 'Identifier') {
-        return expression.name;
-    }
-    return '';
+    return name;
 }
 /**
  * Extracts the injection token name from a decorator like @Inject(TokenName).
  *
- * @param decorator - The decorator AST node
- * @returns The token identifier name, or null if not a simple identifier
+ * @param decorator - The decorator AST node.
+ * @returns The token identifier name, or null if not a simple identifier.
  */ function getInjectTokenFromDecorator(decorator) {
     var expression = decorator.expression;
+    var tokenName = null;
     if (expression.type === 'CallExpression' && expression.callee.type === 'Identifier' && expression.callee.name === 'Inject') {
         var firstArg = expression.arguments[0];
         if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'Identifier') {
-            return firstArg.name;
+            tokenName = firstArg.name;
         }
     }
-    return null;
+    return tokenName;
 }
 /**
  * Extracts the parameter name from a constructor parameter node.
  *
- * @param param - The parameter AST node
- * @returns The parameter name for error reporting
+ * @param param - The parameter AST node.
+ * @returns The parameter name for error reporting.
  */ function getParamName(param) {
+    var name = '(unknown)';
     if (param.type === 'TSParameterProperty') {
         var inner = param.parameter;
         if (inner.type === 'Identifier') {
-            return inner.name;
-        }
-        if (inner.type === 'AssignmentPattern' && inner.left.type === 'Identifier') {
-            return inner.left.name;
+            name = inner.name;
+        } else if (inner.type === 'AssignmentPattern' && inner.left.type === 'Identifier') {
+            name = inner.left.name;
         }
+    } else if (param.type === 'Identifier') {
+        name = param.name;
+    } else if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') {
+        name = param.left.name;
     }
-    if (param.type === 'Identifier') {
-        return param.name;
-    }
-    if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') {
-        return param.left.name;
-    }
-    return '(unknown)';
+    return name;
 }
 /**
  * Gets the class-typed injection token name from a parameter's type annotation, if available.
@@ -114,16 +112,17 @@ function _unsupported_iterable_to_array(o, minLen) {
  * Returns the type name only for simple TSTypeReference identifiers (i.e. class names like `FooApi`).
  * Returns null for primitives, union types, generics, or any non-simple type reference.
  *
- * @param param - The parameter AST node
- * @returns The type name to use as injection token, or null if not auto-fixable
+ * @param param - The parameter AST node.
+ * @returns The type name to use as injection token, or null if not auto-fixable.
  */ function getInjectTokenName(param) {
     var _target_typeAnnotation, _typeAnnotation_typeName;
     var target = param.type === 'TSParameterProperty' ? param.parameter : param;
     var typeAnnotation = (_target_typeAnnotation = target.typeAnnotation) === null || _target_typeAnnotation === void 0 ? void 0 : _target_typeAnnotation.typeAnnotation;
+    var tokenName = null;
     if ((typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.type) === 'TSTypeReference' && ((_typeAnnotation_typeName = typeAnnotation.typeName) === null || _typeAnnotation_typeName === void 0 ? void 0 : _typeAnnotation_typeName.type) === 'Identifier' && !typeAnnotation.typeArguments) {
-        return typeAnnotation.typeName.name;
+        tokenName = typeAnnotation.typeName.name;
     }
-    return null;
+    return tokenName;
 }
 /**
  * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
@@ -143,7 +142,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  *
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
- */ var nestjsRequireInjectRule = {
+ */ var NESTJS_REQUIRE_INJECT_RULE = {
     meta: {
         type: 'problem',
         fixable: 'code',
@@ -239,124 +238,122 @@ function _unsupported_iterable_to_array(o, minLen) {
             },
             ClassDeclaration: function ClassDeclaration(classNode) {
                 var decorators = classNode.decorators;
-                if (!decorators || decorators.length === 0) {
-                    return;
-                }
-                var matchedClassDecorator = decorators.find(function(d) {
+                var matchedClassDecorator = decorators && decorators.length > 0 ? decorators.find(function(d) {
                     var name = getDecoratorName(d);
                     return classDecorators.has(name) && nestjsImports.has(name);
-                });
-                if (!matchedClassDecorator) {
-                    return;
-                }
-                var classDecoratorName = getDecoratorName(matchedClassDecorator);
-                var constructor = classNode.body.body.find(function(member) {
+                }) : undefined;
+                var constructor = matchedClassDecorator ? classNode.body.body.find(function(member) {
                     return member.type === 'MethodDefinition' && member.kind === 'constructor';
-                });
-                if (!(constructor === null || constructor === void 0 ? void 0 : constructor.value.params) || constructor.value.params.length === 0) {
-                    return;
-                }
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    var _loop = function() {
-                        var param = _step.value;
-                        var paramDecoratorsOnNode = param.decorators;
-                        var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
-                            return paramDecorators.has(getDecoratorName(d));
-                        });
-                        if (hasValidDecorator) {
-                            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                            try {
-                                var _loop = function() {
-                                    var decorator = _step1.value;
-                                    var tokenName = getInjectTokenFromDecorator(decorator);
-                                    if (tokenName) {
-                                        var typeImportInfo = typeOnlyImports.get(tokenName);
-                                        if (typeImportInfo) {
-                                            context.report({
-                                                node: decorator,
-                                                messageId: 'typeOnlyInjectToken',
-                                                data: {
-                                                    token: tokenName
-                                                },
-                                                fix: function fix(fixer) {
-                                                    if (typeImportInfo.isDeclarationLevel) {
-                                                        // `import type { X } from '...'` → `import { X } from '...'`
-                                                        // Remove 'type ' after 'import '
-                                                        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
-                                                        return fixer.removeRange([
-                                                            importKeywordEnd,
-                                                            importKeywordEnd + 'type '.length
-                                                        ]);
+                }) : undefined;
+                var params = constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
+                var shouldCheckParams = Boolean(matchedClassDecorator && params && params.length > 0);
+                if (shouldCheckParams) {
+                    var classDecoratorName = getDecoratorName(matchedClassDecorator);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        var _loop = function() {
+                            var param = _step.value;
+                            var paramDecoratorsOnNode = param.decorators;
+                            var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
+                                return paramDecorators.has(getDecoratorName(d));
+                            });
+                            if (hasValidDecorator) {
+                                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    var _loop = function() {
+                                        var decorator = _step1.value;
+                                        var tokenName = getInjectTokenFromDecorator(decorator);
+                                        if (tokenName) {
+                                            var typeImportInfo = typeOnlyImports.get(tokenName);
+                                            if (typeImportInfo) {
+                                                context.report({
+                                                    node: decorator,
+                                                    messageId: 'typeOnlyInjectToken',
+                                                    data: {
+                                                        token: tokenName
+                                                    },
+                                                    fix: function fix(fixer) {
+                                                        var fixResult;
+                                                        if (typeImportInfo.isDeclarationLevel) {
+                                                            // `import type { X } from '...'` → `import { X } from '...'`
+                                                            // Remove 'type ' after 'import '
+                                                            var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
+                                                            fixResult = fixer.removeRange([
+                                                                importKeywordEnd,
+                                                                importKeywordEnd + 'type '.length
+                                                            ]);
+                                                        } else {
+                                                            // `import { type X }` → `import { X }`
+                                                            // The specifier range includes 'type X', so remove 'type ' prefix
+                                                            var specRange = typeImportInfo.specifier.range;
+                                                            var importedRange = typeImportInfo.specifier.imported.range;
+                                                            fixResult = fixer.removeRange([
+                                                                specRange[0],
+                                                                importedRange[0]
+                                                            ]);
+                                                        }
+                                                        return fixResult;
                                                     }
-                                                    // `import { type X }` → `import { X }`
-                                                    // The specifier range includes 'type X', so remove 'type ' prefix
-                                                    var specRange = typeImportInfo.specifier.range;
-                                                    var importedRange = typeImportInfo.specifier.imported.range;
-                                                    return fixer.removeRange([
-                                                        specRange[0],
-                                                        importedRange[0]
-                                                    ]);
-                                                }
-                                            });
-                                            // Remove from tracking so we don't report the same import twice
-                                            typeOnlyImports.delete(tokenName);
+                                                });
+                                                // Remove from tracking so we don't report the same import twice
+                                                typeOnlyImports.delete(tokenName);
+                                            }
                                         }
-                                    }
-                                };
-                                // Has @Inject() — check if the injection token is a type-only import
-                                for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                            } catch (err) {
-                                _didIteratorError = true;
-                                _iteratorError = err;
-                            } finally{
-                                try {
-                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                        _iterator.return();
-                                    }
+                                    };
+                                    // Has @Inject() — check if the injection token is a type-only import
+                                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
                                 } finally{
-                                    if (_didIteratorError) {
-                                        throw _iteratorError;
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
                                     }
                                 }
-                            }
-                        } else {
-                            // Missing @Inject() entirely
-                            var tokenName = getInjectTokenName(param);
-                            context.report({
-                                node: param,
-                                messageId: 'missingInject',
-                                data: {
-                                    name: getParamName(param),
-                                    classDecorator: classDecoratorName
-                                },
-                                fix: tokenName ? function(fixer) {
-                                    var fixes = [];
-                                    fixes.push(fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") ")));
-                                    if (!nestjsImports.has('Inject') && nestjsImportNode) {
-                                        var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
-                                        if (lastSpecifier) {
-                                            fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
+                            } else {
+                                // Missing @Inject() entirely
+                                var tokenName = getInjectTokenName(param);
+                                context.report({
+                                    node: param,
+                                    messageId: 'missingInject',
+                                    data: {
+                                        name: getParamName(param),
+                                        classDecorator: classDecoratorName
+                                    },
+                                    fix: tokenName ? function(fixer) {
+                                        var fixes = [];
+                                        fixes.push(fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") ")));
+                                        if (!nestjsImports.has('Inject') && nestjsImportNode) {
+                                            var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
+                                            if (lastSpecifier) {
+                                                fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
+                                            }
+                                            nestjsImports.add('Inject');
                                         }
-                                        nestjsImports.add('Inject');
-                                    }
-                                    return fixes;
-                                } : undefined
-                            });
-                        }
-                    };
-                    for(var _iterator = constructor.value.params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
+                                        return fixes;
+                                    } : undefined
+                                });
+                            }
+                        };
+                        for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
                     } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
                         }
                     }
                 }
@@ -370,10 +367,15 @@ function _unsupported_iterable_to_array(o, minLen) {
  *
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
- */ var nestjsEslintPlugin = {
+ */ var NESTJS_ESLINT_PLUGIN = {
     rules: {
-        'require-nest-inject': nestjsRequireInjectRule
+        'require-nest-inject': NESTJS_REQUIRE_INJECT_RULE
     }
 };
+/**
+ * camelCase alias of {@link NESTJS_ESLINT_PLUGIN} matching the conventional ESLint plugin export name.
+ *
+ * @dbxAllowConstantName
+ */ var nestjsESLintPlugin = NESTJS_ESLINT_PLUGIN;
 
-export { nestjsEslintPlugin, nestjsRequireInjectRule };
+export { NESTJS_ESLINT_PLUGIN, NESTJS_REQUIRE_INJECT_RULE, nestjsESLintPlugin };

package/eslint/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dereekb/nestjs/eslint",
-  "version": "13.11.14",
+  "version": "13.11.16",
   "peerDependencies": {
-    "@typescript-eslint/utils": "8.59.0"
+    "@typescript-eslint/utils": "8.59.3"
   },
   "devDependencies": {
     "@angular/core": "21.2.11",
     "@nestjs/common": "^11.1.19",
     "@nestjs/core": "^11.1.19",
-    "@typescript-eslint/parser": "8.59.0",
-    "eslint": "9.39.4"
+    "@typescript-eslint/parser": "8.59.3",
+    "eslint": "10.4.0"
   },
   "exports": {
     "./package.json": "./package.json",

package/eslint/src/lib/index.d.ts

@@ -1,2 +1,2 @@
-export { nestjsRequireInjectRule, type NestjsRequireInjectRuleOptions } from './require-inject.rule';
-export { nestjsEslintPlugin } from './plugin';
+export { NESTJS_REQUIRE_INJECT_RULE, type NestjsRequireInjectRuleOptions } from './require-inject.rule';
+export { NESTJS_ESLINT_PLUGIN, nestjsESLintPlugin, type NestjsEslintPlugin } from './plugin';

package/eslint/src/lib/plugin.d.ts

@@ -13,4 +13,10 @@ export interface NestjsEslintPlugin {
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
  */
-export declare const nestjsEslintPlugin: NestjsEslintPlugin;
+export declare const NESTJS_ESLINT_PLUGIN: NestjsEslintPlugin;
+/**
+ * camelCase alias of {@link NESTJS_ESLINT_PLUGIN} matching the conventional ESLint plugin export name.
+ *
+ * @dbxAllowConstantName
+ */
+export declare const nestjsESLintPlugin: NestjsEslintPlugin;

package/eslint/src/lib/require-inject.rule.d.ts

@@ -61,5 +61,5 @@ export interface NestjsRequireInjectRuleDefinition {
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
  */
-export declare const nestjsRequireInjectRule: NestjsRequireInjectRuleDefinition;
+export declare const NESTJS_REQUIRE_INJECT_RULE: NestjsRequireInjectRuleDefinition;
 export {};