eslint-plugin-unicorn-ts 0.0.1-security → 50.0.1

package/rules/switch-case-braces.js

@@ -0,0 +1,109 @@
+'use strict';
+const {isColonToken} = require('@eslint-community/eslint-utils');
+const getSwitchCaseHeadLocation = require('./utils/get-switch-case-head-location.js');
+const getIndentString = require('./utils/get-indent-string.js');
+const {replaceNodeOrTokenAndSpacesBefore} = require('./fix/index.js');
+
+const MESSAGE_ID_EMPTY_CLAUSE = 'switch-case-braces/empty';
+const MESSAGE_ID_MISSING_BRACES = 'switch-case-braces/missing';
+const MESSAGE_ID_UNNECESSARY_BRACES = 'switch-case-braces/unnecessary';
+const messages = {
+	[MESSAGE_ID_EMPTY_CLAUSE]: 'Unexpected braces in empty case clause.',
+	[MESSAGE_ID_MISSING_BRACES]: 'Missing braces in case clause.',
+	[MESSAGE_ID_UNNECESSARY_BRACES]: 'Unnecessary braces in case clause.',
+};
+
+function * removeBraces(fixer, node, sourceCode) {
+	const [blockStatement] = node.consequent;
+	const openingBraceToken = sourceCode.getFirstToken(blockStatement);
+	yield * replaceNodeOrTokenAndSpacesBefore(openingBraceToken, '', fixer, sourceCode);
+
+	const closingBraceToken = sourceCode.getLastToken(blockStatement);
+	yield fixer.remove(closingBraceToken);
+}
+
+function * addBraces(fixer, node, sourceCode) {
+	const colonToken = sourceCode.getTokenAfter(
+		node.test || sourceCode.getFirstToken(node),
+		isColonToken,
+	);
+	yield fixer.insertTextAfter(colonToken, ' {');
+
+	const lastToken = sourceCode.getLastToken(node);
+	const indent = getIndentString(node, sourceCode);
+	yield fixer.insertTextAfter(lastToken, `\n${indent}}`);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const isBracesRequired = context.options[0] !== 'avoid';
+	const {sourceCode} = context;
+
+	return {
+		SwitchCase(node) {
+			const {consequent} = node;
+			if (consequent.length === 0) {
+				return;
+			}
+
+			if (
+				consequent.length === 1
+				&& consequent[0].type === 'BlockStatement'
+				&& consequent[0].body.length === 0
+			) {
+				return {
+					node,
+					loc: sourceCode.getFirstToken(consequent[0]).loc,
+					messageId: MESSAGE_ID_EMPTY_CLAUSE,
+					fix: fixer => removeBraces(fixer, node, sourceCode),
+				};
+			}
+
+			if (
+				isBracesRequired
+				&& !(
+					consequent.length === 1
+					&& consequent[0].type === 'BlockStatement'
+				)
+			) {
+				return {
+					node,
+					loc: getSwitchCaseHeadLocation(node, sourceCode),
+					messageId: MESSAGE_ID_MISSING_BRACES,
+					fix: fixer => addBraces(fixer, node, sourceCode),
+				};
+			}
+
+			if (
+				!isBracesRequired
+				&& consequent.length === 1
+				&& consequent[0].type === 'BlockStatement'
+				&& consequent[0].body.every(node =>
+					node.type !== 'VariableDeclaration'
+					&& node.type !== 'FunctionDeclaration',
+				)
+			) {
+				return {
+					node,
+					loc: sourceCode.getFirstToken(consequent[0]).loc,
+					messageId: MESSAGE_ID_UNNECESSARY_BRACES,
+					fix: fixer => removeBraces(fixer, node, sourceCode),
+				};
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce consistent brace style for `case` clauses.',
+		},
+		fixable: 'code',
+		schema: [{enum: ['always', 'avoid']}],
+		messages,
+	},
+};

package/rules/template-indent.js

@@ -0,0 +1,219 @@
+'use strict';
+const stripIndent = require('strip-indent');
+const indentString = require('indent-string');
+const esquery = require('esquery');
+const {replaceTemplateElement} = require('./fix/index.js');
+const {isMethodCall, isCallExpression} = require('./ast/index.js');
+
+const MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE = 'template-indent';
+const messages = {
+	[MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE]: 'Templates should be properly indented.',
+};
+
+const isJestInlineSnapshot = node =>
+	isMethodCall(node.parent, {
+		method: 'toMatchInlineSnapshot',
+		argumentsLength: 1,
+		optionalCall: false,
+		optionalMember: false,
+	})
+	&& node.parent.arguments[0] === node
+	&& isCallExpression(node.parent.callee.object, {
+		name: 'expect',
+		argumentsLength: 1,
+		optionalCall: false,
+		optionalMember: false,
+	});
+
+const parsedEsquerySelectors = new Map();
+const parseEsquerySelector = selector => {
+	if (!parsedEsquerySelectors.has(selector)) {
+		parsedEsquerySelectors.set(selector, esquery.parse(selector));
+	}
+
+	return parsedEsquerySelectors.get(selector);
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const options = {
+		tags: ['outdent', 'dedent', 'gql', 'sql', 'html', 'styled'],
+		functions: ['dedent', 'stripIndent'],
+		selectors: [],
+		comments: ['HTML', 'indent'],
+		...context.options[0],
+	};
+
+	options.comments = options.comments.map(comment => comment.toLowerCase());
+
+	/** @param {import('@babel/core').types.TemplateLiteral} node */
+	const getProblem = node => {
+		const delimiter = '__PLACEHOLDER__' + Math.random();
+		const joined = node.quasis
+			.map(quasi => {
+				const untrimmedText = sourceCode.getText(quasi);
+				return untrimmedText.slice(1, quasi.tail ? -1 : -2);
+			})
+			.join(delimiter);
+
+		const eolMatch = joined.match(/\r?\n/);
+		if (!eolMatch) {
+			return;
+		}
+
+		const eol = eolMatch[0];
+
+		const startLine = sourceCode.lines[node.loc.start.line - 1];
+		const marginMatch = startLine.match(/^(\s*)\S/);
+		const parentMargin = marginMatch ? marginMatch[1] : '';
+
+		let indent;
+		if (typeof options.indent === 'string') {
+			indent = options.indent;
+		} else if (typeof options.indent === 'number') {
+			indent = ' '.repeat(options.indent);
+		} else {
+			const tabs = parentMargin.startsWith('\t');
+			indent = tabs ? '\t' : '  ';
+		}
+
+		const dedented = stripIndent(joined);
+		const trimmed = dedented.replaceAll(new RegExp(`^${eol}|${eol}[ \t]*$`, 'g'), '');
+
+		const fixed
+			= eol
+			+ indentString(trimmed, 1, {indent: parentMargin + indent})
+			+ eol
+			+ parentMargin;
+
+		if (fixed === joined) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE,
+			fix: fixer => fixed
+				.split(delimiter)
+				.map((replacement, index) => replaceTemplateElement(fixer, node.quasis[index], replacement)),
+		};
+	};
+
+	const shouldIndent = node => {
+		if (options.comments.length > 0) {
+			const previousToken = sourceCode.getTokenBefore(node, {includeComments: true});
+			if (previousToken?.type === 'Block' && options.comments.includes(previousToken.value.trim().toLowerCase())) {
+				return true;
+			}
+		}
+
+		if (isJestInlineSnapshot(node)) {
+			return true;
+		}
+
+		if (
+			options.tags.length > 0
+			&& node.parent.type === 'TaggedTemplateExpression'
+			&& node.parent.quasi === node
+			&& node.parent.tag.type === 'Identifier'
+			&& options.tags.includes(node.parent.tag.name)
+		) {
+			return true;
+		}
+
+		if (
+			options.functions.length > 0
+			&& node.parent.type === 'CallExpression'
+			&& node.parent.arguments.includes(node)
+			&& node.parent.callee.type === 'Identifier'
+			&& options.functions.includes(node.parent.callee.name)
+		) {
+			return true;
+		}
+
+		if (options.selectors.length > 0) {
+			const ancestors = sourceCode.getAncestors(node).reverse();
+			if (options.selectors.some(selector => esquery.matches(node, parseEsquerySelector(selector), ancestors))) {
+				return true;
+			}
+		}
+
+		return false;
+	};
+
+	return {
+		/** @param {import('@babel/core').types.TemplateLiteral} node */
+		TemplateLiteral(node) {
+			if (!shouldIndent(node)) {
+				return;
+			}
+
+			return getProblem(node);
+		},
+	};
+};
+
+/** @type {import('json-schema').JSONSchema7[]} */
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			indent: {
+				oneOf: [
+					{
+						type: 'string',
+						pattern: /^\s+$/.source,
+					},
+					{
+						type: 'integer',
+						minimum: 1,
+					},
+				],
+			},
+			tags: {
+				type: 'array',
+				uniqueItems: true,
+				items: {
+					type: 'string',
+				},
+			},
+			functions: {
+				type: 'array',
+				uniqueItems: true,
+				items: {
+					type: 'string',
+				},
+			},
+			selectors: {
+				type: 'array',
+				uniqueItems: true,
+				items: {
+					type: 'string',
+				},
+			},
+			comments: {
+				type: 'array',
+				uniqueItems: true,
+				items: {
+					type: 'string',
+				},
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Fix whitespace-insensitive template indentation.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};

package/rules/text-encoding-identifier-case.js

@@ -0,0 +1,108 @@
+'use strict';
+const {replaceStringLiteral} = require('./fix/index.js');
+
+const MESSAGE_ID_ERROR = 'text-encoding-identifier/error';
+const MESSAGE_ID_SUGGESTION = 'text-encoding-identifier/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer `{{replacement}}` over `{{value}}`.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace `{{value}}` with `{{replacement}}`.',
+};
+
+const getReplacement = encoding => {
+	switch (encoding.toLowerCase()) {
+		// eslint-disable-next-line unicorn/text-encoding-identifier-case
+		case 'utf-8':
+		case 'utf8': {
+			return 'utf8';
+		}
+
+		case 'ascii': {
+			return 'ascii';
+		}
+		// No default
+	}
+};
+
+// `fs.{readFile,readFileSync}()`
+const isFsReadFileEncoding = node =>
+	node.parent.type === 'CallExpression'
+	&& !node.parent.optional
+	&& node.parent.arguments[1] === node
+	&& node.parent.arguments[0].type !== 'SpreadElement'
+	&& node.parent.callee.type === 'MemberExpression'
+	&& !node.parent.callee.optional
+	&& !node.parent.callee.computed
+	&& node.parent.callee.property.type === 'Identifier'
+	&& (node.parent.callee.property.name === 'readFile' || node.parent.callee.property.name === 'readFileSync');
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	Literal(node) {
+		if (typeof node.value !== 'string') {
+			return;
+		}
+
+		if (
+			// eslint-disable-next-line unicorn/text-encoding-identifier-case
+			node.value === 'utf-8'
+			&& node.parent.type === 'JSXAttribute'
+			&& node.parent.value === node
+			&& node.parent.name.type === 'JSXIdentifier'
+			&& node.parent.name.name.toLowerCase() === 'charset'
+			&& node.parent.parent.type === 'JSXOpeningElement'
+			&& node.parent.parent.attributes.includes(node.parent)
+			&& node.parent.parent.name.type === 'JSXIdentifier'
+			&& node.parent.parent.name.name.toLowerCase() === 'meta'
+		) {
+			return;
+		}
+
+		const {raw} = node;
+		const value = raw.slice(1, -1);
+
+		const replacement = getReplacement(value);
+		if (!replacement || replacement === value) {
+			return;
+		}
+
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		const fix = fixer => replaceStringLiteral(fixer, node, replacement);
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				value,
+				replacement,
+			},
+		};
+
+		if (isFsReadFileEncoding(node)) {
+			problem.fix = fix;
+			return problem;
+		}
+
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION,
+				fix: fixer => replaceStringLiteral(fixer, node, replacement),
+			},
+		];
+
+		return problem;
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent case for text encoding identifiers.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/throw-new-error.js

@@ -0,0 +1,53 @@
+'use strict';
+const {switchCallExpressionToNewExpression} = require('./fix/index.js');
+
+const messageId = 'throw-new-error';
+const messages = {
+	[messageId]: 'Use `new` when throwing an error.',
+};
+
+const customError = /^(?:[A-Z][\da-z]*)*Error$/;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (!(
+			node.parent.type === 'ThrowStatement'
+			&& node.parent.argument === node
+		)) {
+			return;
+		}
+
+		const {callee} = node;
+		if (!(
+			(callee.type === 'Identifier' && customError.test(callee.name))
+			|| (
+				callee.type === 'MemberExpression'
+				&& !callee.computed
+				&& callee.property.type === 'Identifier'
+				&& customError.test(callee.property.name)
+			)
+		)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId,
+			fix: fixer => switchCallExpressionToNewExpression(node, context.sourceCode, fixer),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require `new` when throwing an error.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/utils/array-or-object-prototype-property.js

@@ -0,0 +1,63 @@
+'use strict';
+const {isMemberExpression} = require('../ast/index.js');
+
+/**
+@param {
+	{
+		object?: string,
+		method?: string,
+		methods?: string[],
+	}
+} [options]
+@returns {string}
+*/
+function isPrototypeProperty(node, options) {
+	const {
+		object,
+		property,
+		properties,
+	} = {
+		property: '',
+		properties: [],
+		...options,
+	};
+
+	if (!isMemberExpression(node, {
+		property,
+		properties,
+		optional: false,
+	})) {
+		return;
+	}
+
+	const objectNode = node.object;
+
+	return (
+		// `Object.prototype.method` or `Array.prototype.method`
+		isMemberExpression(objectNode, {
+			object,
+			property: 'prototype',
+			optional: false,
+		})
+		// `[].method`
+		|| (
+			object === 'Array'
+			&& objectNode.type === 'ArrayExpression'
+			&& objectNode.elements.length === 0
+		)
+		// `{}.method`
+		|| (
+			object === 'Object'
+			&& objectNode.type === 'ObjectExpression'
+			&& objectNode.properties.length === 0
+		)
+	);
+}
+
+const isArrayPrototypeProperty = (node, options) => isPrototypeProperty(node, {...options, object: 'Array'});
+const isObjectPrototypeProperty = (node, options) => isPrototypeProperty(node, {...options, object: 'Object'});
+
+module.exports = {
+	isArrayPrototypeProperty,
+	isObjectPrototypeProperty,
+};

package/rules/utils/assert-token.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const ISSUE_LINK_PREFIX = 'https://github.com/sindresorhus/eslint-plugin-unicorn/issues/new?';
+function assertToken(token, {test, expected, ruleId}) {
+	if (test?.(token)) {
+		return;
+	}
+
+	expected = Array.isArray(expected) ? expected : [expected];
+	expected = expected.map(expectedToken => typeof expectedToken === 'string' ? {value: expectedToken} : expectedToken);
+
+	if (
+		!test
+		&& expected.some(
+			expectedToken =>
+				Object.entries(expectedToken)
+					.every(([key, value]) => token[key] === value),
+		)
+	) {
+		return;
+	}
+
+	const actual = `'${JSON.stringify({value: token.value, type: token.type})}'`;
+	expected = expected.map(expectedToken => `'${JSON.stringify(expectedToken)}'`).join(' or ');
+	const title = `\`${ruleId}\`: Unexpected token ${actual}`;
+	const issueLink = `${ISSUE_LINK_PREFIX}title=${encodeURIComponent(title)}`;
+	const message = `Expected token ${expected}, got ${actual}.\nPlease open an issue at ${issueLink}.`;
+
+	throw new Error(message);
+}
+
+module.exports = assertToken;