@typescript-eslint/eslint-plugin - npm Package Compare versions

Comparing version 8.1.1-alpha.10 to 8.1.1-alpha.11

dist/rules/array-type.js

@@ -85,2 +85,3 @@ "use strict";
             errorStringGenericSimple: "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.",
+            errorStringArraySimpleReadonly: "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.",
         },
@@ -183,3 +184,5 @@ schema: [
                         : 'errorStringArray'
-                    : 'errorStringArraySimple';
+                    : isReadonlyArrayType && node.typeName.name !== 'ReadonlyArray'
+                        ? 'errorStringArraySimpleReadonly'
+                        : 'errorStringArraySimple';
                 if (!typeParams || typeParams.length === 0) {
@@ -186,0 +189,0 @@ // Create an 'any' array

dist/rules/enum-utils/shared.js

@@ -100,3 +100,3 @@ "use strict";
                 case ts.SyntaxKind.StringLiteral: {
-                    const memberName = memberNameIdentifier.text.replace(/'/g, "\\'");
+                    const memberName = memberNameIdentifier.text.replaceAll("'", "\\'");
                     return `${enumName}['${memberName}']`;
@@ -103,0 +103,0 @@ }

dist/rules/member-ordering.js

@@ -509,3 +509,3 @@ "use strict";
     const lowestRanks = Array.isArray(lowestRank) ? lowestRank : [lowestRank];
-    return lowestRanks.map(rank => rank.replace(/-/g, ' ')).join(', ');
+    return lowestRanks.map(rank => rank.replaceAll('-', ' ')).join(', ');
 }
@@ -512,0 +512,0 @@ exports.default = (0, util_1.createRule)({

dist/rules/naming-convention-utils/shared.js

@@ -8,3 +8,3 @@ "use strict";
 function selectorTypeToMessageString(selectorType) {
-    const notCamelCase = selectorType.replace(/([A-Z])/g, ' $1');
+    const notCamelCase = selectorType.replaceAll(/([A-Z])/g, ' $1');
     return notCamelCase.charAt(0).toUpperCase() + notCamelCase.slice(1);
@@ -11,0 +11,0 @@ }

dist/rules/no-invalid-void-type.js

@@ -82,5 +82,5 @@ "use strict";
                     .getText(node.parent.parent.typeName)
-                    .replace(/ /gu, '');
+                    .replaceAll(' ', '');
                 if (!allowInGenericTypeArguments
-                    .map(s => s.replace(/ /gu, ''))
+                    .map(s => s.replaceAll(' ', ''))
                     .includes(fullyQualifiedName)) {
@@ -87,0 +87,0 @@ context.report({

dist/rules/no-redundant-type-constituents.js

@@ -91,2 +91,5 @@ "use strict";
     }
+    if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) {
+        return type.aliasSymbol.escapedName.toString();
+    }
     if ((0, util_1.isTypeAnyType)(type)) {
@@ -174,2 +177,3 @@ return 'any';
             overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
+            errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
         },
@@ -239,3 +243,5 @@ schema: [],
                                 },
-                                messageId,
+                                messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any'
+                                    ? 'errorTypeOverrides'
+                                    : messageId,
                                 node: typeNode,
@@ -341,3 +347,5 @@ });
                                 },
-                                messageId: 'overrides',
+                                messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any'
+                                    ? 'errorTypeOverrides'
+                                    : 'overrides',
                                 node: typeNode,
@@ -344,0 +352,0 @@ });

dist/rules/no-restricted-types.js

@@ -6,3 +6,3 @@ "use strict";
 function removeSpaces(str) {
-    return str.replace(/\s/g, '');
+    return str.replaceAll(/\s/g, '');
 }
@@ -9,0 +9,0 @@ function stringifyNode(node, sourceCode) {

dist/rules/no-unnecessary-template-expression.js

@@ -136,3 +136,3 @@ "use strict";
                                 // In regular expressions, we escape every backslash
-                                String(expression.value).replace(/\\/g, '\\\\'))
+                                String(expression.value).replaceAll('\\', '\\\\'))
                             // The string or RegExp may contain ` or ${.
@@ -151,3 +151,3 @@ // We want both of these to be escaped in the final template expression.
                             // \\${ -> \\\${
-                            .replace(new RegExp(`${String(evenNumOfBackslashesRegExp.source)}(\`|\\\${)`, 'g'), '\\$1');
+                            .replaceAll(new RegExp(`${String(evenNumOfBackslashesRegExp.source)}(\`|\\\${)`, 'g'), '\\$1');
                         // `...${'...$'}{...`
@@ -154,0 +154,0 @@ //           ^^^^

dist/rules/no-unnecessary-type-assertion.js

@@ -79,21 +79,48 @@ "use strict";
                 // also ignore function arguments as they can't be used before defined
-                ts.isVariableDeclaration(declaration) &&
+                ts.isVariableDeclaration(declaration)) {
+                // For var declarations, we need to check whether the node
+                // is actually in a descendant of its declaration or not. If not,
+                // it may be used before defined.
+                // eg
+                // if (Math.random() < 0.5) {
+                //     var x: number  = 2;
+                // } else {
+                //     x!.toFixed();
+                // }
+                if (ts.isVariableDeclarationList(declaration.parent) &&
+                    // var
+                    declaration.parent.flags === ts.NodeFlags.None &&
+                    // If they are not in the same file it will not exist.
+                    // This situation must not occur using before defined.
+                    services.tsNodeToESTreeNodeMap.has(declaration)) {
+                    const declaratorNode = services.tsNodeToESTreeNodeMap.get(declaration);
+                    const scope = context.sourceCode.getScope(node);
+                    const declaratorScope = context.sourceCode.getScope(declaratorNode);
+                    let parentScope = declaratorScope;
+                    while ((parentScope = parentScope.upper)) {
+                        if (parentScope === scope) {
+                            return true;
+                        }
+                    }
+                }
+                if (
                 // is it `const x!: number`
                 declaration.initializer === undefined &&
-                declaration.exclamationToken === undefined &&
-                declaration.type !== undefined) {
-                // check if the defined variable type has changed since assignment
-                const declarationType = checker.getTypeFromTypeNode(declaration.type);
-                const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
-                if (declarationType === type &&
-                    // `declare`s are never narrowed, so never skip them
-                    !(ts.isVariableDeclarationList(declaration.parent) &&
-                        ts.isVariableStatement(declaration.parent.parent) &&
-                        tsutils.includesModifier((0, util_1.getModifiers)(declaration.parent.parent), ts.SyntaxKind.DeclareKeyword))) {
-                    // possibly used before assigned, so just skip it
-                    // better to false negative and skip it, than false positive and fix to compile erroring code
-                    //
-                    // no better way to figure this out right now
-                    // https://github.com/Microsoft/TypeScript/issues/31124
-                    return true;
+                    declaration.exclamationToken === undefined &&
+                    declaration.type !== undefined) {
+                    // check if the defined variable type has changed since assignment
+                    const declarationType = checker.getTypeFromTypeNode(declaration.type);
+                    const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+                    if (declarationType === type &&
+                        // `declare`s are never narrowed, so never skip them
+                        !(ts.isVariableDeclarationList(declaration.parent) &&
+                            ts.isVariableStatement(declaration.parent.parent) &&
+                            tsutils.includesModifier((0, util_1.getModifiers)(declaration.parent.parent), ts.SyntaxKind.DeclareKeyword))) {
+                        // possibly used before assigned, so just skip it
+                        // better to false negative and skip it, than false positive and fix to compile erroring code
+                        //
+                        // no better way to figure this out right now
+                        // https://github.com/Microsoft/TypeScript/issues/31124
+                        return true;
+                    }
                 }
@@ -100,0 +127,0 @@ }

dist/rules/no-unnecessary-type-parameters.js

@@ -249,3 +249,3 @@ "use strict";
                     // They have properties, so we need to avoid double-counting.
-                    visitType(type.templateType, false);
+                    visitType(type.templateType ?? type.constraintType, false);
                 }
@@ -252,0 +252,0 @@ }

dist/rules/no-unsafe-enum-comparison.js

@@ -33,9 +33,19 @@ "use strict";
  */
-function typeViolates(leftTypeParts, right) {
-    const leftValueKinds = new Set(leftTypeParts.map(getEnumValueType));
-    return ((leftValueKinds.has(ts.TypeFlags.Number) &&
-        tsutils.isTypeFlagSet(right, ts.TypeFlags.Number | ts.TypeFlags.NumberLike)) ||
-        (leftValueKinds.has(ts.TypeFlags.String) &&
-            tsutils.isTypeFlagSet(right, ts.TypeFlags.String | ts.TypeFlags.StringLike)));
+function typeViolates(leftTypeParts, rightType) {
+    const leftEnumValueTypes = new Set(leftTypeParts.map(getEnumValueType));
+    return ((leftEnumValueTypes.has(ts.TypeFlags.Number) && isNumberLike(rightType)) ||
+        (leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
 }
+function isNumberLike(type) {
+    const typeParts = tsutils.intersectionTypeParts(type);
+    return typeParts.some(typePart => {
+        return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike);
+    });
+}
+function isStringLike(type) {
+    const typeParts = tsutils.intersectionTypeParts(type);
+    return typeParts.some(typePart => {
+        return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.String | ts.TypeFlags.StringLike);
+    });
+}
 /**
@@ -93,2 +103,9 @@ * @returns What type a type's enum value is (number or string), if either.
             }
+            // We need to split the type into the union type parts in order to find
+            // valid enum comparisons like:
+            //
+            // ```ts
+            // declare const something: Fruit | Vegetable;
+            // something === Fruit.Apple;
+            // ```
             const leftTypeParts = tsutils.unionTypeParts(leftType);
@@ -95,0 +112,0 @@ const rightTypeParts = tsutils.unionTypeParts(rightType);

dist/rules/prefer-includes.js

@@ -135,3 +135,3 @@ "use strict";
             const replaceRegex = new RegExp(Object.values(EscapeMap).join('|'), 'g');
-            return str.replace(replaceRegex, char => EscapeMap[char]);
+            return str.replaceAll(replaceRegex, char => EscapeMap[char]);
         }
@@ -138,0 +138,0 @@ function checkArrayIndexOf(node, allowFixing) {

dist/rules/require-await.js

@@ -42,3 +42,5 @@ "use strict";
             missingAwait: "{{name}} has no 'await' expression.",
+            removeAsync: "Remove 'async'.",
         },
+        hasSuggestions: true,
     },
@@ -75,2 +77,68 @@ defaultOptions: [],
                 !(scopeInfo.isGen && scopeInfo.isAsyncYield)) {
+                // If the function belongs to a method definition or
+                // property, then the function's range may not include the
+                // `async` keyword and we should look at the parent instead.
+                const nodeWithAsyncKeyword = (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    node.parent.value === node) ||
+                    (node.parent.type === utils_1.AST_NODE_TYPES.Property &&
+                        node.parent.method &&
+                        node.parent.value === node)
+                    ? node.parent
+                    : node;
+                const asyncToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(nodeWithAsyncKeyword, token => token.value === 'async'), 'The node is an async function, so it must have an "async" token.');
+                const asyncRange = [
+                    asyncToken.range[0],
+                    (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(asyncToken, {
+                        includeComments: true,
+                    }), 'There will always be a token after the "async" keyword.').range[0],
+                ];
+                // Removing the `async` keyword can cause parsing errors if the
+                // current statement is relying on automatic semicolon insertion.
+                // If ASI is currently being used, then we should replace the
+                // `async` keyword with a semicolon.
+                const nextToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(asyncToken), 'There will always be a token after the "async" keyword.');
+                const addSemiColon = nextToken.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                    (nextToken.value === '[' || nextToken.value === '(') &&
+                    (nodeWithAsyncKeyword.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+                        (0, util_1.isStartOfExpressionStatement)(nodeWithAsyncKeyword)) &&
+                    (0, util_1.needsPrecedingSemicolon)(context.sourceCode, nodeWithAsyncKeyword);
+                const changes = [
+                    { range: asyncRange, replacement: addSemiColon ? ';' : undefined },
+                ];
+                // If there's a return type annotation and it's a
+                // `Promise<T>`, we can also change the return type
+                // annotation to just `T` as part of the suggestion.
+                // Alternatively, if the function is a generator and
+                // the return type annotation is `AsyncGenerator<T>`,
+                // then we can change it to `Generator<T>`.
+                if (node.returnType?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    if (scopeInfo.isGen) {
+                        if (hasTypeName(node.returnType.typeAnnotation, 'AsyncGenerator')) {
+                            changes.push({
+                                range: node.returnType.typeAnnotation.typeName.range,
+                                replacement: 'Generator',
+                            });
+                        }
+                    }
+                    else if (hasTypeName(node.returnType.typeAnnotation, 'Promise') &&
+                        node.returnType.typeAnnotation.typeArguments != null) {
+                        const openAngle = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node.returnType.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                            token.value === '<'), 'There are type arguments, so the angle bracket will exist.');
+                        const closeAngle = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node.returnType.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                            token.value === '>'), 'There are type arguments, so the angle bracket will exist.');
+                        changes.push(
+                        // Remove the closing angled bracket.
+                        { range: closeAngle.range, replacement: undefined }, 
+                        // Remove the "Promise" identifier
+                        // and the opening angled bracket.
+                        {
+                            range: [
+                                node.returnType.typeAnnotation.typeName.range[0],
+                                openAngle.range[1],
+                            ],
+                            replacement: undefined,
+                        });
+                    }
+                }
                 context.report({
@@ -83,2 +151,10 @@ node,
                     },
+                    suggest: [
+                        {
+                            messageId: 'removeAsync',
+                            fix: (fixer) => changes.map(change => change.replacement !== undefined
+                                ? fixer.replaceTextRange(change.range, change.replacement)
+                                : fixer.removeRange(change.range)),
+                        },
+                    ],
                 });
@@ -177,2 +253,6 @@ }
 }
+function hasTypeName(typeReference, typeName) {
+    return (typeReference.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeReference.typeName.name === typeName);
+}
 //# sourceMappingURL=require-await.js.map

dist/rules/use-unknown-in-catch-callback-variable.js

@@ -29,3 +29,11 @@ "use strict";
 const util_1 = require("../util");
-const useUnknownMessageBase = 'Prefer the safe `: unknown` for a catch callback variable.';
+const useUnknownMessageBase = 'Prefer the safe `: unknown` for a `{{method}}`{{append}} callback variable.';
+/**
+ * `x.memberName` => 'memberKey'
+ *
+ * `const mk = 'memberKey'; x[mk]` => 'memberKey'
+ *
+ * `const mk = 1234; x[mk]` => 1234
+ */
+const getStaticMemberAccessKey = ({ computed, property }, scope) => computed ? (0, util_1.getStaticValue)(property, scope) : { value: property.name };
 exports.default = (0, util_1.createRule)({
@@ -35,3 +43,3 @@ name: 'use-unknown-in-catch-callback-variable',
         docs: {
-            description: 'Enforce typing arguments in `.catch()` callbacks as `unknown`',
+            description: 'Enforce typing arguments in Promise rejection callbacks as `unknown`',
             requiresTypeChecking: true,
@@ -45,5 +53,4 @@ recommended: 'strict',
             useUnknownObjectDestructuringPattern: `${useUnknownMessageBase} The thrown error may be nullable, or may not have the expected shape.`,
-            useUnknownSpreadArgs: `${useUnknownMessageBase} The argument list may contain a handler that does not use \`unknown\` for the catch callback variable.`,
-            addUnknownTypeAnnotationSuggestion: 'Add an explicit `: unknown` type annotation to the catch variable.',
-            addUnknownRestTypeAnnotationSuggestion: 'Add an explicit `: [unknown]` type annotation to the catch rest variable.',
+            addUnknownTypeAnnotationSuggestion: 'Add an explicit `: unknown` type annotation to the rejection callback variable.',
+            addUnknownRestTypeAnnotationSuggestion: 'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',
             wrongTypeAnnotationSuggestion: 'Change existing type annotation to `: unknown`.',
@@ -58,13 +65,4 @@ wrongRestTypeAnnotationSuggestion: 'Change existing type annotation to `: [unknown]`.',
     create(context) {
-        const services = (0, util_1.getParserServices)(context);
-        const checker = services.program.getTypeChecker();
-        function isPromiseCatchAccess(node) {
-            if (!(node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                isStaticMemberAccessOfValue(node, 'catch'))) {
-                return false;
-            }
-            const objectTsNode = services.esTreeNodeToTSNodeMap.get(node.object);
-            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            return tsutils.isThenableType(checker, tsNode, checker.getTypeAtLocation(objectTsNode));
-        }
+        const { program, esTreeNodeToTSNodeMap } = (0, util_1.getParserServices)(context);
+        const checker = program.getTypeChecker();
         function isFlaggableHandlerType(type) {
@@ -104,36 +102,7 @@ for (const unionPart of tsutils.unionTypeParts(type)) {
         }
-        /**
-         * If passed an ordinary expression, this will check it as expected.
-         *
-         * If passed a spread element, it treats it as the union of unwrapped array/tuple type.
-         */
         function shouldFlagArgument(node) {
-            const argument = services.esTreeNodeToTSNodeMap.get(node);
+            const argument = esTreeNodeToTSNodeMap.get(node);
             const typeOfArgument = checker.getTypeAtLocation(argument);
             return isFlaggableHandlerType(typeOfArgument);
         }
-        function shouldFlagMultipleSpreadArgs(argumentsList) {
-            // One could try to be clever about unpacking fixed length tuples and stuff
-            // like that, but there's no need, since this is all invalid use of `.catch`
-            // anyway at the end of the day. Instead, we'll just check whether any of the
-            // possible args types would violate the rule on its own.
-            return argumentsList.some(argument => shouldFlagArgument(argument));
-        }
-        function shouldFlagSingleSpreadArg(node) {
-            const spreadArgs = services.esTreeNodeToTSNodeMap.get(node.argument);
-            const spreadArgsType = checker.getTypeAtLocation(spreadArgs);
-            if (checker.isArrayType(spreadArgsType)) {
-                const arrayType = checker.getTypeArguments(spreadArgsType)[0];
-                return isFlaggableHandlerType(arrayType);
-            }
-            if (checker.isTupleType(spreadArgsType)) {
-                const firstType = checker.getTypeArguments(spreadArgsType).at(0);
-                if (!firstType) {
-                    // empty spread args. Suspect code, but not a problem for this rule.
-                    return false;
-                }
-                return isFlaggableHandlerType(firstType);
-            }
-            return true;
-        }
         /**
@@ -146,3 +115,3 @@ * Analyzes the syntax of the catch argument and makes a best effort to pinpoint
          */
-        function refineReportForNormalArgumentIfPossible(argument) {
+        function refineReportIfPossible(argument) {
             // Only know how to be helpful if a function literal has been provided.
@@ -233,35 +202,41 @@ if (!(argument.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
         return {
-            CallExpression(node) {
-                if (node.arguments.length === 0 || !isPromiseCatchAccess(node.callee)) {
+            CallExpression({ arguments: args, callee }) {
+                if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
                     return;
                 }
-                const firstArgument = node.arguments[0];
-                // Deal with some special cases around spread element args.
-                // promise.catch(...handlers), promise.catch(...handlers, ...moreHandlers).
-                if (firstArgument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    if (node.arguments.length === 1) {
-                        if (shouldFlagSingleSpreadArg(firstArgument)) {
-                            context.report({
-                                node: firstArgument,
-                                messageId: 'useUnknown',
-                            });
-                        }
-                    }
-                    else if (shouldFlagMultipleSpreadArgs(node.arguments)) {
-                        context.report({
-                            node,
-                            messageId: 'useUnknownSpreadArgs',
-                        });
-                    }
+                const staticMemberAccessKey = getStaticMemberAccessKey(callee, context.sourceCode.getScope(callee));
+                if (!staticMemberAccessKey) {
                     return;
                 }
-                // First argument is an "ordinary" argument (i.e. not a spread argument)
+                const promiseMethodInfo = [
+                    { method: 'catch', append: '', argIndexToCheck: 0 },
+                    { method: 'then', append: ' rejection', argIndexToCheck: 1 },
+                ].find(({ method }) => staticMemberAccessKey.value === method);
+                if (!promiseMethodInfo) {
+                    return;
+                }
+                // Need to be enough args to check
+                const { argIndexToCheck, ...data } = promiseMethodInfo;
+                if (args.length < argIndexToCheck + 1) {
+                    return;
+                }
+                // Argument to check, and all arguments before it, must be "ordinary" arguments (i.e. no spread arguments)
                 // promise.catch(f), promise.catch(() => {}), promise.catch(<expression>, <<other-args>>)
-                if (shouldFlagArgument(firstArgument)) {
+                const argsToCheck = args.slice(0, argIndexToCheck + 1);
+                if (argsToCheck.some(({ type }) => type === utils_1.AST_NODE_TYPES.SpreadElement)) {
+                    return;
+                }
+                if (!tsutils.isThenableType(checker, esTreeNodeToTSNodeMap.get(callee), checker.getTypeAtLocation(esTreeNodeToTSNodeMap.get(callee.object)))) {
+                    return;
+                }
+                // the `some` check above has already excluded `SpreadElement`, so we are safe to assert the same
+                const node = argsToCheck[argIndexToCheck];
+                if (shouldFlagArgument(node)) {
                     // We are now guaranteed to report, but we have a bit of work to do
                     // to determine exactly where, and whether we can fix it.
-                    const overrides = refineReportForNormalArgumentIfPossible(firstArgument);
+                    const overrides = refineReportIfPossible(node);
                     context.report({
-                        node: firstArgument,
+                        node,
                         messageId: 'useUnknown',
+                        data,
                         ...overrides,
@@ -274,16 +249,2 @@ });
 });
-/**
- * Answers whether the member expression looks like
- * `x.memberName`, `x['memberName']`,
- * or even `const mn = 'memberName'; x[mn]` (or optional variants thereof).
- */
-function isStaticMemberAccessOfValue(memberExpression, value, scope) {
-    if (!memberExpression.computed) {
-        // x.memberName case.
-        return memberExpression.property.name === value;
-    }
-    // x['memberName'] cases.
-    const staticValueResult = (0, util_1.getStaticValue)(memberExpression.property, scope);
-    return staticValueResult != null && value === staticValueResult.value;
-}
 //# sourceMappingURL=use-unknown-in-catch-callback-variable.js.map

dist/util/escapeRegExp.js

@@ -12,5 +12,5 @@ "use strict";
     return string && reHasRegExpChar.test(string)
-        ? string.replace(reRegExpChar, '\\$&')
+        ? string.replaceAll(reRegExpChar, '\\$&')
         : string;
 }
 //# sourceMappingURL=escapeRegExp.js.map

dist/util/index.js

@@ -31,4 +31,6 @@ "use strict";
 __exportStar(require("./isNullLiteral"), exports);
+__exportStar(require("./isStartOfExpressionStatement"), exports);
 __exportStar(require("./isUndefinedIdentifier"), exports);
 __exportStar(require("./misc"), exports);
+__exportStar(require("./needsPrecedingSemiColon"), exports);
 __exportStar(require("./objectIterators"), exports);
@@ -35,0 +37,0 @@ __exportStar(require("./scopeUtils"), exports);

package.json

 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.1.1-alpha.10",
+  "version": "8.1.1-alpha.11",
   "description": "TypeScript plugin for ESLint",
@@ -63,6 +63,6 @@ "files": [
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.1.1-alpha.10",
-    "@typescript-eslint/type-utils": "8.1.1-alpha.10",
-    "@typescript-eslint/utils": "8.1.1-alpha.10",
-    "@typescript-eslint/visitor-keys": "8.1.1-alpha.10",
+    "@typescript-eslint/scope-manager": "8.1.1-alpha.11",
+    "@typescript-eslint/type-utils": "8.1.1-alpha.11",
+    "@typescript-eslint/utils": "8.1.1-alpha.11",
+    "@typescript-eslint/visitor-keys": "8.1.1-alpha.11",
     "graphemer": "^1.4.0",
@@ -78,4 +78,4 @@ "ignore": "^5.3.1",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.1.1-alpha.10",
-    "@typescript-eslint/rule-tester": "8.1.1-alpha.10",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.1.1-alpha.11",
+    "@typescript-eslint/rule-tester": "8.1.1-alpha.11",
     "ajv": "^6.12.6",
@@ -82,0 +82,0 @@ "cross-env": "^7.0.3",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

2581476

increased by0.75%

Number of package files

532

increased by0.76%

Lines of code

29485

increased by0.74%

Dependency changes

• + Added@typescript-eslint/scope-manager@8.1.1-alpha.11(transitive)

• + Added@typescript-eslint/type-utils@8.1.1-alpha.11(transitive)

• + Added@typescript-eslint/types@8.1.1-alpha.11(transitive)

• + Added@typescript-eslint/typescript-estree@8.1.1-alpha.11(transitive)

• + Added@typescript-eslint/utils@8.1.1-alpha.11(transitive)

• + Added@typescript-eslint/visitor-keys@8.1.1-alpha.11(transitive)

• - Removed@typescript-eslint/scope-manager@8.1.1-alpha.10(transitive)

• - Removed@typescript-eslint/type-utils@8.1.1-alpha.10(transitive)

• - Removed@typescript-eslint/types@8.1.1-alpha.10(transitive)

• - Removed@typescript-eslint/typescript-estree@8.1.1-alpha.10(transitive)

• - Removed@typescript-eslint/utils@8.1.1-alpha.10(transitive)

• - Removed@typescript-eslint/visitor-keys@8.1.1-alpha.10(transitive)

• Updated@typescript-eslint/scope-manager@8.1.1-alpha.11

• Updated@typescript-eslint/type-utils@8.1.1-alpha.11

• Updated@typescript-eslint/utils@8.1.1-alpha.11

• Updated@typescript-eslint/visitor-keys@8.1.1-alpha.11