@alexlit/lint-kit 175.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/import-style.js

@@ -0,0 +1,375 @@
+import {getStringIfConstant} from '@eslint-community/eslint-utils';
+import {isCallExpression} from './ast/index.js';
+
+const MESSAGE_ID = 'importStyle';
+const messages = {
+	[MESSAGE_ID]: 'Use {{allowedStyles}} import for module `{{moduleName}}`.',
+};
+
+const getActualImportDeclarationStyles = importDeclaration => {
+	const {specifiers} = importDeclaration;
+
+	if (specifiers.length === 0) {
+		return ['unassigned'];
+	}
+
+	const styles = new Set();
+
+	for (const specifier of specifiers) {
+		if (specifier.type === 'ImportDefaultSpecifier') {
+			styles.add('default');
+			continue;
+		}
+
+		if (specifier.type === 'ImportNamespaceSpecifier') {
+			styles.add('namespace');
+			continue;
+		}
+
+		if (specifier.type === 'ImportSpecifier') {
+			if (specifier.imported.type === 'Identifier' && specifier.imported.name === 'default') {
+				styles.add('default');
+				continue;
+			}
+
+			styles.add('named');
+			continue;
+		}
+	}
+
+	return [...styles];
+};
+
+const getActualExportDeclarationStyles = exportDeclaration => {
+	const {specifiers} = exportDeclaration;
+
+	if (specifiers.length === 0) {
+		return ['unassigned'];
+	}
+
+	const styles = new Set();
+
+	for (const specifier of specifiers) {
+		if (specifier.type === 'ExportSpecifier') {
+			if (specifier.exported.type === 'Identifier' && specifier.exported.name === 'default') {
+				styles.add('default');
+				continue;
+			}
+
+			styles.add('named');
+			continue;
+		}
+	}
+
+	return [...styles];
+};
+
+const getActualAssignmentTargetImportStyles = assignmentTarget => {
+	if (assignmentTarget.type === 'Identifier' || assignmentTarget.type === 'ArrayPattern') {
+		return ['namespace'];
+	}
+
+	if (assignmentTarget.type === 'ObjectPattern') {
+		if (assignmentTarget.properties.length === 0) {
+			return ['unassigned'];
+		}
+
+		const styles = new Set();
+
+		for (const property of assignmentTarget.properties) {
+			if (property.type === 'RestElement') {
+				styles.add('named');
+				continue;
+			}
+
+			if (property.key.type === 'Identifier') {
+				if (property.key.name === 'default') {
+					styles.add('default');
+				} else {
+					styles.add('named');
+				}
+			}
+		}
+
+		return [...styles];
+	}
+
+	// Next line is not test-coverable until unforceable changes to the language
+	// like an addition of new AST node types usable in `const __HERE__ = foo;`.
+	// An exotic custom parser or a bug in one could cover it too.
+	/* c8 ignore next */
+	return [];
+};
+
+const isAssignedDynamicImport = node =>
+	node.parent.type === 'AwaitExpression'
+	&& node.parent.argument === node
+	&& node.parent.parent.type === 'VariableDeclarator'
+	&& node.parent.parent.init === node.parent;
+
+// Keep this alphabetically sorted for easier maintenance
+const defaultStyles = {
+	chalk: {
+		default: true,
+	},
+	path: {
+		default: true,
+	},
+	'node:path': {
+		default: true,
+	},
+	util: {
+		named: true,
+	},
+	'node:util': {
+		named: true,
+	},
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	let [
+		{
+			styles = {},
+			extendDefaultStyles = true,
+			checkImport = true,
+			checkDynamicImport = true,
+			checkExportFrom = false,
+			checkRequire = true,
+		} = {},
+	] = context.options;
+
+	styles = extendDefaultStyles
+		? Object.fromEntries(
+			[...Object.keys(defaultStyles), ...Object.keys(styles)]
+				.map(name => [name, styles[name] === false ? {} : {...defaultStyles[name], ...styles[name]}]),
+		)
+		: styles;
+
+	styles = new Map(
+		Object.entries(styles).map(
+			([moduleName, styles]) =>
+				[moduleName, new Set(Object.entries(styles).filter(([, isAllowed]) => isAllowed).map(([style]) => style))],
+		),
+	);
+
+	const {sourceCode} = context;
+
+	// eslint-disable-next-line max-params
+	const report = (node, moduleName, actualImportStyles, allowedImportStyles, isRequire = false) => {
+		if (!allowedImportStyles || allowedImportStyles.size === 0) {
+			return;
+		}
+
+		let effectiveAllowedImportStyles = allowedImportStyles;
+
+		// For `require`, `'default'` style allows both `x = require('x')` (`'namespace'` style) and
+		// `{default: x} = require('x')` (`'default'` style) since we don't know in advance
+		// whether `'x'` is a compiled ES6 module (with `default` key) or a CommonJS module and `require`
+		// does not provide any automatic interop for this, so the user may have to use either of these.
+		if (isRequire && allowedImportStyles.has('default') && !allowedImportStyles.has('namespace')) {
+			effectiveAllowedImportStyles = new Set(allowedImportStyles);
+			effectiveAllowedImportStyles.add('namespace');
+		}
+
+		if (actualImportStyles.every(style => effectiveAllowedImportStyles.has(style))) {
+			return;
+		}
+
+		const data = {
+			allowedStyles: new Intl.ListFormat('en-US', {type: 'disjunction'}).format([...allowedImportStyles.keys()]),
+			moduleName,
+		};
+
+		context.report({
+			node,
+			messageId: MESSAGE_ID,
+			data,
+		});
+	};
+
+	if (checkImport) {
+		context.on('ImportDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualImportDeclarationStyles(node);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkDynamicImport) {
+		context.on('ImportExpression', node => {
+			if (isAssignedDynamicImport(node)) {
+				return;
+			}
+
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['unassigned'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+
+		context.on('VariableDeclarator', node => {
+			if (!(
+				node.init?.type === 'AwaitExpression'
+				&& node.init.argument.type === 'ImportExpression'
+			)) {
+				return;
+			}
+
+			const assignmentTargetNode = node.id;
+			const moduleNameNode = node.init.argument.source;
+			const moduleName = getStringIfConstant(moduleNameNode, sourceCode.getScope(moduleNameNode));
+
+			if (!moduleName) {
+				return;
+			}
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualAssignmentTargetImportStyles(assignmentTargetNode);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkExportFrom) {
+		context.on('ExportAllDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['namespace'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+
+		context.on('ExportNamedDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualExportDeclarationStyles(node);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkRequire) {
+		context.on('CallExpression', node => {
+			if (!(
+				isCallExpression(node, {
+					name: 'require',
+					argumentsLength: 1,
+					optional: false,
+				})
+				&& (node.parent.type === 'ExpressionStatement' && node.parent.expression === node)
+			)) {
+				return;
+			}
+
+			const moduleName = getStringIfConstant(node.arguments[0], sourceCode.getScope(node.arguments[0]));
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['unassigned'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles, true);
+		});
+
+		context.on('VariableDeclarator', node => {
+			if (!(
+				node.init?.type === 'CallExpression'
+				&& node.init.callee.type === 'Identifier'
+				&& node.init.callee.name === 'require'
+			)) {
+				return;
+			}
+
+			const assignmentTargetNode = node.id;
+			const moduleNameNode = node.init.arguments[0];
+			const moduleName = getStringIfConstant(moduleNameNode, sourceCode.getScope(moduleNameNode));
+
+			if (!moduleName) {
+				return;
+			}
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualAssignmentTargetImportStyles(assignmentTargetNode);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles, true);
+		});
+	}
+};
+
+const schema = {
+	type: 'array',
+	additionalItems: false,
+	items: [
+		{
+			type: 'object',
+			additionalProperties: false,
+			properties: {
+				checkImport: {
+					type: 'boolean',
+				},
+				checkDynamicImport: {
+					type: 'boolean',
+				},
+				checkExportFrom: {
+					type: 'boolean',
+				},
+				checkRequire: {
+					type: 'boolean',
+				},
+				extendDefaultStyles: {
+					type: 'boolean',
+				},
+				styles: {
+					$ref: '#/definitions/moduleStyles',
+				},
+			},
+		},
+	],
+	definitions: {
+		moduleStyles: {
+			type: 'object',
+			additionalProperties: {
+				$ref: '#/definitions/styles',
+			},
+		},
+		styles: {
+			anyOf: [
+				{
+					enum: [
+						false,
+					],
+				},
+				{
+					$ref: '#/definitions/booleanObject',
+				},
+			],
+		},
+		booleanObject: {
+			type: 'object',
+			additionalProperties: {
+				type: 'boolean',
+			},
+		},
+	},
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce specific import styles per module.',
+			recommended: 'unopinionated',
+		},
+		schema,
+		defaultOptions: [{}],
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/index.js

@@ -0,0 +1,143 @@
+// Generated file, DO NOT edit
+
+export {default as 'better-regex'} from './better-regex.js';
+export {default as 'catch-error-name'} from './catch-error-name.js';
+export {default as 'consistent-assert'} from './consistent-assert.js';
+export {default as 'consistent-date-clone'} from './consistent-date-clone.js';
+export {default as 'consistent-destructuring'} from './consistent-destructuring.js';
+export {default as 'consistent-empty-array-spread'} from './consistent-empty-array-spread.js';
+export {default as 'consistent-existence-index-check'} from './consistent-existence-index-check.js';
+export {default as 'consistent-function-scoping'} from './consistent-function-scoping.js';
+export {default as 'custom-error-definition'} from './custom-error-definition.js';
+export {default as 'empty-brace-spaces'} from './empty-brace-spaces.js';
+export {default as 'error-message'} from './error-message.js';
+export {default as 'escape-case'} from './escape-case.js';
+export {default as 'expiring-todo-comments'} from './expiring-todo-comments.js';
+export {default as 'explicit-length-check'} from './explicit-length-check.js';
+export {default as 'filename-case'} from './filename-case.js';
+export {default as 'import-style'} from './import-style.js';
+export {default as 'new-for-builtins'} from './new-for-builtins.js';
+export {default as 'no-abusive-eslint-disable'} from './no-abusive-eslint-disable.js';
+export {default as 'no-accessor-recursion'} from './no-accessor-recursion.js';
+export {default as 'no-anonymous-default-export'} from './no-anonymous-default-export.js';
+export {default as 'no-array-callback-reference'} from './no-array-callback-reference.js';
+export {default as 'no-array-for-each'} from './no-array-for-each.js';
+export {default as 'no-array-method-this-argument'} from './no-array-method-this-argument.js';
+export {default as 'no-array-reduce'} from './no-array-reduce.js';
+export {default as 'no-array-reverse'} from './no-array-reverse.js';
+export {default as 'no-array-sort'} from './no-array-sort.js';
+export {default as 'no-await-expression-member'} from './no-await-expression-member.js';
+export {default as 'no-await-in-promise-methods'} from './no-await-in-promise-methods.js';
+export {default as 'no-console-spaces'} from './no-console-spaces.js';
+export {default as 'no-document-cookie'} from './no-document-cookie.js';
+export {default as 'no-empty-file'} from './no-empty-file.js';
+export {default as 'no-for-loop'} from './no-for-loop.js';
+export {default as 'no-hex-escape'} from './no-hex-escape.js';
+export {default as 'no-immediate-mutation'} from './no-immediate-mutation.js';
+export {default as 'no-instanceof-builtins'} from './no-instanceof-builtins.js';
+export {default as 'no-invalid-fetch-options'} from './no-invalid-fetch-options.js';
+export {default as 'no-invalid-remove-event-listener'} from './no-invalid-remove-event-listener.js';
+export {default as 'no-keyword-prefix'} from './no-keyword-prefix.js';
+export {default as 'no-lonely-if'} from './no-lonely-if.js';
+export {default as 'no-magic-array-flat-depth'} from './no-magic-array-flat-depth.js';
+export {default as 'no-named-default'} from './no-named-default.js';
+export {default as 'no-negated-condition'} from './no-negated-condition.js';
+export {default as 'no-negation-in-equality-check'} from './no-negation-in-equality-check.js';
+export {default as 'no-nested-ternary'} from './no-nested-ternary.js';
+export {default as 'no-new-array'} from './no-new-array.js';
+export {default as 'no-new-buffer'} from './no-new-buffer.js';
+export {default as 'no-null'} from './no-null.js';
+export {default as 'no-object-as-default-parameter'} from './no-object-as-default-parameter.js';
+export {default as 'no-process-exit'} from './no-process-exit.js';
+export {default as 'no-single-promise-in-promise-methods'} from './no-single-promise-in-promise-methods.js';
+export {default as 'no-static-only-class'} from './no-static-only-class.js';
+export {default as 'no-thenable'} from './no-thenable.js';
+export {default as 'no-this-assignment'} from './no-this-assignment.js';
+export {default as 'no-typeof-undefined'} from './no-typeof-undefined.js';
+export {default as 'no-unnecessary-array-flat-depth'} from './no-unnecessary-array-flat-depth.js';
+export {default as 'no-unnecessary-array-splice-count'} from './no-unnecessary-array-splice-count.js';
+export {default as 'no-unnecessary-await'} from './no-unnecessary-await.js';
+export {default as 'no-unnecessary-polyfills'} from './no-unnecessary-polyfills.js';
+export {default as 'no-unnecessary-slice-end'} from './no-unnecessary-slice-end.js';
+export {default as 'no-unreadable-array-destructuring'} from './no-unreadable-array-destructuring.js';
+export {default as 'no-unreadable-iife'} from './no-unreadable-iife.js';
+export {default as 'no-unused-properties'} from './no-unused-properties.js';
+export {default as 'no-useless-collection-argument'} from './no-useless-collection-argument.js';
+export {default as 'no-useless-error-capture-stack-trace'} from './no-useless-error-capture-stack-trace.js';
+export {default as 'no-useless-fallback-in-spread'} from './no-useless-fallback-in-spread.js';
+export {default as 'no-useless-length-check'} from './no-useless-length-check.js';
+export {default as 'no-useless-promise-resolve-reject'} from './no-useless-promise-resolve-reject.js';
+export {default as 'no-useless-spread'} from './no-useless-spread.js';
+export {default as 'no-useless-switch-case'} from './no-useless-switch-case.js';
+export {default as 'no-useless-undefined'} from './no-useless-undefined.js';
+export {default as 'no-zero-fractions'} from './no-zero-fractions.js';
+export {default as 'number-literal-case'} from './number-literal-case.js';
+export {default as 'numeric-separators-style'} from './numeric-separators-style.js';
+export {default as 'prefer-add-event-listener'} from './prefer-add-event-listener.js';
+export {default as 'prefer-array-find'} from './prefer-array-find.js';
+export {default as 'prefer-array-flat-map'} from './prefer-array-flat-map.js';
+export {default as 'prefer-array-flat'} from './prefer-array-flat.js';
+export {default as 'prefer-array-index-of'} from './prefer-array-index-of.js';
+export {default as 'prefer-array-some'} from './prefer-array-some.js';
+export {default as 'prefer-at'} from './prefer-at.js';
+export {default as 'prefer-bigint-literals'} from './prefer-bigint-literals.js';
+export {default as 'prefer-blob-reading-methods'} from './prefer-blob-reading-methods.js';
+export {default as 'prefer-class-fields'} from './prefer-class-fields.js';
+export {default as 'prefer-classlist-toggle'} from './prefer-classlist-toggle.js';
+export {default as 'prefer-code-point'} from './prefer-code-point.js';
+export {default as 'prefer-date-now'} from './prefer-date-now.js';
+export {default as 'prefer-default-parameters'} from './prefer-default-parameters.js';
+export {default as 'prefer-dom-node-append'} from './prefer-dom-node-append.js';
+export {default as 'prefer-dom-node-dataset'} from './prefer-dom-node-dataset.js';
+export {default as 'prefer-dom-node-remove'} from './prefer-dom-node-remove.js';
+export {default as 'prefer-dom-node-text-content'} from './prefer-dom-node-text-content.js';
+export {default as 'prefer-event-target'} from './prefer-event-target.js';
+export {default as 'prefer-export-from'} from './prefer-export-from.js';
+export {default as 'prefer-global-this'} from './prefer-global-this.js';
+export {default as 'prefer-import-meta-properties'} from './prefer-import-meta-properties.js';
+export {default as 'prefer-includes'} from './prefer-includes.js';
+export {default as 'prefer-json-parse-buffer'} from './prefer-json-parse-buffer.js';
+export {default as 'prefer-keyboard-event-key'} from './prefer-keyboard-event-key.js';
+export {default as 'prefer-logical-operator-over-ternary'} from './prefer-logical-operator-over-ternary.js';
+export {default as 'prefer-math-min-max'} from './prefer-math-min-max.js';
+export {default as 'prefer-math-trunc'} from './prefer-math-trunc.js';
+export {default as 'prefer-modern-dom-apis'} from './prefer-modern-dom-apis.js';
+export {default as 'prefer-modern-math-apis'} from './prefer-modern-math-apis.js';
+export {default as 'prefer-module'} from './prefer-module.js';
+export {default as 'prefer-native-coercion-functions'} from './prefer-native-coercion-functions.js';
+export {default as 'prefer-negative-index'} from './prefer-negative-index.js';
+export {default as 'prefer-node-protocol'} from './prefer-node-protocol.js';
+export {default as 'prefer-number-properties'} from './prefer-number-properties.js';
+export {default as 'prefer-object-from-entries'} from './prefer-object-from-entries.js';
+export {default as 'prefer-optional-catch-binding'} from './prefer-optional-catch-binding.js';
+export {default as 'prefer-prototype-methods'} from './prefer-prototype-methods.js';
+export {default as 'prefer-query-selector'} from './prefer-query-selector.js';
+export {default as 'prefer-reflect-apply'} from './prefer-reflect-apply.js';
+export {default as 'prefer-regexp-test'} from './prefer-regexp-test.js';
+export {default as 'prefer-response-static-json'} from './prefer-response-static-json.js';
+export {default as 'prefer-set-has'} from './prefer-set-has.js';
+export {default as 'prefer-set-size'} from './prefer-set-size.js';
+export {default as 'prefer-single-call'} from './prefer-single-call.js';
+export {default as 'prefer-spread'} from './prefer-spread.js';
+export {default as 'prefer-string-raw'} from './prefer-string-raw.js';
+export {default as 'prefer-string-replace-all'} from './prefer-string-replace-all.js';
+export {default as 'prefer-string-slice'} from './prefer-string-slice.js';
+export {default as 'prefer-string-starts-ends-with'} from './prefer-string-starts-ends-with.js';
+export {default as 'prefer-string-trim-start-end'} from './prefer-string-trim-start-end.js';
+export {default as 'prefer-structured-clone'} from './prefer-structured-clone.js';
+export {default as 'prefer-switch'} from './prefer-switch.js';
+export {default as 'prefer-ternary'} from './prefer-ternary.js';
+export {default as 'prefer-top-level-await'} from './prefer-top-level-await.js';
+export {default as 'prefer-type-error'} from './prefer-type-error.js';
+export {default as 'prevent-abbreviations'} from './prevent-abbreviations.js';
+export {default as 'relative-url-style'} from './relative-url-style.js';
+export {default as 'require-array-join-separator'} from './require-array-join-separator.js';
+export {default as 'require-module-attributes'} from './require-module-attributes.js';
+export {default as 'require-module-specifiers'} from './require-module-specifiers.js';
+export {default as 'require-number-to-fixed-digits-argument'} from './require-number-to-fixed-digits-argument.js';
+export {default as 'require-post-message-target-origin'} from './require-post-message-target-origin.js';
+export {default as 'string-content'} from './string-content.js';
+export {default as 'switch-case-braces'} from './switch-case-braces.js';
+export {default as 'template-indent'} from './template-indent.js';
+export {default as 'text-encoding-identifier-case'} from './text-encoding-identifier-case.js';
+export {default as 'throw-new-error'} from './throw-new-error.js';

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/new-for-builtins.js

@@ -0,0 +1,112 @@
+import {GlobalReferenceTracker} from './utils/global-reference-tracker.js';
+import * as builtins from './utils/builtins.js';
+import {
+	switchCallExpressionToNewExpression,
+	switchNewExpressionToCallExpression,
+	fixSpaceAroundKeyword,
+} from './fix/index.js';
+
+const MESSAGE_ID_ERROR_DATE = 'error-date';
+const MESSAGE_ID_SUGGESTION_DATE = 'suggestion-date';
+
+const messages = {
+	enforce: 'Use `new {{name}}()` instead of `{{name}}()`.',
+	disallow: 'Use `{{name}}()` instead of `new {{name}}()`.',
+	[MESSAGE_ID_ERROR_DATE]: 'Use `String(new Date())` instead of `Date()`.',
+	[MESSAGE_ID_SUGGESTION_DATE]: 'Switch to `String(new Date())`.',
+};
+
+function enforceNewExpression({node, path: [name]}, context) {
+	if (name === 'Object') {
+		const {parent} = node;
+		if (
+			parent.type === 'BinaryExpression'
+			&& (parent.operator === '===' || parent.operator === '!==')
+			&& (parent.left === node || parent.right === node)
+		) {
+			return;
+		}
+	}
+
+	// `Date()` returns a string representation of the current date and time, exactly as `new Date().toString()` does.
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date#return_value
+	if (name === 'Date') {
+		function * fix(fixer) {
+			yield fixer.replaceText(node, 'String(new Date())');
+			yield fixSpaceAroundKeyword(fixer, node, context);
+		}
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR_DATE,
+		};
+
+		if (context.sourceCode.getCommentsInside(node).length === 0 && node.arguments.length === 0) {
+			problem.fix = fix;
+		} else {
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION_DATE,
+					fix,
+				},
+			];
+		}
+
+		return problem;
+	}
+
+	return {
+		node,
+		messageId: 'enforce',
+		data: {name},
+		fix: fixer => switchCallExpressionToNewExpression(node, context, fixer),
+	};
+}
+
+function enforceCallExpression({node, path: [name]}, context) {
+	const problem = {
+		node,
+		messageId: 'disallow',
+		data: {name},
+	};
+
+	if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
+		problem.fix = fixer => switchNewExpressionToCallExpression(node, context, fixer);
+	}
+
+	return problem;
+}
+
+const newExpressionTracker = new GlobalReferenceTracker({
+	objects: builtins.disallowNew,
+	type: GlobalReferenceTracker.CONSTRUCT,
+	handle: enforceCallExpression,
+});
+const callExpressionTracker = new GlobalReferenceTracker({
+	objects: builtins.enforceNew,
+	type: GlobalReferenceTracker.CALL,
+	handle: enforceNewExpression,
+});
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	newExpressionTracker.listen({context});
+	callExpressionTracker.listen({context});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-abusive-eslint-disable.js

@@ -0,0 +1,63 @@
+import {ConfigCommentParser} from '@eslint/plugin-kit';
+
+const MESSAGE_ID = 'no-abusive-eslint-disable';
+const messages = {
+	[MESSAGE_ID]: 'Specify the rules you want to disable.',
+};
+
+// https://github.com/eslint/eslint/blob/ecd0ede7fd2ccbb4c0daf0e4732e97ea0f49db1b/lib/linter/linter.js#L509-L512
+const eslintDisableDirectives = new Set([
+	'eslint-disable',
+	'eslint-disable-line',
+	'eslint-disable-next-line',
+]);
+
+let commentParser;
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* Program(node) {
+		for (const comment of node.comments) {
+			commentParser ??= new ConfigCommentParser();
+			const result = commentParser.parseDirective(comment.value);
+
+			if (!(
+				// It's a eslint-disable comment
+				eslintDisableDirectives.has(result?.label)
+				// But it did not specify any rules
+				&& !result?.value
+			)) {
+				return;
+			}
+
+			const {sourceCode} = context;
+
+			yield {
+				// Can't set it at the given location as the warning
+				// will be ignored due to the disable comment
+				loc: {
+					start: {
+						...sourceCode.getLoc(comment).start,
+						column: -1,
+					},
+					end: sourceCode.getLoc(comment).end,
+				},
+				messageId: MESSAGE_ID,
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce specifying rules to disable in `eslint-disable` comments.',
+			recommended: 'unopinionated',
+		},
+		messages,
+	},
+};
+
+export default config;