eslint-plugin-formatjs 6.4.4 → 6.4.6

package/rules/no-literal-string-in-jsx.js

@@ -1,161 +0,0 @@
-import * as picomatchNs from "picomatch";
-const picomatch = picomatchNs.default ?? picomatchNs;
-const propMatcherSchema = {
-	type: "array",
-	items: {
-		type: "array",
-		items: [{ type: "string" }, { type: "string" }]
-	}
-};
-const defaultPropIncludePattern = [
-	["*", "aria-{label,description,details,errormessage}"],
-	["[a-z]*([a-z0-9])", "(placeholder|title)"],
-	["img", "alt"]
-];
-const defaultPropExcludePattern = [];
-function stringifyJsxTagName(tagName) {
-	switch (tagName.type) {
-		case "JSXIdentifier": return tagName.name;
-		case "JSXMemberExpression": return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
-		case "JSXNamespacedName": return `${tagName.namespace.name}:${tagName.name.name}`;
-	}
-}
-function compilePropMatcher(propMatcher) {
-	return propMatcher.map(([tagNamePattern, propNamePattern]) => {
-		return [picomatch.makeRe(tagNamePattern, { contains: false }), picomatch.makeRe(propNamePattern, { contains: false })];
-	});
-}
-export const name = "no-literal-string-in-jsx";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow untranslated literal strings without translation.",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-jsx"
-		},
-		schema: [{
-			type: "object",
-			additionalProperties: false,
-			properties: { props: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					include: { ...propMatcherSchema },
-					exclude: { ...propMatcherSchema }
-				}
-			} }
-		}],
-		messages: { noLiteralStringInJsx: "Cannot have untranslated text in JSX" }
-	},
-	create(context) {
-		const userConfig = context.options[0] || {};
-		const propIncludePattern = compilePropMatcher([...defaultPropIncludePattern, ...userConfig.props?.include ?? []]);
-		const propExcludePattern = compilePropMatcher([...defaultPropExcludePattern, ...userConfig.props?.exclude ?? []]);
-		const lexicalJsxStack = [];
-		const shouldSkipCurrentJsxElement = () => {
-			const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
-			if (currentJsxNode.type === "JSXFragment") {
-				return false;
-			}
-			const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
-			// Check if children should be excluded
-			for (const [tagNamePattern, propNamePattern] of propExcludePattern) {
-				if (tagNamePattern.test(nameString) && propNamePattern.test("children")) {
-					return true;
-				}
-			}
-			return false;
-		};
-		const shouldSkipCurrentJsxAttribute = (node) => {
-			const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
-			if (currentJsxNode.type === "JSXFragment") {
-				return false;
-			}
-			const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
-			const attributeName = typeof node.name.name === "string" ? node.name.name : node.name.name.name;
-			// match exclude
-			for (const [tagNamePattern, propNamePattern] of propExcludePattern) {
-				if (tagNamePattern.test(nameString) && propNamePattern.test(attributeName)) {
-					return true;
-				}
-			}
-			// match include
-			for (const [tagNamePattern, propNamePattern] of propIncludePattern) {
-				if (tagNamePattern.test(nameString) && propNamePattern.test(attributeName)) {
-					return false;
-				}
-			}
-			return true;
-		};
-		const checkJSXExpression = (node) => {
-			// Check if this is either a string literal / template literal, or the concat of them.
-			// It also ignores the empty string.
-			if (node.type === "Literal" && typeof node.value === "string" && node.value.length > 0 || node.type === "TemplateLiteral" && (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0)) {
-				context.report({
-					node,
-					messageId: "noLiteralStringInJsx"
-				});
-			} else if (node.type === "BinaryExpression" && node.operator === "+") {
-				checkJSXExpression(node.left);
-				checkJSXExpression(node.right);
-			} else if (node.type === "ConditionalExpression") {
-				checkJSXExpression(node.consequent);
-				checkJSXExpression(node.alternate);
-			} else if (node.type === "LogicalExpression") {
-				checkJSXExpression(node.left);
-				checkJSXExpression(node.right);
-			}
-		};
-		return {
-			JSXElement: (node) => {
-				lexicalJsxStack.push(node);
-			},
-			"JSXElement:exit": () => {
-				lexicalJsxStack.pop();
-			},
-			JSXFragment: (node) => {
-				lexicalJsxStack.push(node);
-			},
-			"JSXFragment:exit": () => {
-				lexicalJsxStack.pop();
-			},
-			JSXAttribute: (node) => {
-				if (shouldSkipCurrentJsxAttribute(node)) {
-					return;
-				}
-				if (!node.value) {
-					return;
-				}
-				if (node.value.type === "Literal" && typeof node.value.value === "string" && node.value.value.length > 0) {
-					context.report({
-						node,
-						messageId: "noLiteralStringInJsx"
-					});
-				} else if (node.value.type === "JSXExpressionContainer" && node.value.expression.type !== "JSXEmptyExpression") {
-					checkJSXExpression(node.value.expression);
-				}
-			},
-			JSXText: (node) => {
-				// Ignore purely spacing fragments
-				if (!node.value.replace(/\s*/gm, "")) {
-					return;
-				}
-				if (shouldSkipCurrentJsxElement()) {
-					return;
-				}
-				context.report({
-					node,
-					messageId: "noLiteralStringInJsx"
-				});
-			},
-			"JSXElement > JSXExpressionContainer": (node) => {
-				if (shouldSkipCurrentJsxElement()) {
-					return;
-				}
-				if (node.expression.type !== "JSXEmptyExpression") {
-					checkJSXExpression(node.expression);
-				}
-			}
-		};
-	}
-};

package/rules/no-literal-string-in-object.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-literal-string-in-object";
-export declare const rule: Rule.RuleModule;

package/rules/no-literal-string-in-object.js

@@ -1,59 +0,0 @@
-export const name = "no-literal-string-in-object";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce translation of specific object properties",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-object"
-		},
-		schema: [{
-			type: "object",
-			properties: { include: {
-				type: "array",
-				items: { type: "string" },
-				default: ["label"]
-			} },
-			additionalProperties: false
-		}],
-		messages: { untranslatedProperty: "Object property: `{{propertyKey}}` might contain an untranslated literal string" }
-	},
-	create(context) {
-		const propertyVisitor = (node) => {
-			checkProperty(context, node);
-		};
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ Property: propertyVisitor }, { Property: propertyVisitor });
-		}
-		return { Property: propertyVisitor };
-	}
-};
-function checkProperty(context, node) {
-	const config = {
-		include: ["label"],
-		...context.options[0]
-	};
-	const propertyKey = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" && typeof node.key.value === "string" ? node.key.value : null;
-	if (!propertyKey || !config.include.includes(propertyKey)) {
-		return;
-	}
-	checkPropertyValue(context, node.value, propertyKey);
-}
-function checkPropertyValue(context, node, propertyKey) {
-	if (node.type === "Literal" && typeof node.value === "string" && node.value.length > 0 || node.type === "TemplateLiteral" && (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0)) {
-		context.report({
-			node,
-			messageId: "untranslatedProperty",
-			data: { propertyKey }
-		});
-	} else if (node.type === "BinaryExpression" && node.operator === "+") {
-		checkPropertyValue(context, node.left, propertyKey);
-		checkPropertyValue(context, node.right, propertyKey);
-	} else if (node.type === "ConditionalExpression") {
-		checkPropertyValue(context, node.consequent, propertyKey);
-		checkPropertyValue(context, node.alternate, propertyKey);
-	} else if (node.type === "LogicalExpression") {
-		checkPropertyValue(context, node.left, propertyKey);
-		checkPropertyValue(context, node.right, propertyKey);
-	}
-}

package/rules/no-missing-icu-plural-one-placeholders.d.ts

@@ -1,5 +0,0 @@
-import type { Rule } from "eslint";
-import { type CoreMessageIds } from "../messages.js";
-export declare const name = "no-missing-icu-plural-one-placeholders";
-export type MessageIds = "noMissingIcuPluralOnePlaceholders" | CoreMessageIds;
-export declare const rule: Rule.RuleModule;

package/rules/no-missing-icu-plural-one-placeholders.js

@@ -1,94 +0,0 @@
-import { isLiteralElement, isPluralElement, isSelectElement, isTagElement, parse } from "@formatjs/icu-messageformat-parser";
-import MagicString from "magic-string";
-import { extractMessages, patchMessage } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-export const name = "no-missing-icu-plural-one-placeholders";
-function verifyAst(context, messageNode, ast) {
-	const patches = [];
-	_verifyAstAndReplace(ast);
-	if (patches.length > 0) {
-		const patchedMessage = patchMessage(messageNode, ast, (content) => {
-			return patches.reduce((magicString, patch) => {
-				switch (patch.type) {
-					case "prependLeft": return magicString.prependLeft(patch.index, patch.content);
-					case "remove": return magicString.remove(patch.start, patch.end);
-					case "update": return magicString.update(patch.start, patch.end, patch.content);
-				}
-			}, new MagicString(content)).toString();
-		});
-		context.report({
-			node: messageNode,
-			messageId: "noMissingIcuPluralOnePlaceholders",
-			fix: patchedMessage !== null ? (fixer) => fixer.replaceText(messageNode, patchedMessage) : null
-		});
-	}
-	function _verifyAstAndReplace(ast, root = true) {
-		for (const el of ast) {
-			if (isPluralElement(el) && el.options["one"]) {
-				_verifyAstAndReplace(el.options["one"].value, false);
-			} else if (isSelectElement(el)) {
-				for (const { value } of Object.values(el.options)) {
-					_verifyAstAndReplace(value, root);
-				}
-			} else if (isTagElement(el)) {
-				_verifyAstAndReplace(el.children, root);
-			} else if (!root && isLiteralElement(el)) {
-				const match = el.value.match(/\b1\b/);
-				if (match && el.location) {
-					patches.push({
-						type: "update",
-						start: el.location.start.offset,
-						end: el.location.end.offset,
-						content: el.value.replace(match[0], "#")
-					});
-				}
-			}
-		}
-	}
-}
-function checkNode(context, node) {
-	const msgs = extractMessages(node);
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { captureLocation: true });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-			continue;
-		}
-		verifyAst(context, messageNode, ast);
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "We use `one {# item}` instead of `one {1 item}` in ICU messages as some locales use the `one` formatting for other similar numbers.",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-explicit-icu-plural"
-		},
-		fixable: "code",
-		messages: {
-			...CORE_MESSAGES,
-			noMissingIcuPluralOnePlaceholders: "Use `one {# item}` instead of `one {1 item}` in ICU messages."
-		},
-		schema: []
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/no-multiple-plurals.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-multiple-plurals";
-export declare const rule: Rule.RuleModule;

package/rules/no-multiple-plurals.js

@@ -1,76 +0,0 @@
-import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function verifyAst(ast, pluralCount = { count: 0 }) {
-	const errors = [];
-	for (const el of ast) {
-		if (isPluralElement(el)) {
-			pluralCount.count++;
-			if (pluralCount.count > 1) {
-				errors.push({
-					messageId: "noMultiplePlurals",
-					data: {}
-				});
-			}
-			const { options } = el;
-			for (const selector of Object.keys(options)) {
-				errors.push(...verifyAst(options[selector].value, pluralCount));
-			}
-		}
-	}
-	return errors;
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-			continue;
-		}
-		const errors = verifyAst(ast);
-		for (const error of errors) {
-			context.report({
-				node,
-				...error
-			});
-		}
-	}
-}
-export const name = "no-multiple-plurals";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow multiple plural rules in the same message",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-multiple-plurals"
-		},
-		fixable: "code",
-		schema: [],
-		messages: {
-			...CORE_MESSAGES,
-			noMultiplePlurals: "Multiple plural rules in the same message"
-		}
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/no-multiple-whitespaces.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-multiple-whitespaces";
-export declare const rule: Rule.RuleModule;

package/rules/no-multiple-whitespaces.js

@@ -1,126 +0,0 @@
-import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings, patchMessage } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function isAstValid(ast) {
-	for (const element of ast) {
-		switch (element.type) {
-			case TYPE.literal:
-				if (/\s{2,}/gm.test(element.value)) {
-					return false;
-				}
-				break;
-			case TYPE.argument:
-			case TYPE.date:
-			case TYPE.number:
-			case TYPE.pound:
-			case TYPE.time: break;
-			case TYPE.plural:
-			case TYPE.select: {
-				for (const option of Object.values(element.options)) {
-					if (!isAstValid(option.value)) {
-						return false;
-					}
-				}
-				break;
-			}
-			case TYPE.tag: return isAstValid(element.children);
-		}
-	}
-	return true;
-}
-function trimMultiWhitespaces(message, ast) {
-	const literalElements = [];
-	const collectLiteralElements = (elements) => {
-		for (const element of elements) {
-			switch (element.type) {
-				case TYPE.literal:
-					literalElements.push(element);
-					break;
-				case TYPE.argument:
-				case TYPE.date:
-				case TYPE.number:
-				case TYPE.pound:
-				case TYPE.time: break;
-				case TYPE.plural:
-				case TYPE.select: {
-					for (const option of Object.values(element.options)) {
-						collectLiteralElements(option.value);
-					}
-					break;
-				}
-				case TYPE.tag:
-					collectLiteralElements(element.children);
-					break;
-			}
-		}
-	};
-	collectLiteralElements(ast);
-	// Surgically trim whitespaces in the literal element ranges.
-	// This is to preserve the original whitespaces and newlines info that are lost to parsing.
-	let trimmedFragments = [];
-	let currentOffset = 0;
-	for (const literal of literalElements) {
-		const { start, end } = literal.location;
-		const startOffset = start.offset;
-		const endOffset = end.offset;
-		trimmedFragments.push(message.slice(currentOffset, startOffset));
-		trimmedFragments.push(message.slice(startOffset, endOffset).replace(/\s{2,}/gm, " "));
-		currentOffset = endOffset;
-	}
-	trimmedFragments.push(message.slice(currentOffset));
-	return trimmedFragments.join("");
-}
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { captureLocation: true });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e instanceof Error ? e.message : String(e) }
-			});
-			return;
-		}
-		if (!isAstValid(ast)) {
-			const newMessage = patchMessage(messageNode, ast, trimMultiWhitespaces);
-			context.report({
-				node: messageNode,
-				messageId: "noMultipleWhitespaces",
-				fix: newMessage !== null ? (fixer) => fixer.replaceText(messageNode, newMessage) : null
-			});
-		}
-	}
-}
-export const name = "no-multiple-whitespaces";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Prevents usage of multiple consecutive whitespaces in message",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-multiple-whitespaces"
-		},
-		messages: {
-			...CORE_MESSAGES,
-			noMultipleWhitespaces: "Multiple consecutive whitespaces are not allowed"
-		},
-		fixable: "code",
-		schema: []
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/no-offset.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-offset";
-export declare const rule: Rule.RuleModule;

package/rules/no-offset.js

@@ -1,75 +0,0 @@
-import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function verifyAst(ast) {
-	const errors = [];
-	for (const el of ast) {
-		if (isPluralElement(el)) {
-			if (el.offset) {
-				errors.push({
-					messageId: "noOffset",
-					data: {}
-				});
-			}
-			const { options } = el;
-			for (const selector of Object.keys(options)) {
-				errors.push(...verifyAst(options[selector].value));
-			}
-		}
-	}
-	return errors;
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-			continue;
-		}
-		const errors = verifyAst(ast);
-		for (const error of errors) {
-			context.report({
-				node: messageNode,
-				...error
-			});
-		}
-	}
-}
-export const name = "no-offset";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow offset in plural rules",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-offset"
-		},
-		fixable: "code",
-		messages: {
-			...CORE_MESSAGES,
-			noOffset: "offset is not allowed"
-		},
-		schema: []
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/no-useless-message.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-useless-message";
-export declare const rule: Rule.RuleModule;

package/rules/no-useless-message.js

@@ -1,69 +0,0 @@
-import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function verifyAst(ast) {
-	if (ast.length !== 1) {
-		return;
-	}
-	switch (ast[0].type) {
-		case TYPE.argument: return "unnecessaryFormat";
-		case TYPE.number: return "unnecessaryFormatNumber";
-		case TYPE.date: return "unnecessaryFormatDate";
-		case TYPE.time: return "unnecessaryFormatTime";
-	}
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-			continue;
-		}
-		const messageId = verifyAst(ast);
-		if (messageId) context.report({
-			node: messageNode,
-			messageId
-		});
-	}
-}
-export const name = "no-useless-message";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow unnecessary formatted message",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-useless-message"
-		},
-		fixable: "code",
-		schema: [],
-		messages: {
-			...CORE_MESSAGES,
-			unnecessaryFormat: "Unnecessary formatted message.",
-			unnecessaryFormatNumber: "Unnecessary formatted message: just use FormattedNumber or intl.formatNumber.",
-			unnecessaryFormatDate: "Unnecessary formatted message: just use FormattedDate or intl.formatDate.",
-			unnecessaryFormatTime: "Unnecessary formatted message: just use FormattedTime or intl.formatTime."
-		}
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};