@dereekb/nestjs 13.38.0 → 13.40.0

package/eslint/index.cjs.js

@@ -1,418 +0,0 @@
-'use strict';
-
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-/**
- * The import source that NestJS decorators come from.
- */ var NESTJS_COMMON_MODULE = '@nestjs/common';
-/**
- * NestJS class decorators that make a class eligible for dependency injection.
- */ var NESTJS_CLASS_DECORATORS = new Set([
-    'Injectable',
-    'Controller',
-    'Resolver'
-]);
-/**
- * Decorators that count as valid parameter injection markers.
- * Any parameter with at least one of these is considered properly annotated.
- */ var VALID_PARAM_DECORATORS = new Set([
-    'Inject',
-    'Optional',
-    'Self',
-    'SkipSelf',
-    'Host'
-]);
-/**
- * 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
- * ```
- */ function getDecoratorName(decorator) {
-    var expression = decorator.expression;
-    var name = '';
-    if (expression.type === 'CallExpression') {
-        if (expression.callee.type === 'Identifier') {
-            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;
-    }
-    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.
- */ 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') {
-            tokenName = firstArg.name;
-        }
-    }
-    return tokenName;
-}
-/**
- * Extracts the parameter name from a constructor parameter node.
- *
- * @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') {
-            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;
-    }
-    return name;
-}
-/**
- * Gets the class-typed injection token name from a parameter's type annotation, if available.
- *
- * 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.
- */ 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) {
-        tokenName = typeAnnotation.typeName.name;
-    }
-    return tokenName;
-}
-/**
- * Returns the first class decorator that is both in `classDecorators` and imported from '@nestjs/common'.
- *
- * @param classNode - The ClassDeclaration AST node.
- * @param classDecorators - Class decorator names that trigger this rule.
- * @param nestjsImports - Identifiers known to be imported from '@nestjs/common'.
- * @returns The matched decorator node, or undefined when none matches.
- */ function findMatchedClassDecorator(classNode, classDecorators, nestjsImports) {
-    var decorators = classNode.decorators;
-    if (!decorators || decorators.length === 0) return undefined;
-    return decorators.find(function(d) {
-        var name = getDecoratorName(d);
-        return classDecorators.has(name) && nestjsImports.has(name);
-    });
-}
-/**
- * Returns the constructor parameter list of a class declaration, if a constructor is present.
- *
- * @param classNode - The ClassDeclaration AST node.
- * @returns The parameter list, or undefined when there's no constructor.
- */ function findConstructorParams(classNode) {
-    var constructor = classNode.body.body.find(function(member) {
-        return member.type === 'MethodDefinition' && member.kind === 'constructor';
-    });
-    return constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
-}
-/**
- * Builds the fixer for converting a type-only import into a value import so it
- * can be used as an `@Inject()` token at runtime.
- *
- * @param fixer - The ESLint fixer instance.
- * @param typeImportInfo - Info about the type-only import to convert.
- * @returns The fixer command produced by `fixer.removeRange`.
- */ function buildTypeOnlyImportFix(fixer, typeImportInfo) {
-    var fixResult;
-    if (typeImportInfo.isDeclarationLevel) {
-        // `import type { X } from '...'` → `import { X } from '...'`
-        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
-        fixResult = fixer.removeRange([
-            importKeywordEnd,
-            importKeywordEnd + 'type '.length
-        ]);
-    } else {
-        // `import { type X }` → `import { X }`
-        var specRange = typeImportInfo.specifier.range;
-        var importedRange = typeImportInfo.specifier.imported.range;
-        fixResult = fixer.removeRange([
-            specRange[0],
-            importedRange[0]
-        ]);
-    }
-    return fixResult;
-}
-/**
- * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
- *
- * Required when emitDecoratorMetadata is disabled — without it, NestJS cannot infer
- * constructor parameter types and will throw at runtime if @Inject() is missing.
- *
- * Only applies to decorators imported from '@nestjs/common', so Angular @Injectable()
- * classes are not affected.
- *
- * Also flags injection tokens that are type-only imports (`import type { X }` or
- * `import { type X }`), since those cannot be used as values at runtime.
- *
- * Auto-fixes:
- * - Missing @Inject(): adds `@Inject(ClassName)` for simple class-typed parameters
- * - Type-only imports: removes the `type` modifier from the import specifier
- *
- * 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 NESTJS_REQUIRE_INJECT_RULE = {
-    meta: {
-        type: 'problem',
-        fixable: 'code',
-        docs: {
-            description: 'Require @Inject() decorator on constructor parameters in NestJS injectable classes',
-            recommended: true
-        },
-        messages: {
-            missingInject: 'Constructor parameter "{{name}}" in @{{classDecorator}}() class must have an @Inject() decorator. Without emitDecoratorMetadata, NestJS cannot infer the injection token and will throw at runtime.',
-            typeOnlyInjectToken: '@Inject({{token}}) uses "{{token}}" which is a type-only import. It must be a value import to be used as an injection token at runtime.'
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    additionalClassDecorators: {
-                        type: 'array',
-                        items: {
-                            type: 'string'
-                        },
-                        description: 'Additional class decorator names (beyond Injectable, Controller, Resolver) that should trigger this rule.'
-                    },
-                    additionalParamDecorators: {
-                        type: 'array',
-                        items: {
-                            type: 'string'
-                        },
-                        description: 'Additional parameter decorator names (beyond Inject, Optional, Self, SkipSelf, Host) to treat as valid injection markers.'
-                    }
-                },
-                additionalProperties: false
-            }
-        ]
-    },
-    create: function create(context) {
-        var options = context.options[0] || {};
-        var classDecorators = new Set(_to_consumable_array(NESTJS_CLASS_DECORATORS).concat(_to_consumable_array(options.additionalClassDecorators || [])));
-        var paramDecorators = new Set(_to_consumable_array(VALID_PARAM_DECORATORS).concat(_to_consumable_array(options.additionalParamDecorators || [])));
-        /**
-         * Tracks identifiers imported from '@nestjs/common'.
-         * Only decorators whose local name appears in this set will trigger the rule.
-         */ var nestjsImports = new Set();
-        /**
-         * Tracks all type-only imports across the file, keyed by local identifier name.
-         * Used to detect when @Inject(Token) uses a type-only import.
-         */ var typeOnlyImports = new Map();
-        /**
-         * Reference to the '@nestjs/common' ImportDeclaration node, used for adding
-         * the Inject import if it's missing during auto-fix.
-         */ var nestjsImportNode = null;
-        return {
-            ImportDeclaration: function ImportDeclaration(node) {
-                var isDeclarationTypeOnly = node.importKind === 'type';
-                if (node.source.value === NESTJS_COMMON_MODULE) {
-                    nestjsImportNode = node;
-                }
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = node.specifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var specifier = _step.value;
-                        if (specifier.type !== 'ImportSpecifier') {
-                            continue;
-                        }
-                        var localName = specifier.local.name;
-                        // Track @nestjs/common imports
-                        if (node.source.value === NESTJS_COMMON_MODULE) {
-                            nestjsImports.add(localName);
-                        }
-                        // Track type-only imports from any source
-                        var isTypeOnly = isDeclarationTypeOnly || specifier.importKind === 'type';
-                        if (isTypeOnly) {
-                            typeOnlyImports.set(localName, {
-                                specifier: specifier,
-                                declaration: node,
-                                isDeclarationLevel: isDeclarationTypeOnly
-                            });
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            },
-            ClassDeclaration: function ClassDeclaration(classNode) {
-                var matchedClassDecorator = findMatchedClassDecorator(classNode, classDecorators, nestjsImports);
-                if (!matchedClassDecorator) return;
-                var params = findConstructorParams(classNode);
-                if (!params || params.length === 0) return;
-                var classDecoratorName = getDecoratorName(matchedClassDecorator);
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var param = _step.value;
-                        processConstructorParam(param, classDecoratorName);
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            }
-        };
-        function processConstructorParam(param, classDecoratorName) {
-            var paramDecoratorsOnNode = param.decorators;
-            var hasValidDecorator = !!paramDecoratorsOnNode && paramDecoratorsOnNode.some(function(d) {
-                return paramDecorators.has(getDecoratorName(d));
-            });
-            if (hasValidDecorator) {
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var decorator = _step.value;
-                        reportTypeOnlyTokenIfAny(decorator);
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            } else {
-                reportMissingInject(param, classDecoratorName);
-            }
-        }
-        function reportTypeOnlyTokenIfAny(decorator) {
-            var tokenName = getInjectTokenFromDecorator(decorator);
-            if (!tokenName) return;
-            var typeImportInfo = typeOnlyImports.get(tokenName);
-            if (!typeImportInfo) return;
-            context.report({
-                node: decorator,
-                messageId: 'typeOnlyInjectToken',
-                data: {
-                    token: tokenName
-                },
-                fix: function fix(fixer) {
-                    return buildTypeOnlyImportFix(fixer, typeImportInfo);
-                }
-            });
-            // Remove from tracking so we don't report the same import twice
-            typeOnlyImports.delete(tokenName);
-        }
-        function reportMissingInject(param, classDecoratorName) {
-            var tokenName = getInjectTokenName(param);
-            context.report({
-                node: param,
-                messageId: 'missingInject',
-                data: {
-                    name: getParamName(param),
-                    classDecorator: classDecoratorName
-                },
-                fix: tokenName ? function(fixer) {
-                    return buildMissingInjectFix(fixer, param, tokenName);
-                } : undefined
-            });
-        }
-        function buildMissingInjectFix(fixer, param, tokenName) {
-            var fixes = [
-                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');
-            }
-            return fixes;
-        }
-    }
-};
-
-/**
- * ESLint plugin for NestJS rules.
- *
- * 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 NESTJS_ESLINT_PLUGIN = {
-    rules: {
-        '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;
-
-exports.NESTJS_ESLINT_PLUGIN = NESTJS_ESLINT_PLUGIN;
-exports.NESTJS_REQUIRE_INJECT_RULE = NESTJS_REQUIRE_INJECT_RULE;
-exports.nestjsESLintPlugin = nestjsESLintPlugin;

package/eslint/index.cjs.mjs

@@ -1,2 +0,0 @@
-export * from './index.cjs.js';
-export { _default as default } from './index.cjs.default.js';

package/index.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./index.cjs.js').default;