Add components

slider/node_modules/eslint/lib/rules/object-curly-newline.js

@@ -0,0 +1,383 @@
+/**
+ * @fileoverview Rule to require or disallow line breaks inside braces.
+ * @author Toru Nagashima
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+// Schema objects.
+const OPTION_VALUE = {
+	oneOf: [
+		{
+			enum: ["always", "never"],
+		},
+		{
+			type: "object",
+			properties: {
+				multiline: {
+					type: "boolean",
+				},
+				minProperties: {
+					type: "integer",
+					minimum: 0,
+				},
+				consistent: {
+					type: "boolean",
+				},
+			},
+			additionalProperties: false,
+			minProperties: 1,
+		},
+	],
+};
+
+/**
+ * Normalizes a given option value.
+ * @param {string|Object|undefined} value An option value to parse.
+ * @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object.
+ */
+function normalizeOptionValue(value) {
+	let multiline = false;
+	let minProperties = Number.POSITIVE_INFINITY;
+	let consistent = false;
+
+	if (value) {
+		if (value === "always") {
+			minProperties = 0;
+		} else if (value === "never") {
+			minProperties = Number.POSITIVE_INFINITY;
+		} else {
+			multiline = Boolean(value.multiline);
+			minProperties = value.minProperties || Number.POSITIVE_INFINITY;
+			consistent = Boolean(value.consistent);
+		}
+	} else {
+		consistent = true;
+	}
+
+	return { multiline, minProperties, consistent };
+}
+
+/**
+ * Checks if a value is an object.
+ * @param {any} value The value to check
+ * @returns {boolean} `true` if the value is an object, otherwise `false`
+ */
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+
+/**
+ * Checks if an option is a node-specific option
+ * @param {any} option The option to check
+ * @returns {boolean} `true` if the option is node-specific, otherwise `false`
+ */
+function isNodeSpecificOption(option) {
+	return isObject(option) || typeof option === "string";
+}
+
+/**
+ * Normalizes a given option value.
+ * @param {string|Object|undefined} options An option value to parse.
+ * @returns {{
+ *   ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean},
+ *   ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean}
+ * }} Normalized option object.
+ */
+function normalizeOptions(options) {
+	if (
+		isObject(options) &&
+		Object.values(options).some(isNodeSpecificOption)
+	) {
+		return {
+			ObjectExpression: normalizeOptionValue(options.ObjectExpression),
+			ObjectPattern: normalizeOptionValue(options.ObjectPattern),
+			ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),
+			ExportNamedDeclaration: normalizeOptionValue(
+				options.ExportDeclaration,
+			),
+		};
+	}
+
+	const value = normalizeOptionValue(options);
+
+	return {
+		ObjectExpression: value,
+		ObjectPattern: value,
+		ImportDeclaration: value,
+		ExportNamedDeclaration: value,
+	};
+}
+
+/**
+ * Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration
+ * node needs to be checked for missing line breaks
+ * @param {ASTNode} node Node under inspection
+ * @param {Object} options option specific to node type
+ * @param {Token} first First object property
+ * @param {Token} last Last object property
+ * @returns {boolean} `true` if node needs to be checked for missing line breaks
+ */
+function areLineBreaksRequired(node, options, first, last) {
+	let objectProperties;
+
+	if (node.type === "ObjectExpression" || node.type === "ObjectPattern") {
+		objectProperties = node.properties;
+	} else {
+		// is ImportDeclaration or ExportNamedDeclaration
+		objectProperties = node.specifiers.filter(
+			s => s.type === "ImportSpecifier" || s.type === "ExportSpecifier",
+		);
+	}
+
+	return (
+		objectProperties.length >= options.minProperties ||
+		(options.multiline &&
+			objectProperties.length > 0 &&
+			first.loc.start.line !== last.loc.end.line)
+	);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "10.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "object-curly-newline",
+						url: "https://eslint.style/rules/object-curly-newline",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description:
+				"Enforce consistent line breaks after opening and before closing braces",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/object-curly-newline",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				oneOf: [
+					OPTION_VALUE,
+					{
+						type: "object",
+						properties: {
+							ObjectExpression: OPTION_VALUE,
+							ObjectPattern: OPTION_VALUE,
+							ImportDeclaration: OPTION_VALUE,
+							ExportDeclaration: OPTION_VALUE,
+						},
+						additionalProperties: false,
+						minProperties: 1,
+					},
+				],
+			},
+		],
+
+		messages: {
+			unexpectedLinebreakBeforeClosingBrace:
+				"Unexpected line break before this closing brace.",
+			unexpectedLinebreakAfterOpeningBrace:
+				"Unexpected line break after this opening brace.",
+			expectedLinebreakBeforeClosingBrace:
+				"Expected a line break before this closing brace.",
+			expectedLinebreakAfterOpeningBrace:
+				"Expected a line break after this opening brace.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const normalizedOptions = normalizeOptions(context.options[0]);
+
+		/**
+		 * Reports a given node if it violated this rule.
+		 * @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
+		 * @returns {void}
+		 */
+		function check(node) {
+			const options = normalizedOptions[node.type];
+
+			if (
+				(node.type === "ImportDeclaration" &&
+					!node.specifiers.some(
+						specifier => specifier.type === "ImportSpecifier",
+					)) ||
+				(node.type === "ExportNamedDeclaration" &&
+					!node.specifiers.some(
+						specifier => specifier.type === "ExportSpecifier",
+					))
+			) {
+				return;
+			}
+
+			const openBrace = sourceCode.getFirstToken(
+				node,
+				token => token.value === "{",
+			);
+
+			let closeBrace;
+
+			if (node.typeAnnotation) {
+				closeBrace = sourceCode.getTokenBefore(node.typeAnnotation);
+			} else {
+				closeBrace = sourceCode.getLastToken(
+					node,
+					token => token.value === "}",
+				);
+			}
+
+			let first = sourceCode.getTokenAfter(openBrace, {
+				includeComments: true,
+			});
+			let last = sourceCode.getTokenBefore(closeBrace, {
+				includeComments: true,
+			});
+
+			const needsLineBreaks = areLineBreaksRequired(
+				node,
+				options,
+				first,
+				last,
+			);
+
+			const hasCommentsFirstToken = astUtils.isCommentToken(first);
+			const hasCommentsLastToken = astUtils.isCommentToken(last);
+
+			/*
+			 * Use tokens or comments to check multiline or not.
+			 * But use only tokens to check whether line breaks are needed.
+			 * This allows:
+			 *     var obj = { // eslint-disable-line foo
+			 *         a: 1
+			 *     }
+			 */
+			first = sourceCode.getTokenAfter(openBrace);
+			last = sourceCode.getTokenBefore(closeBrace);
+
+			if (needsLineBreaks) {
+				if (astUtils.isTokenOnSameLine(openBrace, first)) {
+					context.report({
+						messageId: "expectedLinebreakAfterOpeningBrace",
+						node,
+						loc: openBrace.loc,
+						fix(fixer) {
+							if (hasCommentsFirstToken) {
+								return null;
+							}
+
+							return fixer.insertTextAfter(openBrace, "\n");
+						},
+					});
+				}
+				if (astUtils.isTokenOnSameLine(last, closeBrace)) {
+					context.report({
+						messageId: "expectedLinebreakBeforeClosingBrace",
+						node,
+						loc: closeBrace.loc,
+						fix(fixer) {
+							if (hasCommentsLastToken) {
+								return null;
+							}
+
+							return fixer.insertTextBefore(closeBrace, "\n");
+						},
+					});
+				}
+			} else {
+				const consistent = options.consistent;
+				const hasLineBreakBetweenOpenBraceAndFirst =
+					!astUtils.isTokenOnSameLine(openBrace, first);
+				const hasLineBreakBetweenCloseBraceAndLast =
+					!astUtils.isTokenOnSameLine(last, closeBrace);
+
+				if (
+					(!consistent && hasLineBreakBetweenOpenBraceAndFirst) ||
+					(consistent &&
+						hasLineBreakBetweenOpenBraceAndFirst &&
+						!hasLineBreakBetweenCloseBraceAndLast)
+				) {
+					context.report({
+						messageId: "unexpectedLinebreakAfterOpeningBrace",
+						node,
+						loc: openBrace.loc,
+						fix(fixer) {
+							if (hasCommentsFirstToken) {
+								return null;
+							}
+
+							return fixer.removeRange([
+								openBrace.range[1],
+								first.range[0],
+							]);
+						},
+					});
+				}
+				if (
+					(!consistent && hasLineBreakBetweenCloseBraceAndLast) ||
+					(consistent &&
+						!hasLineBreakBetweenOpenBraceAndFirst &&
+						hasLineBreakBetweenCloseBraceAndLast)
+				) {
+					context.report({
+						messageId: "unexpectedLinebreakBeforeClosingBrace",
+						node,
+						loc: closeBrace.loc,
+						fix(fixer) {
+							if (hasCommentsLastToken) {
+								return null;
+							}
+
+							return fixer.removeRange([
+								last.range[1],
+								closeBrace.range[0],
+							]);
+						},
+					});
+				}
+			}
+		}
+
+		return {
+			ObjectExpression: check,
+			ObjectPattern: check,
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+		};
+	},
+};