140 lines
5.0 KiB
Plaintext
140 lines
5.0 KiB
Plaintext
import { _ as ASSIGNMENT_OPERATOR, f as createRule, z as isKeywordToken } from "../utils.js";
|
|
var indent_binary_ops_default = createRule({
|
|
name: "indent-binary-ops",
|
|
meta: {
|
|
type: "layout",
|
|
docs: { description: "Indentation for binary operators" },
|
|
fixable: "whitespace",
|
|
schema: [{ oneOf: [{
|
|
type: "integer",
|
|
minimum: 0
|
|
}, {
|
|
type: "string",
|
|
enum: ["tab"]
|
|
}] }],
|
|
defaultOptions: [2],
|
|
messages: { wrongIndentation: "Expected indentation of {{expected}}" }
|
|
},
|
|
create: (context, options) => {
|
|
const { sourceCode } = context;
|
|
const indentStr = options[0] === "tab" ? " " : " ".repeat(options[0] ?? 2);
|
|
const indentCache = /* @__PURE__ */ new Map();
|
|
function getIndentOfLine(line) {
|
|
if (indentCache.has(line)) return indentCache.get(line);
|
|
return sourceCode.lines[line - 1].match(/^\s*/)?.[0] ?? "";
|
|
}
|
|
function subtractionIndent(indent) {
|
|
if (options[0] === "tab") return indent.slice(1);
|
|
return indent.slice(options[0] ?? 2);
|
|
}
|
|
function getTargetIndent(indent, needAdditionIndent, needSubtractionIndent) {
|
|
if (needAdditionIndent && !needSubtractionIndent) return indent + indentStr;
|
|
if (!needAdditionIndent && needSubtractionIndent) return subtractionIndent(indent);
|
|
return indent;
|
|
}
|
|
function firstTokenOfLine(line) {
|
|
return sourceCode.tokensAndComments.find((token) => token.loc.start.line === line);
|
|
}
|
|
function lastTokenOfLine(line) {
|
|
return [...sourceCode.tokensAndComments].reverse().find((token) => token.loc.end.line === line);
|
|
}
|
|
function isGreaterThanCloseBracketOfLine(line) {
|
|
const tokensAndCommentsOfLine = sourceCode.tokensAndComments.filter((token) => token.loc.start.line === line);
|
|
let openBracketCount = 0;
|
|
let closeBracketCount = 0;
|
|
for (const token of tokensAndCommentsOfLine) {
|
|
if (token.value === "(") openBracketCount++;
|
|
if (token.value === ")") closeBracketCount++;
|
|
}
|
|
return openBracketCount < closeBracketCount;
|
|
}
|
|
function isTypeKeywordOfNode(typeToken, node) {
|
|
while (node.parent) {
|
|
node = node.parent;
|
|
if (node.type === "TSTypeAliasDeclaration" && context.sourceCode.getTokenBefore(node.id) === typeToken) return true;
|
|
}
|
|
return false;
|
|
}
|
|
function handler(node, right) {
|
|
if (node.loc.start.line === node.loc.end.line) return;
|
|
let tokenRight = sourceCode.getFirstToken(right);
|
|
let tokenOperator = sourceCode.getTokenBefore(tokenRight);
|
|
while (tokenOperator.value === "(") {
|
|
tokenRight = tokenOperator;
|
|
tokenOperator = sourceCode.getTokenBefore(tokenRight);
|
|
if (tokenOperator.range[0] <= right.parent.range[0]) return;
|
|
}
|
|
const tokenBeforeAll = sourceCode.getTokenBefore(node);
|
|
const tokenLeft = sourceCode.getTokenBefore(tokenOperator);
|
|
if (!(tokenRight.loc.start.line !== tokenLeft.loc.start.line)) return;
|
|
const firstTokenOfLineLeft = firstTokenOfLine(tokenLeft.loc.start.line);
|
|
const lastTokenOfLineLeft = lastTokenOfLine(tokenLeft.loc.start.line);
|
|
const needAdditionIndent = isKeywordToken(firstTokenOfLineLeft) && ![
|
|
"typeof",
|
|
"instanceof",
|
|
"this"
|
|
].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && isTypeKeywordOfNode(firstTokenOfLineLeft, node) || [
|
|
":",
|
|
"[",
|
|
"(",
|
|
"<"
|
|
].concat(ASSIGNMENT_OPERATOR).includes(lastTokenOfLineLeft?.value || "") || [
|
|
"[",
|
|
"(",
|
|
"{",
|
|
"=>",
|
|
":"
|
|
].concat(ASSIGNMENT_OPERATOR).includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line;
|
|
const needSubtractionIndent = lastTokenOfLineLeft?.value === ")" && isGreaterThanCloseBracketOfLine(tokenLeft.loc.start.line) && ![
|
|
"]",
|
|
")",
|
|
"}"
|
|
].includes(firstTokenOfLineLeft?.value || "");
|
|
const indentLeft = getIndentOfLine(tokenLeft.loc.start.line);
|
|
const indentRight = getIndentOfLine(tokenRight.loc.start.line);
|
|
const indentTarget = getTargetIndent(indentLeft, needAdditionIndent, needSubtractionIndent);
|
|
if (indentTarget !== indentRight) {
|
|
const start = {
|
|
line: tokenRight.loc.start.line,
|
|
column: 0
|
|
};
|
|
const end = {
|
|
line: tokenRight.loc.start.line,
|
|
column: indentRight.length
|
|
};
|
|
context.report({
|
|
loc: {
|
|
start,
|
|
end
|
|
},
|
|
messageId: "wrongIndentation",
|
|
data: { expected: `${indentTarget.length} ${options[0] === "tab" ? "tab" : "space"}${indentTarget.length === 1 ? "" : "s"}` },
|
|
fix(fixer) {
|
|
return fixer.replaceTextRange([sourceCode.getIndexFromLoc(start), sourceCode.getIndexFromLoc(end)], indentTarget);
|
|
}
|
|
});
|
|
indentCache.set(tokenRight.loc.start.line, indentTarget);
|
|
}
|
|
}
|
|
return {
|
|
BinaryExpression(node) {
|
|
handler(node, node.right);
|
|
},
|
|
LogicalExpression(node) {
|
|
handler(node, node.right);
|
|
},
|
|
TSUnionType(node) {
|
|
if (node.types.length > 1) node.types.forEach((type) => {
|
|
handler(node, type);
|
|
});
|
|
},
|
|
TSIntersectionType(node) {
|
|
if (node.types.length > 1) node.types.forEach((type) => {
|
|
handler(node, type);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
});
|
|
export { indent_binary_ops_default as t };
|