eslint-plugin-complete 1.0.0

package/dist/rules/no-object-methods-with-map-set.js

@@ -0,0 +1,84 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { capitalizeFirstLetter, trimPrefix } from "../completeCommon.js";
+import { getTypeName } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+const PROBLEM_METHODS = new Set([
+    "entries",
+    "keys",
+    "values",
+]);
+const PROBLEM_TYPES = new Set([
+    "Map",
+    "Set",
+    "ReadonlyMap",
+    "ReadonlySet",
+]);
+export const noObjectMethodsWithMapSet = createRule({
+    name: "no-object-methods-with-map-set",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows using object methods with maps and sets",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            noObjectEntriesMap: "You cannot use the `Object.entries` method with a map. Consider using the `entries` method on the map instead.",
+            noObjectKeysMap: "You cannot use the `Object.keys` method with a map. Consider using the `keys` method on the map instead.",
+            noObjectValuesMap: "You cannot use the `Object.values` method with a map. Consider using the `values` method on the map instead.",
+            noObjectEntriesSet: "You cannot use the `Object.entries` method with a set. Consider using the `entries` method on the set instead.",
+            noObjectKeysSet: "You cannot use the `Object.keys` method with a set. Consider using the `keys` method on the set instead.",
+            noObjectValuesSet: "You cannot use the `Object.values` method with a set. Consider using the `values` method on the set instead.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            /** When a function or method is called. */
+            CallExpression(node) {
+                // First, check if this is invoking a method on an object.
+                const { callee } = node;
+                if (callee.type !== AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                // Second, check if the object is `Object`.
+                const { object } = callee;
+                if (object.type !== AST_NODE_TYPES.Identifier ||
+                    object.name !== "Object") {
+                    return;
+                }
+                // Third, check if this is one of the problem methods.
+                const { property } = callee;
+                if (property.type !== AST_NODE_TYPES.Identifier ||
+                    !PROBLEM_METHODS.has(property.name)) {
+                    return;
+                }
+                const methodName = property.name;
+                // Fourth, check the type of the thing being passed.
+                const firstArgument = node.arguments[0];
+                if (firstArgument === undefined) {
+                    return;
+                }
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(firstArgument);
+                const type = checker.getTypeAtLocation(tsNode);
+                const typeName = getTypeName(type);
+                if (typeName === undefined) {
+                    return;
+                }
+                if (!PROBLEM_TYPES.has(typeName)) {
+                    return;
+                }
+                const capitalMethodName = capitalizeFirstLetter(methodName);
+                const trimmedTypeName = trimPrefix(typeName, "Readonly");
+                const messageId = `noObject${capitalMethodName}${trimmedTypeName}`;
+                context.report({
+                    loc: node.loc,
+                    messageId,
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-string-length-0.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noStringLength0: ESLintUtils.RuleModule<"noStringLength0", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=no-string-length-0.d.ts.map

package/dist/rules/no-string-length-0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-string-length-0.d.ts","sourceRoot":"","sources":["../../src/rules/no-string-length-0.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAKvE,eAAO,MAAM,eAAe,+HAyD1B,CAAC"}

package/dist/rules/no-string-length-0.js

@@ -0,0 +1,52 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { isFlagSet } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+export const noStringLength0 = createRule({
+    name: "no-string-length-0",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows checking for empty strings via the length method in favor of direct comparison to an empty string",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            noStringLength0: "Compare to an empty string directly instead of using the length method, as it is shorter and easier to read.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        function isStringLength(node) {
+            if (node.type !== AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            if (node.property.type !== AST_NODE_TYPES.Identifier ||
+                node.property.name !== "length") {
+                return false;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.object);
+            const type = checker.getTypeAtLocation(tsNode);
+            // We don't use `isTypeFlagSet` because we don't want to iterate through any unions; we only
+            // want to match exactly `string`.
+            return isFlagSet(type.flags, ts.TypeFlags.String);
+        }
+        return {
+            BinaryExpression(node) {
+                if ((is0(node.left) && isStringLength(node.right)) ||
+                    (is0(node.right) && isStringLength(node.left))) {
+                    context.report({
+                        node,
+                        messageId: "noStringLength0",
+                    });
+                }
+            },
+        };
+    },
+});
+function is0(node) {
+    return node.type === AST_NODE_TYPES.Literal && node.raw === "0";
+}

package/dist/rules/no-template-curly-in-string-fix.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This rule is slightly modified from the original ESLint version:
+ * https://github.com/eslint/eslint/blob/main/lib/rules/no-template-curly-in-string.js
+ */
+export declare const noTemplateCurlyInStringFix: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedTemplateExpression", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=no-template-curly-in-string-fix.d.ts.map

package/dist/rules/no-template-curly-in-string-fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-template-curly-in-string-fix.d.ts","sourceRoot":"","sources":["../../src/rules/no-template-curly-in-string-fix.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,eAAO,MAAM,0BAA0B,8MAmCrC,CAAC"}

package/dist/rules/no-template-curly-in-string-fix.js

@@ -0,0 +1,39 @@
+/**
+ * This rule is slightly modified from the original ESLint version:
+ * https://github.com/eslint/eslint/blob/main/lib/rules/no-template-curly-in-string.js
+ */
+import { createRule } from "../utils.js";
+const ERRONEOUS_TEMPLATE_STRING_REGEX = /\$\{[^}]+\}/u;
+export const noTemplateCurlyInStringFix = createRule({
+    name: "no-template-curly-in-string-fix",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows template literal placeholder syntax in regular strings (and automatically fixes)",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            unexpectedTemplateExpression: "Unexpected template string expression.",
+        },
+        fixable: "code",
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Literal(node) {
+                if (typeof node.value === "string" &&
+                    ERRONEOUS_TEMPLATE_STRING_REGEX.test(node.value)) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedTemplateExpression",
+                        fix(fixer) {
+                            return fixer.replaceText(node, `\`${node.value}\``);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-undefined-return-type.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noUndefinedReturnType: ESLintUtils.RuleModule<"undefinedReturnType", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=no-undefined-return-type.d.ts.map

package/dist/rules/no-undefined-return-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-undefined-return-type.d.ts","sourceRoot":"","sources":["../../src/rules/no-undefined-return-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvD,eAAO,MAAM,qBAAqB,mIAsChC,CAAC"}

package/dist/rules/no-undefined-return-type.js

@@ -0,0 +1,40 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { getTypeName } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+export const noUndefinedReturnType = createRule({
+    name: "no-undefined-return-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows `undefined` return types on functions",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            undefinedReturnType: "Functions cannot have an `undefined` return type. Change the return type to `void` instead.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            FunctionDeclaration(node) {
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const type = checker.getTypeAtLocation(tsNode);
+                const signatures = type.getCallSignatures();
+                for (const signature of signatures) {
+                    const returnType = signature.getReturnType();
+                    const typeName = getTypeName(returnType);
+                    if (typeName === "undefined") {
+                        context.report({
+                            loc: node.loc,
+                            messageId: "undefinedReturnType",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unnecessary-assignment.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export type Options = [];
+export type MessageIds = "unnecessary" | "unnecessaryZero" | "unnecessaryEmptyString" | "unnecessaryShortCircuit";
+export declare const noUnnecessaryAssignment: ESLintUtils.RuleModule<MessageIds, [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=no-unnecessary-assignment.d.ts.map

package/dist/rules/no-unnecessary-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-assignment.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-assignment.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAmBvE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAClB,aAAa,GACb,iBAAiB,GACjB,wBAAwB,GACxB,yBAAyB,CAAC;AAE9B,eAAO,MAAM,uBAAuB,wHA2SlC,CAAC"}

package/dist/rules/no-unnecessary-assignment.js

@@ -0,0 +1,255 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { isFlagSet, unionTypeParts } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+const USELESS_OPERATORS_WITH_ZERO = new Set([
+    "+",
+    "-",
+    "|",
+    // "<<" is technically a useless operator, but we whitelist it so that bit flag enums will not
+    // cause false positives.
+    ">>",
+    ">>>",
+]);
+const USELESS_ASSIGNMENT_OPERATORS_WITH_ZERO = new Set([...USELESS_OPERATORS_WITH_ZERO].map((value) => `${value}=`));
+export const noUnnecessaryAssignment = createRule({
+    name: "no-unnecessary-assignment",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows useless assignments",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            unnecessary: "This assignment is unnecessary because it would have no effect on the variable.",
+            unnecessaryZero: 'This assignment is unnecessary because the "{{ operator }}" operator in combination with 0 would have no effect on a number variable.',
+            unnecessaryEmptyString: "This assignment is unnecessary because adding an empty string would have no effect on a string variable.",
+            unnecessaryShortCircuit: 'This short circuit assignment using the "{{operator}}" operator is unnecessary because it would have no effect on the variable.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        function nodeHasFlagSet(node, flag) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            // We cannot use `isTypeFlagSet` because we do not want to penetrate unions.
+            return isFlagSet(type.flags, flag);
+        }
+        function isBoolean(node) {
+            return nodeHasFlagSet(node, ts.TypeFlags.BooleanLike);
+        }
+        function isNumber(node) {
+            return nodeHasFlagSet(node, ts.TypeFlags.NumberLike);
+        }
+        function isString(node) {
+            return nodeHasFlagSet(node, ts.TypeFlags.StringLike);
+        }
+        function isNull(node) {
+            return nodeHasFlagSet(node, ts.TypeFlags.Null);
+        }
+        function isUndefined(node) {
+            return nodeHasFlagSet(node, ts.TypeFlags.Undefined);
+        }
+        function isTrue(node) {
+            // Checking for the literal value is fast, so we do that first.
+            if (node.type === AST_NODE_TYPES.Literal && node.value === true) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return "intrinsicName" in type && type.intrinsicName === "true";
+        }
+        function isFalse(node) {
+            // Checking for the literal value is fast, so we do that first.
+            if (node.type === AST_NODE_TYPES.Literal && node.value === false) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return "intrinsicName" in type && type.intrinsicName === "false";
+        }
+        function isZero(node) {
+            // Checking for the literal value is fast, so we do that first.
+            if (isLiteralZero(node)) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return "value" in type && type.value === 0;
+        }
+        function isEmptyString(node) {
+            // Checking for the literal value is fast, so we do that first.
+            if (isLiteralEmptyString(node)) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return "value" in type && type.value === "";
+        }
+        function hasNullAndNotUndefined(node) {
+            if (isNull(node)) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            const types = unionTypeParts(type);
+            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null)) &&
+                !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined)));
+        }
+        function hasUndefinedAndNotNull(node) {
+            if (isUndefined(node)) {
+                return true;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            const types = unionTypeParts(type);
+            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined)) &&
+                !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null)));
+        }
+        function checkEqualSign(node) {
+            const leftTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.left);
+            const rightTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.right);
+            const leftType = checker.getTypeAtLocation(leftTSNode);
+            const rightType = checker.getTypeAtLocation(rightTSNode);
+            const isLeftLiteral = isFlagSet(leftType.flags, ts.TypeFlags.Literal);
+            const isRightLiteral = isFlagSet(rightType.flags, ts.TypeFlags.Literal);
+            if (isLeftLiteral && isRightLiteral && leftType === rightType) {
+                context.report({
+                    loc: node.loc,
+                    messageId: "unnecessary",
+                });
+            }
+        }
+        return {
+            AssignmentExpression(node) {
+                if (node.operator === "=") {
+                    checkEqualSign(node);
+                }
+                else if (USELESS_ASSIGNMENT_OPERATORS_WITH_ZERO.has(node.operator) &&
+                    isNumber(node.left) &&
+                    isLiteralZero(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryZero",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                else if (node.operator === "+=" &&
+                    isString(node.left) &&
+                    isLiteralEmptyString(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryEmptyString",
+                    });
+                }
+            },
+            BinaryExpression(node) {
+                if (USELESS_OPERATORS_WITH_ZERO.has(node.operator) &&
+                    ((isNumber(node.left) && isLiteralZero(node.right)) ||
+                        (isNumber(node.right) && isLiteralZero(node.left)))) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryZero",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                // Plus is the only operator valid for strings.
+                if (node.operator === "+" &&
+                    ((isString(node.left) && isLiteralEmptyString(node.right)) ||
+                        (isString(node.right) && isLiteralEmptyString(node.left)))) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryEmptyString",
+                    });
+                }
+            },
+            LogicalExpression(node) {
+                const { parent } = node;
+                if (parent.type !== AST_NODE_TYPES.AssignmentExpression &&
+                    parent.type !== AST_NODE_TYPES.VariableDeclarator) {
+                    return;
+                }
+                if (node.operator === "||" &&
+                    isBoolean(node.left) &&
+                    isFalse(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                if (node.operator === "&&" &&
+                    isBoolean(node.left) &&
+                    isTrue(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                if (node.operator === "||" &&
+                    isNumber(node.left) &&
+                    isZero(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                if (node.operator === "||" &&
+                    isString(node.left) &&
+                    isEmptyString(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                if (node.operator === "??" &&
+                    hasNullAndNotUndefined(node.left) &&
+                    isNull(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+                if (node.operator === "??" &&
+                    hasUndefinedAndNotNull(node.left) &&
+                    isUndefined(node.right)) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unnecessaryShortCircuit",
+                        data: {
+                            operator: node.operator,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+function isLiteralZero(node) {
+    return node.type === AST_NODE_TYPES.Literal && node.value === 0;
+}
+function isLiteralEmptyString(node) {
+    return node.type === AST_NODE_TYPES.Literal && node.raw === '""';
+}

package/dist/rules/no-unsafe-plusplus.d.ts

@@ -0,0 +1,2 @@
+export declare const noUnsafePlusplus: import("@typescript-eslint/utils/ts-eslint").RuleModule<"plusPlus" | "minusMinus", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=no-unsafe-plusplus.d.ts.map

package/dist/rules/no-unsafe-plusplus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsafe-plusplus.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsafe-plusplus.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,yMAwC3B,CAAC"}

package/dist/rules/no-unsafe-plusplus.js

@@ -0,0 +1,34 @@
+import { createRule } from "../utils.js";
+export const noUnsafePlusplus = createRule({
+    name: "no-unsafe-plusplus",
+    meta: {
+        type: "problem",
+        docs: {
+            description: 'Disallow unsafe and confusing uses of the "++" and "--" operators',
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            plusPlus: 'Complex usages of the "++" operator can be confusing. You should only use it in contexts where it could be swapped with "+= 1".',
+            minusMinus: 'Complex usages of the "--" operator can be confusing. You should only use it in contexts where it could be swapped with "-= 1".',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function unsafe(nodeNever) {
+            // The type of the node is "never" for some reason, so cast it to something we can work with.
+            const node = nodeNever;
+            const { operator } = node;
+            const messageId = operator === "--" ? "minusMinus" : "plusPlus";
+            context.report({
+                loc: node.loc,
+                messageId,
+            });
+        }
+        return {
+            ":not(UnaryExpression[operator='void'],ExpressionStatement,SequenceExpression,ForStatement[update.type=UpdateExpression]) > UpdateExpression[prefix='false'], ForStatement[init.type=UpdateExpression] > UpdateExpression[prefix='false'], ForStatement[test.type=UpdateExpression] > UpdateExpression[prefix='false']": unsafe,
+            "SequenceExpression > UpdateExpression[prefix='false']:last-child": unsafe,
+        };
+    },
+});

package/dist/rules/no-useless-return.d.ts

@@ -0,0 +1,2 @@
+export declare const noUselessReturn: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryReturn", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=no-useless-return.d.ts.map

package/dist/rules/no-useless-return.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-useless-return.d.ts","sourceRoot":"","sources":["../../src/rules/no-useless-return.ts"],"names":[],"mappings":"AA6IA,eAAO,MAAM,eAAe,mMAoR1B,CAAC"}