Sep 4, 2024 · Aug 20, 2024 · Aug 20, 2024 · Aug 20, 2024 · Aug 20, 2024 · Aug 20, 2024
diff --git a/eslint.config.mjs b/eslint.config.mjs
      'unicorn/prefer-export-from': 'error',
      'unicorn/prefer-node-protocol': 'error',
      'unicorn/prefer-regexp-test': 'error',
      'unicorn/prefer-spread': 'error',
      'unicorn/prefer-string-replace-all': 'error',
      'unicorn/prefer-structured-clone': 'error',
    },
diff --git a/packages/ast-spec/tests/fixtures.test.ts b/packages/ast-spec/tests/fixtures.test.ts

  // once we've run all the tests, snapshot the list of fixtures that have differences for easy reference
  it('List fixtures with AST differences', () => {
    expect(
      Array.from(fixturesWithASTDifferences).sort(),
    ).toMatchSpecificSnapshot(
    expect([...fixturesWithASTDifferences].sort()).toMatchSpecificSnapshot(
      path.resolve(__dirname, 'fixtures-with-differences-ast.shot'),
    );
  });
  it('List fixtures with Token differences', () => {
    expect(
      Array.from(fixturesWithTokenDifferences).sort(),
    ).toMatchSpecificSnapshot(
    expect([...fixturesWithTokenDifferences].sort()).toMatchSpecificSnapshot(
      path.resolve(__dirname, 'fixtures-with-differences-tokens.shot'),
    );
  });
      Object.fromEntries(
        Object.entries(fixturesWithErrorDifferences).map(([key, value]) => [
          key,
 Array.from(value).sort(),
 [...value].sort(),
        ]),
      ),
    ).toMatchSpecificSnapshot(
  });
  it('List fixtures we expect babel to not support', () => {
    expect(
 Array.from(fixturesConfiguredToExpectBabelToNotSupport).sort(),
 [...fixturesConfiguredToExpectBabelToNotSupport].sort(),
    ).toMatchSpecificSnapshot(
      path.resolve(__dirname, 'fixtures-without-babel-support.shot'),
    );
diff --git a/packages/ast-spec/tests/util/serializers/Node.ts b/packages/ast-spec/tests/util/serializers/Node.ts
    keySet.delete('interpreter');
  }

  returnArray.from(keySet).sort((a, b) =>
  return[...keySet].sort((a, b) =>
    a.localeCompare(b),
  ) as (keyof typeof node)[];
 }
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
 ): IterableIterator<TSESLint.RuleFix> {
  const { node, typeBasedSpecifiers, inlineTypeSpecifiers, valueSpecifiers } =
    report;
  const typeSpecifiers = typeBasedSpecifiers.concat(inlineTypeSpecifiers);
  const typeSpecifiers =[...typeBasedSpecifiers, ...inlineTypeSpecifiers];
  const source = getSourceFromExport(node);
  const specifierNames = typeSpecifiers.map(getSpecifierText).join(', ');

diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
  orderConfig: MemberType[],
 ): number {
  let rank = -1;
  const stack =memberGroups.slice(); // Get a copy of the member groups
  const stack =[...memberGroups]; // Get a copy of the member groups

  while (stack.length > 0 && rank === -1) {
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
    return {
      'Program:exit'(node): void {
        const globalScope = context.sourceCode.getScope(node);
        const stack = globalScope.childScopes.slice();
        const stack =[...globalScope.childScopes];

        while (stack.length) {
          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
              const text = context.sourceCode
                .getText()
                .slice(start, member.range[1]);
              const comments = context.sourceCode
                .getCommentsBefore(member)
                .concat(context.sourceCode.getCommentsAfter(member));
              const comments = [
                ...context.sourceCode.getCommentsBefore(member),
                ...context.sourceCode.getCommentsAfter(member),
              ];
              let suggestion = `${text.slice(0, colonPos)} =>${text.slice(
                colonPos + 1,
              )}`;
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
    });

    return [
      ...Array.from(this.privateModifiableMembers.values()),
      ...Array.from(this.privateModifiableStatics.values()),
      ...this.privateModifiableMembers.values(),
      ...this.privateModifiableStatics.values(),
    ];
  }
 }
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
        'checkScope() called without a current scope',
      );
      const failures = checkOverloads(
 Array.from(scope.overloads.values()),
 [...scope.overloads.values()],
        scope.typeParameters,
      );
      addFailures(failures);
diff --git a/packages/rule-schema-to-typescript-types/src/generateType.ts b/packages/rule-schema-to-typescript-types/src/generateType.ts
      throw new UnexpectedError(
        `Could not find definition for $ref ${
          schema.$ref
        }.\nAvailable refs:\n${Array.from(refMap.keys()).join('\n')})`,
        }.\nAvailable refs:\n${[...refMap.keys()].join('\n')})`,
        schema,
      );
    }
diff --git a/packages/rule-schema-to-typescript-types/src/optimizeAST.ts b/packages/rule-schema-to-typescript-types/src/optimizeAST.ts
      for (const element of elements) {
        uniqueElementsMap.set(JSON.stringify(element), element);
      }
      const uniqueElements =Array.from(uniqueElementsMap.values());
      const uniqueElements =[...uniqueElementsMap.values()];

      // @ts-expect-error -- purposely overwriting the property with a flattened list
      ast.elements = uniqueElements;
diff --git a/packages/rule-schema-to-typescript-types/src/printAST.ts b/packages/rule-schema-to-typescript-types/src/printAST.ts
      const code = printAndMaybeParenthesise(ast.elementType);
      return {
        code: `${code.code}[]`,
        commentLines: ast.commentLines.concat(code.commentLines),
        commentLines:[...ast.commentLines, ...code.commentLines],
      };
    }

diff --git a/packages/rule-tester/src/utils/flat-config-schema.ts b/packages/rule-tester/src/utils/flat-config-schema.ts
  ruleOptions: SharedConfig.RuleLevel | SharedConfig.RuleLevelAndOptions,
 ): SharedConfig.RuleLevelAndOptions {
  const finalOptions = Array.isArray(ruleOptions)
    ?ruleOptions.slice(0)
    ?[...ruleOptions]
    : [ruleOptions];

  finalOptions[0] = ruleSeverities.get(
diff --git a/packages/scope-manager/src/ScopeManager.ts b/packages/scope-manager/src/ScopeManager.ts
      scope.childScopes.forEach(recurse);
    }
    this.scopes.forEach(recurse);
    returnArray.from(variables).sort((a, b) => a.$id - b.$id);
    return[...variables].sort((a, b) => a.$id - b.$id);
  }

  constructor(options: ScopeManagerOptions) {
diff --git a/packages/scope-manager/tests/fixtures.test.ts b/packages/scope-manager/tests/fixtures.test.ts

        if (type[1] && !type[1].has(value)) {
          throw new Error(
            `Expected value for ${key} to be one of (${Array.from(type[1]).join(
            `Expected value for ${key} to be one of (${[...type[1]].join(
              ' | ',
            )}), but got ${value as string}`,
          );
diff --git a/packages/typescript-estree/src/convert.ts b/packages/typescript-estree/src/convert.ts
                );
                break;
              case SyntaxKind.NamedImports:
                result.specifiers = result.specifiers.concat(
                  node.importClause.namedBindings.elements.map(el =>
                    this.convertChild(el),
                result.specifiers.push(
 ...node.importClause.namedBindings.elements.map(
 el =>this.convertChild(el) as TSESTree.ImportClause,
                  ),
                );
                break;
            left.type === AST_NODE_TYPES.SequenceExpression &&
            node.left.kind !== SyntaxKind.ParenthesizedExpression
          ) {
            result.expressions = result.expressions.concat(left.expressions);
            result.expressions.push(...left.expressions);
          } else {
            result.expressions.push(left);
          }
diff --git a/packages/typescript-estree/src/create-program/createProjectProgramError.ts b/packages/typescript-estree/src/create-program/createProjectProgramError.ts
  describedFilePath: string,
  parseSettings: ParseSettings,
 ): string {
  const relativeProjects =Array.from(parseSettings.projects.values()).map(
  const relativeProjects =[...parseSettings.projects.values()].map(
    projectFile => describeFilePath(projectFile, parseSettings.tsconfigRootDir),
  );

diff --git a/packages/typescript-estree/src/create-program/getWatchProgramsForProjects.ts b/packages/typescript-estree/src/create-program/getWatchProgramsForProjects.ts
        path,
        !extensions
          ? undefined
          : extensions.concat(parseSettings.extraFileExtensions),
          :[...extensions, ...parseSettings.extraFileExtensions],
        exclude,
        include,
        depth,
diff --git a/packages/typescript-estree/src/getModifiers.ts b/packages/typescript-estree/src/getModifiers.ts
    if (includeIllegalModifiers || ts.canHaveModifiers(node)) {
      // eslint-disable-next-line @typescript-eslint/no-deprecated -- this is safe as it's guarded
      const modifiers = ts.getModifiers(node as ts.HasModifiers);
      return modifiers ?Array.from(modifiers) : undefined;
      return modifiers ?[...modifiers] : undefined;
    }

    return undefined;
    if (includeIllegalDecorators || ts.canHaveDecorators(node)) {
      // eslint-disable-next-line @typescript-eslint/no-deprecated -- this is safe as it's guarded
      const decorators = ts.getDecorators(node as ts.HasDecorators);
      return decorators ?Array.from(decorators) : undefined;
      return decorators ?[...decorators] : undefined;
    }

    return undefined;
diff --git a/packages/typescript-estree/src/parseSettings/resolveProjectList.ts b/packages/typescript-estree/src/parseSettings/resolveProjectList.ts
  }

  const uniqueCanonicalProjectPaths = new Map(
    nonGlobProjects
      .concat(globProjectPaths)
      .map(project => [
        getCanonicalFileName(
          ensureAbsolutePath(project, options.tsconfigRootDir),
        ),
    [...nonGlobProjects, ...globProjectPaths].map(project => [
      getCanonicalFileName(
        ensureAbsolutePath(project, options.tsconfigRootDir),
      ]),
      ),
      ensureAbsolutePath(project, options.tsconfigRootDir),
    ]),
  );

  log(
diff --git a/packages/typescript-estree/src/parseSettings/warnAboutTSVersion.ts b/packages/typescript-estree/src/parseSettings/warnAboutTSVersion.ts
 const ACTIVE_TYPESCRIPT_VERSION = ts.version;
 const isRunningSupportedTypeScriptVersion = semver.satisfies(
  ACTIVE_TYPESCRIPT_VERSION,
  [SUPPORTED_TYPESCRIPT_VERSIONS]
    .concat(SUPPORTED_PRERELEASE_RANGES)
    .join(' || '),
  [SUPPORTED_TYPESCRIPT_VERSIONS, ...SUPPORTED_PRERELEASE_RANGES].join(' || '),
 );

 let warnedAboutTSVersion = false;
diff --git a/packages/typescript-estree/src/useProgramFromProjectService.ts b/packages/typescript-estree/src/useProgramFromProjectService.ts
      serviceSettings.maximumDefaultProjectFileMatchCount
    ) {
      const filePrintLimit = 20;
      const filesToPrint =Array.from(defaultProjectMatchedFiles).slice(
      const filesToPrint =[...defaultProjectMatchedFiles].slice(
        0,
        filePrintLimit,
      );
diff --git a/packages/utils/src/eslint-utils/deepMerge.ts b/packages/utils/src/eslint-utils/deepMerge.ts
  second: ObjectLike = {},
 ): Record<string, unknown> {
  // get the unique set of keys across both objects
  const keys = new Set(Object.keys(first).concat(Object.keys(second)));
  const keys = new Set([...Object.keys(first), ...Object.keys(second)]);

  return Object.fromEntries(
 Array.from(keys,key => {
 [...keys].map(key => {
      const firstHasKey = key in first;
      const secondHasKey = key in second;
      const firstValue = first[key];
diff --git a/packages/website-eslint/src/mock/path.js b/packages/website-eslint/src/mock/path.js
    }
  }

  let outputParts = [];
  for (let i = samePartsLength; i < fromParts.length; i++) {
    outputParts.push('..');
  }

  outputParts = outputParts.concat(toParts.slice(samePartsLength));

  return outputParts.join('/');
  return [
    ...Array(fromParts.length - samePartsLength).fill('..'),
    ...toParts.slice(samePartsLength),
  ].join('/');
 }

 export const sep = '/';
diff --git a/packages/website/src/components/config/ConfigTypeScript.tsx b/packages/website/src/components/config/ConfigTypeScript.tsx
              key: item.name,
              type: 'string',
              label: item.description.message,
              enum: ['', ...Array.from<string>(item.type.keys())],
              enum: ['', ...item.type.keys()],
            });
          }
          return group;
diff --git a/packages/website/src/components/editor/LoadedEditor.tsx b/packages/website/src/components/editor/LoadedEditor.tsx
      enableSchemaRequest: false,
      allowComments: true,
      schemas: [
        ...Array.from(webLinter.rules.values()).map(rule => ({
        ...[...webLinter.rules.values()].map(rule => ({
          uri: createRuleUri(rule.name),
          schema: getRuleJsonSchemaWithErrorLevel(rule.name, rule.schema),
        })),
diff --git a/packages/website/src/components/editor/useSandboxServices.ts b/packages/website/src/components/editor/useSandboxServices.ts
        );

        onLoaded(
          Array.from(webLinter.rules.values()),
          Array.from(
            new Set([...sandboxInstance.supportedVersions, window.ts.version]),
          )
          [...webLinter.rules.values()],
          [
            ...new Set([
              ...sandboxInstance.supportedVersions,
              window.ts.version,
            ]),
          ]
            .filter(item =>
              semverSatisfies(item, rootPackageJson.devDependencies.typescript),
            )
diff --git a/packages/website/src/components/lib/jsonSchema.ts b/packages/website/src/components/lib/jsonSchema.ts
          value = {
            description: item.description.message,
            items: {
              enum:Array.from(item.element.type.keys()),
              enum:[...item.element.type.keys()],
              type: 'string',
            },
            type: 'array',
          };
        } else if (item.type instanceof Map) {
          value = {
            description: item.description.message,
            enum:Array.from(item.type.keys()),
            enum:[...item.type.keys()],
            type: 'string',
          };
        }
diff --git a/packages/website/src/components/linter/createLinter.ts b/packages/website/src/components/linter/createLinter.ts
  applyTSConfig('/tsconfig.json');

  return {
    configs:Array.from(configs.keys()),
    configs:[...configs.keys()],
    onLint: onLint.register,
    onParse: onParse.register,
    rules,
diff --git a/packages/website/src/components/linter/createParser.ts b/packages/website/src/components/linter/createParser.ts
  ): tsvfs.VirtualTypeScriptEnvironment => {
    return vfs.createVirtualTypeScriptEnvironment(
      system,
 Array.from(registeredFiles),
 [...registeredFiles],
      window.ts,
      compilerOptions,
    );
diff --git a/packages/website/src/theme/NotFound/Content/index.tsx b/packages/website/src/theme/NotFound/Content/index.tsx
          <h1 className={styles.title}>
            <div className={styles.code}>$ npx eslint .</div>
            <strong>
              {`'${location.pathname}'`.split('').map((letter, i) => (
              {[...`'${location.pathname}'`].map((letter, i) => (
                <span className={styles.word} key={i}>
                  {letter}
                </span>
diff --git a/tools/scripts/generate-lib.mts b/tools/scripts/generate-lib.mts

    if (requiredBaseImports.size > 0) {
      imports.push(
        `import {${Array.from(requiredBaseImports)
        `import {${[...requiredBaseImports]
          .sort()
          .join(',')}} from './${BASE_CONFIG_MODULE_NAME}';`,
      );
  // generate a string union type for the lib names

  const libUnionCode = [
    `type Lib = ${Array.from(libMap.keys())
      .map(k => `'${k}'`)
      .join(' | ')};`,
    `type Lib = ${[...libMap.keys()].map(k => `'${k}'`).join(' | ')};`,
    '',
    'export { Lib };',
  ];
Original file line number	Diff line number	Diff line change
Expand Up		@@ -332,6 +332,7 @@ export default tseslint.config(
		'unicorn/prefer-export-from': 'error',
		'unicorn/prefer-node-protocol': 'error',
		'unicorn/prefer-regexp-test': 'error',
		'unicorn/prefer-spread': 'error',
		'unicorn/prefer-string-replace-all': 'error',
		'unicorn/prefer-structured-clone': 'error',
		},
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -339,16 +339,12 @@ describe('AST Fixtures', () => {

		// once we've run all the tests, snapshot the list of fixtures that have differences for easy reference
		it('List fixtures with AST differences', () => {
		expect(
		Array.from(fixturesWithASTDifferences).sort(),
		).toMatchSpecificSnapshot(
		expect([...fixturesWithASTDifferences].sort()).toMatchSpecificSnapshot(
		path.resolve(__dirname, 'fixtures-with-differences-ast.shot'),
		);
		});
		it('List fixtures with Token differences', () => {
		expect(
		Array.from(fixturesWithTokenDifferences).sort(),
		).toMatchSpecificSnapshot(
		expect([...fixturesWithTokenDifferences].sort()).toMatchSpecificSnapshot(
		path.resolve(__dirname, 'fixtures-with-differences-tokens.shot'),
		);
		});
Expand All		@@ -357,7 +353,7 @@ describe('AST Fixtures', () => {
		Object.fromEntries(
		Object.entries(fixturesWithErrorDifferences).map(([key, value]) => [
		key,
		Array.from(value).sort(),
		[...value].sort(),
		]),
		),
		).toMatchSpecificSnapshot(
Expand All		@@ -366,7 +362,7 @@ describe('AST Fixtures', () => {
		});
		it('List fixtures we expect babel to not support', () => {
		expect(
		Array.from(fixturesConfiguredToExpectBabelToNotSupport).sort(),
		[...fixturesConfiguredToExpectBabelToNotSupport].sort(),
		).toMatchSpecificSnapshot(
		path.resolve(__dirname, 'fixtures-without-babel-support.shot'),
		);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -22,7 +22,7 @@ function sortKeys<Node extends TSESTree.Node>(
		keySet.delete('interpreter');
		}

		returnArray.from(keySet).sort((a, b) =>
		return[...keySet].sort((a, b) =>
		a.localeCompare(b),
		) as (keyof typeof node)[];
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -291,7 +291,7 @@ function* fixSeparateNamedExports(
		): IterableIterator<TSESLint.RuleFix> {
		const { node, typeBasedSpecifiers, inlineTypeSpecifiers, valueSpecifiers } =
		report;
		const typeSpecifiers = typeBasedSpecifiers.concat(inlineTypeSpecifiers);
		const typeSpecifiers =[...typeBasedSpecifiers, ...inlineTypeSpecifiers];
		const source = getSourceFromExport(node);
		const specifierNames = typeSpecifiers.map(getSpecifierText).join(', ');

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -509,7 +509,7 @@ function getRankOrder(
		orderConfig: MemberType[],
		): number {
		let rank = -1;
		const stack =memberGroups.slice(); // Get a copy of the member groups
		const stack =[...memberGroups]; // Get a copy of the member groups

		while (stack.length > 0 && rank === -1) {
		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -645,7 +645,7 @@ export default createRule<Options, MessageIds>({
		return {
		'Program:exit'(node): void {
		const globalScope = context.sourceCode.getScope(node);
		const stack = globalScope.childScopes.slice();
		const stack =[...globalScope.childScopes];

		while (stack.length) {
		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -108,9 +108,10 @@ export default createRule({
		const text = context.sourceCode
		.getText()
		.slice(start, member.range[1]);
		const comments = context.sourceCode
		.getCommentsBefore(member)
		.concat(context.sourceCode.getCommentsAfter(member));
		const comments = [
		...context.sourceCode.getCommentsBefore(member),
		...context.sourceCode.getCommentsAfter(member),
		];
		let suggestion = `${text.slice(0, colonPos)} =>${text.slice(
		colonPos + 1,
		)}`;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -460,8 +460,8 @@ class ClassScope {
		});

		return [
		...Array.from(this.privateModifiableMembers.values()),
		...Array.from(this.privateModifiableStatics.values()),
		...this.privateModifiableMembers.values(),
		...this.privateModifiableStatics.values(),
		];
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -515,7 +515,7 @@ export default createRule<Options, MessageIds>({
		'checkScope() called without a current scope',
		);
		const failures = checkOverloads(
		Array.from(scope.overloads.values()),
		[...scope.overloads.values()],
		scope.typeParameters,
		);
		addFailures(failures);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -38,7 +38,7 @@ export function generateType(schema: JSONSchema4, refMap: RefMap): AST {
		throw new UnexpectedError(
		`Could not find definition for $ref ${
		schema.$ref
		}.\nAvailable refs:\n${Array.from(refMap.keys()).join('\n')})`,
		}.\nAvailable refs:\n${[...refMap.keys()].join('\n')})`,
		schema,
		);
		}
Expand Down