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

package/rules/error-message.js

@@ -0,0 +1,104 @@
+'use strict';
+const {getStaticValue} = require('@eslint-community/eslint-utils');
+const isShadowed = require('./utils/is-shadowed.js');
+const {isCallOrNewExpression} = require('./ast/index.js');
+
+const MESSAGE_ID_MISSING_MESSAGE = 'missing-message';
+const MESSAGE_ID_EMPTY_MESSAGE = 'message-is-empty-string';
+const MESSAGE_ID_NOT_STRING = 'message-is-not-a-string';
+const messages = {
+	[MESSAGE_ID_MISSING_MESSAGE]: 'Pass a message to the `{{constructorName}}` constructor.',
+	[MESSAGE_ID_EMPTY_MESSAGE]: 'Error message should not be an empty string.',
+	[MESSAGE_ID_NOT_STRING]: 'Error message should be a string.',
+};
+
+const builtinErrors = [
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+	'Error',
+	'EvalError',
+	'RangeError',
+	'ReferenceError',
+	'SyntaxError',
+	'TypeError',
+	'URIError',
+	'InternalError',
+	'AggregateError',
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on(['CallExpression', 'NewExpression'], expression => {
+		if (!isCallOrNewExpression(expression, {
+			names: builtinErrors,
+			optional: false,
+		})) {
+			return;
+		}
+
+		const scope = context.sourceCode.getScope(expression);
+		if (isShadowed(scope, expression.callee)) {
+			return;
+		}
+
+		const constructorName = expression.callee.name;
+		const messageArgumentIndex = constructorName === 'AggregateError' ? 1 : 0;
+		const callArguments = expression.arguments;
+
+		// If message is `SpreadElement` or there is `SpreadElement` before message
+		if (callArguments.some((node, index) => index <= messageArgumentIndex && node.type === 'SpreadElement')) {
+			return;
+		}
+
+		const node = callArguments[messageArgumentIndex];
+		if (!node) {
+			return {
+				node: expression,
+				messageId: MESSAGE_ID_MISSING_MESSAGE,
+				data: {constructorName},
+			};
+		}
+
+		// These types can't be string, and `getStaticValue` may don't know the value
+		// Add more types, if issue reported
+		if (node.type === 'ArrayExpression' || node.type === 'ObjectExpression') {
+			return {
+				node,
+				messageId: MESSAGE_ID_NOT_STRING,
+			};
+		}
+
+		const staticResult = getStaticValue(node, scope);
+
+		// We don't know the value of `message`
+		if (!staticResult) {
+			return;
+		}
+
+		const {value} = staticResult;
+		if (typeof value !== 'string') {
+			return {
+				node,
+				messageId: MESSAGE_ID_NOT_STRING,
+			};
+		}
+
+		if (value === '') {
+			return {
+				node,
+				messageId: MESSAGE_ID_EMPTY_MESSAGE,
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce passing a `message` value when creating a built-in error.',
+		},
+		messages,
+	},
+};

package/rules/escape-case.js

@@ -0,0 +1,63 @@
+'use strict';
+const {replaceTemplateElement} = require('./fix/index.js');
+const {isRegexLiteral, isStringLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'escape-case';
+const messages = {
+	[MESSAGE_ID]: 'Use uppercase characters for the value of the escape sequence.',
+};
+
+const escapeWithLowercase = /(?<=(?:^|[^\\])(?:\\\\)*\\)(?<data>x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u{[\dA-Fa-f]+})/g;
+const escapePatternWithLowercase = /(?<=(?:^|[^\\])(?:\\\\)*\\)(?<data>x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u{[\dA-Fa-f]+}|c[a-z])/g;
+const getProblem = ({node, original, regex = escapeWithLowercase, fix}) => {
+	const fixed = original.replace(regex, data => data.slice(0, 1) + data.slice(1).toUpperCase());
+
+	if (fixed !== original) {
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			fix: fixer => fix ? fix(fixer, fixed) : fixer.replaceText(node, fixed),
+		};
+	}
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('Literal', node => {
+		if (isStringLiteral(node)) {
+			return getProblem({
+				node,
+				original: node.raw,
+			});
+		}
+	});
+
+	context.on('Literal', node => {
+		if (isRegexLiteral(node)) {
+			return getProblem({
+				node,
+				original: node.raw,
+				regex: escapePatternWithLowercase,
+			});
+		}
+	});
+
+	context.on('TemplateElement', node => getProblem({
+		node,
+		original: node.value.raw,
+		fix: (fixer, fixed) => replaceTemplateElement(fixer, node, fixed),
+	}));
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require escape sequences to use uppercase values.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};