Add components
This commit is contained in:
358
slider/node_modules/eslint/lib/rules/lines-between-class-members.js
generated
vendored
Normal file
358
slider/node_modules/eslint/lib/rules/lines-between-class-members.js
generated
vendored
Normal file
@@ -0,0 +1,358 @@
|
||||
/**
|
||||
* @fileoverview Rule to check empty newline between class members
|
||||
* @author 薛定谔的猫<hh_2013@foxmail.com>
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Types of class members.
|
||||
* Those have `test` method to check it matches to the given class member.
|
||||
* @private
|
||||
*/
|
||||
const ClassMemberTypes = {
|
||||
"*": { test: () => true },
|
||||
field: { test: node => node.type === "PropertyDefinition" },
|
||||
method: { test: node => node.type === "MethodDefinition" },
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// 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: "lines-between-class-members",
|
||||
url: "https://eslint.style/rules/lines-between-class-members",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Require or disallow an empty line between class members",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/lines-between-class-members",
|
||||
},
|
||||
|
||||
fixable: "whitespace",
|
||||
|
||||
schema: [
|
||||
{
|
||||
anyOf: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
enforce: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "object",
|
||||
properties: {
|
||||
blankLine: {
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
prev: {
|
||||
enum: ["method", "field", "*"],
|
||||
},
|
||||
next: {
|
||||
enum: ["method", "field", "*"],
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
required: ["blankLine", "prev", "next"],
|
||||
},
|
||||
minItems: 1,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
required: ["enforce"],
|
||||
},
|
||||
{
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
exceptAfterSingleLine: {
|
||||
type: "boolean",
|
||||
default: false,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
messages: {
|
||||
never: "Unexpected blank line between class members.",
|
||||
always: "Expected blank line between class members.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const options = [];
|
||||
|
||||
options[0] = context.options[0] || "always";
|
||||
options[1] = context.options[1] || { exceptAfterSingleLine: false };
|
||||
|
||||
const configureList =
|
||||
typeof options[0] === "object"
|
||||
? options[0].enforce
|
||||
: [{ blankLine: options[0], prev: "*", next: "*" }];
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Gets a pair of tokens that should be used to check lines between two class member nodes.
|
||||
*
|
||||
* In most cases, this returns the very last token of the current node and
|
||||
* the very first token of the next node.
|
||||
* For example:
|
||||
*
|
||||
* class C {
|
||||
* x = 1; // curLast: `;` nextFirst: `in`
|
||||
* in = 2
|
||||
* }
|
||||
*
|
||||
* There is only one exception. If the given node ends with a semicolon, and it looks like
|
||||
* a semicolon-less style's semicolon - one that is not on the same line as the preceding
|
||||
* token, but is on the line where the next class member starts - this returns the preceding
|
||||
* token and the semicolon as boundary tokens.
|
||||
* For example:
|
||||
*
|
||||
* class C {
|
||||
* x = 1 // curLast: `1` nextFirst: `;`
|
||||
* ;in = 2
|
||||
* }
|
||||
* When determining the desired layout of the code, we should treat this semicolon as
|
||||
* a part of the next class member node instead of the one it technically belongs to.
|
||||
* @param {ASTNode} curNode Current class member node.
|
||||
* @param {ASTNode} nextNode Next class member node.
|
||||
* @returns {Token} The actual last token of `node`.
|
||||
* @private
|
||||
*/
|
||||
function getBoundaryTokens(curNode, nextNode) {
|
||||
const lastToken = sourceCode.getLastToken(curNode);
|
||||
const prevToken = sourceCode.getTokenBefore(lastToken);
|
||||
const nextToken = sourceCode.getFirstToken(nextNode); // skip possible lone `;` between nodes
|
||||
|
||||
const isSemicolonLessStyle =
|
||||
astUtils.isSemicolonToken(lastToken) &&
|
||||
!astUtils.isTokenOnSameLine(prevToken, lastToken) &&
|
||||
astUtils.isTokenOnSameLine(lastToken, nextToken);
|
||||
|
||||
return isSemicolonLessStyle
|
||||
? { curLast: prevToken, nextFirst: lastToken }
|
||||
: { curLast: lastToken, nextFirst: nextToken };
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.
|
||||
* @param {Token} prevLastToken The last token in the previous member node.
|
||||
* @param {Token} nextFirstToken The first token in the next member node.
|
||||
* @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
|
||||
* @returns {Token} The last token among the consecutive tokens.
|
||||
*/
|
||||
function findLastConsecutiveTokenAfter(
|
||||
prevLastToken,
|
||||
nextFirstToken,
|
||||
maxLine,
|
||||
) {
|
||||
const after = sourceCode.getTokenAfter(prevLastToken, {
|
||||
includeComments: true,
|
||||
});
|
||||
|
||||
if (
|
||||
after !== nextFirstToken &&
|
||||
after.loc.start.line - prevLastToken.loc.end.line <= maxLine
|
||||
) {
|
||||
return findLastConsecutiveTokenAfter(
|
||||
after,
|
||||
nextFirstToken,
|
||||
maxLine,
|
||||
);
|
||||
}
|
||||
return prevLastToken;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.
|
||||
* @param {Token} nextFirstToken The first token in the next member node.
|
||||
* @param {Token} prevLastToken The last token in the previous member node.
|
||||
* @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
|
||||
* @returns {Token} The first token among the consecutive tokens.
|
||||
*/
|
||||
function findFirstConsecutiveTokenBefore(
|
||||
nextFirstToken,
|
||||
prevLastToken,
|
||||
maxLine,
|
||||
) {
|
||||
const before = sourceCode.getTokenBefore(nextFirstToken, {
|
||||
includeComments: true,
|
||||
});
|
||||
|
||||
if (
|
||||
before !== prevLastToken &&
|
||||
nextFirstToken.loc.start.line - before.loc.end.line <= maxLine
|
||||
) {
|
||||
return findFirstConsecutiveTokenBefore(
|
||||
before,
|
||||
prevLastToken,
|
||||
maxLine,
|
||||
);
|
||||
}
|
||||
return nextFirstToken;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there is a token or comment between two tokens.
|
||||
* @param {Token} before The token before.
|
||||
* @param {Token} after The token after.
|
||||
* @returns {boolean} True if there is a token or comment between two tokens.
|
||||
*/
|
||||
function hasTokenOrCommentBetween(before, after) {
|
||||
return (
|
||||
sourceCode.getTokensBetween(before, after, {
|
||||
includeComments: true,
|
||||
}).length !== 0
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given node matches the given type.
|
||||
* @param {ASTNode} node The class member node to check.
|
||||
* @param {string} type The class member type to check.
|
||||
* @returns {boolean} `true` if the class member node matched the type.
|
||||
* @private
|
||||
*/
|
||||
function match(node, type) {
|
||||
return ClassMemberTypes[type].test(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the last matched configuration from the configureList.
|
||||
* @param {ASTNode} prevNode The previous node to match.
|
||||
* @param {ASTNode} nextNode The current node to match.
|
||||
* @returns {string|null} Padding type or `null` if no matches were found.
|
||||
* @private
|
||||
*/
|
||||
function getPaddingType(prevNode, nextNode) {
|
||||
for (let i = configureList.length - 1; i >= 0; --i) {
|
||||
const configure = configureList[i];
|
||||
const matched =
|
||||
match(prevNode, configure.prev) &&
|
||||
match(nextNode, configure.next);
|
||||
|
||||
if (matched) {
|
||||
return configure.blankLine;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
ClassBody(node) {
|
||||
const body = node.body;
|
||||
|
||||
for (let i = 0; i < body.length - 1; i++) {
|
||||
const curFirst = sourceCode.getFirstToken(body[i]);
|
||||
const { curLast, nextFirst } = getBoundaryTokens(
|
||||
body[i],
|
||||
body[i + 1],
|
||||
);
|
||||
const isMulti = !astUtils.isTokenOnSameLine(
|
||||
curFirst,
|
||||
curLast,
|
||||
);
|
||||
const skip = !isMulti && options[1].exceptAfterSingleLine;
|
||||
const beforePadding = findLastConsecutiveTokenAfter(
|
||||
curLast,
|
||||
nextFirst,
|
||||
1,
|
||||
);
|
||||
const afterPadding = findFirstConsecutiveTokenBefore(
|
||||
nextFirst,
|
||||
curLast,
|
||||
1,
|
||||
);
|
||||
const isPadded =
|
||||
afterPadding.loc.start.line -
|
||||
beforePadding.loc.end.line >
|
||||
1;
|
||||
const hasTokenInPadding = hasTokenOrCommentBetween(
|
||||
beforePadding,
|
||||
afterPadding,
|
||||
);
|
||||
const curLineLastToken = findLastConsecutiveTokenAfter(
|
||||
curLast,
|
||||
nextFirst,
|
||||
0,
|
||||
);
|
||||
const paddingType = getPaddingType(body[i], body[i + 1]);
|
||||
|
||||
if (paddingType === "never" && isPadded) {
|
||||
context.report({
|
||||
node: body[i + 1],
|
||||
messageId: "never",
|
||||
|
||||
fix(fixer) {
|
||||
if (hasTokenInPadding) {
|
||||
return null;
|
||||
}
|
||||
return fixer.replaceTextRange(
|
||||
[
|
||||
beforePadding.range[1],
|
||||
afterPadding.range[0],
|
||||
],
|
||||
"\n",
|
||||
);
|
||||
},
|
||||
});
|
||||
} else if (paddingType === "always" && !skip && !isPadded) {
|
||||
context.report({
|
||||
node: body[i + 1],
|
||||
messageId: "always",
|
||||
|
||||
fix(fixer) {
|
||||
if (hasTokenInPadding) {
|
||||
return null;
|
||||
}
|
||||
return fixer.insertTextAfter(
|
||||
curLineLastToken,
|
||||
"\n",
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user