mirror of
https://github.com/Sevichecc/Urara-Blog.git
synced 2025-05-03 19:39:29 +08:00
1140 lines
No EOL
58 KiB
Text
1140 lines
No EOL
58 KiB
Text
"use strict";
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const utils_1 = require("@typescript-eslint/utils");
|
|
const OffsetStorage_1 = require("./OffsetStorage");
|
|
const TokenInfo_1 = require("./TokenInfo");
|
|
const util_1 = require("../../util");
|
|
const GLOBAL_LINEBREAK_REGEX = /\r\n|[\r\n\u2028\u2029]/gu;
|
|
const WHITESPACE_REGEX = /\s*$/u;
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
const KNOWN_NODES = new Set([
|
|
utils_1.AST_NODE_TYPES.AssignmentExpression,
|
|
utils_1.AST_NODE_TYPES.AssignmentPattern,
|
|
utils_1.AST_NODE_TYPES.ArrayExpression,
|
|
utils_1.AST_NODE_TYPES.ArrayPattern,
|
|
utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
|
|
utils_1.AST_NODE_TYPES.AwaitExpression,
|
|
utils_1.AST_NODE_TYPES.BlockStatement,
|
|
utils_1.AST_NODE_TYPES.BinaryExpression,
|
|
utils_1.AST_NODE_TYPES.BreakStatement,
|
|
utils_1.AST_NODE_TYPES.CallExpression,
|
|
utils_1.AST_NODE_TYPES.CatchClause,
|
|
utils_1.AST_NODE_TYPES.ClassBody,
|
|
utils_1.AST_NODE_TYPES.ClassDeclaration,
|
|
utils_1.AST_NODE_TYPES.ClassExpression,
|
|
utils_1.AST_NODE_TYPES.ConditionalExpression,
|
|
utils_1.AST_NODE_TYPES.ContinueStatement,
|
|
utils_1.AST_NODE_TYPES.DoWhileStatement,
|
|
utils_1.AST_NODE_TYPES.DebuggerStatement,
|
|
utils_1.AST_NODE_TYPES.EmptyStatement,
|
|
utils_1.AST_NODE_TYPES.ExpressionStatement,
|
|
utils_1.AST_NODE_TYPES.ForStatement,
|
|
utils_1.AST_NODE_TYPES.ForInStatement,
|
|
utils_1.AST_NODE_TYPES.ForOfStatement,
|
|
utils_1.AST_NODE_TYPES.FunctionDeclaration,
|
|
utils_1.AST_NODE_TYPES.FunctionExpression,
|
|
utils_1.AST_NODE_TYPES.Identifier,
|
|
utils_1.AST_NODE_TYPES.IfStatement,
|
|
utils_1.AST_NODE_TYPES.Literal,
|
|
utils_1.AST_NODE_TYPES.LabeledStatement,
|
|
utils_1.AST_NODE_TYPES.LogicalExpression,
|
|
utils_1.AST_NODE_TYPES.MemberExpression,
|
|
utils_1.AST_NODE_TYPES.MetaProperty,
|
|
utils_1.AST_NODE_TYPES.MethodDefinition,
|
|
utils_1.AST_NODE_TYPES.NewExpression,
|
|
utils_1.AST_NODE_TYPES.ObjectExpression,
|
|
utils_1.AST_NODE_TYPES.ObjectPattern,
|
|
utils_1.AST_NODE_TYPES.Program,
|
|
utils_1.AST_NODE_TYPES.Property,
|
|
utils_1.AST_NODE_TYPES.RestElement,
|
|
utils_1.AST_NODE_TYPES.ReturnStatement,
|
|
utils_1.AST_NODE_TYPES.SequenceExpression,
|
|
utils_1.AST_NODE_TYPES.SpreadElement,
|
|
utils_1.AST_NODE_TYPES.Super,
|
|
utils_1.AST_NODE_TYPES.SwitchCase,
|
|
utils_1.AST_NODE_TYPES.SwitchStatement,
|
|
utils_1.AST_NODE_TYPES.TaggedTemplateExpression,
|
|
utils_1.AST_NODE_TYPES.TemplateElement,
|
|
utils_1.AST_NODE_TYPES.TemplateLiteral,
|
|
utils_1.AST_NODE_TYPES.ThisExpression,
|
|
utils_1.AST_NODE_TYPES.ThrowStatement,
|
|
utils_1.AST_NODE_TYPES.TryStatement,
|
|
utils_1.AST_NODE_TYPES.UnaryExpression,
|
|
utils_1.AST_NODE_TYPES.UpdateExpression,
|
|
utils_1.AST_NODE_TYPES.VariableDeclaration,
|
|
utils_1.AST_NODE_TYPES.VariableDeclarator,
|
|
utils_1.AST_NODE_TYPES.WhileStatement,
|
|
utils_1.AST_NODE_TYPES.WithStatement,
|
|
utils_1.AST_NODE_TYPES.YieldExpression,
|
|
utils_1.AST_NODE_TYPES.JSXIdentifier,
|
|
utils_1.AST_NODE_TYPES.JSXMemberExpression,
|
|
utils_1.AST_NODE_TYPES.JSXEmptyExpression,
|
|
utils_1.AST_NODE_TYPES.JSXExpressionContainer,
|
|
utils_1.AST_NODE_TYPES.JSXElement,
|
|
utils_1.AST_NODE_TYPES.JSXClosingElement,
|
|
utils_1.AST_NODE_TYPES.JSXOpeningElement,
|
|
utils_1.AST_NODE_TYPES.JSXAttribute,
|
|
utils_1.AST_NODE_TYPES.JSXSpreadAttribute,
|
|
utils_1.AST_NODE_TYPES.JSXText,
|
|
utils_1.AST_NODE_TYPES.ExportDefaultDeclaration,
|
|
utils_1.AST_NODE_TYPES.ExportNamedDeclaration,
|
|
utils_1.AST_NODE_TYPES.ExportAllDeclaration,
|
|
utils_1.AST_NODE_TYPES.ExportSpecifier,
|
|
utils_1.AST_NODE_TYPES.ImportDeclaration,
|
|
utils_1.AST_NODE_TYPES.ImportSpecifier,
|
|
utils_1.AST_NODE_TYPES.ImportDefaultSpecifier,
|
|
utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier,
|
|
// Class properties aren't yet supported by eslint...
|
|
utils_1.AST_NODE_TYPES.PropertyDefinition,
|
|
// ts keywords
|
|
utils_1.AST_NODE_TYPES.TSAbstractKeyword,
|
|
utils_1.AST_NODE_TYPES.TSAnyKeyword,
|
|
utils_1.AST_NODE_TYPES.TSBooleanKeyword,
|
|
utils_1.AST_NODE_TYPES.TSNeverKeyword,
|
|
utils_1.AST_NODE_TYPES.TSNumberKeyword,
|
|
utils_1.AST_NODE_TYPES.TSStringKeyword,
|
|
utils_1.AST_NODE_TYPES.TSSymbolKeyword,
|
|
utils_1.AST_NODE_TYPES.TSUndefinedKeyword,
|
|
utils_1.AST_NODE_TYPES.TSUnknownKeyword,
|
|
utils_1.AST_NODE_TYPES.TSVoidKeyword,
|
|
utils_1.AST_NODE_TYPES.TSNullKeyword,
|
|
// ts specific nodes we want to support
|
|
utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
|
|
utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition,
|
|
utils_1.AST_NODE_TYPES.TSArrayType,
|
|
utils_1.AST_NODE_TYPES.TSAsExpression,
|
|
utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSConditionalType,
|
|
utils_1.AST_NODE_TYPES.TSConstructorType,
|
|
utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSDeclareFunction,
|
|
utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
|
|
utils_1.AST_NODE_TYPES.TSEnumDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSEnumMember,
|
|
utils_1.AST_NODE_TYPES.TSExportAssignment,
|
|
utils_1.AST_NODE_TYPES.TSExternalModuleReference,
|
|
utils_1.AST_NODE_TYPES.TSFunctionType,
|
|
utils_1.AST_NODE_TYPES.TSImportType,
|
|
utils_1.AST_NODE_TYPES.TSIndexedAccessType,
|
|
utils_1.AST_NODE_TYPES.TSIndexSignature,
|
|
utils_1.AST_NODE_TYPES.TSInferType,
|
|
utils_1.AST_NODE_TYPES.TSInterfaceBody,
|
|
utils_1.AST_NODE_TYPES.TSInterfaceDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSInterfaceHeritage,
|
|
utils_1.AST_NODE_TYPES.TSIntersectionType,
|
|
utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSLiteralType,
|
|
utils_1.AST_NODE_TYPES.TSMappedType,
|
|
utils_1.AST_NODE_TYPES.TSMethodSignature,
|
|
'TSMinusToken',
|
|
utils_1.AST_NODE_TYPES.TSModuleBlock,
|
|
utils_1.AST_NODE_TYPES.TSModuleDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSNonNullExpression,
|
|
utils_1.AST_NODE_TYPES.TSParameterProperty,
|
|
'TSPlusToken',
|
|
utils_1.AST_NODE_TYPES.TSPropertySignature,
|
|
utils_1.AST_NODE_TYPES.TSQualifiedName,
|
|
'TSQuestionToken',
|
|
utils_1.AST_NODE_TYPES.TSRestType,
|
|
utils_1.AST_NODE_TYPES.TSThisType,
|
|
utils_1.AST_NODE_TYPES.TSTupleType,
|
|
utils_1.AST_NODE_TYPES.TSTypeAnnotation,
|
|
utils_1.AST_NODE_TYPES.TSTypeLiteral,
|
|
utils_1.AST_NODE_TYPES.TSTypeOperator,
|
|
utils_1.AST_NODE_TYPES.TSTypeParameter,
|
|
utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation,
|
|
utils_1.AST_NODE_TYPES.TSTypeReference,
|
|
utils_1.AST_NODE_TYPES.TSUnionType,
|
|
]);
|
|
const STATEMENT_LIST_PARENTS = new Set([
|
|
utils_1.AST_NODE_TYPES.Program,
|
|
utils_1.AST_NODE_TYPES.BlockStatement,
|
|
utils_1.AST_NODE_TYPES.SwitchCase,
|
|
]);
|
|
const DEFAULT_VARIABLE_INDENT = 1;
|
|
const DEFAULT_PARAMETER_INDENT = 1;
|
|
const DEFAULT_FUNCTION_BODY_INDENT = 1;
|
|
/*
|
|
* General rule strategy:
|
|
* 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another
|
|
* specified token or to the first column.
|
|
* 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a
|
|
* BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly
|
|
* brace of the BlockStatement.
|
|
* 3. After traversing the AST, calculate the expected indentation levels of every token according to the
|
|
* OffsetStorage container.
|
|
* 4. For each line, compare the expected indentation of the first token to the actual indentation in the file,
|
|
* and report the token if the two values are not equal.
|
|
*/
|
|
const ELEMENT_LIST_SCHEMA = {
|
|
oneOf: [
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
{
|
|
enum: ['first', 'off'],
|
|
},
|
|
],
|
|
};
|
|
exports.default = (0, util_1.createRule)({
|
|
name: 'indent',
|
|
meta: {
|
|
type: 'layout',
|
|
docs: {
|
|
description: 'Enforce consistent indentation.',
|
|
recommended: false,
|
|
},
|
|
fixable: 'whitespace',
|
|
schema: [
|
|
{
|
|
oneOf: [
|
|
{
|
|
enum: ['tab'],
|
|
},
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
SwitchCase: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
default: 0,
|
|
},
|
|
VariableDeclarator: {
|
|
oneOf: [
|
|
ELEMENT_LIST_SCHEMA,
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
var: ELEMENT_LIST_SCHEMA,
|
|
let: ELEMENT_LIST_SCHEMA,
|
|
const: ELEMENT_LIST_SCHEMA,
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
outerIIFEBody: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
MemberExpression: {
|
|
oneOf: [
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
{
|
|
enum: ['off'],
|
|
},
|
|
],
|
|
},
|
|
FunctionDeclaration: {
|
|
type: 'object',
|
|
properties: {
|
|
parameters: ELEMENT_LIST_SCHEMA,
|
|
body: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
FunctionExpression: {
|
|
type: 'object',
|
|
properties: {
|
|
parameters: ELEMENT_LIST_SCHEMA,
|
|
body: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
CallExpression: {
|
|
type: 'object',
|
|
properties: {
|
|
arguments: ELEMENT_LIST_SCHEMA,
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
ArrayExpression: ELEMENT_LIST_SCHEMA,
|
|
ObjectExpression: ELEMENT_LIST_SCHEMA,
|
|
ImportDeclaration: ELEMENT_LIST_SCHEMA,
|
|
flatTernaryExpressions: {
|
|
type: 'boolean',
|
|
default: false,
|
|
},
|
|
ignoredNodes: {
|
|
type: 'array',
|
|
items: {
|
|
type: 'string',
|
|
not: {
|
|
pattern: ':exit$',
|
|
},
|
|
},
|
|
},
|
|
ignoreComments: {
|
|
type: 'boolean',
|
|
default: false,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
messages: {
|
|
wrongIndentation: 'Expected indentation of {{expected}} but found {{actual}}.',
|
|
},
|
|
},
|
|
defaultOptions: [
|
|
// typescript docs and playground use 4 space indent
|
|
4,
|
|
{
|
|
// typescript docs indent the case from the switch
|
|
// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-8.html#example-4
|
|
SwitchCase: 1,
|
|
VariableDeclarator: {
|
|
var: DEFAULT_VARIABLE_INDENT,
|
|
let: DEFAULT_VARIABLE_INDENT,
|
|
const: DEFAULT_VARIABLE_INDENT,
|
|
},
|
|
outerIIFEBody: 1,
|
|
FunctionDeclaration: {
|
|
parameters: DEFAULT_PARAMETER_INDENT,
|
|
body: DEFAULT_FUNCTION_BODY_INDENT,
|
|
},
|
|
FunctionExpression: {
|
|
parameters: DEFAULT_PARAMETER_INDENT,
|
|
body: DEFAULT_FUNCTION_BODY_INDENT,
|
|
},
|
|
CallExpression: {
|
|
arguments: DEFAULT_PARAMETER_INDENT,
|
|
},
|
|
MemberExpression: 1,
|
|
ArrayExpression: 1,
|
|
ObjectExpression: 1,
|
|
ImportDeclaration: 1,
|
|
flatTernaryExpressions: false,
|
|
ignoredNodes: [],
|
|
ignoreComments: false,
|
|
},
|
|
],
|
|
create(context, [userIndent, userOptions]) {
|
|
const indentType = userIndent === 'tab' ? 'tab' : 'space';
|
|
const indentSize = userIndent === 'tab' ? 1 : userIndent;
|
|
const options = userOptions;
|
|
if (typeof userOptions.VariableDeclarator === 'number' ||
|
|
userOptions.VariableDeclarator === 'first') {
|
|
// typescript doesn't narrow the type for some reason
|
|
options.VariableDeclarator = {
|
|
var: userOptions.VariableDeclarator,
|
|
let: userOptions.VariableDeclarator,
|
|
const: userOptions.VariableDeclarator,
|
|
};
|
|
}
|
|
const sourceCode = context.getSourceCode();
|
|
const tokenInfo = new TokenInfo_1.TokenInfo(sourceCode);
|
|
const offsets = new OffsetStorage_1.OffsetStorage(tokenInfo, indentSize, indentType === 'space' ? ' ' : '\t');
|
|
const parameterParens = new WeakSet();
|
|
/**
|
|
* Creates an error message for a line, given the expected/actual indentation.
|
|
* @param expectedAmount The expected amount of indentation characters for this line
|
|
* @param actualSpaces The actual number of indentation spaces that were found on this line
|
|
* @param actualTabs The actual number of indentation tabs that were found on this line
|
|
* @returns An error message for this line
|
|
*/
|
|
function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {
|
|
const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? '' : 's'}`; // e.g. "2 tabs"
|
|
const foundSpacesWord = `space${actualSpaces === 1 ? '' : 's'}`; // e.g. "space"
|
|
const foundTabsWord = `tab${actualTabs === 1 ? '' : 's'}`; // e.g. "tabs"
|
|
let foundStatement;
|
|
if (actualSpaces > 0) {
|
|
/*
|
|
* Abbreviate the message if the expected indentation is also spaces.
|
|
* e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces'
|
|
*/
|
|
foundStatement =
|
|
indentType === 'space'
|
|
? actualSpaces
|
|
: `${actualSpaces} ${foundSpacesWord}`;
|
|
}
|
|
else if (actualTabs > 0) {
|
|
foundStatement =
|
|
indentType === 'tab' ? actualTabs : `${actualTabs} ${foundTabsWord}`;
|
|
}
|
|
else {
|
|
foundStatement = '0';
|
|
}
|
|
return {
|
|
expected: expectedStatement,
|
|
actual: foundStatement,
|
|
};
|
|
}
|
|
/**
|
|
* Reports a given indent violation
|
|
* @param token Token violating the indent rule
|
|
* @param neededIndent Expected indentation string
|
|
*/
|
|
function report(token, neededIndent) {
|
|
const actualIndent = Array.from(tokenInfo.getTokenIndent(token));
|
|
const numSpaces = actualIndent.filter(char => char === ' ').length;
|
|
const numTabs = actualIndent.filter(char => char === '\t').length;
|
|
context.report({
|
|
node: token,
|
|
messageId: 'wrongIndentation',
|
|
data: createErrorMessageData(neededIndent.length, numSpaces, numTabs),
|
|
loc: {
|
|
start: { line: token.loc.start.line, column: 0 },
|
|
end: { line: token.loc.start.line, column: token.loc.start.column },
|
|
},
|
|
fix(fixer) {
|
|
return fixer.replaceTextRange([token.range[0] - token.loc.start.column, token.range[0]], neededIndent);
|
|
},
|
|
});
|
|
}
|
|
/**
|
|
* Checks if a token's indentation is correct
|
|
* @param token Token to examine
|
|
* @param desiredIndent Desired indentation of the string
|
|
* @returns `true` if the token's indentation is correct
|
|
*/
|
|
function validateTokenIndent(token, desiredIndent) {
|
|
const indentation = tokenInfo.getTokenIndent(token);
|
|
return (indentation === desiredIndent ||
|
|
// To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed spaces and tabs.
|
|
(indentation.includes(' ') && indentation.includes('\t')));
|
|
}
|
|
/**
|
|
* Check to see if the node is a file level IIFE
|
|
* @param node The function node to check.
|
|
* @returns True if the node is the outer IIFE
|
|
*/
|
|
function isOuterIIFE(node) {
|
|
var _a;
|
|
/*
|
|
* Verify that the node is an IIFE
|
|
*/
|
|
if (!node.parent ||
|
|
node.parent.type !== utils_1.AST_NODE_TYPES.CallExpression ||
|
|
node.parent.callee !== node) {
|
|
return false;
|
|
}
|
|
/*
|
|
* Navigate legal ancestors to determine whether this IIFE is outer.
|
|
* A "legal ancestor" is an expression or statement that causes the function to get executed immediately.
|
|
* For example, `!(function(){})()` is an outer IIFE even though it is preceded by a ! operator.
|
|
*/
|
|
let statement = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent;
|
|
while (statement &&
|
|
((statement.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
|
|
['!', '~', '+', '-'].includes(statement.operator)) ||
|
|
statement.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
|
|
statement.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
|
|
statement.type === utils_1.AST_NODE_TYPES.SequenceExpression ||
|
|
statement.type === utils_1.AST_NODE_TYPES.VariableDeclarator)) {
|
|
statement = statement.parent;
|
|
}
|
|
return (!!statement &&
|
|
(statement.type === utils_1.AST_NODE_TYPES.ExpressionStatement ||
|
|
statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) &&
|
|
!!statement.parent &&
|
|
statement.parent.type === utils_1.AST_NODE_TYPES.Program);
|
|
}
|
|
/**
|
|
* Counts the number of linebreaks that follow the last non-whitespace character in a string
|
|
* @param str The string to check
|
|
* @returns The number of JavaScript linebreaks that follow the last non-whitespace character,
|
|
* or the total number of linebreaks if the string is all whitespace.
|
|
*/
|
|
function countTrailingLinebreaks(str) {
|
|
const trailingWhitespace = WHITESPACE_REGEX.exec(str)[0];
|
|
const linebreakMatches = GLOBAL_LINEBREAK_REGEX.exec(trailingWhitespace);
|
|
return linebreakMatches === null ? 0 : linebreakMatches.length;
|
|
}
|
|
/**
|
|
* Check indentation for lists of elements (arrays, objects, function params)
|
|
* @param elements List of elements that should be offset
|
|
* @param startToken The start token of the list that element should be aligned against, e.g. '['
|
|
* @param endToken The end token of the list, e.g. ']'
|
|
* @param offset The amount that the elements should be offset
|
|
*/
|
|
function addElementListIndent(elements, startToken, endToken, offset) {
|
|
/**
|
|
* Gets the first token of a given element, including surrounding parentheses.
|
|
* @param element A node in the `elements` list
|
|
* @returns The first token of this element
|
|
*/
|
|
function getFirstToken(element) {
|
|
let token = sourceCode.getTokenBefore(element);
|
|
while ((0, util_1.isOpeningParenToken)(token) && token !== startToken) {
|
|
token = sourceCode.getTokenBefore(token);
|
|
}
|
|
return sourceCode.getTokenAfter(token);
|
|
}
|
|
// Run through all the tokens in the list, and offset them by one indent level (mainly for comments, other things will end up overridden)
|
|
offsets.setDesiredOffsets([startToken.range[1], endToken.range[0]], startToken, typeof offset === 'number' ? offset : 1);
|
|
offsets.setDesiredOffset(endToken, startToken, 0);
|
|
// If the preference is "first" but there is no first element (e.g. sparse arrays w/ empty first slot), fall back to 1 level.
|
|
const firstElement = elements[0];
|
|
if (offset === 'first' && elements.length && !firstElement) {
|
|
return;
|
|
}
|
|
elements.forEach((element, index) => {
|
|
if (!element) {
|
|
// Skip holes in arrays
|
|
return;
|
|
}
|
|
if (offset === 'off') {
|
|
// Ignore the first token of every element if the "off" option is used
|
|
offsets.ignoreToken(getFirstToken(element));
|
|
}
|
|
// Offset the following elements correctly relative to the first element
|
|
if (index === 0) {
|
|
return;
|
|
}
|
|
if (offset === 'first' &&
|
|
tokenInfo.isFirstTokenOfLine(getFirstToken(element))) {
|
|
offsets.matchOffsetOf(getFirstToken(firstElement), getFirstToken(element));
|
|
}
|
|
else {
|
|
const previousElement = elements[index - 1];
|
|
const firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement);
|
|
const previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement);
|
|
if (previousElement &&
|
|
previousElementLastToken &&
|
|
previousElementLastToken.loc.end.line -
|
|
countTrailingLinebreaks(previousElementLastToken.value) >
|
|
startToken.loc.end.line) {
|
|
offsets.setDesiredOffsets([previousElement.range[1], element.range[1]], firstTokenOfPreviousElement, 0);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Check and decide whether to check for indentation for blockless nodes
|
|
* Scenarios are for or while statements without braces around them
|
|
*/
|
|
function addBlocklessNodeIndent(node) {
|
|
if (node.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
|
|
const lastParentToken = sourceCode.getTokenBefore(node, util_1.isNotOpeningParenToken);
|
|
let firstBodyToken = sourceCode.getFirstToken(node);
|
|
let lastBodyToken = sourceCode.getLastToken(node);
|
|
while ((0, util_1.isOpeningParenToken)(sourceCode.getTokenBefore(firstBodyToken)) &&
|
|
(0, util_1.isClosingParenToken)(sourceCode.getTokenAfter(lastBodyToken))) {
|
|
firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);
|
|
lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);
|
|
}
|
|
offsets.setDesiredOffsets([firstBodyToken.range[0], lastBodyToken.range[1]], lastParentToken, 1);
|
|
/*
|
|
* For blockless nodes with semicolon-first style, don't indent the semicolon.
|
|
* e.g.
|
|
* if (foo) bar()
|
|
* ; [1, 2, 3].map(foo)
|
|
*/
|
|
const lastToken = sourceCode.getLastToken(node);
|
|
if (lastToken &&
|
|
node.type !== utils_1.AST_NODE_TYPES.EmptyStatement &&
|
|
(0, util_1.isSemicolonToken)(lastToken)) {
|
|
offsets.setDesiredOffset(lastToken, lastParentToken, 0);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Checks the indentation for nodes that are like function calls
|
|
*/
|
|
function addFunctionCallIndent(node) {
|
|
const openingParen = node.arguments.length
|
|
? sourceCode.getFirstTokenBetween(node.callee, node.arguments[0], util_1.isOpeningParenToken)
|
|
: sourceCode.getLastToken(node, 1);
|
|
const closingParen = sourceCode.getLastToken(node);
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);
|
|
addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);
|
|
}
|
|
/**
|
|
* Checks the indentation of parenthesized values, given a list of tokens in a program
|
|
* @param tokens A list of tokens
|
|
*/
|
|
function addParensIndent(tokens) {
|
|
const parenStack = [];
|
|
const parenPairs = [];
|
|
tokens.forEach(nextToken => {
|
|
// Accumulate a list of parenthesis pairs
|
|
if ((0, util_1.isOpeningParenToken)(nextToken)) {
|
|
parenStack.push(nextToken);
|
|
}
|
|
else if ((0, util_1.isClosingParenToken)(nextToken)) {
|
|
parenPairs.unshift({ left: parenStack.pop(), right: nextToken });
|
|
}
|
|
});
|
|
parenPairs.forEach(pair => {
|
|
const leftParen = pair.left;
|
|
const rightParen = pair.right;
|
|
// We only want to handle parens around expressions, so exclude parentheses that are in function parameters and function call arguments.
|
|
if (!parameterParens.has(leftParen) &&
|
|
!parameterParens.has(rightParen)) {
|
|
const parenthesizedTokens = new Set(sourceCode.getTokensBetween(leftParen, rightParen));
|
|
parenthesizedTokens.forEach(token => {
|
|
if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) {
|
|
offsets.setDesiredOffset(token, leftParen, 1);
|
|
}
|
|
});
|
|
}
|
|
offsets.setDesiredOffset(rightParen, leftParen, 0);
|
|
});
|
|
}
|
|
/**
|
|
* Ignore all tokens within an unknown node whose offset do not depend
|
|
* on another token's offset within the unknown node
|
|
*/
|
|
function ignoreNode(node) {
|
|
const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true }));
|
|
unknownNodeTokens.forEach(token => {
|
|
if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {
|
|
const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);
|
|
if (token === firstTokenOfLine) {
|
|
offsets.ignoreToken(token);
|
|
}
|
|
else {
|
|
offsets.setDesiredOffset(token, firstTokenOfLine, 0);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Check whether the given token is on the first line of a statement.
|
|
* @param leafNode The expression node that the token belongs directly.
|
|
* @returns `true` if the token is on the first line of a statement.
|
|
*/
|
|
function isOnFirstLineOfStatement(token, leafNode) {
|
|
let node = leafNode;
|
|
while (node.parent &&
|
|
!node.parent.type.endsWith('Statement') &&
|
|
!node.parent.type.endsWith('Declaration')) {
|
|
node = node.parent;
|
|
}
|
|
node = node.parent;
|
|
return !node || node.loc.start.line === token.loc.start.line;
|
|
}
|
|
/**
|
|
* Check whether there are any blank (whitespace-only) lines between
|
|
* two tokens on separate lines.
|
|
* @returns `true` if the tokens are on separate lines and
|
|
* there exists a blank line between them, `false` otherwise.
|
|
*/
|
|
function hasBlankLinesBetween(firstToken, secondToken) {
|
|
const firstTokenLine = firstToken.loc.end.line;
|
|
const secondTokenLine = secondToken.loc.start.line;
|
|
if (firstTokenLine === secondTokenLine ||
|
|
firstTokenLine === secondTokenLine - 1) {
|
|
return false;
|
|
}
|
|
for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) {
|
|
if (!tokenInfo.firstTokensByLineNumber.has(line)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
const ignoredNodeFirstTokens = new Set();
|
|
const baseOffsetListeners = {
|
|
'ArrayExpression, ArrayPattern'(node) {
|
|
var _a;
|
|
const openingBracket = sourceCode.getFirstToken(node);
|
|
const closingBracket = sourceCode.getTokenAfter((_a = node.elements[node.elements.length - 1]) !== null && _a !== void 0 ? _a : openingBracket, util_1.isClosingBracketToken);
|
|
addElementListIndent(node.elements, openingBracket, closingBracket, options.ArrayExpression);
|
|
},
|
|
ArrowFunctionExpression(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
if ((0, util_1.isOpeningParenToken)(firstToken)) {
|
|
const openingParen = firstToken;
|
|
const closingParen = sourceCode.getTokenBefore(node.body, util_1.isClosingParenToken);
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
|
|
}
|
|
addBlocklessNodeIndent(node.body);
|
|
},
|
|
AssignmentExpression(node) {
|
|
const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
|
|
offsets.setDesiredOffsets([operator.range[0], node.range[1]], sourceCode.getLastToken(node.left), 1);
|
|
offsets.ignoreToken(operator);
|
|
offsets.ignoreToken(sourceCode.getTokenAfter(operator));
|
|
},
|
|
'BinaryExpression, LogicalExpression'(node) {
|
|
const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
|
|
/*
|
|
* For backwards compatibility, don't check BinaryExpression indents, e.g.
|
|
* var foo = bar &&
|
|
* baz;
|
|
*/
|
|
const tokenAfterOperator = sourceCode.getTokenAfter(operator);
|
|
offsets.ignoreToken(operator);
|
|
offsets.ignoreToken(tokenAfterOperator);
|
|
offsets.setDesiredOffset(tokenAfterOperator, operator, 0);
|
|
},
|
|
'BlockStatement, ClassBody'(node) {
|
|
let blockIndentLevel;
|
|
if (node.parent && isOuterIIFE(node.parent)) {
|
|
blockIndentLevel = options.outerIIFEBody;
|
|
}
|
|
else if (node.parent &&
|
|
(node.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
|
|
node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
|
|
blockIndentLevel = options.FunctionExpression.body;
|
|
}
|
|
else if (node.parent &&
|
|
node.parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
|
|
blockIndentLevel = options.FunctionDeclaration.body;
|
|
}
|
|
else {
|
|
blockIndentLevel = 1;
|
|
}
|
|
/*
|
|
* For blocks that aren't lone statements, ensure that the opening curly brace
|
|
* is aligned with the parent.
|
|
*/
|
|
if (node.parent && !STATEMENT_LIST_PARENTS.has(node.parent.type)) {
|
|
offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0);
|
|
}
|
|
addElementListIndent(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel);
|
|
},
|
|
CallExpression: addFunctionCallIndent,
|
|
'ClassDeclaration[superClass], ClassExpression[superClass]'(node) {
|
|
const classToken = sourceCode.getFirstToken(node);
|
|
const extendsToken = sourceCode.getTokenBefore(node.superClass, util_1.isNotOpeningParenToken);
|
|
offsets.setDesiredOffsets([extendsToken.range[0], node.body.range[0]], classToken, 1);
|
|
},
|
|
ConditionalExpression(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
// `flatTernaryExpressions` option is for the following style:
|
|
// var a =
|
|
// foo > 0 ? bar :
|
|
// foo < 0 ? baz :
|
|
// /*else*/ qiz ;
|
|
if (!options.flatTernaryExpressions ||
|
|
node.test.loc.end.line !== node.consequent.loc.start.line ||
|
|
isOnFirstLineOfStatement(firstToken, node)) {
|
|
const questionMarkToken = sourceCode.getFirstTokenBetween(node.test, node.consequent, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '?');
|
|
const colonToken = sourceCode.getFirstTokenBetween(node.consequent, node.alternate, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ':');
|
|
const firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken);
|
|
const lastConsequentToken = sourceCode.getTokenBefore(colonToken);
|
|
const firstAlternateToken = sourceCode.getTokenAfter(colonToken);
|
|
offsets.setDesiredOffset(questionMarkToken, firstToken, 1);
|
|
offsets.setDesiredOffset(colonToken, firstToken, 1);
|
|
offsets.setDesiredOffset(firstConsequentToken, firstToken, 1);
|
|
/*
|
|
* The alternate and the consequent should usually have the same indentation.
|
|
* If they share part of a line, align the alternate against the first token of the consequent.
|
|
* This allows the alternate to be indented correctly in cases like this:
|
|
* foo ? (
|
|
* bar
|
|
* ) : ( // this '(' is aligned with the '(' above, so it's considered to be aligned with `foo`
|
|
* baz // as a result, `baz` is offset by 1 rather than 2
|
|
* )
|
|
*/
|
|
if (lastConsequentToken.loc.end.line ===
|
|
firstAlternateToken.loc.start.line) {
|
|
offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0);
|
|
}
|
|
else {
|
|
/**
|
|
* If the alternate and consequent do not share part of a line, offset the alternate from the first
|
|
* token of the conditional expression. For example:
|
|
* foo ? bar
|
|
* : baz
|
|
*
|
|
* If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up
|
|
* having no expected indentation.
|
|
*/
|
|
offsets.setDesiredOffset(firstAlternateToken, firstToken, 1);
|
|
}
|
|
}
|
|
},
|
|
'DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement': (node) => {
|
|
addBlocklessNodeIndent(node.body);
|
|
},
|
|
ExportNamedDeclaration(node) {
|
|
if (node.declaration === null) {
|
|
const closingCurly = sourceCode.getLastToken(node, util_1.isClosingBraceToken);
|
|
// Indent the specifiers in `export {foo, bar, baz}`
|
|
addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);
|
|
if (node.source) {
|
|
// Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'`
|
|
offsets.setDesiredOffsets([closingCurly.range[1], node.range[1]], sourceCode.getFirstToken(node), 1);
|
|
}
|
|
}
|
|
},
|
|
ForStatement(node) {
|
|
const forOpeningParen = sourceCode.getFirstToken(node, 1);
|
|
if (node.init) {
|
|
offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1);
|
|
}
|
|
if (node.test) {
|
|
offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1);
|
|
}
|
|
if (node.update) {
|
|
offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1);
|
|
}
|
|
addBlocklessNodeIndent(node.body);
|
|
},
|
|
'FunctionDeclaration, FunctionExpression'(node) {
|
|
const closingParen = sourceCode.getTokenBefore(node.body);
|
|
const openingParen = sourceCode.getTokenBefore(node.params.length ? node.params[0] : closingParen);
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters);
|
|
},
|
|
IfStatement(node) {
|
|
addBlocklessNodeIndent(node.consequent);
|
|
if (node.alternate &&
|
|
node.alternate.type !== utils_1.AST_NODE_TYPES.IfStatement) {
|
|
addBlocklessNodeIndent(node.alternate);
|
|
}
|
|
},
|
|
ImportDeclaration(node) {
|
|
if (node.specifiers.some(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier)) {
|
|
const openingCurly = sourceCode.getFirstToken(node, util_1.isOpeningBraceToken);
|
|
const closingCurly = sourceCode.getLastToken(node, util_1.isClosingBraceToken);
|
|
addElementListIndent(node.specifiers.filter(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier), openingCurly, closingCurly, options.ImportDeclaration);
|
|
}
|
|
const fromToken = sourceCode.getLastToken(node, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'from');
|
|
const sourceToken = sourceCode.getLastToken(node, token => token.type === utils_1.AST_TOKEN_TYPES.String);
|
|
const semiToken = sourceCode.getLastToken(node, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ';');
|
|
if (fromToken) {
|
|
const end = semiToken && semiToken.range[1] === sourceToken.range[1]
|
|
? node.range[1]
|
|
: sourceToken.range[1];
|
|
offsets.setDesiredOffsets([fromToken.range[0], end], sourceCode.getFirstToken(node), 1);
|
|
}
|
|
},
|
|
'MemberExpression, JSXMemberExpression, MetaProperty'(node) {
|
|
const object = node.type === utils_1.AST_NODE_TYPES.MetaProperty ? node.meta : node.object;
|
|
const isComputed = 'computed' in node && node.computed;
|
|
const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, node.property, util_1.isNotClosingParenToken);
|
|
const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken);
|
|
const objectParenCount = sourceCode.getTokensBetween(object, node.property, { filter: util_1.isClosingParenToken }).length;
|
|
const firstObjectToken = objectParenCount
|
|
? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 })
|
|
: sourceCode.getFirstToken(object);
|
|
const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);
|
|
const firstPropertyToken = isComputed
|
|
? firstNonObjectToken
|
|
: secondNonObjectToken;
|
|
if (isComputed) {
|
|
// For computed MemberExpressions, match the closing bracket with the opening bracket.
|
|
offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0);
|
|
offsets.setDesiredOffsets(node.property.range, firstNonObjectToken, 1);
|
|
}
|
|
/*
|
|
* If the object ends on the same line that the property starts, match against the last token
|
|
* of the object, to ensure that the MemberExpression is not indented.
|
|
*
|
|
* Otherwise, match against the first token of the object, e.g.
|
|
* foo
|
|
* .bar
|
|
* .baz // <-- offset by 1 from `foo`
|
|
*/
|
|
const offsetBase = lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line
|
|
? lastObjectToken
|
|
: firstObjectToken;
|
|
if (typeof options.MemberExpression === 'number') {
|
|
// Match the dot (for non-computed properties) or the opening bracket (for computed properties) against the object.
|
|
offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression);
|
|
/*
|
|
* For computed MemberExpressions, match the first token of the property against the opening bracket.
|
|
* Otherwise, match the first token of the property against the object.
|
|
*/
|
|
offsets.setDesiredOffset(secondNonObjectToken, isComputed ? firstNonObjectToken : offsetBase, options.MemberExpression);
|
|
}
|
|
else {
|
|
// If the MemberExpression option is off, ignore the dot and the first token of the property.
|
|
offsets.ignoreToken(firstNonObjectToken);
|
|
offsets.ignoreToken(secondNonObjectToken);
|
|
// To ignore the property indentation, ensure that the property tokens depend on the ignored tokens.
|
|
offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);
|
|
offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0);
|
|
}
|
|
},
|
|
NewExpression(node) {
|
|
// Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo`
|
|
if (node.arguments.length > 0 ||
|
|
((0, util_1.isClosingParenToken)(sourceCode.getLastToken(node)) &&
|
|
(0, util_1.isOpeningParenToken)(sourceCode.getLastToken(node, 1)))) {
|
|
addFunctionCallIndent(node);
|
|
}
|
|
},
|
|
'ObjectExpression, ObjectPattern'(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node);
|
|
const closingCurly = sourceCode.getTokenAfter(node.properties.length
|
|
? node.properties[node.properties.length - 1]
|
|
: openingCurly, util_1.isClosingBraceToken);
|
|
addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression);
|
|
},
|
|
Property(node) {
|
|
if (!node.shorthand && !node.method && node.kind === 'init') {
|
|
const colon = sourceCode.getFirstTokenBetween(node.key, node.value, util_1.isColonToken);
|
|
offsets.ignoreToken(sourceCode.getTokenAfter(colon));
|
|
}
|
|
},
|
|
SwitchStatement(node) {
|
|
const openingCurly = sourceCode.getTokenAfter(node.discriminant, util_1.isOpeningBraceToken);
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, options.SwitchCase);
|
|
if (node.cases.length) {
|
|
sourceCode
|
|
.getTokensBetween(node.cases[node.cases.length - 1], closingCurly, {
|
|
includeComments: true,
|
|
filter: util_1.isCommentToken,
|
|
})
|
|
.forEach(token => offsets.ignoreToken(token));
|
|
}
|
|
},
|
|
SwitchCase(node) {
|
|
if (!(node.consequent.length === 1 &&
|
|
node.consequent[0].type === utils_1.AST_NODE_TYPES.BlockStatement)) {
|
|
const caseKeyword = sourceCode.getFirstToken(node);
|
|
const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);
|
|
offsets.setDesiredOffsets([caseKeyword.range[1], tokenAfterCurrentCase.range[0]], caseKeyword, 1);
|
|
}
|
|
},
|
|
TemplateLiteral(node) {
|
|
node.expressions.forEach((_, index) => {
|
|
const previousQuasi = node.quasis[index];
|
|
const nextQuasi = node.quasis[index + 1];
|
|
const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line
|
|
? sourceCode.getFirstToken(previousQuasi)
|
|
: null;
|
|
offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, 1);
|
|
offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);
|
|
});
|
|
},
|
|
VariableDeclaration(node) {
|
|
if (node.declarations.length === 0) {
|
|
return;
|
|
}
|
|
let variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind)
|
|
? options.VariableDeclarator[node.kind]
|
|
: DEFAULT_VARIABLE_INDENT;
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
const lastToken = sourceCode.getLastToken(node);
|
|
if (variableIndent === 'first') {
|
|
if (node.declarations.length > 1) {
|
|
addElementListIndent(node.declarations, firstToken, lastToken, 'first');
|
|
return;
|
|
}
|
|
variableIndent = DEFAULT_VARIABLE_INDENT;
|
|
}
|
|
if (node.declarations[node.declarations.length - 1].loc.start.line >
|
|
node.loc.start.line) {
|
|
/*
|
|
* VariableDeclarator indentation is a bit different from other forms of indentation, in that the
|
|
* indentation of an opening bracket sometimes won't match that of a closing bracket. For example,
|
|
* the following indentations are correct:
|
|
*
|
|
* var foo = {
|
|
* ok: true
|
|
* };
|
|
*
|
|
* var foo = {
|
|
* ok: true,
|
|
* },
|
|
* bar = 1;
|
|
*
|
|
* Account for when exiting the AST (after indentations have already been set for the nodes in
|
|
* the declaration) by manually increasing the indentation level of the tokens in this declarator
|
|
* on the same line as the start of the declaration, provided that there are declarators that
|
|
* follow this one.
|
|
*/
|
|
offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true);
|
|
}
|
|
else {
|
|
offsets.setDesiredOffsets(node.range, firstToken, variableIndent);
|
|
}
|
|
if ((0, util_1.isSemicolonToken)(lastToken)) {
|
|
offsets.ignoreToken(lastToken);
|
|
}
|
|
},
|
|
VariableDeclarator(node) {
|
|
if (node.init) {
|
|
const equalOperator = sourceCode.getTokenBefore(node.init, util_1.isNotOpeningParenToken);
|
|
const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator);
|
|
offsets.ignoreToken(equalOperator);
|
|
offsets.ignoreToken(tokenAfterOperator);
|
|
offsets.setDesiredOffsets([tokenAfterOperator.range[0], node.range[1]], equalOperator, 1);
|
|
offsets.setDesiredOffset(equalOperator, sourceCode.getLastToken(node.id), 0);
|
|
}
|
|
},
|
|
'JSXAttribute[value]'(node) {
|
|
const nodeValue = node.value;
|
|
const equalsToken = sourceCode.getFirstTokenBetween(node.name, nodeValue, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '=');
|
|
offsets.setDesiredOffsets([equalsToken.range[0], nodeValue.range[1]], sourceCode.getFirstToken(node.name), 1);
|
|
},
|
|
JSXElement(node) {
|
|
if (node.closingElement) {
|
|
addElementListIndent(node.children, sourceCode.getFirstToken(node.openingElement), sourceCode.getFirstToken(node.closingElement), 1);
|
|
}
|
|
},
|
|
JSXOpeningElement(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
let closingToken;
|
|
if (node.selfClosing) {
|
|
closingToken = sourceCode.getLastToken(node, { skip: 1 });
|
|
offsets.setDesiredOffset(sourceCode.getLastToken(node), closingToken, 0);
|
|
}
|
|
else {
|
|
closingToken = sourceCode.getLastToken(node);
|
|
}
|
|
offsets.setDesiredOffsets(node.name.range, sourceCode.getFirstToken(node));
|
|
addElementListIndent(node.attributes, firstToken, closingToken, 1);
|
|
},
|
|
JSXClosingElement(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
offsets.setDesiredOffsets(node.name.range, firstToken, 1);
|
|
},
|
|
JSXExpressionContainer(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node);
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, 1);
|
|
},
|
|
'*'(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
// Ensure that the children of every node are indented at least as much as the first token.
|
|
if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {
|
|
offsets.setDesiredOffsets(node.range, firstToken, 0);
|
|
}
|
|
},
|
|
};
|
|
const listenerCallQueue = [];
|
|
/*
|
|
* To ignore the indentation of a node:
|
|
* 1. Don't call the node's listener when entering it (if it has a listener)
|
|
* 2. Don't set any offsets against the first token of the node.
|
|
* 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.
|
|
*/
|
|
const offsetListeners = Object.keys(baseOffsetListeners).reduce(
|
|
/*
|
|
* Offset listener calls are deferred until traversal is finished, and are called as
|
|
* part of the final `Program:exit` listener. This is necessary because a node might
|
|
* be matched by multiple selectors.
|
|
*
|
|
* Example: Suppose there is an offset listener for `Identifier`, and the user has
|
|
* specified in configuration that `MemberExpression > Identifier` should be ignored.
|
|
* Due to selector specificity rules, the `Identifier` listener will get called first. However,
|
|
* if a given Identifier node is supposed to be ignored, then the `Identifier` offset listener
|
|
* should not have been called at all. Without doing extra selector matching, we don't know
|
|
* whether the Identifier matches the `MemberExpression > Identifier` selector until the
|
|
* `MemberExpression > Identifier` listener is called.
|
|
*
|
|
* To avoid this, the `Identifier` listener isn't called until traversal finishes and all
|
|
* ignored nodes are known.
|
|
*/
|
|
(acc, key) => {
|
|
const listener = baseOffsetListeners[key];
|
|
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
|
|
acc[key] = node => listenerCallQueue.push({ listener, node });
|
|
return acc;
|
|
}, {});
|
|
// For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set.
|
|
const ignoredNodes = new Set();
|
|
/**
|
|
* Ignores a node
|
|
* @param node The node to ignore
|
|
*/
|
|
function addToIgnoredNodes(node) {
|
|
ignoredNodes.add(node);
|
|
ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
|
|
}
|
|
const ignoredNodeListeners = options.ignoredNodes.reduce((listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }), {});
|
|
/*
|
|
* Join the listeners, and add a listener to verify that all tokens actually have the correct indentation
|
|
* at the end.
|
|
*
|
|
* Using Object.assign will cause some offset listeners to be overwritten if the same selector also appears
|
|
* in `ignoredNodeListeners`. This isn't a problem because all of the matching nodes will be ignored,
|
|
* so those listeners wouldn't be called anyway.
|
|
*/
|
|
return Object.assign(offsetListeners, ignoredNodeListeners, {
|
|
'*:exit'(node) {
|
|
// If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it.
|
|
if (!KNOWN_NODES.has(node.type)) {
|
|
addToIgnoredNodes(node);
|
|
}
|
|
},
|
|
'Program:exit'() {
|
|
// If ignoreComments option is enabled, ignore all comment tokens.
|
|
if (options.ignoreComments) {
|
|
sourceCode
|
|
.getAllComments()
|
|
.forEach(comment => offsets.ignoreToken(comment));
|
|
}
|
|
// Invoke the queued offset listeners for the nodes that aren't ignored.
|
|
listenerCallQueue
|
|
.filter(nodeInfo => !ignoredNodes.has(nodeInfo.node))
|
|
.forEach(nodeInfo => nodeInfo.listener(nodeInfo.node));
|
|
// Update the offsets for ignored nodes to prevent their child tokens from being reported.
|
|
ignoredNodes.forEach(ignoreNode);
|
|
addParensIndent(sourceCode.ast.tokens);
|
|
/*
|
|
* Create a Map from (token) => (precedingToken).
|
|
* This is necessary because sourceCode.getTokenBefore does not handle a comment as an argument correctly.
|
|
*/
|
|
const precedingTokens = sourceCode.ast.comments.reduce((commentMap, comment) => {
|
|
var _a;
|
|
const tokenBefore = sourceCode.getTokenBefore(comment, {
|
|
includeComments: true,
|
|
});
|
|
return commentMap.set(comment, (_a = commentMap.get(tokenBefore)) !== null && _a !== void 0 ? _a : tokenBefore);
|
|
}, new WeakMap());
|
|
sourceCode.lines.forEach((_, lineIndex) => {
|
|
const lineNumber = lineIndex + 1;
|
|
if (!tokenInfo.firstTokensByLineNumber.has(lineNumber)) {
|
|
// Don't check indentation on blank lines
|
|
return;
|
|
}
|
|
const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(lineNumber);
|
|
if (firstTokenOfLine.loc.start.line !== lineNumber) {
|
|
// Don't check the indentation of multi-line tokens (e.g. template literals or block comments) twice.
|
|
return;
|
|
}
|
|
// If the token matches the expected expected indentation, don't report it.
|
|
if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {
|
|
return;
|
|
}
|
|
if ((0, util_1.isCommentToken)(firstTokenOfLine)) {
|
|
const tokenBefore = precedingTokens.get(firstTokenOfLine);
|
|
const tokenAfter = tokenBefore
|
|
? sourceCode.getTokenAfter(tokenBefore)
|
|
: sourceCode.ast.tokens[0];
|
|
const mayAlignWithBefore = tokenBefore &&
|
|
!hasBlankLinesBetween(tokenBefore, firstTokenOfLine);
|
|
const mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter);
|
|
// If a comment matches the expected indentation of the token immediately before or after, don't report it.
|
|
if ((mayAlignWithBefore &&
|
|
validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore))) ||
|
|
(mayAlignWithAfter &&
|
|
validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter)))) {
|
|
return;
|
|
}
|
|
}
|
|
// Otherwise, report the token/comment.
|
|
report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
|
|
});
|
|
},
|
|
});
|
|
},
|
|
});
|
|
//# sourceMappingURL=index.js.map |