robojerk/codeql-action

Update checked-in dependencies

Browse source
This commit is contained in:
github-actions[bot] 2025-05-12 18:01:08 +00:00
parent d5e9ae3f8b
commit 3d97729508
174 changed files with 5012 additions and 828 deletions
Download patch file Download diff file Expand all files Collapse all files

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts generated vendored
View file

@ -89,6 +89,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-type-arguments': "error";
'@typescript-eslint/no-unnecessary-type-assertion': "error";
'@typescript-eslint/no-unnecessary-type-constraint': "error";
'@typescript-eslint/no-unnecessary-type-conversion': "error";
'@typescript-eslint/no-unnecessary-type-parameters': "error";
'@typescript-eslint/no-unsafe-argument': "error";
'@typescript-eslint/no-unsafe-assignment': "error";

2
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAyJiC"}
{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA0JiC"}

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js generated vendored
View file

@ -96,6 +96,7 @@ module.exports = {
'@typescript-eslint/no-unnecessary-type-arguments': 'error',
'@typescript-eslint/no-unnecessary-type-assertion': 'error',
'@typescript-eslint/no-unnecessary-type-constraint': 'error',
'@typescript-eslint/no-unnecessary-type-conversion': 'error',
'@typescript-eslint/no-unnecessary-type-parameters': 'error',
'@typescript-eslint/no-unsafe-argument': 'error',
'@typescript-eslint/no-unsafe-assignment': 'error',

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts generated vendored
View file

@ -29,6 +29,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-template-expression': "off";
'@typescript-eslint/no-unnecessary-type-arguments': "off";
'@typescript-eslint/no-unnecessary-type-assertion': "off";
'@typescript-eslint/no-unnecessary-type-conversion': "off";
'@typescript-eslint/no-unnecessary-type-parameters': "off";
'@typescript-eslint/no-unsafe-argument': "off";
'@typescript-eslint/no-unsafe-assignment': "off";

2
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA8DiC"}
{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA+DiC"}

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js generated vendored
View file

@ -32,6 +32,7 @@ module.exports = {
'@typescript-eslint/no-unnecessary-template-expression': 'off',
'@typescript-eslint/no-unnecessary-type-arguments': 'off',
'@typescript-eslint/no-unnecessary-type-assertion': 'off',
'@typescript-eslint/no-unnecessary-type-conversion': 'off',
'@typescript-eslint/no-unnecessary-type-parameters': 'off',
'@typescript-eslint/no-unsafe-argument': 'off',
'@typescript-eslint/no-unsafe-assignment': 'off',

2
node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAiKE"}
{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAkKE"}

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js generated vendored
View file

@ -109,6 +109,7 @@ exports.default = (plugin, parser) => [
'@typescript-eslint/no-unnecessary-type-arguments': 'error',
'@typescript-eslint/no-unnecessary-type-assertion': 'error',
'@typescript-eslint/no-unnecessary-type-constraint': 'error',
'@typescript-eslint/no-unnecessary-type-conversion': 'error',
'@typescript-eslint/no-unnecessary-type-parameters': 'error',
'@typescript-eslint/no-unsafe-argument': 'error',
'@typescript-eslint/no-unsafe-assignment': 'error',

2
node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAoEG"}
{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAqEG"}

1
node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js generated vendored
View file

@ -37,6 +37,7 @@ exports.default = (_plugin, _parser) => ({
'@typescript-eslint/no-unnecessary-template-expression': 'off',
'@typescript-eslint/no-unnecessary-type-arguments': 'off',
'@typescript-eslint/no-unnecessary-type-assertion': 'off',
'@typescript-eslint/no-unnecessary-type-conversion': 'off',
'@typescript-eslint/no-unnecessary-type-parameters': 'off',
'@typescript-eslint/no-unsafe-argument': 'off',
'@typescript-eslint/no-unsafe-assignment': 'off',

3
node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts generated vendored
View file

@ -91,6 +91,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-type-arguments': "error";
'@typescript-eslint/no-unnecessary-type-assertion': "error";
'@typescript-eslint/no-unnecessary-type-constraint': "error";
'@typescript-eslint/no-unnecessary-type-conversion': "error";
'@typescript-eslint/no-unnecessary-type-parameters': "error";
'@typescript-eslint/no-unsafe-argument': "error";
'@typescript-eslint/no-unsafe-assignment': "error";
@ -192,6 +193,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-template-expression': "off";
'@typescript-eslint/no-unnecessary-type-arguments': "off";
'@typescript-eslint/no-unnecessary-type-assertion': "off";
'@typescript-eslint/no-unnecessary-type-conversion': "off";
'@typescript-eslint/no-unnecessary-type-parameters': "off";
'@typescript-eslint/no-unsafe-argument': "off";
'@typescript-eslint/no-unsafe-assignment': "off";
@ -774,6 +776,7 @@ declare const _default: {
'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

2
node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}

3
node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts generated vendored
View file

@ -113,6 +113,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-type-arguments': "error";
'@typescript-eslint/no-unnecessary-type-assertion': "error";
'@typescript-eslint/no-unnecessary-type-constraint': "error";
'@typescript-eslint/no-unnecessary-type-conversion': "error";
'@typescript-eslint/no-unnecessary-type-parameters': "error";
'@typescript-eslint/no-unsafe-argument': "error";
'@typescript-eslint/no-unsafe-assignment': "error";
@ -214,6 +215,7 @@ declare const _default: {
'@typescript-eslint/no-unnecessary-template-expression': "off";
'@typescript-eslint/no-unnecessary-type-arguments': "off";
'@typescript-eslint/no-unnecessary-type-assertion': "off";
'@typescript-eslint/no-unnecessary-type-conversion': "off";
'@typescript-eslint/no-unnecessary-type-parameters': "off";
'@typescript-eslint/no-unsafe-argument': "off";
'@typescript-eslint/no-unsafe-assignment': "off";
@ -797,6 +799,7 @@ declare const _default: {
'no-unnecessary-type-arguments': TSESLint.RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unnecessary-type-assertion': TSESLint.RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unnecessary-type-constraint': TSESLint.RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unnecessary-type-conversion': TSESLint.RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unnecessary-type-parameters': TSESLint.RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unsafe-argument': TSESLint.RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
'no-unsafe-assignment': TSESLint.RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

2
node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}
{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js generated vendored
View file

@ -50,7 +50,7 @@ exports.default = (0, util_1.createRule)({
return {
...(0, util_1.getNameFromMember)(member, context.sourceCode),
callSignature: false,
static: !!member.static,
static: member.static,
};
case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration:
return {

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js generated vendored
View file

@ -87,7 +87,7 @@ exports.default = (0, util_1.createRule)({
return;
}
const hasAsyncIteratorSymbol = tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncIterator', checker) != null);
if (!hasAsyncIteratorSymbol) {
context.report({
@ -118,7 +118,7 @@ exports.default = (0, util_1.createRule)({
continue;
}
const hasAsyncDisposeSymbol = tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncDispose', checker) != null);
if (!hasAsyncDisposeSymbol) {
context.report({

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"consistent-indexed-object-style.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-indexed-object-style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,gCAAgC,GAChC,cAAc,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,iBAAiB,GAAG,QAAQ,CAAC,CAAC;;AAErD,wBA4OG"}
{"version":3,"file":"consistent-indexed-object-style.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-indexed-object-style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,gCAAgC,GAChC,cAAc,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,iBAAiB,GAAG,QAAQ,CAAC,CAAC;;AAErD,wBA2OG"}

13
node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.js generated vendored
View file

@ -139,9 +139,7 @@ exports.default = (0, util_1.createRule)({
const scope = context.sourceCode.getScope(key);
const superVar = utils_1.ASTUtils.findVariable(scope, parentId.name);
if (superVar) {
const isCircular = superVar.references.some(item => item.isTypeReference &&
node.range[0] <= item.identifier.range[0] &&
node.range[1] >= item.identifier.range[1]);
const isCircular = isDeeplyReferencingType(node.parent, superVar, new Set([parentId]));
if (isCircular) {
return;
}
@ -155,7 +153,9 @@ exports.default = (0, util_1.createRule)({
...(canFix && {
fix: (fixer) => {
const keyType = context.sourceCode.getText(constraint);
const valueType = context.sourceCode.getText(node.typeAnnotation);
const valueType = node.typeAnnotation
? context.sourceCode.getText(node.typeAnnotation)
: 'any';
let recordText = `Record<${keyType}, ${valueType}>`;
if (node.optional === '+' || node.optional === true) {
recordText = `Partial<${recordText}>`;
@ -201,6 +201,11 @@ function isDeeplyReferencingType(node, superVar, visited) {
return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
return [node.indexType, node.objectType].some(type => isDeeplyReferencingType(type, superVar, visited));
case utils_1.AST_NODE_TYPES.TSMappedType:
if (node.typeAnnotation) {
return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
}
break;
case utils_1.AST_NODE_TYPES.TSConditionalType:
return [
node.checkType,

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.js generated vendored
View file

@ -66,7 +66,7 @@ function getBaseEnumType(typeChecker, type) {
*/
function getEnumLiterals(type) {
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral));
}
/**

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js generated vendored
View file

@ -116,13 +116,13 @@ exports.default = (0, util_1.createRule)({
}
}
}
if (!!funcName && !!options.allowedNames.includes(funcName)) {
if (!!funcName && options.allowedNames.includes(funcName)) {
return true;
}
}
if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
node.id &&
!!options.allowedNames.includes(node.id.name)) {
options.allowedNames.includes(node.id.name)) {
return true;
}
return false;

1
node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts generated vendored
View file

@ -107,6 +107,7 @@ declare const rules: {
'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-type-assertion").MessageIds, import("./no-unnecessary-type-assertion").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-argument").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAqIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAsIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.js generated vendored
View file

@ -77,6 +77,7 @@ const no_unnecessary_template_expression_1 = __importDefault(require("./no-unnec
const no_unnecessary_type_arguments_1 = __importDefault(require("./no-unnecessary-type-arguments"));
const no_unnecessary_type_assertion_1 = __importDefault(require("./no-unnecessary-type-assertion"));
const no_unnecessary_type_constraint_1 = __importDefault(require("./no-unnecessary-type-constraint"));
const no_unnecessary_type_conversion_1 = __importDefault(require("./no-unnecessary-type-conversion"));
const no_unnecessary_type_parameters_1 = __importDefault(require("./no-unnecessary-type-parameters"));
const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument"));
const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment"));
@ -208,6 +209,7 @@ const rules = {
'no-unnecessary-type-arguments': no_unnecessary_type_arguments_1.default,
'no-unnecessary-type-assertion': no_unnecessary_type_assertion_1.default,
'no-unnecessary-type-constraint': no_unnecessary_type_constraint_1.default,
'no-unnecessary-type-conversion': no_unnecessary_type_conversion_1.default,
'no-unnecessary-type-parameters': no_unnecessary_type_parameters_1.default,
'no-unsafe-argument': no_unsafe_argument_1.default,
'no-unsafe-assignment': no_unsafe_assignment_1.default,

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.js generated vendored
View file

@ -326,7 +326,7 @@ function isMemberOptional(node) {
case utils_1.AST_NODE_TYPES.PropertyDefinition:
case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
case utils_1.AST_NODE_TYPES.MethodDefinition:
return !!node.optional;
return node.optional;
}
return false;
}

6
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.js generated vendored
View file

@ -327,7 +327,7 @@ exports.default = (0, util_1.createRule)({
return callSignatures.some(signature => {
const returnType = signature.getReturnType();
return tsutils
.unionTypeParts(returnType)
.unionConstituents(returnType)
.some(tsutils.isIntrinsicVoidType);
});
}
@ -342,14 +342,14 @@ exports.default = (0, util_1.createRule)({
if (functionTSNode.type) {
const returnType = checker.getTypeFromTypeNode(functionTSNode.type);
return tsutils
.unionTypeParts(returnType)
.unionConstituents(returnType)
.some(tsutils.isIntrinsicVoidType);
}
if (ts.isExpression(functionTSNode)) {
const functionType = checker.getContextualType(functionTSNode);
if (functionType) {
return tsutils
.unionTypeParts(functionType)
.unionConstituents(functionType)
.some(isFunctionReturnTypeIncludesVoid);
}
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"no-deprecated.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgBpD,KAAK,UAAU,GAAG,YAAY,GAAG,sBAAsB,CAAC;AAExD,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAChC;CACF,CAAC;;AAEF,wBA0XG"}
{"version":3,"file":"no-deprecated.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgBpD,KAAK,UAAU,GAAG,YAAY,GAAG,sBAAsB,CAAC;AAExD,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAChC;CACF,CAAC;;AAEF,wBAmaG"}

33
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.js generated vendored
View file

@ -318,6 +318,38 @@ exports.default = (0, util_1.createRule)({
node,
});
}
function checkMemberExpression(node) {
if (!node.computed) {
return;
}
const propertyType = services.getTypeAtLocation(node.property);
if (propertyType.isLiteral()) {
const objectType = services.getTypeAtLocation(node.object);
const propertyName = propertyType.isStringLiteral()
? propertyType.value
: String(propertyType.value);
const property = objectType.getProperty(propertyName);
const reason = getJsDocDeprecation(property);
if (reason == null) {
return;
}
if ((0, util_1.typeMatchesSomeSpecifier)(objectType, allow, services.program)) {
return;
}
context.report({
...(reason
? {
messageId: 'deprecatedWithReason',
data: { name: propertyName, reason },
}
: {
messageId: 'deprecated',
data: { name: propertyName },
}),
node: node.property,
});
}
}
return {
Identifier: checkIdentifier,
JSXIdentifier(node) {
@ -325,6 +357,7 @@ exports.default = (0, util_1.createRule)({
checkIdentifier(node);
}
},
MemberExpression: checkMemberExpression,
PrivateIdentifier: checkIdentifier,
Super: checkIdentifier,
};

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.js generated vendored
View file

@ -39,10 +39,10 @@ exports.default = (0, util_1.createRule)({
}
let value;
if (isStringLiteral(member.initializer)) {
value = String(member.initializer.value);
value = member.initializer.value;
}
else if (isNumberLiteral(member.initializer)) {
value = Number(member.initializer.value);
value = member.initializer.value;
}
else if (isStaticTemplateLiteral(member.initializer)) {
value = member.initializer.quasis[0].value.cooked;

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAmHG"}
{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAkHG"}

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.js generated vendored
View file

@ -75,9 +75,9 @@ exports.default = (0, util_1.createRule)({
const mergedWithClassDeclaration = scope.set
.get(node.id.name)
?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
const isInAmbientDeclaration = !!((0, util_1.isDefinitionFile)(context.filename) &&
const isInAmbientDeclaration = (0, util_1.isDefinitionFile)(context.filename) &&
scope.type === scope_manager_1.ScopeType.tsModule &&
scope.block.declare);
scope.block.declare;
const useAutoFix = !(isInAmbientDeclaration || mergedWithClassDeclaration);
context.report({
node: node.id,

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAkaG"}
{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmBpD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAqZG"}

42
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.js generated vendored
View file

@ -37,6 +37,7 @@ const utils_1 = require("@typescript-eslint/utils");
const tsutils = __importStar(require("ts-api-utils"));
const ts = __importStar(require("typescript"));
const util_1 = require("../util");
const promiseUtils_1 = require("../util/promiseUtils");
const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
const messageBaseVoid = 'Promises must be awaited, end with a call to .catch, end with a call to .then with a rejection handler' +
' or be explicitly marked as ignored with the `void` operator.';
@ -256,33 +257,20 @@ exports.default = (0, util_1.createRule)({
if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
// If the outer expression is a call, a `.catch()` or `.then()` with
// rejection handler handles the promise.
const { callee } = node;
if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
const methodName = (0, util_1.getStaticMemberAccessValue)(callee, context);
const catchRejectionHandler = methodName === 'catch' && node.arguments.length >= 1
? node.arguments[0]
: undefined;
if (catchRejectionHandler) {
if (isValidRejectionHandler(catchRejectionHandler)) {
const promiseHandlingMethodCall = (0, promiseUtils_1.parseCatchCall)(node, context) ?? (0, promiseUtils_1.parseThenCall)(node, context);
if (promiseHandlingMethodCall != null) {
const onRejected = promiseHandlingMethodCall.onRejected;
if (onRejected != null) {
if (isValidRejectionHandler(onRejected)) {
return { isUnhandled: false };
}
return { isUnhandled: true, nonFunctionHandler: true };
}
const thenRejectionHandler = methodName === 'then' && node.arguments.length >= 2
? node.arguments[1]
: undefined;
if (thenRejectionHandler) {
if (isValidRejectionHandler(thenRejectionHandler)) {
return { isUnhandled: false };
}
return { isUnhandled: true, nonFunctionHandler: true };
}
// `x.finally()` is transparent to resolution of the promise, so check `x`.
// ("object" in this context is the `x` in `x.finally()`)
const promiseFinallyObject = methodName === 'finally' ? callee.object : undefined;
if (promiseFinallyObject) {
return isUnhandledPromise(checker, promiseFinallyObject);
}
return { isUnhandled: true };
}
const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context);
if (promiseFinallyCall != null) {
return isUnhandledPromise(checker, promiseFinallyCall.object);
}
// All other cases are unhandled.
return { isUnhandled: true };
@ -309,7 +297,7 @@ exports.default = (0, util_1.createRule)({
function isPromiseArray(node) {
const type = checker.getTypeAtLocation(node);
for (const ty of tsutils
.unionTypeParts(type)
.unionConstituents(type)
.map(t => checker.getApparentType(t))) {
if (checker.isArrayType(ty)) {
const arrayType = checker.getTypeArguments(ty)[0];
@ -334,7 +322,7 @@ exports.default = (0, util_1.createRule)({
return false;
}
// Otherwise, we always consider the built-in Promise to be Promise-like...
const typeParts = tsutils.unionTypeParts(checker.getApparentType(type));
const typeParts = tsutils.unionConstituents(checker.getApparentType(type));
if (typeParts.some(typePart => (0, util_1.isBuiltinSymbolLike)(services.program, typePart, 'Promise'))) {
return true;
}
@ -363,7 +351,7 @@ exports.default = (0, util_1.createRule)({
},
});
function hasMatchingSignature(type, matcher) {
for (const t of tsutils.unionTypeParts(type)) {
for (const t of tsutils.unionConstituents(type)) {
if (t.getCallSignatures().some(matcher)) {
return true;
}
@ -372,7 +360,7 @@ function hasMatchingSignature(type, matcher) {
}
function isFunctionParam(checker, param, node) {
const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
for (const t of tsutils.unionTypeParts(type)) {
for (const t of tsutils.unionConstituents(type)) {
if (t.getCallSignatures().length !== 0) {
return true;
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js generated vendored
View file

@ -79,7 +79,7 @@ exports.default = (0, util_1.createRule)({
]);
};
const argType = services.getTypeAtLocation(node.argument);
const unionParts = tsutils.unionTypeParts(argType);
const unionParts = tsutils.unionConstituents(argType);
if (unionParts.every(part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
context.report({
node,

16
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js generated vendored
View file

@ -551,7 +551,7 @@ exports.default = (0, util_1.createRule)({
});
function isSometimesThenable(checker, node) {
const type = checker.getTypeAtLocation(node);
for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
if (tsutils.isThenableType(checker, node, subType)) {
return true;
}
@ -564,7 +564,7 @@ function isSometimesThenable(checker, node) {
// branches is thenable.
function isAlwaysThenable(checker, node) {
const type = checker.getTypeAtLocation(node);
for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
const thenProp = subType.getProperty('then');
// If one of the alternates has no then property, it is not thenable in all
// cases.
@ -576,7 +576,7 @@ function isAlwaysThenable(checker, node) {
// be of the right form to consider it thenable.
const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
let hasThenableSignature = false;
for (const subType of tsutils.unionTypeParts(thenType)) {
for (const subType of tsutils.unionConstituents(thenType)) {
for (const signature of subType.getCallSignatures()) {
if (signature.parameters.length !== 0 &&
isFunctionParam(checker, signature.parameters[0], node)) {
@ -602,7 +602,7 @@ function isAlwaysThenable(checker, node) {
}
function isFunctionParam(checker, param, node) {
const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
for (const subType of tsutils.unionTypeParts(type)) {
for (const subType of tsutils.unionConstituents(type)) {
if (subType.getCallSignatures().length !== 0) {
return true;
}
@ -641,7 +641,7 @@ function voidFunctionArguments(checker, node) {
const type = checker.getTypeAtLocation(node.expression);
// We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
// See https://github.com/microsoft/TypeScript/issues/48077
for (const subType of tsutils.unionTypeParts(type)) {
for (const subType of tsutils.unionConstituents(type)) {
// Standard function calls and `new` have two different types of signatures
const signatures = ts.isCallExpression(node)
? subType.getCallSignatures()
@ -698,7 +698,7 @@ function anySignatureIsThenableType(checker, node, type) {
* @returns Whether type is a thenable-returning function.
*/
function isThenableReturningFunctionType(checker, node, type) {
for (const subType of tsutils.unionTypeParts(type)) {
for (const subType of tsutils.unionConstituents(type)) {
if (anySignatureIsThenableType(checker, node, subType)) {
return true;
}
@ -710,7 +710,7 @@ function isThenableReturningFunctionType(checker, node, type) {
*/
function isVoidReturningFunctionType(checker, node, type) {
let hadVoidReturn = false;
for (const subType of tsutils.unionTypeParts(type)) {
for (const subType of tsutils.unionConstituents(type)) {
for (const signature of subType.getCallSignatures()) {
const returnType = signature.getReturnType();
// If a certain positional argument accepts both thenable and void returns,
@ -729,7 +729,7 @@ function isVoidReturningFunctionType(checker, node, type) {
function returnsThenable(checker, node) {
const type = checker.getApparentType(checker.getTypeAtLocation(node));
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(t => anySignatureIsThenableType(checker, node, t));
}
function getHeritageTypes(checker, tsNode) {

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js generated vendored
View file

@ -97,7 +97,7 @@ exports.default = (0, util_1.createRule)({
}
}
function getMapSpreadSuggestions(node, type) {
const types = tsutils.unionTypeParts(type);
const types = tsutils.unionConstituents(type);
if (types.some(t => !isMap(services.program, t))) {
return null;
}
@ -208,7 +208,7 @@ exports.default = (0, util_1.createRule)({
});
function isIterable(type, checker) {
return tsutils
.typeParts(type)
.typeConstituents(type)
.some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker));
}
function isArray(checker, type) {

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js generated vendored
View file

@ -156,7 +156,7 @@ function describeLiteralTypeNode(typeNode) {
return 'literal type';
}
function isNodeInsideReturnType(node) {
return !!(node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
(0, util_1.isFunctionOrFunctionType)(node.parent.parent));
}
/**
@ -168,7 +168,7 @@ function unionTypePartsUnlessBoolean(type) {
tsutils.isFalseLiteralType(type.types[0]) &&
tsutils.isTrueLiteralType(type.types[1])
? [type]
: tsutils.unionTypeParts(type);
: tsutils.unionConstituents(type);
}
exports.default = (0, util_1.createRule)({
name: 'no-redundant-type-constituents',

10
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js generated vendored
View file

@ -44,14 +44,14 @@ function isNullishType(type) {
return tsutils.isTypeFlagSet(type, nullishFlag);
}
function isAlwaysNullish(type) {
return tsutils.unionTypeParts(type).every(isNullishType);
return tsutils.unionConstituents(type).every(isNullishType);
}
/**
* Note that this differs from {@link isNullableType} in that it doesn't consider
* `any` or `unknown` to be nullable.
*/
function isPossiblyNullish(type) {
return tsutils.unionTypeParts(type).some(isNullishType);
return tsutils.unionConstituents(type).some(isNullishType);
}
function toStaticValue(type) {
// type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
@ -198,13 +198,13 @@ exports.default = (0, util_1.createRule)({
function nodeIsArrayType(node) {
const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
return tsutils
.unionTypeParts(nodeType)
.unionConstituents(nodeType)
.some(part => checker.isArrayType(part));
}
function nodeIsTupleType(node) {
const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
return tsutils
.unionTypeParts(nodeType)
.unionConstituents(nodeType)
.some(part => checker.isTupleType(part));
}
function isArrayIndexExpression(node) {
@ -223,7 +223,7 @@ exports.default = (0, util_1.createRule)({
// `any` or `unknown` or a naked type variable
function isConditionalAlwaysNecessary(type) {
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(part => (0, util_1.isTypeAnyType)(part) ||
(0, util_1.isTypeUnknownType)(part) ||
(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable));

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAuB1D,wBAmbG"}
{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAqB1D,wBAgbG"}

6
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js generated vendored
View file

@ -43,7 +43,7 @@ const evenNumOfBackslashesRegExp = /(?<!(?:[^\\]|^)(?:\\\\)*\\)/;
// '\\\\$' <- true
// '\\\\\\$' <- false
function endsWithUnescapedDollarSign(str) {
return new RegExp(`${String(evenNumOfBackslashesRegExp.source)}\\$$`).test(str);
return new RegExp(`${evenNumOfBackslashesRegExp.source}\\$$`).test(str);
}
exports.default = (0, util_1.createRule)({
name: 'no-unnecessary-template-expression',
@ -77,7 +77,7 @@ exports.default = (0, util_1.createRule)({
return isStringLike(type);
}
function isEnumMemberType(type) {
return tsutils.typeParts(type).some(t => {
return tsutils.typeConstituents(type).some(t => {
const symbol = t.getSymbol();
return !!(symbol?.valueDeclaration && ts.isEnumMember(symbol.valueDeclaration));
});
@ -233,7 +233,7 @@ exports.default = (0, util_1.createRule)({
// \\` -> \\\`
// \${ -> \${
// \\${ -> \\\${
.replaceAll(new RegExp(`${String(evenNumOfBackslashesRegExp.source)}(\`|\\\${)`, 'g'), '\\$1');
.replaceAll(new RegExp(`${evenNumOfBackslashesRegExp.source}(\`|\\\${)`, 'g'), '\\$1');
// `...${'...$'}{...`
// ^^^^
if (nextCharacterIsOpeningCurlyBrace &&

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js generated vendored
View file

@ -171,10 +171,10 @@ exports.default = (0, util_1.createRule)({
(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
const uncastParts = tsutils
.unionTypeParts(uncast)
.unionConstituents(uncast)
.filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
const castParts = tsutils
.unionTypeParts(cast)
.unionConstituents(cast)
.filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
if (uncastParts.length !== castParts.length) {
return false;

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
type MessageIds = 'suggestRemove' | 'suggestSatisfies' | 'unnecessaryTypeConversion';
declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
export default _default;
//# sourceMappingURL=no-unnecessary-type-conversion.d.ts.map

1
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"no-unnecessary-type-conversion.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-conversion.ts"],"names":[],"mappings":"AAgBA,KAAK,UAAU,GACX,eAAe,GACf,kBAAkB,GAClB,2BAA2B,CAAC;;AAEhC,wBAqVG"}

306
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.js generated vendored Normal file
View file

@ -0,0 +1,306 @@
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("@typescript-eslint/utils");
const tsutils = __importStar(require("ts-api-utils"));
const ts = __importStar(require("typescript"));
const util_1 = require("../util");
exports.default = (0, util_1.createRule)({
name: 'no-unnecessary-type-conversion',
meta: {
type: 'suggestion',
docs: {
description: 'Disallow conversion idioms when they do not change the type or value of the expression',
requiresTypeChecking: true,
},
hasSuggestions: true,
messages: {
suggestRemove: 'Remove the type conversion.',
suggestSatisfies: 'Instead, assert that the value satisfies the {{type}} type.',
unnecessaryTypeConversion: '{{violation}} does not change the type or value of the {{type}}.',
},
schema: [],
},
defaultOptions: [],
create(context) {
function doesUnderlyingTypeMatchFlag(type, typeFlag) {
return tsutils
.unionConstituents(type)
.every(t => (0, util_1.isTypeFlagSet)(t, typeFlag));
}
const services = (0, util_1.getParserServices)(context);
function handleUnaryOperator(node, typeFlag, typeString, violation, isDoubleOperator) {
const outerNode = isDoubleOperator ? node.parent : node;
const type = services.getTypeAtLocation(node.argument);
if (doesUnderlyingTypeMatchFlag(type, typeFlag)) {
const wrappingFixerParams = {
node: outerNode,
innerNode: [node.argument],
sourceCode: context.sourceCode,
};
context.report({
loc: {
start: outerNode.loc.start,
end: {
column: node.loc.start.column + 1,
line: node.loc.start.line,
},
},
messageId: 'unnecessaryTypeConversion',
data: { type: typeString, violation },
suggest: [
{
messageId: 'suggestRemove',
fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: typeString },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies ${typeString}`,
}),
},
],
});
}
}
return {
'AssignmentExpression[operator = "+="]'(node) {
if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
node.right.value === '' &&
doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
const wrappingFixerParams = {
node,
innerNode: [node.left],
sourceCode: context.sourceCode,
};
context.report({
node,
messageId: 'unnecessaryTypeConversion',
data: {
type: 'string',
violation: "Concatenating a string with ''",
},
suggest: [
{
messageId: 'suggestRemove',
fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement
? (fixer) => [
fixer.removeRange([
node.parent.range[0],
node.parent.range[1],
]),
]
: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: 'string' },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies string`,
}),
},
],
});
}
},
'BinaryExpression[operator = "+"]'(node) {
if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
node.right.value === '' &&
doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
const wrappingFixerParams = {
node,
innerNode: [node.left],
sourceCode: context.sourceCode,
};
context.report({
loc: {
start: node.left.loc.end,
end: node.loc.end,
},
messageId: 'unnecessaryTypeConversion',
data: {
type: 'string',
violation: "Concatenating a string with ''",
},
suggest: [
{
messageId: 'suggestRemove',
fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: 'string' },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies string`,
}),
},
],
});
}
else if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
node.left.value === '' &&
doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.right), ts.TypeFlags.StringLike)) {
const wrappingFixerParams = {
node,
innerNode: [node.right],
sourceCode: context.sourceCode,
};
context.report({
loc: {
start: node.loc.start,
end: node.right.loc.start,
},
messageId: 'unnecessaryTypeConversion',
data: {
type: 'string',
violation: "Concatenating '' with a string",
},
suggest: [
{
messageId: 'suggestRemove',
fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: 'string' },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies string`,
}),
},
],
});
}
},
CallExpression(node) {
const nodeCallee = node.callee;
const builtInTypeFlags = {
BigInt: ts.TypeFlags.BigIntLike,
Boolean: ts.TypeFlags.BooleanLike,
Number: ts.TypeFlags.NumberLike,
String: ts.TypeFlags.StringLike,
};
if (nodeCallee.type !== utils_1.AST_NODE_TYPES.Identifier ||
!(nodeCallee.name in builtInTypeFlags)) {
return;
}
const typeFlag = builtInTypeFlags[nodeCallee.name];
const scope = context.sourceCode.getScope(node);
const variable = scope.set.get(nodeCallee.name);
if (!!variable?.defs.length ||
!doesUnderlyingTypeMatchFlag((0, util_1.getConstrainedTypeAtLocation)(services, node.arguments[0]), typeFlag)) {
return;
}
const wrappingFixerParams = {
node,
innerNode: [node.arguments[0]],
sourceCode: context.sourceCode,
};
const typeString = nodeCallee.name.toLowerCase();
context.report({
node: nodeCallee,
messageId: 'unnecessaryTypeConversion',
data: {
type: nodeCallee.name.toLowerCase(),
violation: `Passing a ${typeString} to ${nodeCallee.name}()`,
},
suggest: [
{
messageId: 'suggestRemove',
fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: typeString },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies ${typeString}`,
}),
},
],
});
},
'CallExpression > MemberExpression.callee > Identifier[name = "toString"].property'(node) {
const memberExpr = node.parent;
const type = (0, util_1.getConstrainedTypeAtLocation)(services, memberExpr.object);
if (doesUnderlyingTypeMatchFlag(type, ts.TypeFlags.StringLike)) {
const wrappingFixerParams = {
node: memberExpr.parent,
innerNode: [memberExpr.object],
sourceCode: context.sourceCode,
};
context.report({
loc: {
start: memberExpr.property.loc.start,
end: memberExpr.parent.loc.end,
},
messageId: 'unnecessaryTypeConversion',
data: {
type: 'string',
violation: "Calling a string's .toString() method",
},
suggest: [
{
messageId: 'suggestRemove',
fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
},
{
messageId: 'suggestSatisfies',
data: { type: 'string' },
fix: (0, util_1.getWrappingFixer)({
...wrappingFixerParams,
wrap: expr => `${expr} satisfies string`,
}),
},
],
});
}
},
'UnaryExpression[operator = "!"] > UnaryExpression[operator = "!"]'(node) {
handleUnaryOperator(node, ts.TypeFlags.BooleanLike, 'boolean', 'Using !! on a boolean', true);
},
'UnaryExpression[operator = "+"]'(node) {
handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using the unary + operator on a number', false);
},
'UnaryExpression[operator = "~"] > UnaryExpression[operator = "~"]'(node) {
handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using ~~ on a number', true);
},
};
},
});

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"no-unnecessary-type-parameters.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-parameters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAoBnE,wBAqLG"}
{"version":3,"file":"no-unnecessary-type-parameters.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-parameters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAqBnE,wBA0MG"}

23
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.js generated vendored
View file

@ -101,7 +101,28 @@ exports.default = (0, util_1.createRule)({
for (const reference of smTypeParameterVariable.references) {
if (reference.isTypeReference) {
const referenceNode = reference.identifier;
yield fixer.replaceText(referenceNode, constraintText);
const isComplexType = constraint?.type === utils_1.AST_NODE_TYPES.TSUnionType ||
constraint?.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
constraint?.type === utils_1.AST_NODE_TYPES.TSConditionalType;
const hasMatchingAncestorType = [
utils_1.AST_NODE_TYPES.TSArrayType,
utils_1.AST_NODE_TYPES.TSIndexedAccessType,
utils_1.AST_NODE_TYPES.TSIntersectionType,
utils_1.AST_NODE_TYPES.TSUnionType,
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
].some(type => referenceNode.parent.parent.type === type);
if (isComplexType && hasMatchingAncestorType) {
const fixResult = (0, util_1.getWrappingFixer)({
node: referenceNode,
innerNode: constraint,
sourceCode: context.sourceCode,
wrap: constraintNode => constraintNode,
})(fixer);
yield fixResult;
}
else {
yield fixer.replaceText(referenceNode, constraintText);
}
}
}
// ...and remove the type parameter itself from the declaration.

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.js generated vendored
View file

@ -168,7 +168,7 @@ exports.default = (0, util_1.createRule)({
}
else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
receiverProperty.key.quasis.length === 1) {
key = String(receiverProperty.key.quasis[0].value.cooked);
key = receiverProperty.key.quasis[0].value.cooked;
}
else {
// can't figure out the name, so skip it

8
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.js generated vendored
View file

@ -46,13 +46,13 @@ function typeViolates(leftTypeParts, rightType) {
(leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
}
function isNumberLike(type) {
const typeParts = tsutils.intersectionTypeParts(type);
const typeParts = tsutils.intersectionConstituents(type);
return typeParts.some(typePart => {
return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike);
});
}
function isStringLike(type) {
const typeParts = tsutils.intersectionTypeParts(type);
const typeParts = tsutils.intersectionConstituents(type);
return typeParts.some(typePart => {
return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.String | ts.TypeFlags.StringLike);
});
@ -116,8 +116,8 @@ exports.default = (0, util_1.createRule)({
// declare const something: Fruit | Vegetable;
// something === Fruit.Apple;
// ```
const leftTypeParts = tsutils.unionTypeParts(leftType);
const rightTypeParts = tsutils.unionTypeParts(rightType);
const leftTypeParts = tsutils.unionConstituents(leftType);
const rightTypeParts = tsutils.unionConstituents(rightType);
// If a type exists in both sides, we consider this comparison safe:
//
// ```ts

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.js generated vendored
View file

@ -61,7 +61,7 @@ exports.default = util.createRule({
const argType = util.getConstrainedTypeAtLocation(services, node.argument);
const checker = services.program.getTypeChecker();
if (tsutils
.unionTypeParts(argType)
.unionConstituents(argType)
.some(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Any |
ts.TypeFlags.Never |
ts.TypeFlags.BigIntLike |

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.js generated vendored
View file

@ -60,7 +60,7 @@ exports.default = (0, util_1.createRule)({
if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
return undefined;
}
return tsutils.unionTypeParts(type);
return tsutils.unionConstituents(type);
};
const couldBeNullish = (type) => {
if (type.flags & ts.TypeFlags.TypeParameter) {

1
node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts generated vendored
View file

@ -3,6 +3,7 @@ export type MessageIds = 'object' | 'undef';
export type Options = [
{
allow?: TypeOrValueSpecifier[];
allowRethrowing?: boolean;
allowThrowingAny?: boolean;
allowThrowingUnknown?: boolean;
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAYpD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBAuFG"}
{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBA4JG"}

47
node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.js generated vendored
View file

@ -34,8 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
})();
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("@typescript-eslint/utils");
const ts_api_utils_1 = require("ts-api-utils");
const ts = __importStar(require("typescript"));
const util_1 = require("../util");
const promiseUtils_1 = require("../util/promiseUtils");
exports.default = (0, util_1.createRule)({
name: 'only-throw-error',
meta: {
@ -59,6 +61,10 @@ exports.default = (0, util_1.createRule)({
...util_1.typeOrValueSpecifiersSchema,
description: 'Type specifiers that can be thrown.',
},
allowRethrowing: {
type: 'boolean',
description: 'Whether to allow rethrowing caught values that are not `Error` objects.',
},
allowThrowingAny: {
type: 'boolean',
description: 'Whether to always allow throwing values typed as `any`.',
@ -74,6 +80,7 @@ exports.default = (0, util_1.createRule)({
defaultOptions: [
{
allow: [],
allowRethrowing: true,
allowThrowingAny: true,
allowThrowingUnknown: true,
},
@ -81,11 +88,51 @@ exports.default = (0, util_1.createRule)({
create(context, [options]) {
const services = (0, util_1.getParserServices)(context);
const allow = options.allow;
function isRethrownError(node) {
if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
return false;
}
const scope = context.sourceCode.getScope(node);
const smVariable = (0, util_1.nullThrows)((0, util_1.findVariable)(scope, node), `Variable ${node.name} should exist in scope manager`);
const variableDefinitions = smVariable.defs.filter(def => def.isVariableDefinition);
if (variableDefinitions.length !== 1) {
return false;
}
const def = smVariable.defs[0];
// try { /* ... */ } catch (x) { throw x; }
if (def.node.type === utils_1.AST_NODE_TYPES.CatchClause) {
return true;
}
// promise.catch(x => { throw x; })
// promise.then(onFulfilled, x => { throw x; })
if (def.node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
def.node.params.length >= 1 &&
def.node.params[0] === def.name &&
def.node.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
const callExpression = def.node.parent;
const parsedPromiseHandlingCall = (0, promiseUtils_1.parseCatchCall)(callExpression, context) ??
(0, promiseUtils_1.parseThenCall)(callExpression, context);
if (parsedPromiseHandlingCall != null) {
const { object, onRejected } = parsedPromiseHandlingCall;
if (onRejected === def.node) {
const tsObjectNode = services.esTreeNodeToTSNodeMap.get(object);
// make sure we're actually dealing with a promise
if ((0, ts_api_utils_1.isThenableType)(services.program.getTypeChecker(), tsObjectNode)) {
return true;
}
}
}
}
return false;
}
function checkThrowArgument(node) {
if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression ||
node.type === utils_1.AST_NODE_TYPES.YieldExpression) {
return;
}
if (options.allowRethrowing && isRethrownError(node)) {
return;
}
const type = services.getTypeAtLocation(node);
if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program)) {
return;

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.js generated vendored
View file

@ -109,7 +109,7 @@ exports.default = (0, util_1.createRule)({
*/
function isArrayish(type) {
let isAtLeastOneArrayishComponent = false;
for (const unionPart of tsutils.unionTypeParts(type)) {
for (const unionPart of tsutils.unionConstituents(type)) {
if (tsutils.isIntrinsicNullType(unionPart) ||
tsutils.isIntrinsicUndefinedType(unionPart)) {
continue;
@ -117,7 +117,7 @@ exports.default = (0, util_1.createRule)({
// apparently checker.isArrayType(T[] & S[]) => false.
// so we need to check the intersection parts individually.
const isArrayOrIntersectionThereof = tsutils
.intersectionTypeParts(unionPart)
.intersectionConstituents(unionPart)
.every(intersectionPart => checker.isArrayType(intersectionPart) ||
checker.isTupleType(intersectionPart));
if (!isArrayOrIntersectionThereof) {

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAqCnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,6BAA6B,GAC7B,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA8jBG"}
{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAyCnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,6BAA6B,GAC7B,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA+kBG"}

14
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.js generated vendored
View file

@ -37,6 +37,7 @@ const utils_1 = require("@typescript-eslint/utils");
const tsutils = __importStar(require("ts-api-utils"));
const ts = __importStar(require("typescript"));
const util_1 = require("../util");
const getWrappedCode_1 = require("../util/getWrappedCode");
const isMemberAccessLike = (0, util_1.isNodeOfTypes)([
utils_1.AST_NODE_TYPES.ChainExpression,
utils_1.AST_NODE_TYPES.Identifier,
@ -194,9 +195,9 @@ exports.default = (0, util_1.createRule)({
return false;
}
if (tsutils
.typeParts(type)
.typeConstituents(type)
.some(t => tsutils
.intersectionTypeParts(t)
.intersectionConstituents(t)
.some(t => tsutils.isTypeFlagSet(t, ignorableFlags)))) {
return false;
}
@ -354,7 +355,8 @@ exports.default = (0, util_1.createRule)({
if (operator == null) {
return;
}
const nullishCoalescingParams = getNullishCoalescingParams(node, getBranchNodes(node, operator).nonNullishBranch, nodesInsideTestExpression, operator);
const { nonNullishBranch, nullishBranch } = getBranchNodes(node, operator);
const nullishCoalescingParams = getNullishCoalescingParams(node, nonNullishBranch, nodesInsideTestExpression, operator);
if (nullishCoalescingParams.isFixable) {
context.report({
node,
@ -366,7 +368,11 @@ exports.default = (0, util_1.createRule)({
messageId: 'suggestNullish',
data: { equals: '' },
fix(fixer) {
return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${(0, util_1.getTextWithParentheses)(context.sourceCode, getBranchNodes(node, operator).nullishBranch)}`);
const nullishBranchText = (0, util_1.getTextWithParentheses)(context.sourceCode, nullishBranch);
const rightOperandReplacement = (0, util_1.isParenthesized)(nullishBranch, context.sourceCode)
? nullishBranchText
: (0, getWrappedCode_1.getWrappedCode)(nullishBranchText, (0, util_1.getOperatorPrecedenceForNode)(nullishBranch), util_1.OperatorPrecedence.Coalesce);
return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${rightOperandReplacement}`);
},
},
],

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.js generated vendored
View file

@ -43,7 +43,7 @@ const compareNodes_1 = require("./compareNodes");
const gatherLogicalOperands_1 = require("./gatherLogicalOperands");
function includesType(parserServices, node, typeFlagIn) {
const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown;
const types = (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node));
const types = (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node));
for (const type of types) {
if ((0, util_1.isTypeFlagSet)(type, typeFlag)) {
return true;

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js generated vendored
View file

@ -39,7 +39,7 @@ const ts_api_utils_1 = require("ts-api-utils");
const ts = __importStar(require("typescript"));
function checkNullishAndReport(context, parserServices, { requireNullish }, maybeNullishNodes, descriptor) {
if (!requireNullish ||
maybeNullishNodes.some(node => (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
maybeNullishNodes.some(node => (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
context.report(descriptor);
}
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js generated vendored
View file

@ -72,7 +72,7 @@ var NullishComparisonType;
const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) {
const type = parserServices.getTypeAtLocation(node);
const types = (0, ts_api_utils_1.unionTypeParts)(type);
const types = (0, ts_api_utils_1.unionConstituents)(type);
if (disallowFalseyLiteral &&
/*
```

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.js generated vendored
View file

@ -56,9 +56,9 @@ exports.default = (0, util_1.createRule)({
const checker = services.program.getTypeChecker();
function isArrayType(type) {
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.every(unionPart => tsutils
.intersectionTypeParts(unionPart)
.intersectionConstituents(unionPart)
.every(t => checker.isArrayType(t) || checker.isTupleType(t)));
}
return {

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.js generated vendored
View file

@ -147,7 +147,7 @@ exports.default = (0, util_1.createRule)({
});
}
const argumentType = services.getTypeAtLocation(argumentNode);
const argumentTypes = collectArgumentTypes(tsutils.unionTypeParts(argumentType));
const argumentTypes = collectArgumentTypes(tsutils.unionConstituents(argumentType));
switch (argumentTypes) {
case ArgumentType.RegExp:
return context.report({

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.js generated vendored
View file

@ -73,7 +73,7 @@ exports.default = (0, util_1.createRule)({
}
function isThisSpecifiedInParameters(originalFunc) {
const firstArg = originalFunc.params.at(0);
return !!(firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
return (firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
}
function isFunctionReturningThis(originalFunc, originalClass) {
if (isThisSpecifiedInParameters(originalFunc)) {

8
node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js generated vendored
View file

@ -156,7 +156,7 @@ exports.default = (0, util_1.createRule)({
continue;
}
// RegExps also contain ts.TypeFlags.Any & ts.TypeFlags.Object
for (const subBaseType of tsutils.unionTypeParts(baseType)) {
for (const subBaseType of tsutils.unionConstituents(baseType)) {
const typeName = (0, util_1.getTypeName)(typeChecker, subBaseType);
if (typeName === 'RegExp'
? !allowRegExp ||
@ -221,11 +221,11 @@ exports.default = (0, util_1.createRule)({
});
function isDeeplyObjectType(type) {
return type.isIntersection()
? tsutils.intersectionTypeParts(type).every(tsutils.isObjectType)
: tsutils.unionTypeParts(type).every(tsutils.isObjectType);
? tsutils.intersectionConstituents(type).every(tsutils.isObjectType)
: tsutils.unionConstituents(type).every(tsutils.isObjectType);
}
function isTypeFlagSetInUnion(type, flag) {
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(subType => tsutils.isTypeFlagSet(subType, flag));
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAm/BG"}
{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAq/BG"}

6
node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js generated vendored
View file

@ -237,7 +237,7 @@ exports.default = (0, util_1.createRule)({
return type;
});
const flattenTypes = [
...new Set(returnTypes.flatMap(type => tsutils.unionTypeParts(type))),
...new Set(returnTypes.flatMap(type => tsutils.unionConstituents(type))),
];
const types = inspectVariantTypes(flattenTypes);
const reportType = determineReportType(types);
@ -774,7 +774,7 @@ exports.default = (0, util_1.createRule)({
*/
function checkNode(node) {
const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
const types = inspectVariantTypes(tsutils.unionTypeParts(type));
const types = inspectVariantTypes(tsutils.unionConstituents(type));
const reportType = determineReportType(types);
if (reportType != null) {
context.report({
@ -799,7 +799,7 @@ exports.default = (0, util_1.createRule)({
// If incoming type is either "true" or "false", there will be one type
// object with intrinsicName set accordingly
// If incoming type is boolean, there will be two type objects with
// intrinsicName set "true" and "false" each because of ts-api-utils.unionTypeParts()
// intrinsicName set "true" and "false" each because of ts-api-utils.unionConstituents()
if (booleans.length === 1) {
variantTypes.add(tsutils.isTrueLiteralType(booleans[0]) ? 'truthy boolean' : 'boolean');
}

8
node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js generated vendored
View file

@ -122,8 +122,8 @@ exports.default = (0, util_1.createRule)({
caseTypes.add(caseType);
}
const missingLiteralBranchTypes = [];
for (const unionPart of tsutils.unionTypeParts(discriminantType)) {
for (const intersectionPart of tsutils.intersectionTypeParts(unionPart)) {
for (const unionPart of tsutils.unionConstituents(discriminantType)) {
for (const intersectionPart of tsutils.intersectionConstituents(unionPart)) {
if (caseTypes.has(intersectionPart) ||
!isTypeLiteralLikeType(intersectionPart)) {
continue;
@ -284,8 +284,8 @@ function isTypeLiteralLikeType(type) {
*/
function doesTypeContainNonLiteralType(type) {
return tsutils
.unionTypeParts(type)
.unionConstituents(type)
.some(type => tsutils
.intersectionTypeParts(type)
.intersectionConstituents(type)
.every(subType => !isTypeLiteralLikeType(subType)));
}

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA0KG"}
{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA4KG"}

4
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js generated vendored
View file

@ -215,8 +215,8 @@ exports.default = (0, util_1.createRule)({
}
}
for (const intersectionPart of tsutils
.unionTypeParts(services.getTypeAtLocation(node))
.flatMap(unionPart => tsutils.intersectionTypeParts(unionPart))) {
.unionConstituents(services.getTypeAtLocation(node))
.flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
const reported = checkIfMethodAndReport(property.key, intersectionPart.getProperty(property.key.name));
if (reported) {
break;

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"unified-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/unified-signatures.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gCAAgC,CAAC,EAAE,OAAO,CAAC;QAC3C,iCAAiC,CAAC,EAAE,OAAO,CAAC;KAC7C;CACF,CAAC;;AAEF,wBAyiBG"}
{"version":3,"file":"unified-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/unified-signatures.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gCAAgC,CAAC,EAAE,OAAO,CAAC;QAC3C,iCAAiC,CAAC,EAAE,OAAO,CAAC;KAC7C;CACF,CAAC;;AAEF,wBA8kBG"}

27
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js generated vendored
View file

@ -147,6 +147,12 @@ exports.default = (0, util_1.createRule)({
}
/** Detect `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`. */
function signaturesDifferBySingleParameter(types1, types2) {
const firstParam1 = types1[0];
const firstParam2 = types2[0];
// exempt signatures with `this: void` from the rule
if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) {
return undefined;
}
const index = getIndexOfFirstDifference(types1, types2, parametersAreEqual);
if (index == null) {
return undefined;
@ -164,6 +170,16 @@ exports.default = (0, util_1.createRule)({
? { kind: 'single-parameter-difference', p0: a, p1: b }
: undefined;
}
function isThisParam(param) {
return (param != null &&
param.type === utils_1.AST_NODE_TYPES.Identifier &&
param.name === 'this');
}
function isThisVoidParam(param) {
return (isThisParam(param) &&
param.typeAnnotation?.typeAnnotation.type ===
utils_1.AST_NODE_TYPES.TSVoidKeyword);
}
/**
* Detect `a(): void` and `a(x: number): void`.
* Returns the parameter declaration (`x: number` in this example) that should be optional/rest, and overload it's a part of.
@ -175,6 +191,17 @@ exports.default = (0, util_1.createRule)({
const longer = sig1.length < sig2.length ? sig2 : sig1;
const shorter = sig1.length < sig2.length ? sig1 : sig2;
const shorterSig = sig1.length < sig2.length ? a : b;
const firstParam1 = sig1.at(0);
const firstParam2 = sig2.at(0);
// If one signature has explicit this type and another doesn't, they can't
// be unified.
if (isThisParam(firstParam1) !== isThisParam(firstParam2)) {
return undefined;
}
// exempt signatures with `this: void` from the rule
if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) {
return undefined;
}
// If one is has 2+ parameters more than the other, they must all be optional/rest.
// Differ by optional parameters: f() and f(x), f() and f(x, ?y, ...z)
// Not allowed: f() and f(x, y)

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js generated vendored
View file

@ -63,7 +63,7 @@ exports.default = (0, util_1.createRule)({
const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context);
const checker = program.getTypeChecker();
function isFlaggableHandlerType(type) {
for (const unionPart of tsutils.unionTypeParts(type)) {
for (const unionPart of tsutils.unionConstituents(type)) {
const callSignatures = tsutils.getCallSignaturesOfType(unionPart);
if (callSignatures.length === 0) {
// Ignore any non-function components to the type. Those are not this rule's problem.

8
node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts generated vendored
View file

@ -16,13 +16,13 @@ interface WrappingFixerParams {
* Receives multiple arguments if there are multiple innerNodes.
* E.g. ``code => `${code} != null` ``
*/
wrap: (...code: string[]) => string;
wrap?: (...code: string[]) => string;
}
/**
* Wraps node with some code. Adds parenthesis as necessary.
* Wraps node with some code. Adds parentheses as necessary.
* @returns Fixer which adds the specified code and parens if necessary.
*/
export declare function getWrappingFixer(params: WrappingFixerParams): TSESLint.ReportFixFunction;
export declare function getWrappingFixer(params: WrappingFixerParams): (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix;
/**
* If the node to be moved and the destination node require parentheses, include parentheses in the node to be moved.
* @param sourceCode Source code of current file
@ -36,7 +36,7 @@ export declare function getMovedNodeCode(params: {
sourceCode: Readonly<TSESLint.SourceCode>;
}): string;
/**
* Check if a node will always have the same precedence if it's parent changes.
* Check if a node will always have the same precedence if its parent changes.
*/
export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;
export {};

2
node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,QAAQ,CAAC,iBAAiB,CA2C5B;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}
{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,KAAK,QAAQ,CAAC,OAAO,CA+CjD;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}

7
node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.js generated vendored
View file

@ -5,7 +5,7 @@ exports.getMovedNodeCode = getMovedNodeCode;
exports.isStrongPrecedenceNode = isStrongPrecedenceNode;
const utils_1 = require("@typescript-eslint/utils");
/**
* Wraps node with some code. Adds parenthesis as necessary.
* Wraps node with some code. Adds parentheses as necessary.
* @returns Fixer which adds the specified code and parens if necessary.
*/
function getWrappingFixer(params) {
@ -25,6 +25,9 @@ function getWrappingFixer(params) {
}
return code;
});
if (!wrap) {
return fixer.replaceText(node, innerCodes.join(''));
}
// do the wrapping
let code = wrap(...innerCodes);
// check the outer expression's precedence
@ -63,7 +66,7 @@ function getMovedNodeCode(params) {
return `(${code})`;
}
/**
* Check if a node will always have the same precedence if it's parent changes.
* Check if a node will always have the same precedence if its parent changes.
*/
function isStrongPrecedenceNode(innerNode) {
return (innerNode.type === utils_1.AST_NODE_TYPES.Literal ||

4
node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.js generated vendored
View file

@ -58,7 +58,7 @@ function isArrayMethodCallWithPredicate(context, services, node) {
const checker = services.program.getTypeChecker();
const type = (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object);
return tsutils
.unionTypeParts(type)
.flatMap(part => tsutils.intersectionTypeParts(part))
.unionConstituents(type)
.flatMap(part => tsutils.intersectionConstituents(part))
.some(t => checker.isArrayType(t) || checker.isTupleType(t));
}

28
node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts generated vendored Normal file
View file

@ -0,0 +1,28 @@
import type { TSESTree } from '@typescript-eslint/utils';
import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
/**
* Parses a syntactically possible `Promise.then()` call. Does not check the
* type of the callee.
*/
export declare function parseThenCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
onFulfilled?: TSESTree.Expression | undefined;
onRejected?: TSESTree.Expression | undefined;
object: TSESTree.Expression;
} | undefined;
/**
* Parses a syntactically possible `Promise.catch()` call. Does not check the
* type of the callee.
*/
export declare function parseCatchCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
onRejected?: TSESTree.Expression | undefined;
object: TSESTree.Expression;
} | undefined;
/**
* Parses a syntactically possible `Promise.finally()` call. Does not check the
* type of the callee.
*/
export declare function parseFinallyCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
object: TSESTree.Expression;
onFinally?: TSESTree.Expression | undefined;
} | undefined;
//# sourceMappingURL=promiseUtils.d.ts.map

1
node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/util/promiseUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAMtE;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9C,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAqCZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAuBZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;CAC7C,GACD,SAAS,CAsBZ"}

98
node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.js generated vendored Normal file
View file

@ -0,0 +1,98 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseThenCall = parseThenCall;
exports.parseCatchCall = parseCatchCall;
exports.parseFinallyCall = parseFinallyCall;
const utils_1 = require("@typescript-eslint/utils");
const misc_1 = require("./misc");
/**
* Parses a syntactically possible `Promise.then()` call. Does not check the
* type of the callee.
*/
function parseThenCall(node, context) {
if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
if (methodName === 'then') {
if (node.arguments.length >= 1) {
if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
return {
object: node.callee.object,
};
}
if (node.arguments.length >= 2) {
if (node.arguments[1].type === utils_1.AST_NODE_TYPES.SpreadElement) {
return {
object: node.callee.object,
onFulfilled: node.arguments[0],
};
}
return {
object: node.callee.object,
onFulfilled: node.arguments[0],
onRejected: node.arguments[1],
};
}
return {
object: node.callee.object,
onFulfilled: node.arguments[0],
};
}
return {
object: node.callee.object,
};
}
}
return undefined;
}
/**
* Parses a syntactically possible `Promise.catch()` call. Does not check the
* type of the callee.
*/
function parseCatchCall(node, context) {
if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
if (methodName === 'catch') {
if (node.arguments.length >= 1) {
if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
return {
object: node.callee.object,
};
}
return {
object: node.callee.object,
onRejected: node.arguments[0],
};
}
return {
object: node.callee.object,
};
}
}
return undefined;
}
/**
* Parses a syntactically possible `Promise.finally()` call. Does not check the
* type of the callee.
*/
function parseFinallyCall(node, context) {
if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
if (methodName === 'finally') {
if (node.arguments.length >= 1) {
if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
return {
object: node.callee.object,
};
}
return {
object: node.callee.object,
onFinally: node.arguments[0],
};
}
return {
object: node.callee.object,
};
}
}
return undefined;
}

8
node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.js generated vendored
View file

@ -41,18 +41,18 @@ const getValueOfLiteralType_1 = require("./getValueOfLiteralType");
const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
(type.isLiteral() && !!(0, getValueOfLiteralType_1.getValueOfLiteralType)(type));
const isPossiblyFalsy = (type) => tsutils
.unionTypeParts(type)
.unionConstituents(type)
// Intersections like `string & {}` can also be possibly falsy,
// requiring us to look into the intersection.
.flatMap(type => tsutils.intersectionTypeParts(type))
.flatMap(type => tsutils.intersectionConstituents(type))
// PossiblyFalsy flag includes literal values, so exclude ones that
// are definitely truthy
.filter(t => !isTruthyLiteral(t))
.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
exports.isPossiblyFalsy = isPossiblyFalsy;
const isPossiblyTruthy = (type) => tsutils
.unionTypeParts(type)
.map(type => tsutils.intersectionTypeParts(type))
.unionConstituents(type)
.map(type => tsutils.intersectionConstituents(type))
.some(intersectionParts =>
// It is possible to define intersections that are always falsy,
// like `"" & { __brand: string }`.

79
node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unnecessary-type-conversion.mdx generated vendored Normal file
View file

@ -0,0 +1,79 @@
---
description: 'Disallow conversion idioms when they do not change the type or value of the expression.'
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
> 🛑 This file is source code, not the primary documentation location! 🛑
>
> See **https://typescript-eslint.io/rules/no-unnecessary-type-conversion** for documentation.
JavaScript provides several commonly used idioms to convert values to a specific type:
- Primitive coercion (e.g. `Boolean(value)`, `String(value)`): using a built-in primitive function
- String concatenation (e.g. `value + ''`): turning a value into a string
- Unary coercion (e.g. `+value`, `!!value`): using a built-in operator
- The `.toString()` method defined on many types
These conversions are unnecessary if the value is already of that type.
## Examples
<Tabs>
<TabItem value="❌ Incorrect">
```ts
String('123');
'123'.toString();
'' + '123';
'123' + '';
Number(123);
+123;
~~123;
Boolean(true);
!!true;
BigInt(BigInt(1));
let str = '123';
str += '';
```
</TabItem>
<TabItem value="✅ Correct">
```ts
function foo(bar: string | number) {
String(bar);
bar.toString();
'' + bar;
bar + '';
Number(bar);
+bar;
~~bar;
Boolean(bar);
!!bar;
BigInt(1);
bar += '';
}
```
</TabItem>
</Tabs>
## When Not To Use It
If you don't care about having no-op type conversions in your code, then you can turn off this rule.
If you have types which are not accurate, then this rule might cause you to remove conversions that you actually do need.
## Related To
- [no-unnecessary-type-assertion](./no-unnecessary-type-assertion.mdx)
- [no-useless-template-literals](./no-useless-template-literals.mdx)

6
node_modules/@typescript-eslint/eslint-plugin/docs/rules/only-throw-error.mdx generated vendored
View file

@ -123,6 +123,11 @@ interface Options {
| string
)[];
/**
* Whether to allow rethrowing caught values that are not `Error` objects.
*/
allowRethrowing?: boolean;
/**
* Whether to always allow throwing values typed as `any`.
*/
@ -136,6 +141,7 @@ interface Options {
const defaultOptions: Options = {
allow: [],
allowRethrowing: false,
allowThrowingAny: true,
allowThrowingUnknown: true,
};

17
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/scope-manager/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/scope-manager",
"version": "8.31.1",
"version": "8.32.1",
"description": "TypeScript scope analyser for ESLint",
"files": [
"dist",
@ -38,7 +38,7 @@
],
"scripts": {
"build": "tsc -b tsconfig.build.json",
"clean": "rimraf dist/ _ts4.3/ coverage/",
"clean": "rimraf dist/ coverage/",
"clean-fixtures": "rimraf -g \"./src/**/fixtures/**/snapshots\"",
"format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
"generate-lib": "npx nx generate-lib repo",
@ -47,17 +47,18 @@
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/visitor-keys": "8.31.1"
"@typescript-eslint/types": "8.32.1",
"@typescript-eslint/visitor-keys": "8.32.1"
},
"devDependencies": {
"@typescript-eslint/typescript-estree": "8.31.1",
"@vitest/coverage-v8": "^3.1.1",
"@typescript-eslint/typescript-estree": "8.32.1",
"@vitest/coverage-v8": "^3.1.3",
"@vitest/pretty-format": "^3.1.3",
"glob": "*",
"prettier": "^3.2.5",
"pretty-format": "*",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

6
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/types/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/types",
"version": "8.31.1",
"version": "8.32.1",
"description": "Types for the TypeScript-ESTree AST spec",
"files": [
"dist",
@ -67,12 +67,12 @@
}
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@vitest/coverage-v8": "^3.1.3",
"prettier": "^3.2.5",
"rimraf": "*",
"tsx": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

2
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/dist/convert.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAyhFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}
{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAiiFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}

27
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/dist/convert.js generated vendored
View file

@ -2081,12 +2081,14 @@ class Converter {
constraint: this.convertChild(node.typeParameter.constraint),
key: this.convertChild(node.typeParameter.name),
nameType: this.convertChild(node.nameType) ?? null,
optional: node.questionToken &&
(node.questionToken.kind === SyntaxKind.QuestionToken ||
(0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)),
readonly: node.readonlyToken &&
(node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
(0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)),
optional: node.questionToken
? node.questionToken.kind === SyntaxKind.QuestionToken ||
(0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)
: false,
readonly: node.readonlyToken
? node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
(0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)
: undefined,
typeAnnotation: node.type && this.convertChild(node.type),
}, 'typeParameter', "'constraint' and 'key'", this.convertChild(node.typeParameter)));
}
@ -2250,21 +2252,24 @@ class Converter {
const commaToken = (0, node_utils_1.findNextToken)(node.argument, node, this.ast);
const openBraceToken = (0, node_utils_1.findNextToken)(commaToken, node, this.ast);
const closeBraceToken = (0, node_utils_1.findNextToken)(node.attributes, node, this.ast);
const withToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
const withTokenRange = (0, node_utils_1.getRange)(withToken, this.ast);
const withOrAssertToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
const withOrAssertTokenRange = (0, node_utils_1.getRange)(withOrAssertToken, this.ast);
const withOrAssertName = withOrAssertToken.kind === ts.SyntaxKind.AssertKeyword
? 'assert'
: 'with';
options = this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.ObjectExpression,
range: [openBraceToken.getStart(this.ast), closeBraceToken.end],
properties: [
this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.Property,
range: [withTokenRange[0], node.attributes.end],
range: [withOrAssertTokenRange[0], node.attributes.end],
computed: false,
key: this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.Identifier,
range: withTokenRange,
range: withOrAssertTokenRange,
decorators: [],
name: 'with',
name: withOrAssertName,
optional: false,
typeAnnotation: undefined,
}),

16
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/typescript-estree",
"version": "8.31.1",
"version": "8.32.1",
"description": "A parser that converts TypeScript source code into an ESTree compatible form",
"files": [
"dist",
@ -45,30 +45,30 @@
],
"scripts": {
"build": "tsc -b tsconfig.build.json",
"clean": "tsc -b tsconfig.build.json --clean",
"postclean": "rimraf dist/ coverage/",
"clean": "rimraf dist/ coverage/",
"format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
"lint": "npx nx lint",
"test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/visitor-keys": "8.31.1",
"@typescript-eslint/types": "8.32.1",
"@typescript-eslint/visitor-keys": "8.32.1",
"debug": "^4.3.4",
"fast-glob": "^3.3.2",
"is-glob": "^4.0.3",
"minimatch": "^9.0.4",
"semver": "^7.6.0",
"ts-api-utils": "^2.0.1"
"ts-api-utils": "^2.1.0"
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@types/is-glob": "^4.0.4",
"@vitest/coverage-v8": "^3.1.3",
"glob": "*",
"prettier": "^3.2.5",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"peerDependencies": {
"typescript": ">=4.8.4 <5.9.0"

14
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/utils/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/utils",
"version": "8.31.1",
"version": "8.32.1",
"description": "Utilities for working with TypeScript + ESLint together",
"files": [
"dist",
@ -62,21 +62,21 @@
"check-types": "npx nx typecheck"
},
"dependencies": {
"@eslint-community/eslint-utils": "^4.4.0",
"@typescript-eslint/scope-manager": "8.31.1",
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/typescript-estree": "8.31.1"
"@eslint-community/eslint-utils": "^4.7.0",
"@typescript-eslint/scope-manager": "8.32.1",
"@typescript-eslint/types": "8.32.1",
"@typescript-eslint/typescript-estree": "8.32.1"
},
"peerDependencies": {
"eslint": "^8.57.0 || ^9.0.0",
"typescript": ">=4.8.4 <5.9.0"
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@vitest/coverage-v8": "^3.1.3",
"prettier": "^3.2.5",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

8
node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/visitor-keys/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/visitor-keys",
"version": "8.31.1",
"version": "8.32.1",
"description": "Visitor keys used to help traverse the TypeScript-ESTree AST",
"files": [
"dist",
@ -46,15 +46,15 @@
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/types": "8.32.1",
"eslint-visitor-keys": "^4.2.0"
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@vitest/coverage-v8": "^3.1.3",
"prettier": "^3.2.5",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

21
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/LICENSE-MIT generated vendored Normal file
View file

@ -0,0 +1,21 @@
Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
http://kael.me/
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

452
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/README.md generated vendored Normal file
View file

@ -0,0 +1,452 @@
| Linux / MacOS / Windows | Coverage | Downloads |
| ----------------------- | -------- | --------- |
| [![build][bb]][bl] | [![coverage][cb]][cl] | [![downloads][db]][dl] |
[bb]: https://github.com/kaelzhang/node-ignore/actions/workflows/nodejs.yml/badge.svg
[bl]: https://github.com/kaelzhang/node-ignore/actions/workflows/nodejs.yml
[cb]: https://codecov.io/gh/kaelzhang/node-ignore/branch/master/graph/badge.svg
[cl]: https://codecov.io/gh/kaelzhang/node-ignore
[db]: http://img.shields.io/npm/dm/ignore.svg
[dl]: https://www.npmjs.org/package/ignore
# ignore
`ignore` is a manager, filter and parser which implemented in pure JavaScript according to the [.gitignore spec 2.22.1](http://git-scm.com/docs/gitignore).
`ignore` is used by eslint, gitbook and [many others](https://www.npmjs.com/browse/depended/ignore).
Pay **ATTENTION** that [`minimatch`](https://www.npmjs.org/package/minimatch) (which used by `fstream-ignore`) does not follow the gitignore spec.
To filter filenames according to a .gitignore file, I recommend this npm package, `ignore`.
To parse an `.npmignore` file, you should use `minimatch`, because an `.npmignore` file is parsed by npm using `minimatch` and it does not work in the .gitignore way.
### Tested on
`ignore` is fully tested, and has more than **five hundreds** of unit tests.
- Linux + Node: `0.8` - `7.x`
- Windows + Node: `0.10` - `7.x`, node < `0.10` is not tested due to the lack of support of appveyor.
Actually, `ignore` does not rely on any versions of node specially.
Since `4.0.0`, ignore will no longer support `node < 6` by default, to use in node < 6, `require('ignore/legacy')`. For details, see [CHANGELOG](https://github.com/kaelzhang/node-ignore/blob/master/CHANGELOG.md).
## Table Of Main Contents
- [Usage](#usage)
- [`Pathname` Conventions](#pathname-conventions)
- See Also:
- [`glob-gitignore`](https://www.npmjs.com/package/glob-gitignore) matches files using patterns and filters them according to gitignore rules.
- [Upgrade Guide](#upgrade-guide)
## Install
```sh
npm i ignore
```
## Usage
```js
import ignore from 'ignore'
const ig = ignore().add(['.abc/*', '!.abc/d/'])
```
### Filter the given paths
```js
const paths = [
'.abc/a.js', // filtered out
'.abc/d/e.js' // included
]
ig.filter(paths) // ['.abc/d/e.js']
ig.ignores('.abc/a.js') // true
```
### As the filter function
```js
paths.filter(ig.createFilter()); // ['.abc/d/e.js']
```
### Win32 paths will be handled
```js
ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
// if the code above runs on windows, the result will be
// ['.abc\\d\\e.js']
```
## Why another ignore?
- `ignore` is a standalone module, and is much simpler so that it could easy work with other programs, unlike [isaacs](https://npmjs.org/~isaacs)'s [fstream-ignore](https://npmjs.org/package/fstream-ignore) which must work with the modules of the fstream family.
- `ignore` only contains utility methods to filter paths according to the specified ignore rules, so
- `ignore` never try to find out ignore rules by traversing directories or fetching from git configurations.
- `ignore` don't cares about sub-modules of git projects.
- Exactly according to [gitignore man page](http://git-scm.com/docs/gitignore), fixes some known matching issues of fstream-ignore, such as:
- '`/*.js`' should only match '`a.js`', but not '`abc/a.js`'.
- '`**/foo`' should match '`foo`' anywhere.
- Prevent re-including a file if a parent directory of that file is excluded.
- Handle trailing whitespaces:
- `'a '`(one space) should not match `'a '`(two spaces).
- `'a \ '` matches `'a '`
- All test cases are verified with the result of `git check-ignore`.
# Methods
## .add(pattern: string | Ignore): this
## .add(patterns: Array<string | Ignore>): this
## .add({pattern: string, mark?: string}): this since 7.0.0
- **pattern** `string | Ignore` An ignore pattern string, or the `Ignore` instance
- **patterns** `Array<string | Ignore>` Array of ignore patterns.
- **mark?** `string` Pattern mark, which is used to associate the pattern with a certain marker, such as the line no of the `.gitignore` file. Actually it could be an arbitrary string and is optional.
Adds a rule or several rules to the current manager.
Returns `this`
Notice that a line starting with `'#'`(hash) is treated as a comment. Put a backslash (`'\'`) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.
```js
ignore().add('#abc').ignores('#abc') // false
ignore().add('\\#abc').ignores('#abc') // true
```
`pattern` could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just `ignore().add()` the content of a ignore file:
```js
ignore()
.add(fs.readFileSync(filenameOfGitignore).toString())
.filter(filenames)
```
`pattern` could also be an `ignore` instance, so that we could easily inherit the rules of another `Ignore` instance.
## .ignores(pathname: [Pathname](#pathname-conventions)): boolean
> new in 3.2.0
Returns `Boolean` whether `pathname` should be ignored.
```js
ig.ignores('.abc/a.js') // true
```
Please **PAY ATTENTION** that `.ignores()` is **NOT** equivalent to `git check-ignore` although in most cases they return equivalent results.
However, for the purposes of imitating the behavior of `git check-ignore`, please use `.checkIgnore()` instead.
### `Pathname` Conventions:
#### 1. `Pathname` should be a `path.relative()`d pathname
`Pathname` should be a string that have been `path.join()`ed, or the return value of `path.relative()` to the current directory,
```js
// WRONG, an error will be thrown
ig.ignores('./abc')
// WRONG, for it will never happen, and an error will be thrown
// If the gitignore rule locates at the root directory,
// `'/abc'` should be changed to `'abc'`.
// ```
// path.relative('/', '/abc') -> 'abc'
// ```
ig.ignores('/abc')
// WRONG, that it is an absolute path on Windows, an error will be thrown
ig.ignores('C:\\abc')
// Right
ig.ignores('abc')
// Right
ig.ignores(path.join('./abc')) // path.join('./abc') -> 'abc'
```
In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
Suppose the dir structure is:
```
/path/to/your/repo
|-- a
| |-- a.js
|
|-- .b
|
|-- .c
|-- .DS_store
```
Then the `paths` might be like this:
```js
[
'a/a.js'
'.b',
'.c/.DS_store'
]
```
#### 2. filenames and dirnames
`node-ignore` does NO `fs.stat` during path matching, so `node-ignore` treats
- `foo` as a file
- **`foo/` as a directory**
For the example below:
```js
// First, we add a ignore pattern to ignore a directory
ig.add('config/')
// `ig` does NOT know if 'config', in the real world,
// is a normal file, directory or something.
ig.ignores('config')
// `ig` treats `config` as a file, so it returns `false`
ig.ignores('config/')
// returns `true`
```
Specially for people who develop some library based on `node-ignore`, it is important to understand that.
Usually, you could use [`glob`](http://npmjs.org/package/glob) with `option.mark = true` to fetch the structure of the current directory:
```js
import glob from 'glob'
glob('**', {
// Adds a / character to directory matches.
mark: true
}, (err, files) => {
if (err) {
return console.error(err)
}
let filtered = ignore().add(patterns).filter(files)
console.log(filtered)
})
```
## .filter(paths: Array&lt;Pathname&gt;): Array&lt;Pathname&gt;
```ts
type Pathname = string
```
Filters the given array of pathnames, and returns the filtered array.
- **paths** `Array.<Pathname>` The array of `pathname`s to be filtered.
## .createFilter()
Creates a filter function which could filter an array of paths with `Array.prototype.filter`.
Returns `function(path)` the filter function.
## .test(pathname: Pathname): TestResult
> New in 5.0.0
Returns `TestResult`
```ts
// Since 5.0.0
interface TestResult {
ignored: boolean
// true if the `pathname` is finally unignored by some negative pattern
unignored: boolean
// The `IgnoreRule` which ignores the pathname
rule?: IgnoreRule
}
// Since 7.0.0
interface IgnoreRule {
// The original pattern
pattern: string
// Whether the pattern is a negative pattern
negative: boolean
// Which is used for other packages to build things upon `node-ignore`
mark?: string
}
```
- `{ignored: true, unignored: false}`: the `pathname` is ignored
- `{ignored: false, unignored: true}`: the `pathname` is unignored
- `{ignored: false, unignored: false}`: the `pathname` is never matched by any ignore rules.
## .checkIgnore(target: string): TestResult
> new in 7.0.0
Debugs gitignore / exclude files, which is equivalent to `git check-ignore -v`. Usually this method is used for other packages to implement the function of `git check-ignore -v` upon `node-ignore`
- **target** `string` the target to test.
Returns `TestResult`
```js
ig.add({
pattern: 'foo/*',
mark: '60'
})
const {
ignored,
rule
} = checkIgnore('foo/')
if (ignored) {
console.log(`.gitignore:${result}:${rule.mark}:${rule.pattern} foo/`)
}
// .gitignore:60:foo/* foo/
```
Please pay attention that this method does not have a strong built-in cache mechanism.
The purpose of introducing this method is to make it possible to implement the `git check-ignore` command in JavaScript based on `node-ignore`.
So do not use this method in those situations where performance is extremely important.
## static `isPathValid(pathname): boolean` since 5.0.0
Check whether the `pathname` is an valid `path.relative()`d path according to the [convention](#1-pathname-should-be-a-pathrelatived-pathname).
This method is **NOT** used to check if an ignore pattern is valid.
```js
import {isPathValid} from 'ignore'
isPathValid('./foo') // false
```
## <strike>.addIgnoreFile(path)</strike>
REMOVED in `3.x` for now.
To upgrade `ignore@2.x` up to `3.x`, use
```js
import fs from 'fs'
if (fs.existsSync(filename)) {
ignore().add(fs.readFileSync(filename).toString())
}
```
instead.
## ignore(options)
### `options.ignorecase` since 4.0.0
Similar as the `core.ignorecase` option of [git-config](https://git-scm.com/docs/git-config), `node-ignore` will be case insensitive if `options.ignorecase` is set to `true` (the default value), otherwise case sensitive.
```js
const ig = ignore({
ignorecase: false
})
ig.add('*.png')
ig.ignores('*.PNG') // false
```
### `options.ignoreCase?: boolean` since 5.2.0
Which is alternative to `options.ignoreCase`
### `options.allowRelativePaths?: boolean` since 5.2.0
This option brings backward compatibility with projects which based on `ignore@4.x`. If `options.allowRelativePaths` is `true`, `ignore` will not check whether the given path to be tested is [`path.relative()`d](#pathname-conventions).
However, passing a relative path, such as `'./foo'` or `'../foo'`, to test if it is ignored or not is not a good practise, which might lead to unexpected behavior
```js
ignore({
allowRelativePaths: true
}).ignores('../foo/bar.js') // And it will not throw
```
****
# Upgrade Guide
## Upgrade 4.x -> 5.x
Since `5.0.0`, if an invalid `Pathname` passed into `ig.ignores()`, an error will be thrown, unless `options.allowRelative = true` is passed to the `Ignore` factory.
While `ignore < 5.0.0` did not make sure what the return value was, as well as
```ts
.ignores(pathname: Pathname): boolean
.filter(pathnames: Array<Pathname>): Array<Pathname>
.createFilter(): (pathname: Pathname) => boolean
.test(pathname: Pathname): {ignored: boolean, unignored: boolean}
```
See the convention [here](#1-pathname-should-be-a-pathrelatived-pathname) for details.
If there are invalid pathnames, the conversion and filtration should be done by users.
```js
import {isPathValid} from 'ignore' // introduced in 5.0.0
const paths = [
// invalid
//////////////////
'',
false,
'../foo',
'.',
//////////////////
// valid
'foo'
]
.filter(isPathValid)
ig.filter(paths)
```
## Upgrade 3.x -> 4.x
Since `4.0.0`, `ignore` will no longer support node < 6, to use `ignore` in node < 6:
```js
var ignore = require('ignore/legacy')
```
## Upgrade 2.x -> 3.x
- All `options` of 2.x are unnecessary and removed, so just remove them.
- `ignore()` instance is no longer an [`EventEmitter`](nodejs.org/api/events.html), and all events are unnecessary and removed.
- `.addIgnoreFile()` is removed, see the [.addIgnoreFile](#addignorefilepath) section for details.
****
# Collaborators
- [@whitecolor](https://github.com/whitecolor) *Alex*
- [@SamyPesse](https://github.com/SamyPesse) *Samy Pessé*
- [@azproduction](https://github.com/azproduction) *Mikhail Davydov*
- [@TrySound](https://github.com/TrySound) *Bogdan Chadkin*
- [@JanMattner](https://github.com/JanMattner) *Jan Mattner*
- [@ntwb](https://github.com/ntwb) *Stephen Edgar*
- [@kasperisager](https://github.com/kasperisager) *Kasper Isager*
- [@sandersn](https://github.com/sandersn) *Nathan Shively-Sanders*

81
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,81 @@
type Pathname = string
interface IgnoreRule {
pattern: string
mark?: string
negative: boolean
}
interface TestResult {
ignored: boolean
unignored: boolean
rule?: IgnoreRule
}
interface PatternParams {
pattern: string
mark?: string
}
/**
* Creates new ignore manager.
*/
declare function ignore(options?: ignore.Options): ignore.Ignore
declare namespace ignore {
interface Ignore {
/**
* Adds one or several rules to the current manager.
* @param {string[]} patterns
* @returns IgnoreBase
*/
add(
patterns: string | Ignore | readonly (string | Ignore)[] | PatternParams
): this
/**
* Filters the given array of pathnames, and returns the filtered array.
* NOTICE that each path here should be a relative path to the root of your repository.
* @param paths the array of paths to be filtered.
* @returns The filtered array of paths
*/
filter(pathnames: readonly Pathname[]): Pathname[]
/**
* Creates a filter function which could filter
* an array of paths with Array.prototype.filter.
*/
createFilter(): (pathname: Pathname) => boolean
/**
* Returns Boolean whether pathname should be ignored.
* @param {string} pathname a path to check
* @returns boolean
*/
ignores(pathname: Pathname): boolean
/**
* Returns whether pathname should be ignored or unignored
* @param {string} pathname a path to check
* @returns TestResult
*/
test(pathname: Pathname): TestResult
/**
* Debugs ignore rules and returns the checking result, which is
* equivalent to `git check-ignore -v`.
* @returns TestResult
*/
checkIgnore(pathname: Pathname): TestResult
}
interface Options {
ignorecase?: boolean
// For compatibility
ignoreCase?: boolean
allowRelativePaths?: boolean
}
function isPathValid(pathname: string): boolean
}
export = ignore

779
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/index.js generated vendored Normal file
View file

@ -0,0 +1,779 @@
// A simple implementation of make-array
function makeArray (subject) {
return Array.isArray(subject)
? subject
: [subject]
}
const UNDEFINED = undefined
const EMPTY = ''
const SPACE = ' '
const ESCAPE = '\\'
const REGEX_TEST_BLANK_LINE = /^\s+$/
const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/
const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
const REGEX_SPLITALL_CRLF = /\r?\n/g
// Invalid:
// - /foo,
// - ./foo,
// - ../foo,
// - .
// - ..
// Valid:
// - .foo
const REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/
const REGEX_TEST_TRAILING_SLASH = /\/$/
const SLASH = '/'
// Do not use ternary expression here, since "istanbul ignore next" is buggy
let TMP_KEY_IGNORE = 'node-ignore'
/* istanbul ignore else */
if (typeof Symbol !== 'undefined') {
TMP_KEY_IGNORE = Symbol.for('node-ignore')
}
const KEY_IGNORE = TMP_KEY_IGNORE
const define = (object, key, value) => {
Object.defineProperty(object, key, {value})
return value
}
const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
const RETURN_FALSE = () => false
// Sanitize the range of a regular expression
// The cases are complicated, see test cases for details
const sanitizeRange = range => range.replace(
REGEX_REGEXP_RANGE,
(match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
? match
// Invalid range (out of order) which is ok for gitignore rules but
// fatal for JavaScript regular expression, so eliminate it.
: EMPTY
)
// See fixtures #59
const cleanRangeBackSlash = slashes => {
const {length} = slashes
return slashes.slice(0, length - length % 2)
}
// > If the pattern ends with a slash,
// > it is removed for the purpose of the following description,
// > but it would only find a match with a directory.
// > In other words, foo/ will match a directory foo and paths underneath it,
// > but will not match a regular file or a symbolic link foo
// > (this is consistent with the way how pathspec works in general in Git).
// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
// you could use option `mark: true` with `glob`
// '`foo/`' should not continue with the '`..`'
const REPLACERS = [
[
// Remove BOM
// TODO:
// Other similar zero-width characters?
/^\uFEFF/,
() => EMPTY
],
// > Trailing spaces are ignored unless they are quoted with backslash ("\")
[
// (a\ ) -> (a )
// (a ) -> (a)
// (a ) -> (a)
// (a \ ) -> (a )
/((?:\\\\)*?)(\\?\s+)$/,
(_, m1, m2) => m1 + (
m2.indexOf('\\') === 0
? SPACE
: EMPTY
)
],
// Replace (\ ) with ' '
// (\ ) -> ' '
// (\\ ) -> '\\ '
// (\\\ ) -> '\\ '
[
/(\\+?)\s/g,
(_, m1) => {
const {length} = m1
return m1.slice(0, length - length % 2) + SPACE
}
],
// Escape metacharacters
// which is written down by users but means special for regular expressions.
// > There are 12 characters with special meanings:
// > - the backslash \,
// > - the caret ^,
// > - the dollar sign $,
// > - the period or dot .,
// > - the vertical bar or pipe symbol |,
// > - the question mark ?,
// > - the asterisk or star *,
// > - the plus sign +,
// > - the opening parenthesis (,
// > - the closing parenthesis ),
// > - and the opening square bracket [,
// > - the opening curly brace {,
// > These special characters are often called "metacharacters".
[
/[\\$.|*+(){^]/g,
match => `\\${match}`
],
[
// > a question mark (?) matches a single character
/(?!\\)\?/g,
() => '[^/]'
],
// leading slash
[
// > A leading slash matches the beginning of the pathname.
// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
// A leading slash matches the beginning of the pathname
/^\//,
() => '^'
],
// replace special metacharacter slash after the leading slash
[
/\//g,
() => '\\/'
],
[
// > A leading "**" followed by a slash means match in all directories.
// > For example, "**/foo" matches file or directory "foo" anywhere,
// > the same as pattern "foo".
// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
// > under directory "foo".
// Notice that the '*'s have been replaced as '\\*'
/^\^*\\\*\\\*\\\//,
// '**/foo' <-> 'foo'
() => '^(?:.*\\/)?'
],
// starting
[
// there will be no leading '/'
// (which has been replaced by section "leading slash")
// If starts with '**', adding a '^' to the regular expression also works
/^(?=[^^])/,
function startingReplacer () {
// If has a slash `/` at the beginning or middle
return !/\/(?!$)/.test(this)
// > Prior to 2.22.1
// > If the pattern does not contain a slash /,
// > Git treats it as a shell glob pattern
// Actually, if there is only a trailing slash,
// git also treats it as a shell glob pattern
// After 2.22.1 (compatible but clearer)
// > If there is a separator at the beginning or middle (or both)
// > of the pattern, then the pattern is relative to the directory
// > level of the particular .gitignore file itself.
// > Otherwise the pattern may also match at any level below
// > the .gitignore level.
? '(?:^|\\/)'
// > Otherwise, Git treats the pattern as a shell glob suitable for
// > consumption by fnmatch(3)
: '^'
}
],
// two globstars
[
// Use lookahead assertions so that we could match more than one `'/**'`
/\\\/\\\*\\\*(?=\\\/|$)/g,
// Zero, one or several directories
// should not use '*', or it will be replaced by the next replacer
// Check if it is not the last `'/**'`
(_, index, str) => index + 6 < str.length
// case: /**/
// > A slash followed by two consecutive asterisks then a slash matches
// > zero or more directories.
// > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
// '/**/'
? '(?:\\/[^\\/]+)*'
// case: /**
// > A trailing `"/**"` matches everything inside.
// #21: everything inside but it should not include the current folder
: '\\/.+'
],
// normal intermediate wildcards
[
// Never replace escaped '*'
// ignore rule '\*' will match the path '*'
// 'abc.*/' -> go
// 'abc.*' -> skip this rule,
// coz trailing single wildcard will be handed by [trailing wildcard]
/(^|[^\\]+)(\\\*)+(?=.+)/g,
// '*.js' matches '.js'
// '*.js' doesn't match 'abc'
(_, p1, p2) => {
// 1.
// > An asterisk "*" matches anything except a slash.
// 2.
// > Other consecutive asterisks are considered regular asterisks
// > and will match according to the previous rules.
const unescaped = p2.replace(/\\\*/g, '[^\\/]*')
return p1 + unescaped
}
],
[
// unescape, revert step 3 except for back slash
// For example, if a user escape a '\\*',
// after step 3, the result will be '\\\\\\*'
/\\\\\\(?=[$.|*+(){^])/g,
() => ESCAPE
],
[
// '\\\\' -> '\\'
/\\\\/g,
() => ESCAPE
],
[
// > The range notation, e.g. [a-zA-Z],
// > can be used to match one of the characters in a range.
// `\` is escaped by step 3
/(\\)?\[([^\]/]*?)(\\*)($|\])/g,
(match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
// '\\[bar]' -> '\\\\[bar\\]'
? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
: close === ']'
? endEscape.length % 2 === 0
// A normal case, and it is a range notation
// '[bar]'
// '[bar\\\\]'
? `[${sanitizeRange(range)}${endEscape}]`
// Invalid range notaton
// '[bar\\]' -> '[bar\\\\]'
: '[]'
: '[]'
],
// ending
[
// 'js' will not match 'js.'
// 'ab' will not match 'abc'
/(?:[^*])$/,
// WTF!
// https://git-scm.com/docs/gitignore
// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
// which re-fixes #24, #38
// > If there is a separator at the end of the pattern then the pattern
// > will only match directories, otherwise the pattern can match both
// > files and directories.
// 'js*' will not match 'a.js'
// 'js/' will not match 'a.js'
// 'js' will match 'a.js' and 'a.js/'
match => /\/$/.test(match)
// foo/ will not match 'foo'
? `${match}$`
// foo matches 'foo' and 'foo/'
: `${match}(?=$|\\/$)`
]
]
const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/
const MODE_IGNORE = 'regex'
const MODE_CHECK_IGNORE = 'checkRegex'
const UNDERSCORE = '_'
const TRAILING_WILD_CARD_REPLACERS = {
[MODE_IGNORE] (_, p1) {
const prefix = p1
// '\^':
// '/*' does not match EMPTY
// '/*' does not match everything
// '\\\/':
// 'abc/*' does not match 'abc/'
? `${p1}[^/]+`
// 'a*' matches 'a'
// 'a*' matches 'aa'
: '[^/]*'
return `${prefix}(?=$|\\/$)`
},
[MODE_CHECK_IGNORE] (_, p1) {
// When doing `git check-ignore`
const prefix = p1
// '\\\/':
// 'abc/*' DOES match 'abc/' !
? `${p1}[^/]*`
// 'a*' matches 'a'
// 'a*' matches 'aa'
: '[^/]*'
return `${prefix}(?=$|\\/$)`
}
}
// @param {pattern}
const makeRegexPrefix = pattern => REPLACERS.reduce(
(prev, [matcher, replacer]) =>
prev.replace(matcher, replacer.bind(pattern)),
pattern
)
const isString = subject => typeof subject === 'string'
// > A blank line matches no files, so it can serve as a separator for readability.
const checkPattern = pattern => pattern
&& isString(pattern)
&& !REGEX_TEST_BLANK_LINE.test(pattern)
&& !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
// > A line starting with # serves as a comment.
&& pattern.indexOf('#') !== 0
const splitPattern = pattern => pattern
.split(REGEX_SPLITALL_CRLF)
.filter(Boolean)
class IgnoreRule {
constructor (
pattern,
mark,
body,
ignoreCase,
negative,
prefix
) {
this.pattern = pattern
this.mark = mark
this.negative = negative
define(this, 'body', body)
define(this, 'ignoreCase', ignoreCase)
define(this, 'regexPrefix', prefix)
}
get regex () {
const key = UNDERSCORE + MODE_IGNORE
if (this[key]) {
return this[key]
}
return this._make(MODE_IGNORE, key)
}
get checkRegex () {
const key = UNDERSCORE + MODE_CHECK_IGNORE
if (this[key]) {
return this[key]
}
return this._make(MODE_CHECK_IGNORE, key)
}
_make (mode, key) {
const str = this.regexPrefix.replace(
REGEX_REPLACE_TRAILING_WILDCARD,
// It does not need to bind pattern
TRAILING_WILD_CARD_REPLACERS[mode]
)
const regex = this.ignoreCase
? new RegExp(str, 'i')
: new RegExp(str)
return define(this, key, regex)
}
}
const createRule = ({
pattern,
mark
}, ignoreCase) => {
let negative = false
let body = pattern
// > An optional prefix "!" which negates the pattern;
if (body.indexOf('!') === 0) {
negative = true
body = body.substr(1)
}
body = body
// > Put a backslash ("\") in front of the first "!" for patterns that
// > begin with a literal "!", for example, `"\!important!.txt"`.
.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
// > Put a backslash ("\") in front of the first hash for patterns that
// > begin with a hash.
.replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')
const regexPrefix = makeRegexPrefix(body)
return new IgnoreRule(
pattern,
mark,
body,
ignoreCase,
negative,
regexPrefix
)
}
class RuleManager {
constructor (ignoreCase) {
this._ignoreCase = ignoreCase
this._rules = []
}
_add (pattern) {
// #32
if (pattern && pattern[KEY_IGNORE]) {
this._rules = this._rules.concat(pattern._rules._rules)
this._added = true
return
}
if (isString(pattern)) {
pattern = {
pattern
}
}
if (checkPattern(pattern.pattern)) {
const rule = createRule(pattern, this._ignoreCase)
this._added = true
this._rules.push(rule)
}
}
// @param {Array<string> | string | Ignore} pattern
add (pattern) {
this._added = false
makeArray(
isString(pattern)
? splitPattern(pattern)
: pattern
).forEach(this._add, this)
return this._added
}
// Test one single path without recursively checking parent directories
//
// - checkUnignored `boolean` whether should check if the path is unignored,
// setting `checkUnignored` to `false` could reduce additional
// path matching.
// - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
// @returns {TestResult} true if a file is ignored
test (path, checkUnignored, mode) {
let ignored = false
let unignored = false
let matchedRule
this._rules.forEach(rule => {
const {negative} = rule
// | ignored : unignored
// -------- | ---------------------------------------
// negative | 0:0 | 0:1 | 1:0 | 1:1
// -------- | ------- | ------- | ------- | --------
// 0 | TEST | TEST | SKIP | X
// 1 | TESTIF | SKIP | TEST | X
// - SKIP: always skip
// - TEST: always test
// - TESTIF: only test if checkUnignored
// - X: that never happen
if (
unignored === negative && ignored !== unignored
|| negative && !ignored && !unignored && !checkUnignored
) {
return
}
const matched = rule[mode].test(path)
if (!matched) {
return
}
ignored = !negative
unignored = negative
matchedRule = negative
? UNDEFINED
: rule
})
const ret = {
ignored,
unignored
}
if (matchedRule) {
ret.rule = matchedRule
}
return ret
}
}
const throwError = (message, Ctor) => {
throw new Ctor(message)
}
const checkPath = (path, originalPath, doThrow) => {
if (!isString(path)) {
return doThrow(
`path must be a string, but got \`${originalPath}\``,
TypeError
)
}
// We don't know if we should ignore EMPTY, so throw
if (!path) {
return doThrow(`path must not be empty`, TypeError)
}
// Check if it is a relative path
if (checkPath.isNotRelative(path)) {
const r = '`path.relative()`d'
return doThrow(
`path should be a ${r} string, but got "${originalPath}"`,
RangeError
)
}
return true
}
const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)
checkPath.isNotRelative = isNotRelative
// On windows, the following function will be replaced
/* istanbul ignore next */
checkPath.convert = p => p
class Ignore {
constructor ({
ignorecase = true,
ignoreCase = ignorecase,
allowRelativePaths = false
} = {}) {
define(this, KEY_IGNORE, true)
this._rules = new RuleManager(ignoreCase)
this._strictPathCheck = !allowRelativePaths
this._initCache()
}
_initCache () {
// A cache for the result of `.ignores()`
this._ignoreCache = Object.create(null)
// A cache for the result of `.test()`
this._testCache = Object.create(null)
}
add (pattern) {
if (this._rules.add(pattern)) {
// Some rules have just added to the ignore,
// making the behavior changed,
// so we need to re-initialize the result cache
this._initCache()
}
return this
}
// legacy
addPattern (pattern) {
return this.add(pattern)
}
// @returns {TestResult}
_test (originalPath, cache, checkUnignored, slices) {
const path = originalPath
// Supports nullable path
&& checkPath.convert(originalPath)
checkPath(
path,
originalPath,
this._strictPathCheck
? throwError
: RETURN_FALSE
)
return this._t(path, cache, checkUnignored, slices)
}
checkIgnore (path) {
// If the path doest not end with a slash, `.ignores()` is much equivalent
// to `git check-ignore`
if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
return this.test(path)
}
const slices = path.split(SLASH).filter(Boolean)
slices.pop()
if (slices.length) {
const parent = this._t(
slices.join(SLASH) + SLASH,
this._testCache,
true,
slices
)
if (parent.ignored) {
return parent
}
}
return this._rules.test(path, false, MODE_CHECK_IGNORE)
}
_t (
// The path to be tested
path,
// The cache for the result of a certain checking
cache,
// Whether should check if the path is unignored
checkUnignored,
// The path slices
slices
) {
if (path in cache) {
return cache[path]
}
if (!slices) {
// path/to/a.js
// ['path', 'to', 'a.js']
slices = path.split(SLASH).filter(Boolean)
}
slices.pop()
// If the path has no parent directory, just test it
if (!slices.length) {
return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE)
}
const parent = this._t(
slices.join(SLASH) + SLASH,
cache,
checkUnignored,
slices
)
// If the path contains a parent directory, check the parent first
return cache[path] = parent.ignored
// > It is not possible to re-include a file if a parent directory of
// > that file is excluded.
? parent
: this._rules.test(path, checkUnignored, MODE_IGNORE)
}
ignores (path) {
return this._test(path, this._ignoreCache, false).ignored
}
createFilter () {
return path => !this.ignores(path)
}
filter (paths) {
return makeArray(paths).filter(this.createFilter())
}
// @returns {TestResult}
test (path) {
return this._test(path, this._testCache, true)
}
}
const factory = options => new Ignore(options)
const isPathValid = path =>
checkPath(path && checkPath.convert(path), path, RETURN_FALSE)
// Windows
// --------------------------------------------------------------
/* istanbul ignore next */
if (
// Detect `process` so that it can run in browsers.
typeof process !== 'undefined'
&& (
process.env && process.env.IGNORE_TEST_WIN32
|| process.platform === 'win32'
)
) {
/* eslint no-control-regex: "off" */
const makePosix = str => /^\\\\\?\\/.test(str)
|| /["<>|\u0000-\u001F]+/u.test(str)
? str
: str.replace(/\\/g, '/')
checkPath.convert = makePosix
// 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
// 'd:\\foo'
const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i
checkPath.isNotRelative = path =>
REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)
|| isNotRelative(path)
}
// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////
module.exports = factory
// Although it is an anti-pattern,
// it is still widely misused by a lot of libraries in github
// Ref: https://github.com/search?q=ignore.default%28%29&type=code
factory.default = factory
module.exports.isPathValid = isPathValid

673
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/legacy.js generated vendored Normal file
View file

@ -0,0 +1,673 @@
"use strict";
var _TRAILING_WILD_CARD_R;
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
// A simple implementation of make-array
function makeArray(subject) {
return Array.isArray(subject) ? subject : [subject];
}
var UNDEFINED = undefined;
var EMPTY = '';
var SPACE = ' ';
var ESCAPE = '\\';
var REGEX_TEST_BLANK_LINE = /^\s+$/;
var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
var REGEX_SPLITALL_CRLF = /\r?\n/g;
// Invalid:
// - /foo,
// - ./foo,
// - ../foo,
// - .
// - ..
// Valid:
// - .foo
var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
var REGEX_TEST_TRAILING_SLASH = /\/$/;
var SLASH = '/';
// Do not use ternary expression here, since "istanbul ignore next" is buggy
var TMP_KEY_IGNORE = 'node-ignore';
/* istanbul ignore else */
if (typeof Symbol !== 'undefined') {
TMP_KEY_IGNORE = Symbol["for"]('node-ignore');
}
var KEY_IGNORE = TMP_KEY_IGNORE;
var define = function define(object, key, value) {
Object.defineProperty(object, key, {
value: value
});
return value;
};
var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
var RETURN_FALSE = function RETURN_FALSE() {
return false;
};
// Sanitize the range of a regular expression
// The cases are complicated, see test cases for details
var sanitizeRange = function sanitizeRange(range) {
return range.replace(REGEX_REGEXP_RANGE, function (match, from, to) {
return from.charCodeAt(0) <= to.charCodeAt(0) ? match
// Invalid range (out of order) which is ok for gitignore rules but
// fatal for JavaScript regular expression, so eliminate it.
: EMPTY;
});
};
// See fixtures #59
var cleanRangeBackSlash = function cleanRangeBackSlash(slashes) {
var length = slashes.length;
return slashes.slice(0, length - length % 2);
};
// > If the pattern ends with a slash,
// > it is removed for the purpose of the following description,
// > but it would only find a match with a directory.
// > In other words, foo/ will match a directory foo and paths underneath it,
// > but will not match a regular file or a symbolic link foo
// > (this is consistent with the way how pathspec works in general in Git).
// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
// you could use option `mark: true` with `glob`
// '`foo/`' should not continue with the '`..`'
var REPLACERS = [[
// Remove BOM
// TODO:
// Other similar zero-width characters?
/^\uFEFF/, function () {
return EMPTY;
}],
// > Trailing spaces are ignored unless they are quoted with backslash ("\")
[
// (a\ ) -> (a )
// (a ) -> (a)
// (a ) -> (a)
// (a \ ) -> (a )
/((?:\\\\)*?)(\\?\s+)$/, function (_, m1, m2) {
return m1 + (m2.indexOf('\\') === 0 ? SPACE : EMPTY);
}],
// Replace (\ ) with ' '
// (\ ) -> ' '
// (\\ ) -> '\\ '
// (\\\ ) -> '\\ '
[/(\\+?)\s/g, function (_, m1) {
var length = m1.length;
return m1.slice(0, length - length % 2) + SPACE;
}],
// Escape metacharacters
// which is written down by users but means special for regular expressions.
// > There are 12 characters with special meanings:
// > - the backslash \,
// > - the caret ^,
// > - the dollar sign $,
// > - the period or dot .,
// > - the vertical bar or pipe symbol |,
// > - the question mark ?,
// > - the asterisk or star *,
// > - the plus sign +,
// > - the opening parenthesis (,
// > - the closing parenthesis ),
// > - and the opening square bracket [,
// > - the opening curly brace {,
// > These special characters are often called "metacharacters".
[/[\\$.|*+(){^]/g, function (match) {
return "\\".concat(match);
}], [
// > a question mark (?) matches a single character
/(?!\\)\?/g, function () {
return '[^/]';
}],
// leading slash
[
// > A leading slash matches the beginning of the pathname.
// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
// A leading slash matches the beginning of the pathname
/^\//, function () {
return '^';
}],
// replace special metacharacter slash after the leading slash
[/\//g, function () {
return '\\/';
}], [
// > A leading "**" followed by a slash means match in all directories.
// > For example, "**/foo" matches file or directory "foo" anywhere,
// > the same as pattern "foo".
// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
// > under directory "foo".
// Notice that the '*'s have been replaced as '\\*'
/^\^*\\\*\\\*\\\//,
// '**/foo' <-> 'foo'
function () {
return '^(?:.*\\/)?';
}],
// starting
[
// there will be no leading '/'
// (which has been replaced by section "leading slash")
// If starts with '**', adding a '^' to the regular expression also works
/^(?=[^^])/, function startingReplacer() {
// If has a slash `/` at the beginning or middle
return !/\/(?!$)/.test(this)
// > Prior to 2.22.1
// > If the pattern does not contain a slash /,
// > Git treats it as a shell glob pattern
// Actually, if there is only a trailing slash,
// git also treats it as a shell glob pattern
// After 2.22.1 (compatible but clearer)
// > If there is a separator at the beginning or middle (or both)
// > of the pattern, then the pattern is relative to the directory
// > level of the particular .gitignore file itself.
// > Otherwise the pattern may also match at any level below
// > the .gitignore level.
? '(?:^|\\/)'
// > Otherwise, Git treats the pattern as a shell glob suitable for
// > consumption by fnmatch(3)
: '^';
}],
// two globstars
[
// Use lookahead assertions so that we could match more than one `'/**'`
/\\\/\\\*\\\*(?=\\\/|$)/g,
// Zero, one or several directories
// should not use '*', or it will be replaced by the next replacer
// Check if it is not the last `'/**'`
function (_, index, str) {
return index + 6 < str.length
// case: /**/
// > A slash followed by two consecutive asterisks then a slash matches
// > zero or more directories.
// > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
// '/**/'
? '(?:\\/[^\\/]+)*'
// case: /**
// > A trailing `"/**"` matches everything inside.
// #21: everything inside but it should not include the current folder
: '\\/.+';
}],
// normal intermediate wildcards
[
// Never replace escaped '*'
// ignore rule '\*' will match the path '*'
// 'abc.*/' -> go
// 'abc.*' -> skip this rule,
// coz trailing single wildcard will be handed by [trailing wildcard]
/(^|[^\\]+)(\\\*)+(?=.+)/g,
// '*.js' matches '.js'
// '*.js' doesn't match 'abc'
function (_, p1, p2) {
// 1.
// > An asterisk "*" matches anything except a slash.
// 2.
// > Other consecutive asterisks are considered regular asterisks
// > and will match according to the previous rules.
var unescaped = p2.replace(/\\\*/g, '[^\\/]*');
return p1 + unescaped;
}], [
// unescape, revert step 3 except for back slash
// For example, if a user escape a '\\*',
// after step 3, the result will be '\\\\\\*'
/\\\\\\(?=[$.|*+(){^])/g, function () {
return ESCAPE;
}], [
// '\\\\' -> '\\'
/\\\\/g, function () {
return ESCAPE;
}], [
// > The range notation, e.g. [a-zA-Z],
// > can be used to match one of the characters in a range.
// `\` is escaped by step 3
/(\\)?\[([^\]/]*?)(\\*)($|\])/g, function (match, leadEscape, range, endEscape, close) {
return leadEscape === ESCAPE
// '\\[bar]' -> '\\\\[bar\\]'
? "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close) : close === ']' ? endEscape.length % 2 === 0
// A normal case, and it is a range notation
// '[bar]'
// '[bar\\\\]'
? "[".concat(sanitizeRange(range)).concat(endEscape, "]") // Invalid range notaton
// '[bar\\]' -> '[bar\\\\]'
: '[]' : '[]';
}],
// ending
[
// 'js' will not match 'js.'
// 'ab' will not match 'abc'
/(?:[^*])$/,
// WTF!
// https://git-scm.com/docs/gitignore
// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
// which re-fixes #24, #38
// > If there is a separator at the end of the pattern then the pattern
// > will only match directories, otherwise the pattern can match both
// > files and directories.
// 'js*' will not match 'a.js'
// 'js/' will not match 'a.js'
// 'js' will match 'a.js' and 'a.js/'
function (match) {
return /\/$/.test(match)
// foo/ will not match 'foo'
? "".concat(match, "$") // foo matches 'foo' and 'foo/'
: "".concat(match, "(?=$|\\/$)");
}]];
var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
var MODE_IGNORE = 'regex';
var MODE_CHECK_IGNORE = 'checkRegex';
var UNDERSCORE = '_';
var TRAILING_WILD_CARD_REPLACERS = (_TRAILING_WILD_CARD_R = {}, _defineProperty(_TRAILING_WILD_CARD_R, MODE_IGNORE, function (_, p1) {
var prefix = p1
// '\^':
// '/*' does not match EMPTY
// '/*' does not match everything
// '\\\/':
// 'abc/*' does not match 'abc/'
? "".concat(p1, "[^/]+") // 'a*' matches 'a'
// 'a*' matches 'aa'
: '[^/]*';
return "".concat(prefix, "(?=$|\\/$)");
}), _defineProperty(_TRAILING_WILD_CARD_R, MODE_CHECK_IGNORE, function (_, p1) {
// When doing `git check-ignore`
var prefix = p1
// '\\\/':
// 'abc/*' DOES match 'abc/' !
? "".concat(p1, "[^/]*") // 'a*' matches 'a'
// 'a*' matches 'aa'
: '[^/]*';
return "".concat(prefix, "(?=$|\\/$)");
}), _TRAILING_WILD_CARD_R);
// @param {pattern}
var makeRegexPrefix = function makeRegexPrefix(pattern) {
return REPLACERS.reduce(function (prev, _ref) {
var _ref2 = _slicedToArray(_ref, 2),
matcher = _ref2[0],
replacer = _ref2[1];
return prev.replace(matcher, replacer.bind(pattern));
}, pattern);
};
var isString = function isString(subject) {
return typeof subject === 'string';
};
// > A blank line matches no files, so it can serve as a separator for readability.
var checkPattern = function checkPattern(pattern) {
return pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
// > A line starting with # serves as a comment.
&& pattern.indexOf('#') !== 0;
};
var splitPattern = function splitPattern(pattern) {
return pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
};
var IgnoreRule = /*#__PURE__*/function () {
function IgnoreRule(pattern, mark, body, ignoreCase, negative, prefix) {
_classCallCheck(this, IgnoreRule);
this.pattern = pattern;
this.mark = mark;
this.negative = negative;
define(this, 'body', body);
define(this, 'ignoreCase', ignoreCase);
define(this, 'regexPrefix', prefix);
}
_createClass(IgnoreRule, [{
key: "regex",
get: function get() {
var key = UNDERSCORE + MODE_IGNORE;
if (this[key]) {
return this[key];
}
return this._make(MODE_IGNORE, key);
}
}, {
key: "checkRegex",
get: function get() {
var key = UNDERSCORE + MODE_CHECK_IGNORE;
if (this[key]) {
return this[key];
}
return this._make(MODE_CHECK_IGNORE, key);
}
}, {
key: "_make",
value: function _make(mode, key) {
var str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD,
// It does not need to bind pattern
TRAILING_WILD_CARD_REPLACERS[mode]);
var regex = this.ignoreCase ? new RegExp(str, 'i') : new RegExp(str);
return define(this, key, regex);
}
}]);
return IgnoreRule;
}();
var createRule = function createRule(_ref3, ignoreCase) {
var pattern = _ref3.pattern,
mark = _ref3.mark;
var negative = false;
var body = pattern;
// > An optional prefix "!" which negates the pattern;
if (body.indexOf('!') === 0) {
negative = true;
body = body.substr(1);
}
body = body
// > Put a backslash ("\") in front of the first "!" for patterns that
// > begin with a literal "!", for example, `"\!important!.txt"`.
.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
// > Put a backslash ("\") in front of the first hash for patterns that
// > begin with a hash.
.replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
var regexPrefix = makeRegexPrefix(body);
return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
};
var RuleManager = /*#__PURE__*/function () {
function RuleManager(ignoreCase) {
_classCallCheck(this, RuleManager);
this._ignoreCase = ignoreCase;
this._rules = [];
}
_createClass(RuleManager, [{
key: "_add",
value: function _add(pattern) {
// #32
if (pattern && pattern[KEY_IGNORE]) {
this._rules = this._rules.concat(pattern._rules._rules);
this._added = true;
return;
}
if (isString(pattern)) {
pattern = {
pattern: pattern
};
}
if (checkPattern(pattern.pattern)) {
var rule = createRule(pattern, this._ignoreCase);
this._added = true;
this._rules.push(rule);
}
}
// @param {Array<string> | string | Ignore} pattern
}, {
key: "add",
value: function add(pattern) {
this._added = false;
makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
return this._added;
}
// Test one single path without recursively checking parent directories
//
// - checkUnignored `boolean` whether should check if the path is unignored,
// setting `checkUnignored` to `false` could reduce additional
// path matching.
// - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
// @returns {TestResult} true if a file is ignored
}, {
key: "test",
value: function test(path, checkUnignored, mode) {
var ignored = false;
var unignored = false;
var matchedRule;
this._rules.forEach(function (rule) {
var negative = rule.negative;
// | ignored : unignored
// -------- | ---------------------------------------
// negative | 0:0 | 0:1 | 1:0 | 1:1
// -------- | ------- | ------- | ------- | --------
// 0 | TEST | TEST | SKIP | X
// 1 | TESTIF | SKIP | TEST | X
// - SKIP: always skip
// - TEST: always test
// - TESTIF: only test if checkUnignored
// - X: that never happen
if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
return;
}
var matched = rule[mode].test(path);
if (!matched) {
return;
}
ignored = !negative;
unignored = negative;
matchedRule = negative ? UNDEFINED : rule;
});
var ret = {
ignored: ignored,
unignored: unignored
};
if (matchedRule) {
ret.rule = matchedRule;
}
return ret;
}
}]);
return RuleManager;
}();
var throwError = function throwError(message, Ctor) {
throw new Ctor(message);
};
var checkPath = function checkPath(path, originalPath, doThrow) {
if (!isString(path)) {
return doThrow("path must be a string, but got `".concat(originalPath, "`"), TypeError);
}
// We don't know if we should ignore EMPTY, so throw
if (!path) {
return doThrow("path must not be empty", TypeError);
}
// Check if it is a relative path
if (checkPath.isNotRelative(path)) {
var r = '`path.relative()`d';
return doThrow("path should be a ".concat(r, " string, but got \"").concat(originalPath, "\""), RangeError);
}
return true;
};
var isNotRelative = function isNotRelative(path) {
return REGEX_TEST_INVALID_PATH.test(path);
};
checkPath.isNotRelative = isNotRelative;
// On windows, the following function will be replaced
/* istanbul ignore next */
checkPath.convert = function (p) {
return p;
};
var Ignore = /*#__PURE__*/function () {
function Ignore() {
var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref4$ignorecase = _ref4.ignorecase,
ignorecase = _ref4$ignorecase === void 0 ? true : _ref4$ignorecase,
_ref4$ignoreCase = _ref4.ignoreCase,
ignoreCase = _ref4$ignoreCase === void 0 ? ignorecase : _ref4$ignoreCase,
_ref4$allowRelativePa = _ref4.allowRelativePaths,
allowRelativePaths = _ref4$allowRelativePa === void 0 ? false : _ref4$allowRelativePa;
_classCallCheck(this, Ignore);
define(this, KEY_IGNORE, true);
this._rules = new RuleManager(ignoreCase);
this._strictPathCheck = !allowRelativePaths;
this._initCache();
}
_createClass(Ignore, [{
key: "_initCache",
value: function _initCache() {
// A cache for the result of `.ignores()`
this._ignoreCache = Object.create(null);
// A cache for the result of `.test()`
this._testCache = Object.create(null);
}
}, {
key: "add",
value: function add(pattern) {
if (this._rules.add(pattern)) {
// Some rules have just added to the ignore,
// making the behavior changed,
// so we need to re-initialize the result cache
this._initCache();
}
return this;
}
// legacy
}, {
key: "addPattern",
value: function addPattern(pattern) {
return this.add(pattern);
}
// @returns {TestResult}
}, {
key: "_test",
value: function _test(originalPath, cache, checkUnignored, slices) {
var path = originalPath
// Supports nullable path
&& checkPath.convert(originalPath);
checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
return this._t(path, cache, checkUnignored, slices);
}
}, {
key: "checkIgnore",
value: function checkIgnore(path) {
// If the path doest not end with a slash, `.ignores()` is much equivalent
// to `git check-ignore`
if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
return this.test(path);
}
var slices = path.split(SLASH).filter(Boolean);
slices.pop();
if (slices.length) {
var parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
if (parent.ignored) {
return parent;
}
}
return this._rules.test(path, false, MODE_CHECK_IGNORE);
}
}, {
key: "_t",
value: function _t(
// The path to be tested
path,
// The cache for the result of a certain checking
cache,
// Whether should check if the path is unignored
checkUnignored,
// The path slices
slices) {
if (path in cache) {
return cache[path];
}
if (!slices) {
// path/to/a.js
// ['path', 'to', 'a.js']
slices = path.split(SLASH).filter(Boolean);
}
slices.pop();
// If the path has no parent directory, just test it
if (!slices.length) {
return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
}
var parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
// If the path contains a parent directory, check the parent first
return cache[path] = parent.ignored
// > It is not possible to re-include a file if a parent directory of
// > that file is excluded.
? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
}
}, {
key: "ignores",
value: function ignores(path) {
return this._test(path, this._ignoreCache, false).ignored;
}
}, {
key: "createFilter",
value: function createFilter() {
var _this = this;
return function (path) {
return !_this.ignores(path);
};
}
}, {
key: "filter",
value: function filter(paths) {
return makeArray(paths).filter(this.createFilter());
}
// @returns {TestResult}
}, {
key: "test",
value: function test(path) {
return this._test(path, this._testCache, true);
}
}]);
return Ignore;
}();
var factory = function factory(options) {
return new Ignore(options);
};
var isPathValid = function isPathValid(path) {
return checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
};
// Windows
// --------------------------------------------------------------
/* istanbul ignore next */
if (
// Detect `process` so that it can run in browsers.
typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
/* eslint no-control-regex: "off" */
var makePosix = function makePosix(str) {
return /^\\\\\?\\/.test(str) || /[\0-\x1F"<>\|]+/.test(str) ? str : str.replace(/\\/g, '/');
};
checkPath.convert = makePosix;
// 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
// 'd:\\foo'
var REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
checkPath.isNotRelative = function (path) {
return REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
};
}
// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////
module.exports = factory;
// Although it is an anti-pattern,
// it is still widely misused by a lot of libraries in github
// Ref: https://github.com/search?q=ignore.default%28%29&type=code
factory["default"] = factory;
module.exports.isPathValid = isPathValid;

82
node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/package.json generated vendored Normal file
View file

@ -0,0 +1,82 @@
{
"name": "ignore",
"version": "7.0.4",
"description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
"types": "index.d.ts",
"files": [
"legacy.js",
"index.js",
"index.d.ts",
"LICENSE-MIT"
],
"scripts": {
"prepublishOnly": "npm run build",
"build": "babel -o legacy.js index.js",
"==================== linting ======================": "",
"lint": "eslint .",
"===================== import ======================": "",
"ts": "npm run test:ts && npm run test:16",
"test:ts": "ts-node ./test/import/simple.ts",
"test:16": "npm run test:ts:16 && npm run test:cjs:16 && npm run test:mjs:16",
"test:ts:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.ts && tsc ./test/import/simple.ts --lib ES6 --moduleResolution Node16 --module Node16 && node ./test/import/simple.js",
"test:cjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.cjs",
"test:mjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.mjs && babel -o ./test/import/simple-mjs.js ./test/import/simple.mjs && node ./test/import/simple-mjs.js",
"===================== cases =======================": "",
"test:cases": "npm run tap test/*.test.js -- --coverage",
"tap": "tap --reporter classic",
"===================== debug =======================": "",
"test:git": "npm run tap test/git-check-ignore.test.js",
"test:ignore": "npm run tap test/ignore.test.js",
"test:ignore:only": "IGNORE_ONLY_IGNORES=1 npm run tap test/ignore.test.js",
"test:others": "npm run tap test/others.test.js",
"test:no-coverage": "npm run tap test/*.test.js -- --no-check-coverage",
"test": "npm run lint && npm run ts && npm run build && npm run test:cases",
"test:win32": "IGNORE_TEST_WIN32=1 npm run test",
"report": "tap --coverage-report=html"
},
"repository": {
"type": "git",
"url": "git@github.com:kaelzhang/node-ignore.git"
},
"keywords": [
"ignore",
".gitignore",
"gitignore",
"npmignore",
"rules",
"manager",
"filter",
"regexp",
"regex",
"fnmatch",
"glob",
"asterisks",
"regular-expression"
],
"author": "kael",
"license": "MIT",
"bugs": {
"url": "https://github.com/kaelzhang/node-ignore/issues"
},
"devDependencies": {
"@babel/cli": "^7.22.9",
"@babel/core": "^7.22.9",
"@babel/preset-env": "^7.22.9",
"@typescript-eslint/eslint-plugin": "^8.19.1",
"debug": "^4.3.4",
"eslint": "^8.46.0",
"eslint-config-ostai": "^3.0.0",
"eslint-plugin-import": "^2.28.0",
"mkdirp": "^3.0.1",
"pre-suf": "^1.1.1",
"rimraf": "^6.0.1",
"spawn-sync": "^2.0.0",
"tap": "^16.3.9",
"tmp": "0.2.3",
"ts-node": "^10.9.2",
"typescript": "^5.6.2"
},
"engines": {
"node": ">= 4"
}
}

32
node_modules/@typescript-eslint/eslint-plugin/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/eslint-plugin",
"version": "8.31.1",
"version": "8.32.1",
"description": "TypeScript plugin for ESLint",
"files": [
"dist",
@ -50,50 +50,48 @@
],
"scripts": {
"build": "tsc -b tsconfig.build.json",
"clean": "tsc -b tsconfig.build.json --clean",
"postclean": "rimraf dist && rimraf coverage",
"clean": "rimraf dist/ coverage/",
"format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
"generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
"generate:configs": "npx nx generate-configs repo",
"lint": "npx nx lint",
"test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
"test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts",
"test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts --no-coverage",
"check-types": "npx nx typecheck"
},
"dependencies": {
"@eslint-community/regexpp": "^4.10.0",
"@typescript-eslint/scope-manager": "8.31.1",
"@typescript-eslint/type-utils": "8.31.1",
"@typescript-eslint/utils": "8.31.1",
"@typescript-eslint/visitor-keys": "8.31.1",
"@typescript-eslint/scope-manager": "8.32.1",
"@typescript-eslint/type-utils": "8.32.1",
"@typescript-eslint/utils": "8.32.1",
"@typescript-eslint/visitor-keys": "8.32.1",
"graphemer": "^1.4.0",
"ignore": "^5.3.1",
"ignore": "^7.0.0",
"natural-compare": "^1.4.0",
"ts-api-utils": "^2.0.1"
"ts-api-utils": "^2.1.0"
},
"devDependencies": {
"@types/marked": "^5.0.2",
"@types/mdast": "^4.0.3",
"@types/natural-compare": "*",
"@typescript-eslint/rule-schema-to-typescript-types": "8.31.1",
"@typescript-eslint/rule-tester": "8.31.1",
"@vitest/coverage-v8": "^3.1.1",
"@typescript-eslint/rule-schema-to-typescript-types": "8.32.1",
"@typescript-eslint/rule-tester": "8.32.1",
"@vitest/coverage-v8": "^3.1.3",
"ajv": "^6.12.6",
"cross-fetch": "*",
"eslint": "*",
"json-schema": "*",
"markdown-table": "^3.0.3",
"marked": "^5.1.2",
"marked": "^15.0.0",
"mdast-util-from-markdown": "^2.0.0",
"mdast-util-mdx": "^3.0.0",
"micromark-extension-mdxjs": "^3.0.0",
"prettier": "^3.2.5",
"rimraf": "*",
"title-case": "^3.0.3",
"title-case": "^4.0.0",
"tsx": "*",
"typescript": "*",
"unist-util-visit": "^5.0.0",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"peerDependencies": {
"@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",

17
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/scope-manager/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/scope-manager",
"version": "8.31.1",
"version": "8.32.1",
"description": "TypeScript scope analyser for ESLint",
"files": [
"dist",
@ -38,7 +38,7 @@
],
"scripts": {
"build": "tsc -b tsconfig.build.json",
"clean": "rimraf dist/ _ts4.3/ coverage/",
"clean": "rimraf dist/ coverage/",
"clean-fixtures": "rimraf -g \"./src/**/fixtures/**/snapshots\"",
"format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
"generate-lib": "npx nx generate-lib repo",
@ -47,17 +47,18 @@
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/visitor-keys": "8.31.1"
"@typescript-eslint/types": "8.32.1",
"@typescript-eslint/visitor-keys": "8.32.1"
},
"devDependencies": {
"@typescript-eslint/typescript-estree": "8.31.1",
"@vitest/coverage-v8": "^3.1.1",
"@typescript-eslint/typescript-estree": "8.32.1",
"@vitest/coverage-v8": "^3.1.3",
"@vitest/pretty-format": "^3.1.3",
"glob": "*",
"prettier": "^3.2.5",
"pretty-format": "*",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

6
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/types/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/types",
"version": "8.31.1",
"version": "8.32.1",
"description": "Types for the TypeScript-ESTree AST spec",
"files": [
"dist",
@ -67,12 +67,12 @@
}
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@vitest/coverage-v8": "^3.1.3",
"prettier": "^3.2.5",
"rimraf": "*",
"tsx": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

2
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/typescript-estree/dist/convert.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAyhFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}
{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAiiFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}

27
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/typescript-estree/dist/convert.js generated vendored
View file

@ -2081,12 +2081,14 @@ class Converter {
constraint: this.convertChild(node.typeParameter.constraint),
key: this.convertChild(node.typeParameter.name),
nameType: this.convertChild(node.nameType) ?? null,
optional: node.questionToken &&
(node.questionToken.kind === SyntaxKind.QuestionToken ||
(0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)),
readonly: node.readonlyToken &&
(node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
(0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)),
optional: node.questionToken
? node.questionToken.kind === SyntaxKind.QuestionToken ||
(0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)
: false,
readonly: node.readonlyToken
? node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
(0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)
: undefined,
typeAnnotation: node.type && this.convertChild(node.type),
}, 'typeParameter', "'constraint' and 'key'", this.convertChild(node.typeParameter)));
}
@ -2250,21 +2252,24 @@ class Converter {
const commaToken = (0, node_utils_1.findNextToken)(node.argument, node, this.ast);
const openBraceToken = (0, node_utils_1.findNextToken)(commaToken, node, this.ast);
const closeBraceToken = (0, node_utils_1.findNextToken)(node.attributes, node, this.ast);
const withToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
const withTokenRange = (0, node_utils_1.getRange)(withToken, this.ast);
const withOrAssertToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
const withOrAssertTokenRange = (0, node_utils_1.getRange)(withOrAssertToken, this.ast);
const withOrAssertName = withOrAssertToken.kind === ts.SyntaxKind.AssertKeyword
? 'assert'
: 'with';
options = this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.ObjectExpression,
range: [openBraceToken.getStart(this.ast), closeBraceToken.end],
properties: [
this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.Property,
range: [withTokenRange[0], node.attributes.end],
range: [withOrAssertTokenRange[0], node.attributes.end],
computed: false,
key: this.createNode(node, {
type: ts_estree_1.AST_NODE_TYPES.Identifier,
range: withTokenRange,
range: withOrAssertTokenRange,
decorators: [],
name: 'with',
name: withOrAssertName,
optional: false,
typeAnnotation: undefined,
}),

16
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/typescript-estree/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/typescript-estree",
"version": "8.31.1",
"version": "8.32.1",
"description": "A parser that converts TypeScript source code into an ESTree compatible form",
"files": [
"dist",
@ -45,30 +45,30 @@
],
"scripts": {
"build": "tsc -b tsconfig.build.json",
"clean": "tsc -b tsconfig.build.json --clean",
"postclean": "rimraf dist/ coverage/",
"clean": "rimraf dist/ coverage/",
"format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
"lint": "npx nx lint",
"test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/visitor-keys": "8.31.1",
"@typescript-eslint/types": "8.32.1",
"@typescript-eslint/visitor-keys": "8.32.1",
"debug": "^4.3.4",
"fast-glob": "^3.3.2",
"is-glob": "^4.0.3",
"minimatch": "^9.0.4",
"semver": "^7.6.0",
"ts-api-utils": "^2.0.1"
"ts-api-utils": "^2.1.0"
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@types/is-glob": "^4.0.4",
"@vitest/coverage-v8": "^3.1.3",
"glob": "*",
"prettier": "^3.2.5",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"peerDependencies": {
"typescript": ">=4.8.4 <5.9.0"

8
node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/visitor-keys/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/visitor-keys",
"version": "8.31.1",
"version": "8.32.1",
"description": "Visitor keys used to help traverse the TypeScript-ESTree AST",
"files": [
"dist",
@ -46,15 +46,15 @@
"check-types": "npx nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "8.31.1",
"@typescript-eslint/types": "8.32.1",
"eslint-visitor-keys": "^4.2.0"
},
"devDependencies": {
"@vitest/coverage-v8": "^3.1.1",
"@vitest/coverage-v8": "^3.1.3",
"prettier": "^3.2.5",
"rimraf": "*",
"typescript": "*",
"vitest": "^3.1.1"
"vitest": "^3.1.3"
},
"funding": {
"type": "opencollective",

Some files were not shown because too many files have changed in this diff Show more