feat: docker compose maybe
This commit is contained in:
6
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ast.d.ts
generated
vendored
Normal file
6
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ast.d.ts
generated
vendored
Normal file
@ -0,0 +1,6 @@
|
||||
import type { AST } from 'svelte-eslint-parser';
|
||||
import type { TSESTree } from '@typescript-eslint/types';
|
||||
type AnyToken = AST.Token | AST.Comment;
|
||||
export declare function isWhitespace(token: AnyToken | TSESTree.Comment | null | undefined): boolean;
|
||||
export declare function isNotWhitespace(token: AnyToken | TSESTree.Comment | null | undefined): boolean;
|
||||
export {};
|
||||
15
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ast.js
generated
vendored
Normal file
15
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ast.js
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isNotWhitespace = exports.isWhitespace = void 0;
|
||||
function isWhitespace(token) {
|
||||
return (token != null &&
|
||||
((token.type === 'HTMLText' && !token.value.trim()) ||
|
||||
(token.type === 'JSXText' && !token.value.trim())));
|
||||
}
|
||||
exports.isWhitespace = isWhitespace;
|
||||
function isNotWhitespace(token) {
|
||||
return (token != null &&
|
||||
(token.type !== 'HTMLText' || Boolean(token.value.trim())) &&
|
||||
(token.type !== 'JSXText' || Boolean(token.value.trim())));
|
||||
}
|
||||
exports.isNotWhitespace = isNotWhitespace;
|
||||
28
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/commons.d.ts
generated
vendored
Normal file
28
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/commons.d.ts
generated
vendored
Normal file
@ -0,0 +1,28 @@
|
||||
import type { ASTNode, SourceCode } from '../../types';
|
||||
import type { AST } from 'svelte-eslint-parser';
|
||||
import type { OffsetContext } from './offset-context';
|
||||
export type AnyToken = AST.Token | AST.Comment;
|
||||
export type MaybeNode = {
|
||||
type: string;
|
||||
range: [number, number];
|
||||
loc: AST.SourceLocation;
|
||||
};
|
||||
export type IndentOptions = {
|
||||
indentChar: ' ' | '\t';
|
||||
indentScript: boolean;
|
||||
indentSize: number;
|
||||
switchCase: number;
|
||||
alignAttributesVertically: boolean;
|
||||
ignoredNodes: string[];
|
||||
};
|
||||
export type IndentContext = {
|
||||
sourceCode: SourceCode;
|
||||
options: IndentOptions;
|
||||
offsets: OffsetContext;
|
||||
};
|
||||
export declare function getFirstAndLastTokens(sourceCode: SourceCode, node: ASTNode | AnyToken | MaybeNode, borderOffset?: number): {
|
||||
firstToken: AST.Token;
|
||||
lastToken: AST.Token;
|
||||
};
|
||||
export declare function isBeginningOfLine(sourceCode: SourceCode, node: ASTNode | AnyToken | MaybeNode): boolean;
|
||||
export declare function isBeginningOfElement(node: AST.SvelteText): boolean;
|
||||
55
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/commons.js
generated
vendored
Normal file
55
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/commons.js
generated
vendored
Normal file
@ -0,0 +1,55 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isBeginningOfElement = exports.isBeginningOfLine = exports.getFirstAndLastTokens = void 0;
|
||||
const eslint_utils_1 = require("@eslint-community/eslint-utils");
|
||||
const ast_1 = require("./ast");
|
||||
function getFirstAndLastTokens(sourceCode, node, borderOffset = 0) {
|
||||
let firstToken = sourceCode.getFirstToken(node);
|
||||
let lastToken = sourceCode.getLastToken(node);
|
||||
let left, right;
|
||||
while ((left = sourceCode.getTokenBefore(firstToken)) != null &&
|
||||
(right = sourceCode.getTokenAfter(lastToken)) != null &&
|
||||
(0, eslint_utils_1.isOpeningParenToken)(left) &&
|
||||
(0, eslint_utils_1.isClosingParenToken)(right) &&
|
||||
borderOffset <= left.range[0]) {
|
||||
firstToken = left;
|
||||
lastToken = right;
|
||||
}
|
||||
while ((0, ast_1.isWhitespace)(firstToken) && firstToken.range[0] < lastToken.range[0]) {
|
||||
firstToken = sourceCode.getTokenAfter(firstToken);
|
||||
}
|
||||
while ((0, ast_1.isWhitespace)(lastToken) && firstToken.range[0] < lastToken.range[0]) {
|
||||
lastToken = sourceCode.getTokenBefore(lastToken);
|
||||
}
|
||||
return { firstToken, lastToken };
|
||||
}
|
||||
exports.getFirstAndLastTokens = getFirstAndLastTokens;
|
||||
function isBeginningOfLine(sourceCode, node) {
|
||||
const prevToken = sourceCode.getTokenBefore(node, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
return !prevToken || prevToken.loc.end.line < node.loc.start.line;
|
||||
}
|
||||
exports.isBeginningOfLine = isBeginningOfLine;
|
||||
function isBeginningOfElement(node) {
|
||||
if (node.parent.type === 'SvelteElement' ||
|
||||
node.parent.type === 'SvelteAwaitCatchBlock' ||
|
||||
node.parent.type === 'SvelteAwaitPendingBlock' ||
|
||||
node.parent.type === 'SvelteAwaitThenBlock' ||
|
||||
node.parent.type === 'SvelteEachBlock' ||
|
||||
node.parent.type === 'SvelteElseBlock' ||
|
||||
node.parent.type === 'SvelteIfBlock' ||
|
||||
node.parent.type === 'SvelteKeyBlock' ||
|
||||
node.parent.type === 'SvelteStyleElement') {
|
||||
return node.parent.children[0] === node;
|
||||
}
|
||||
if (node.parent.type === 'Program') {
|
||||
return node.parent.body[0] === node;
|
||||
}
|
||||
return assertNever(node.parent);
|
||||
}
|
||||
exports.isBeginningOfElement = isBeginningOfElement;
|
||||
function assertNever(value) {
|
||||
throw new Error(`This part of the code should never be reached but ${value} made it through.`);
|
||||
}
|
||||
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/es.d.ts
generated
vendored
Normal file
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/es.d.ts
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
import type { IndentContext } from './commons';
|
||||
import type { ESNodeListener } from '../../types-for-node';
|
||||
type NodeListener = ESNodeListener;
|
||||
export declare function defineVisitor(context: IndentContext): NodeListener;
|
||||
export {};
|
||||
731
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/es.js
generated
vendored
Normal file
731
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/es.js
generated
vendored
Normal file
@ -0,0 +1,731 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.defineVisitor = void 0;
|
||||
const commons_1 = require("./commons");
|
||||
const eslint_utils_1 = require("@eslint-community/eslint-utils");
|
||||
const ast_utils_1 = require("../../utils/ast-utils");
|
||||
function defineVisitor(context) {
|
||||
const { sourceCode, offsets, options } = context;
|
||||
function getRootLeft(node) {
|
||||
let target = node;
|
||||
let parent = (0, ast_utils_1.getParent)(target);
|
||||
while (parent &&
|
||||
(parent.type === 'AssignmentExpression' ||
|
||||
parent.type === 'AssignmentPattern' ||
|
||||
parent.type === 'BinaryExpression' ||
|
||||
parent.type === 'LogicalExpression')) {
|
||||
const prevToken = sourceCode.getTokenBefore(target);
|
||||
if (prevToken && (0, eslint_utils_1.isOpeningParenToken)(prevToken)) {
|
||||
break;
|
||||
}
|
||||
target = parent;
|
||||
parent = (0, ast_utils_1.getParent)(target);
|
||||
}
|
||||
return target.left;
|
||||
}
|
||||
const visitor = {
|
||||
Program(node) {
|
||||
for (const body of node.body) {
|
||||
if (body.type === 'SvelteText' && !body.value.trim()) {
|
||||
continue;
|
||||
}
|
||||
offsets.setStartOffsetToken(sourceCode.getFirstToken(body), 0);
|
||||
}
|
||||
},
|
||||
ArrayExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const rightToken = sourceCode.getTokenAfter(node.elements[node.elements.length - 1] || firstToken, { filter: eslint_utils_1.isClosingBracketToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.elements, firstToken, rightToken, 1);
|
||||
},
|
||||
ArrayPattern(node) {
|
||||
visitor.ArrayExpression(node);
|
||||
},
|
||||
ArrowFunctionExpression(node) {
|
||||
const [firstToken, secondToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
const leftToken = node.async ? secondToken : firstToken;
|
||||
const arrowToken = sourceCode.getTokenBefore(node.body, {
|
||||
filter: eslint_utils_1.isArrowToken,
|
||||
includeComments: false
|
||||
});
|
||||
if (node.async) {
|
||||
offsets.setOffsetToken(secondToken, 1, firstToken);
|
||||
}
|
||||
if ((0, eslint_utils_1.isOpeningParenToken)(leftToken)) {
|
||||
const rightToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.params, leftToken, rightToken, 1);
|
||||
}
|
||||
offsets.setOffsetToken(arrowToken, 1, firstToken);
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, firstToken);
|
||||
},
|
||||
AssignmentExpression(node) {
|
||||
const leftNode = getRootLeft(node);
|
||||
const opToken = sourceCode.getTokenAfter(node.left, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightToken = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.right).firstToken;
|
||||
offsets.setOffsetToken([opToken, rightToken], 1, (0, commons_1.getFirstAndLastTokens)(sourceCode, leftNode).firstToken);
|
||||
},
|
||||
AssignmentPattern(node) {
|
||||
visitor.AssignmentExpression(node);
|
||||
},
|
||||
BinaryExpression(node) {
|
||||
visitor.AssignmentExpression(node);
|
||||
},
|
||||
LogicalExpression(node) {
|
||||
visitor.AssignmentExpression(node);
|
||||
},
|
||||
AwaitExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
},
|
||||
RestElement(node) {
|
||||
visitor.AwaitExpression(node);
|
||||
},
|
||||
SpreadElement(node) {
|
||||
visitor.AwaitExpression(node);
|
||||
},
|
||||
UnaryExpression(node) {
|
||||
visitor.AwaitExpression(node);
|
||||
},
|
||||
BlockStatement(node) {
|
||||
offsets.setOffsetElementList(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
ClassBody(node) {
|
||||
visitor.BlockStatement(node);
|
||||
},
|
||||
BreakStatement(node) {
|
||||
if (node.label) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
}
|
||||
},
|
||||
ContinueStatement(node) {
|
||||
visitor.BreakStatement(node);
|
||||
},
|
||||
CallExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(node.typeParameters || node.callee, {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightParenToken = sourceCode.getLastToken(node);
|
||||
if (node.typeParameters) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, firstToken);
|
||||
}
|
||||
for (const optionalToken of sourceCode.getTokensBetween(sourceCode.getLastToken(node.typeParameters || node.callee), leftParenToken, { filter: isOptionalToken, includeComments: false })) {
|
||||
offsets.setOffsetToken(optionalToken, 1, firstToken);
|
||||
}
|
||||
offsets.setOffsetToken(leftParenToken, 1, firstToken);
|
||||
offsets.setOffsetElementList(node.arguments, leftParenToken, rightParenToken, 1);
|
||||
},
|
||||
CatchClause(node) {
|
||||
const catchToken = sourceCode.getFirstToken(node);
|
||||
if (node.param != null) {
|
||||
const leftParenToken = sourceCode.getTokenBefore(node.param);
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.param);
|
||||
offsets.setOffsetToken(leftParenToken, 1, catchToken);
|
||||
offsets.setOffsetElementList([node.param], leftParenToken, rightParenToken, 1);
|
||||
}
|
||||
const bodyToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyToken, 0, catchToken);
|
||||
},
|
||||
ClassDeclaration(node) {
|
||||
const classToken = sourceCode.getFirstToken(node);
|
||||
if (node.id != null) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.id), 1, classToken);
|
||||
}
|
||||
if (node.superClass != null) {
|
||||
const extendsToken = sourceCode.getTokenBefore(node.superClass);
|
||||
const superClassToken = sourceCode.getTokenAfter(extendsToken);
|
||||
offsets.setOffsetToken(extendsToken, 1, classToken);
|
||||
offsets.setOffsetToken(superClassToken, 1, extendsToken);
|
||||
}
|
||||
const bodyToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyToken, 0, classToken);
|
||||
},
|
||||
ClassExpression(node) {
|
||||
visitor.ClassDeclaration(node);
|
||||
},
|
||||
ConditionalExpression(node) {
|
||||
const questionToken = sourceCode.getTokenAfter(node.test, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const consequentToken = sourceCode.getTokenAfter(questionToken);
|
||||
const colonToken = sourceCode.getTokenAfter(node.consequent, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const alternateToken = sourceCode.getTokenAfter(colonToken);
|
||||
let baseNode = node;
|
||||
let parent = (0, ast_utils_1.getParent)(baseNode);
|
||||
while (parent && parent.type === 'ConditionalExpression' && parent.alternate === baseNode) {
|
||||
baseNode = parent;
|
||||
parent = (0, ast_utils_1.getParent)(baseNode);
|
||||
}
|
||||
const baseToken = sourceCode.getFirstToken(baseNode);
|
||||
offsets.setOffsetToken([questionToken, colonToken], 1, baseToken);
|
||||
offsets.setOffsetToken(consequentToken, 1, questionToken);
|
||||
offsets.setOffsetToken(alternateToken, 1, colonToken);
|
||||
},
|
||||
DoWhileStatement(node) {
|
||||
const doToken = sourceCode.getFirstToken(node);
|
||||
const whileToken = sourceCode.getTokenAfter(node.body, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const leftParenToken = sourceCode.getTokenAfter(whileToken);
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.test);
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, doToken);
|
||||
offsets.setOffsetToken(whileToken, 0, doToken);
|
||||
offsets.setOffsetToken(leftParenToken, 1, whileToken);
|
||||
offsets.setOffsetElementList([node.test], leftParenToken, rightParenToken, 1);
|
||||
},
|
||||
ExportAllDeclaration(node) {
|
||||
const exportToken = sourceCode.getFirstToken(node);
|
||||
const tokens = sourceCode.getTokensBetween(exportToken, node.source);
|
||||
const fromIndex = tokens.findIndex((t) => t.value === 'from');
|
||||
const fromToken = tokens[fromIndex];
|
||||
const beforeTokens = tokens.slice(0, fromIndex);
|
||||
const afterTokens = [...tokens.slice(fromIndex + 1), sourceCode.getFirstToken(node.source)];
|
||||
if (!node.exported) {
|
||||
offsets.setOffsetToken(beforeTokens, 1, exportToken);
|
||||
}
|
||||
else {
|
||||
const asIndex = beforeTokens.findIndex((t) => t.value === 'as');
|
||||
offsets.setOffsetToken(beforeTokens.slice(0, asIndex), 1, exportToken);
|
||||
offsets.setOffsetToken(beforeTokens.slice(asIndex), 1, beforeTokens[asIndex - 1]);
|
||||
}
|
||||
offsets.setOffsetToken(fromToken, 0, exportToken);
|
||||
offsets.setOffsetToken(afterTokens, 1, fromToken);
|
||||
const lastToken = sourceCode.getLastToken(node, {
|
||||
filter: eslint_utils_1.isNotSemicolonToken,
|
||||
includeComments: false
|
||||
});
|
||||
const assertionTokens = sourceCode.getTokensBetween(node.source, lastToken);
|
||||
if (assertionTokens.length) {
|
||||
const assertToken = assertionTokens.shift();
|
||||
offsets.setOffsetToken(assertToken, 0, exportToken);
|
||||
const assertionOpen = assertionTokens.shift();
|
||||
if (assertionOpen) {
|
||||
offsets.setOffsetToken(assertionOpen, 1, assertToken);
|
||||
offsets.setOffsetElementList(assertionTokens, assertionOpen, lastToken, 1);
|
||||
}
|
||||
}
|
||||
},
|
||||
ExportDefaultDeclaration(node) {
|
||||
const exportToken = sourceCode.getFirstToken(node);
|
||||
const declarationToken = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.declaration).firstToken;
|
||||
const defaultTokens = sourceCode.getTokensBetween(exportToken, declarationToken);
|
||||
offsets.setOffsetToken([...defaultTokens, declarationToken], 1, exportToken);
|
||||
},
|
||||
ExportNamedDeclaration(node) {
|
||||
const exportToken = sourceCode.getFirstToken(node);
|
||||
if (node.declaration) {
|
||||
const declarationToken = sourceCode.getFirstToken(node.declaration);
|
||||
offsets.setOffsetToken(declarationToken, 1, exportToken);
|
||||
}
|
||||
else {
|
||||
const firstSpecifier = node.specifiers[0];
|
||||
if (!firstSpecifier || firstSpecifier.type === 'ExportSpecifier') {
|
||||
const leftBraceTokens = firstSpecifier
|
||||
? sourceCode.getTokensBetween(exportToken, firstSpecifier)
|
||||
: [sourceCode.getTokenAfter(exportToken)];
|
||||
const rightBraceToken = node.source
|
||||
? sourceCode.getTokenBefore(node.source, {
|
||||
filter: eslint_utils_1.isClosingBraceToken,
|
||||
includeComments: false
|
||||
})
|
||||
: sourceCode.getLastToken(node, {
|
||||
filter: eslint_utils_1.isClosingBraceToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftBraceTokens, 0, exportToken);
|
||||
offsets.setOffsetElementList(node.specifiers, leftBraceTokens[leftBraceTokens.length - 1], rightBraceToken, 1);
|
||||
if (node.source) {
|
||||
const [fromToken, ...tokens] = sourceCode.getTokensBetween(rightBraceToken, node.source);
|
||||
offsets.setOffsetToken(fromToken, 0, exportToken);
|
||||
offsets.setOffsetToken([...tokens, sourceCode.getFirstToken(node.source)], 1, fromToken);
|
||||
const lastToken = sourceCode.getLastToken(node, {
|
||||
filter: eslint_utils_1.isNotSemicolonToken,
|
||||
includeComments: false
|
||||
});
|
||||
const assertionTokens = sourceCode.getTokensBetween(node.source, lastToken);
|
||||
if (assertionTokens.length) {
|
||||
const assertToken = assertionTokens.shift();
|
||||
offsets.setOffsetToken(assertToken, 0, exportToken);
|
||||
const assertionOpen = assertionTokens.shift();
|
||||
if (assertionOpen) {
|
||||
offsets.setOffsetToken(assertionOpen, 1, assertToken);
|
||||
offsets.setOffsetElementList(assertionTokens, assertionOpen, lastToken, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
}
|
||||
}
|
||||
},
|
||||
ExportSpecifier(node) {
|
||||
const tokens = sourceCode.getTokens(node);
|
||||
let firstToken = tokens.shift();
|
||||
if (firstToken.value === 'type') {
|
||||
const typeToken = firstToken;
|
||||
firstToken = tokens.shift();
|
||||
offsets.setOffsetToken(firstToken, 0, typeToken);
|
||||
}
|
||||
offsets.setOffsetToken(tokens, 1, firstToken);
|
||||
},
|
||||
ForInStatement(node) {
|
||||
const forToken = sourceCode.getFirstToken(node);
|
||||
const awaitToken = (node.type === 'ForOfStatement' && node.await && sourceCode.getTokenAfter(forToken)) ||
|
||||
null;
|
||||
const leftParenToken = sourceCode.getTokenAfter(awaitToken || forToken);
|
||||
const leftToken = sourceCode.getFirstToken(node.left);
|
||||
const inOrOfToken = sourceCode.getTokenAfter(node.left, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightToken = sourceCode.getTokenAfter(inOrOfToken);
|
||||
const rightParenToken = sourceCode.getTokenBefore(node.body, {
|
||||
filter: eslint_utils_1.isNotOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
if (awaitToken != null) {
|
||||
offsets.setOffsetToken(awaitToken, 0, forToken);
|
||||
}
|
||||
offsets.setOffsetToken(leftParenToken, 1, forToken);
|
||||
offsets.setOffsetToken(leftToken, 1, leftParenToken);
|
||||
offsets.setOffsetToken([inOrOfToken, rightToken], 1, leftToken);
|
||||
offsets.setOffsetToken(rightParenToken, 0, leftParenToken);
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, forToken);
|
||||
},
|
||||
ForOfStatement(node) {
|
||||
visitor.ForInStatement(node);
|
||||
},
|
||||
ForStatement(node) {
|
||||
const forToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(forToken);
|
||||
const rightParenToken = sourceCode.getTokenBefore(node.body, {
|
||||
filter: eslint_utils_1.isNotOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftParenToken, 1, forToken);
|
||||
offsets.setOffsetElementList([node.init, node.test, node.update], leftParenToken, rightParenToken, 1);
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, forToken);
|
||||
},
|
||||
FunctionDeclaration(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenBefore(node.params[0] ||
|
||||
node.returnType ||
|
||||
sourceCode.getTokenBefore(node.body), {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
let bodyBaseToken = null;
|
||||
if (firstToken.type === 'Punctuator') {
|
||||
bodyBaseToken = sourceCode.getFirstToken((0, ast_utils_1.getParent)(node));
|
||||
}
|
||||
else {
|
||||
let tokenOffset = 0;
|
||||
for (const token of sourceCode.getTokensBetween(firstToken, leftParenToken)) {
|
||||
if (token.value === '<') {
|
||||
break;
|
||||
}
|
||||
if (token.value === '*' || (node.id && token.range[0] === node.id.range[0])) {
|
||||
tokenOffset = 1;
|
||||
}
|
||||
offsets.setOffsetToken(token, tokenOffset, firstToken);
|
||||
}
|
||||
bodyBaseToken = firstToken;
|
||||
}
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftParenToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetToken(leftParenToken, 1, bodyBaseToken);
|
||||
offsets.setOffsetElementList(node.params, leftParenToken, rightParenToken, 1);
|
||||
const bodyToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyToken, 0, bodyBaseToken);
|
||||
},
|
||||
FunctionExpression(node) {
|
||||
visitor.FunctionDeclaration(node);
|
||||
},
|
||||
IfStatement(node) {
|
||||
const [ifToken, ifLeftParenToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
const ifRightParenToken = sourceCode.getTokenBefore(node.consequent, {
|
||||
filter: eslint_utils_1.isClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(ifLeftParenToken, 1, ifToken);
|
||||
offsets.setOffsetToken(ifRightParenToken, 0, ifLeftParenToken);
|
||||
const consequentFirstToken = sourceCode.getFirstToken(node.consequent);
|
||||
offsets.setOffsetToken(consequentFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(consequentFirstToken) ? 0 : 1, ifToken);
|
||||
if (node.alternate != null) {
|
||||
const elseToken = sourceCode.getTokenAfter(node.consequent, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(elseToken, 0, ifToken);
|
||||
const alternateFirstToken = sourceCode.getFirstToken(node.alternate);
|
||||
offsets.setOffsetToken(alternateFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(alternateFirstToken) ? 0 : 1, elseToken);
|
||||
}
|
||||
},
|
||||
ImportDeclaration(node) {
|
||||
const importToken = sourceCode.getFirstToken(node);
|
||||
const tokens = sourceCode.getTokensBetween(importToken, node.source);
|
||||
const fromIndex = tokens.map((t) => t.value).lastIndexOf('from');
|
||||
const { fromToken, beforeTokens, afterTokens } = fromIndex >= 0
|
||||
? {
|
||||
fromToken: tokens[fromIndex],
|
||||
beforeTokens: tokens.slice(0, fromIndex),
|
||||
afterTokens: [...tokens.slice(fromIndex + 1), sourceCode.getFirstToken(node.source)]
|
||||
}
|
||||
: {
|
||||
fromToken: null,
|
||||
beforeTokens: [...tokens, sourceCode.getFirstToken(node.source)],
|
||||
afterTokens: []
|
||||
};
|
||||
const namedSpecifiers = [];
|
||||
for (const specifier of node.specifiers) {
|
||||
if (specifier.type === 'ImportSpecifier') {
|
||||
namedSpecifiers.push(specifier);
|
||||
}
|
||||
else {
|
||||
const removeTokens = sourceCode.getTokens(specifier);
|
||||
removeTokens.shift();
|
||||
for (const token of removeTokens) {
|
||||
const i = beforeTokens.indexOf(token);
|
||||
if (i >= 0) {
|
||||
beforeTokens.splice(i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (namedSpecifiers.length) {
|
||||
const leftBrace = sourceCode.getTokenBefore(namedSpecifiers[0]);
|
||||
const rightBrace = sourceCode.getTokenAfter(namedSpecifiers[namedSpecifiers.length - 1], {
|
||||
filter: eslint_utils_1.isClosingBraceToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetElementList(namedSpecifiers, leftBrace, rightBrace, 1);
|
||||
for (const token of [...sourceCode.getTokensBetween(leftBrace, rightBrace), rightBrace]) {
|
||||
const i = beforeTokens.indexOf(token);
|
||||
if (i >= 0) {
|
||||
beforeTokens.splice(i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (beforeTokens.every((t) => (0, eslint_utils_1.isOpeningBraceToken)(t) || (0, eslint_utils_1.isClosingBraceToken)(t))) {
|
||||
offsets.setOffsetToken(beforeTokens, 0, importToken);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(beforeTokens, 1, importToken);
|
||||
}
|
||||
if (fromToken) {
|
||||
offsets.setOffsetToken(fromToken, 0, importToken);
|
||||
offsets.setOffsetToken(afterTokens, 1, fromToken);
|
||||
}
|
||||
const lastToken = sourceCode.getLastToken(node, {
|
||||
filter: eslint_utils_1.isNotSemicolonToken,
|
||||
includeComments: false
|
||||
});
|
||||
const assertionTokens = sourceCode.getTokensBetween(node.source, lastToken);
|
||||
if (assertionTokens.length) {
|
||||
const assertToken = assertionTokens.shift();
|
||||
offsets.setOffsetToken(assertToken, 0, importToken);
|
||||
const assertionOpen = assertionTokens.shift();
|
||||
if (assertionOpen) {
|
||||
offsets.setOffsetToken(assertionOpen, 1, assertToken);
|
||||
offsets.setOffsetElementList(assertionTokens, assertionOpen, lastToken, 1);
|
||||
}
|
||||
}
|
||||
},
|
||||
ImportExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const rightToken = sourceCode.getLastToken(node);
|
||||
const leftToken = sourceCode.getTokenAfter(firstToken, {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftToken, 1, firstToken);
|
||||
offsets.setOffsetElementList([node.source], leftToken, rightToken, 1);
|
||||
},
|
||||
ImportNamespaceSpecifier(node) {
|
||||
const tokens = sourceCode.getTokens(node);
|
||||
const firstToken = tokens.shift();
|
||||
offsets.setOffsetToken(tokens, 1, firstToken);
|
||||
},
|
||||
ImportSpecifier(node) {
|
||||
visitor.ExportSpecifier(node);
|
||||
},
|
||||
LabeledStatement(node) {
|
||||
const labelToken = sourceCode.getFirstToken(node);
|
||||
const colonToken = sourceCode.getTokenAfter(labelToken);
|
||||
const bodyToken = sourceCode.getTokenAfter(colonToken);
|
||||
offsets.setOffsetToken([colonToken, bodyToken], 1, labelToken);
|
||||
},
|
||||
SvelteReactiveStatement(node) {
|
||||
visitor.LabeledStatement(node);
|
||||
},
|
||||
MemberExpression(node) {
|
||||
const objectToken = sourceCode.getFirstToken(node);
|
||||
if (node.type === 'MemberExpression' && node.computed) {
|
||||
const leftBracketToken = sourceCode.getTokenBefore(node.property, {
|
||||
filter: eslint_utils_1.isOpeningBracketToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightBracketToken = sourceCode.getTokenAfter(node.property, {
|
||||
filter: eslint_utils_1.isClosingBracketToken,
|
||||
includeComments: false
|
||||
});
|
||||
for (const optionalToken of sourceCode.getTokensBetween(sourceCode.getLastToken(node.object), leftBracketToken, { filter: isOptionalToken, includeComments: false })) {
|
||||
offsets.setOffsetToken(optionalToken, 1, objectToken);
|
||||
}
|
||||
offsets.setOffsetToken(leftBracketToken, 1, objectToken);
|
||||
offsets.setOffsetElementList([node.property], leftBracketToken, rightBracketToken, 1);
|
||||
}
|
||||
else {
|
||||
const dotToken = sourceCode.getTokenBefore(node.property);
|
||||
const propertyToken = sourceCode.getTokenAfter(dotToken);
|
||||
offsets.setOffsetToken([dotToken, propertyToken], 1, objectToken);
|
||||
}
|
||||
},
|
||||
MetaProperty(node) {
|
||||
visitor.MemberExpression(node);
|
||||
},
|
||||
MethodDefinition(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.key);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, keyTokens.firstToken);
|
||||
if (node.computed) {
|
||||
prefixTokens.pop();
|
||||
}
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
let lastKeyToken;
|
||||
if (node.computed) {
|
||||
const leftBracketToken = sourceCode.getTokenBefore(keyTokens.firstToken);
|
||||
const rightBracketToken = (lastKeyToken = sourceCode.getTokenAfter(keyTokens.lastToken));
|
||||
offsets.setOffsetToken(leftBracketToken, 0, firstToken);
|
||||
offsets.setOffsetElementList([node.key], leftBracketToken, rightBracketToken, 1);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(keyTokens.firstToken, 0, firstToken);
|
||||
lastKeyToken = keyTokens.lastToken;
|
||||
}
|
||||
if (node.value) {
|
||||
const initToken = sourceCode.getFirstToken(node.value);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(lastKeyToken, initToken), initToken], 1, lastKeyToken);
|
||||
}
|
||||
},
|
||||
Property(node) {
|
||||
visitor.MethodDefinition(node);
|
||||
},
|
||||
NewExpression(node) {
|
||||
const newToken = sourceCode.getFirstToken(node);
|
||||
const calleeTokens = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.callee);
|
||||
offsets.setOffsetToken(calleeTokens.firstToken, 1, newToken);
|
||||
if (node.typeParameters) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, calleeTokens.firstToken);
|
||||
}
|
||||
const leftParenBefore = node.typeParameters || calleeTokens.lastToken;
|
||||
if (node.arguments.length || leftParenBefore.range[1] < node.range[1]) {
|
||||
const rightParenToken = sourceCode.getLastToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(leftParenBefore);
|
||||
offsets.setOffsetToken(leftParenToken, 1, calleeTokens.firstToken);
|
||||
offsets.setOffsetElementList(node.arguments, leftParenToken, rightParenToken, 1);
|
||||
}
|
||||
},
|
||||
ObjectExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const rightToken = sourceCode.getTokenAfter(node.properties[node.properties.length - 1] || firstToken, { filter: eslint_utils_1.isClosingBraceToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.properties, firstToken, rightToken, 1);
|
||||
},
|
||||
ObjectPattern(node) {
|
||||
visitor.ObjectExpression(node);
|
||||
},
|
||||
PropertyDefinition(node) {
|
||||
visitor.MethodDefinition(node);
|
||||
},
|
||||
ReturnStatement(node) {
|
||||
if (node.argument) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
}
|
||||
},
|
||||
ThrowStatement(node) {
|
||||
visitor.ReturnStatement(node);
|
||||
},
|
||||
SequenceExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
offsets.setOffsetElementList(node.expressions, firstToken, null, 0);
|
||||
},
|
||||
SwitchCase(node) {
|
||||
const caseToken = sourceCode.getFirstToken(node);
|
||||
if (node.test != null) {
|
||||
const testTokens = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.test);
|
||||
const colonToken = sourceCode.getTokenAfter(testTokens.lastToken);
|
||||
offsets.setOffsetToken([testTokens.firstToken, colonToken], 1, caseToken);
|
||||
}
|
||||
else {
|
||||
const colonToken = sourceCode.getTokenAfter(caseToken);
|
||||
offsets.setOffsetToken(colonToken, 1, caseToken);
|
||||
}
|
||||
if (node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement') {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.consequent[0]), 0, caseToken);
|
||||
}
|
||||
else {
|
||||
for (const statement of node.consequent) {
|
||||
offsets.setOffsetToken((0, commons_1.getFirstAndLastTokens)(sourceCode, statement).firstToken, 1, caseToken);
|
||||
}
|
||||
}
|
||||
},
|
||||
SwitchStatement(node) {
|
||||
const switchToken = sourceCode.getFirstToken(node);
|
||||
const { firstToken: leftParenToken, lastToken: rightParenToken } = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.discriminant);
|
||||
const leftBraceToken = sourceCode.getTokenAfter(rightParenToken);
|
||||
const rightBraceToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetToken(leftParenToken, 1, switchToken);
|
||||
offsets.setOffsetElementList([node.discriminant], leftParenToken, rightParenToken, 1);
|
||||
offsets.setOffsetToken(leftBraceToken, 0, switchToken);
|
||||
offsets.setOffsetElementList(node.cases, leftBraceToken, rightBraceToken, options.switchCase);
|
||||
},
|
||||
TaggedTemplateExpression(node) {
|
||||
const tagTokens = (0, commons_1.getFirstAndLastTokens)(sourceCode, node.tag);
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.quasi), 1, tagTokens.firstToken);
|
||||
},
|
||||
TemplateLiteral(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const quasiTokens = node.quasis.slice(1).map((n) => sourceCode.getFirstToken(n));
|
||||
const expressionToken = node.quasis.slice(0, -1).map((n) => sourceCode.getTokenAfter(n));
|
||||
offsets.setOffsetToken(quasiTokens, 0, firstToken);
|
||||
offsets.setOffsetToken(expressionToken, 1, firstToken);
|
||||
},
|
||||
TryStatement(node) {
|
||||
const tryToken = sourceCode.getFirstToken(node);
|
||||
const tryBlockToken = sourceCode.getFirstToken(node.block);
|
||||
offsets.setOffsetToken(tryBlockToken, 0, tryToken);
|
||||
if (node.handler != null) {
|
||||
const catchToken = sourceCode.getFirstToken(node.handler);
|
||||
offsets.setOffsetToken(catchToken, 0, tryToken);
|
||||
}
|
||||
if (node.finalizer != null) {
|
||||
const finallyToken = sourceCode.getTokenBefore(node.finalizer);
|
||||
const finallyBlockToken = sourceCode.getFirstToken(node.finalizer);
|
||||
offsets.setOffsetToken([finallyToken, finallyBlockToken], 0, tryToken);
|
||||
}
|
||||
},
|
||||
UpdateExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
},
|
||||
VariableDeclaration(node) {
|
||||
offsets.setOffsetElementList(node.declarations, sourceCode.getFirstToken(node), null, 1);
|
||||
},
|
||||
VariableDeclarator(node) {
|
||||
if (node.init != null) {
|
||||
const idToken = sourceCode.getFirstToken(node);
|
||||
const eqToken = sourceCode.getTokenAfter(node.id);
|
||||
const initToken = sourceCode.getTokenAfter(eqToken);
|
||||
offsets.setOffsetToken([eqToken, initToken], 1, idToken);
|
||||
}
|
||||
},
|
||||
WhileStatement(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(firstToken);
|
||||
const rightParenToken = sourceCode.getTokenBefore(node.body, {
|
||||
filter: eslint_utils_1.isClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftParenToken, 1, firstToken);
|
||||
offsets.setOffsetToken(rightParenToken, 0, leftParenToken);
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, firstToken);
|
||||
},
|
||||
WithStatement(node) {
|
||||
visitor.WhileStatement(node);
|
||||
},
|
||||
YieldExpression(node) {
|
||||
if (node.argument != null) {
|
||||
const [yieldToken, secondToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(secondToken, 1, yieldToken);
|
||||
if (node.delegate) {
|
||||
offsets.setOffsetToken(sourceCode.getTokenAfter(secondToken), 1, yieldToken);
|
||||
}
|
||||
}
|
||||
},
|
||||
DebuggerStatement() {
|
||||
},
|
||||
Identifier() {
|
||||
},
|
||||
ImportDefaultSpecifier() {
|
||||
},
|
||||
Literal() {
|
||||
},
|
||||
PrivateIdentifier() {
|
||||
},
|
||||
Super() {
|
||||
},
|
||||
TemplateElement() {
|
||||
},
|
||||
ThisExpression() {
|
||||
},
|
||||
ExpressionStatement() {
|
||||
},
|
||||
ChainExpression() {
|
||||
},
|
||||
EmptyStatement() {
|
||||
}
|
||||
};
|
||||
const commonVisitor = {
|
||||
':statement, PropertyDefinition'(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
if ((0, eslint_utils_1.isSemicolonToken)(lastToken) && firstToken !== lastToken) {
|
||||
const next = sourceCode.getTokenAfter(lastToken);
|
||||
if (!next || lastToken.loc.start.line < next.loc.start.line) {
|
||||
offsets.setOffsetToken(lastToken, 0, firstToken);
|
||||
}
|
||||
}
|
||||
},
|
||||
':expression'(node) {
|
||||
let leftToken = sourceCode.getTokenBefore(node);
|
||||
let rightToken = sourceCode.getTokenAfter(node);
|
||||
let firstToken = sourceCode.getFirstToken(node);
|
||||
while (leftToken &&
|
||||
(0, eslint_utils_1.isOpeningParenToken)(leftToken) &&
|
||||
rightToken &&
|
||||
(0, eslint_utils_1.isClosingParenToken)(rightToken)) {
|
||||
offsets.setOffsetToken(firstToken, 1, leftToken);
|
||||
offsets.setOffsetToken(rightToken, 0, leftToken);
|
||||
firstToken = leftToken;
|
||||
leftToken = sourceCode.getTokenBefore(leftToken);
|
||||
rightToken = sourceCode.getTokenAfter(rightToken);
|
||||
}
|
||||
}
|
||||
};
|
||||
const v = visitor;
|
||||
return {
|
||||
...v,
|
||||
...commonVisitor
|
||||
};
|
||||
}
|
||||
exports.defineVisitor = defineVisitor;
|
||||
function isOptionalToken(token) {
|
||||
return token.type === 'Punctuator' && token.value === '?.';
|
||||
}
|
||||
3
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/index.d.ts
generated
vendored
Normal file
3
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,3 @@
|
||||
import type { RuleContext, RuleListener } from '../../types';
|
||||
import type { IndentOptions } from './commons';
|
||||
export declare function defineVisitor(context: RuleContext, defaultOptions: Partial<IndentOptions>): RuleListener;
|
||||
235
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/index.js
generated
vendored
Normal file
235
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/index.js
generated
vendored
Normal file
@ -0,0 +1,235 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.defineVisitor = void 0;
|
||||
const SV = __importStar(require("./svelte"));
|
||||
const ES = __importStar(require("./es"));
|
||||
const TS = __importStar(require("./ts"));
|
||||
const ast_1 = require("./ast");
|
||||
const eslint_utils_1 = require("@eslint-community/eslint-utils");
|
||||
const offset_context_1 = require("./offset-context");
|
||||
const compat_1 = require("../../utils/compat");
|
||||
function parseOptions(options, defaultOptions) {
|
||||
const ret = {
|
||||
indentChar: ' ',
|
||||
indentScript: true,
|
||||
indentSize: 2,
|
||||
switchCase: 1,
|
||||
alignAttributesVertically: false,
|
||||
ignoredNodes: [],
|
||||
...defaultOptions
|
||||
};
|
||||
if (Number.isSafeInteger(options.indent)) {
|
||||
ret.indentSize = Number(options.indent);
|
||||
}
|
||||
else if (options.indent === 'tab') {
|
||||
ret.indentChar = '\t';
|
||||
ret.indentSize = 1;
|
||||
}
|
||||
if (typeof options.indentScript === 'boolean') {
|
||||
ret.indentScript = options.indentScript;
|
||||
}
|
||||
if (options.switchCase != null && Number.isSafeInteger(options.switchCase)) {
|
||||
ret.switchCase = options.switchCase;
|
||||
}
|
||||
if (options.ignoredNodes != null) {
|
||||
ret.ignoredNodes = options.ignoredNodes;
|
||||
}
|
||||
if (options.alignAttributesVertically && ret.indentChar === ' ') {
|
||||
ret.alignAttributesVertically = true;
|
||||
}
|
||||
else if (ret.indentChar !== ' ') {
|
||||
ret.alignAttributesVertically = false;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
function defineVisitor(context, defaultOptions) {
|
||||
if (!(0, compat_1.getFilename)(context).endsWith('.svelte'))
|
||||
return {};
|
||||
const options = parseOptions(context.options[0] || {}, defaultOptions);
|
||||
const sourceCode = (0, compat_1.getSourceCode)(context);
|
||||
const offsets = new offset_context_1.OffsetContext({ sourceCode, options });
|
||||
function getIndentText({ line, column }) {
|
||||
return sourceCode.lines[line - 1].slice(0, column);
|
||||
}
|
||||
function validateToken(token, expectedIndent) {
|
||||
const line = token.loc.start.line;
|
||||
const indentText = getIndentText(token.loc.start);
|
||||
if (indentText.trim() !== '') {
|
||||
return;
|
||||
}
|
||||
const actualIndent = token.loc.start.column;
|
||||
const mismatchCharIndexes = [];
|
||||
for (let i = 0; i < indentText.length; ++i) {
|
||||
if (indentText[i] !== options.indentChar) {
|
||||
mismatchCharIndexes.push(i);
|
||||
}
|
||||
}
|
||||
if (actualIndent !== expectedIndent) {
|
||||
const loc = {
|
||||
start: { line, column: 0 },
|
||||
end: { line, column: actualIndent }
|
||||
};
|
||||
context.report({
|
||||
loc,
|
||||
messageId: 'unexpectedIndentation',
|
||||
data: {
|
||||
expectedIndent: String(expectedIndent),
|
||||
actualIndent: String(actualIndent),
|
||||
expectedUnit: options.indentChar === '\t' ? 'tab' : 'space',
|
||||
actualUnit: mismatchCharIndexes.length
|
||||
? 'whitespace'
|
||||
: options.indentChar === '\t'
|
||||
? 'tab'
|
||||
: 'space',
|
||||
expectedIndentPlural: expectedIndent === 1 ? '' : 's',
|
||||
actualIndentPlural: actualIndent === 1 ? '' : 's'
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.replaceTextRange([sourceCode.getIndexFromLoc(loc.start), sourceCode.getIndexFromLoc(loc.end)], options.indentChar.repeat(expectedIndent));
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
for (const i of mismatchCharIndexes) {
|
||||
const loc = {
|
||||
start: { line, column: i },
|
||||
end: { line, column: i + 1 }
|
||||
};
|
||||
context.report({
|
||||
loc,
|
||||
messageId: 'unexpectedChar',
|
||||
data: {
|
||||
expected: JSON.stringify(options.indentChar),
|
||||
actual: JSON.stringify(indentText[i])
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.replaceTextRange([sourceCode.getIndexFromLoc(loc.start), sourceCode.getIndexFromLoc(loc.end)], options.indentChar);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
function processLine(tokens, prevComments, prevToken, calculator) {
|
||||
const firstToken = tokens[0];
|
||||
const actualIndent = firstToken.loc.start.column;
|
||||
const expectedIndent = calculator.getExpectedIndentFromTokens(tokens);
|
||||
if (expectedIndent == null) {
|
||||
calculator.saveExpectedIndent(tokens, actualIndent);
|
||||
return;
|
||||
}
|
||||
calculator.saveExpectedIndent(tokens, Math.min(...tokens
|
||||
.map((t) => calculator.getExpectedIndentFromToken(t))
|
||||
.filter((i) => i != null)));
|
||||
let prev = prevToken;
|
||||
if (prevComments.length) {
|
||||
if (prev && prev.loc.end.line < prevComments[0].loc.start.line) {
|
||||
validateToken(prevComments[0], expectedIndent);
|
||||
}
|
||||
prev = prevComments[prevComments.length - 1];
|
||||
}
|
||||
if (prev && prev.loc.end.line < tokens[0].loc.start.line) {
|
||||
validateToken(tokens[0], expectedIndent);
|
||||
}
|
||||
}
|
||||
const indentContext = {
|
||||
sourceCode,
|
||||
options,
|
||||
offsets
|
||||
};
|
||||
const nodesVisitor = {
|
||||
...ES.defineVisitor(indentContext),
|
||||
...SV.defineVisitor(indentContext),
|
||||
...TS.defineVisitor(indentContext)
|
||||
};
|
||||
const knownNodes = new Set(Object.keys(nodesVisitor));
|
||||
function compositingIgnoresVisitor(visitor) {
|
||||
for (const ignoreSelector of options.ignoredNodes) {
|
||||
const key = `${ignoreSelector}:exit`;
|
||||
if (visitor[key]) {
|
||||
const handler = visitor[key];
|
||||
visitor[key] = function (node, ...args) {
|
||||
const ret = handler.call(this, node, ...args);
|
||||
offsets.ignore(node);
|
||||
return ret;
|
||||
};
|
||||
}
|
||||
else {
|
||||
visitor[key] = (node) => offsets.ignore(node);
|
||||
}
|
||||
}
|
||||
return visitor;
|
||||
}
|
||||
return compositingIgnoresVisitor({
|
||||
...nodesVisitor,
|
||||
'*:exit'(node) {
|
||||
if (!knownNodes.has(node.type)) {
|
||||
offsets.ignore(node);
|
||||
}
|
||||
},
|
||||
'Program:exit'(node) {
|
||||
const calculator = offsets.getOffsetCalculator();
|
||||
let prevToken = null;
|
||||
for (const { prevComments, tokens } of iterateLineTokens()) {
|
||||
processLine(tokens, prevComments, prevToken, calculator);
|
||||
prevToken = tokens[tokens.length - 1];
|
||||
}
|
||||
function* iterateLineTokens() {
|
||||
let line = 0;
|
||||
let prevComments = [];
|
||||
let bufferTokens = [];
|
||||
for (const token of sourceCode.getTokens(node, {
|
||||
includeComments: true,
|
||||
filter: ast_1.isNotWhitespace
|
||||
})) {
|
||||
const thisLine = token.loc.start.line;
|
||||
if (line === thisLine || bufferTokens.length === 0) {
|
||||
bufferTokens.push(token);
|
||||
}
|
||||
else {
|
||||
if ((0, eslint_utils_1.isCommentToken)(bufferTokens[0]) && bufferTokens.every(eslint_utils_1.isCommentToken)) {
|
||||
prevComments.push(bufferTokens[0]);
|
||||
}
|
||||
else {
|
||||
yield {
|
||||
prevComments,
|
||||
tokens: bufferTokens
|
||||
};
|
||||
prevComments = [];
|
||||
}
|
||||
bufferTokens = [token];
|
||||
}
|
||||
line = thisLine;
|
||||
}
|
||||
if (bufferTokens.length && !bufferTokens.every(eslint_utils_1.isCommentToken)) {
|
||||
yield {
|
||||
prevComments,
|
||||
tokens: bufferTokens
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
exports.defineVisitor = defineVisitor;
|
||||
57
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/offset-context.d.ts
generated
vendored
Normal file
57
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/offset-context.d.ts
generated
vendored
Normal file
@ -0,0 +1,57 @@
|
||||
import type { ASTNode, SourceCode } from '../../types';
|
||||
import type { AnyToken, IndentOptions, MaybeNode } from './commons';
|
||||
declare const enum OffsetDataType {
|
||||
normal = 0,
|
||||
align = 1,
|
||||
start = 2
|
||||
}
|
||||
type OffsetData = {
|
||||
type: OffsetDataType.normal;
|
||||
base: number;
|
||||
offset: number;
|
||||
expectedIndent?: number;
|
||||
} | {
|
||||
type: OffsetDataType.align;
|
||||
base: number;
|
||||
alignIndent: number;
|
||||
expectedIndent?: number;
|
||||
} | {
|
||||
type: OffsetDataType.start;
|
||||
offset: number;
|
||||
expectedIndent?: number;
|
||||
};
|
||||
export declare class OffsetContext {
|
||||
private readonly sourceCode;
|
||||
private readonly options;
|
||||
private readonly offsets;
|
||||
private readonly ignoreRanges;
|
||||
constructor(arg: {
|
||||
sourceCode: SourceCode;
|
||||
options: IndentOptions;
|
||||
});
|
||||
setOffsetIndex(index: number, offset: number, base: number): void;
|
||||
private setAlignIndent;
|
||||
setOffsetToken(token: AnyToken | null | undefined | (AnyToken | null | undefined)[], offset: number, baseToken: AnyToken): void;
|
||||
copyOffset(index: number, srcIndex: number): void;
|
||||
setStartOffsetIndex(index: number, offset: number): void;
|
||||
setStartOffsetToken(token: AnyToken | null | undefined | (AnyToken | null | undefined)[], offset: number): void;
|
||||
setOffsetElementList(nodes: (ASTNode | AnyToken | MaybeNode | null | undefined)[], baseNodeOrToken: ASTNode | AnyToken | MaybeNode, lastNodeOrToken: ASTNode | AnyToken | MaybeNode | null, offset: number, align?: boolean): void;
|
||||
private _setOffsetElementList;
|
||||
ignore(node: ASTNode): void;
|
||||
getOffsetCalculator(): OffsetCalculator;
|
||||
}
|
||||
export declare class OffsetCalculator {
|
||||
private readonly options;
|
||||
private readonly offsets;
|
||||
private readonly ignoreRanges;
|
||||
constructor(arg: {
|
||||
offsets: Map<number, OffsetData>;
|
||||
options: IndentOptions;
|
||||
ignoreRanges: [number, number][];
|
||||
});
|
||||
private getExpectedIndentFromIndex;
|
||||
getExpectedIndentFromToken(token: AnyToken): number | null;
|
||||
getExpectedIndentFromTokens(tokens: AnyToken[]): null | number;
|
||||
saveExpectedIndent(tokens: AnyToken[], expectedIndent: number): void;
|
||||
}
|
||||
export {};
|
||||
193
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/offset-context.js
generated
vendored
Normal file
193
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/offset-context.js
generated
vendored
Normal file
@ -0,0 +1,193 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.OffsetCalculator = exports.OffsetContext = void 0;
|
||||
const ast_1 = require("./ast");
|
||||
const commons_1 = require("./commons");
|
||||
const commons_2 = require("./commons");
|
||||
class OffsetContext {
|
||||
constructor(arg) {
|
||||
this.offsets = new Map();
|
||||
this.ignoreRanges = new Map();
|
||||
this.sourceCode = arg.sourceCode;
|
||||
this.options = arg.options;
|
||||
}
|
||||
setOffsetIndex(index, offset, base) {
|
||||
if (index === base) {
|
||||
return;
|
||||
}
|
||||
this.offsets.set(index, {
|
||||
type: 0,
|
||||
base,
|
||||
offset
|
||||
});
|
||||
}
|
||||
setAlignIndent(index, alignIndent, base) {
|
||||
if (index === base) {
|
||||
return;
|
||||
}
|
||||
this.offsets.set(index, {
|
||||
type: 1,
|
||||
base,
|
||||
alignIndent
|
||||
});
|
||||
}
|
||||
setOffsetToken(token, offset, baseToken) {
|
||||
if (!token) {
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(token)) {
|
||||
for (const t of token) {
|
||||
this.setOffsetToken(t, offset, baseToken);
|
||||
}
|
||||
return;
|
||||
}
|
||||
this.setOffsetIndex(token.range[0], offset, baseToken.range[0]);
|
||||
}
|
||||
copyOffset(index, srcIndex) {
|
||||
const offsetData = this.offsets.get(srcIndex);
|
||||
if (!offsetData) {
|
||||
return;
|
||||
}
|
||||
if (offsetData.type === 2) {
|
||||
this.setStartOffsetIndex(index, offsetData.offset);
|
||||
}
|
||||
else if (offsetData.type === 1) {
|
||||
this.setAlignIndent(index, offsetData.alignIndent, offsetData.base);
|
||||
}
|
||||
else {
|
||||
this.setOffsetIndex(index, offsetData.offset, offsetData.base);
|
||||
}
|
||||
}
|
||||
setStartOffsetIndex(index, offset) {
|
||||
this.offsets.set(index, {
|
||||
type: 2,
|
||||
offset
|
||||
});
|
||||
}
|
||||
setStartOffsetToken(token, offset) {
|
||||
if (!token) {
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(token)) {
|
||||
for (const t of token) {
|
||||
this.setStartOffsetToken(t, offset);
|
||||
}
|
||||
return;
|
||||
}
|
||||
this.setStartOffsetIndex(token.range[0], offset);
|
||||
}
|
||||
setOffsetElementList(nodes, baseNodeOrToken, lastNodeOrToken, offset, align) {
|
||||
let setIndent = (token, baseToken) => this.setOffsetToken(token, offset, baseToken);
|
||||
if (align) {
|
||||
for (const n of nodes) {
|
||||
if (n) {
|
||||
if (!(0, commons_1.isBeginningOfLine)(this.sourceCode, n)) {
|
||||
const startLoc = n.loc.start;
|
||||
const alignIndent = startLoc.column - /^\s*/u.exec(this.sourceCode.lines[startLoc.line - 1])[0].length;
|
||||
setIndent = (token, baseToken) => this.setAlignIndent(token.range[0], alignIndent, baseToken.range[0]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
this._setOffsetElementList(nodes, baseNodeOrToken, lastNodeOrToken, setIndent);
|
||||
}
|
||||
_setOffsetElementList(nodes, baseNodeOrToken, lastNodeOrToken, setIndent) {
|
||||
const baseToken = this.sourceCode.getFirstToken(baseNodeOrToken);
|
||||
let prevToken = this.sourceCode.getLastToken(baseNodeOrToken);
|
||||
for (const node of nodes) {
|
||||
if (node == null) {
|
||||
continue;
|
||||
}
|
||||
const elementTokens = (0, commons_2.getFirstAndLastTokens)(this.sourceCode, node, prevToken.range[1]);
|
||||
let t = prevToken;
|
||||
while ((t = this.sourceCode.getTokenAfter(t, {
|
||||
includeComments: true,
|
||||
filter: ast_1.isNotWhitespace
|
||||
})) != null &&
|
||||
t.range[1] <= elementTokens.firstToken.range[0]) {
|
||||
setIndent(t, baseToken);
|
||||
}
|
||||
setIndent(elementTokens.firstToken, baseToken);
|
||||
prevToken = elementTokens.lastToken;
|
||||
}
|
||||
if (lastNodeOrToken) {
|
||||
const lastToken = this.sourceCode.getFirstToken(lastNodeOrToken);
|
||||
let t = prevToken;
|
||||
while ((t = this.sourceCode.getTokenAfter(t, {
|
||||
includeComments: true,
|
||||
filter: ast_1.isNotWhitespace
|
||||
})) != null &&
|
||||
t.range[1] <= lastToken.range[0]) {
|
||||
setIndent(t, baseToken);
|
||||
}
|
||||
this.setOffsetToken(lastToken, 0, baseToken);
|
||||
}
|
||||
}
|
||||
ignore(node) {
|
||||
const range = node.range;
|
||||
const n = this.ignoreRanges.get(range[0]) ?? 0;
|
||||
this.ignoreRanges.set(range[0], Math.max(n, range[1]));
|
||||
}
|
||||
getOffsetCalculator() {
|
||||
return new OffsetCalculator({
|
||||
offsets: this.offsets,
|
||||
options: this.options,
|
||||
ignoreRanges: [...this.ignoreRanges]
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.OffsetContext = OffsetContext;
|
||||
class OffsetCalculator {
|
||||
constructor(arg) {
|
||||
this.offsets = arg.offsets;
|
||||
this.options = arg.options;
|
||||
this.ignoreRanges = arg.ignoreRanges;
|
||||
}
|
||||
getExpectedIndentFromIndex(index) {
|
||||
const offsetInfo = this.offsets.get(index);
|
||||
if (offsetInfo == null) {
|
||||
return null;
|
||||
}
|
||||
if (offsetInfo.expectedIndent != null) {
|
||||
return offsetInfo.expectedIndent;
|
||||
}
|
||||
if (offsetInfo.type === 2) {
|
||||
return offsetInfo.offset * this.options.indentSize;
|
||||
}
|
||||
const baseIndent = this.getExpectedIndentFromIndex(offsetInfo.base);
|
||||
if (baseIndent == null) {
|
||||
return null;
|
||||
}
|
||||
if (offsetInfo.type === 1) {
|
||||
return baseIndent + offsetInfo.alignIndent;
|
||||
}
|
||||
return baseIndent + offsetInfo.offset * this.options.indentSize;
|
||||
}
|
||||
getExpectedIndentFromToken(token) {
|
||||
return this.getExpectedIndentFromIndex(token.range[0]);
|
||||
}
|
||||
getExpectedIndentFromTokens(tokens) {
|
||||
for (const token of tokens) {
|
||||
const index = token.range[0];
|
||||
if (this.ignoreRanges.some(([f, t]) => f <= index && index < t)) {
|
||||
return null;
|
||||
}
|
||||
const expectedIndent = this.getExpectedIndentFromIndex(index);
|
||||
if (expectedIndent != null) {
|
||||
return expectedIndent;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
saveExpectedIndent(tokens, expectedIndent) {
|
||||
for (const token of tokens) {
|
||||
const offsetInfo = this.offsets.get(token.range[0]);
|
||||
if (offsetInfo == null) {
|
||||
continue;
|
||||
}
|
||||
offsetInfo.expectedIndent = offsetInfo.expectedIndent ?? expectedIndent;
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.OffsetCalculator = OffsetCalculator;
|
||||
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/svelte.d.ts
generated
vendored
Normal file
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/svelte.d.ts
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
import type { SvelteNodeListener } from '../../types-for-node';
|
||||
import type { IndentContext } from './commons';
|
||||
type NodeListener = SvelteNodeListener;
|
||||
export declare function defineVisitor(context: IndentContext): NodeListener;
|
||||
export {};
|
||||
378
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/svelte.js
generated
vendored
Normal file
378
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/svelte.js
generated
vendored
Normal file
@ -0,0 +1,378 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.defineVisitor = void 0;
|
||||
const ast_1 = require("./ast");
|
||||
const commons_1 = require("./commons");
|
||||
const commons_2 = require("./commons");
|
||||
const commons_3 = require("./commons");
|
||||
const PREFORMATTED_ELEMENT_NAMES = ['pre', 'textarea', 'template'];
|
||||
function defineVisitor(context) {
|
||||
const { sourceCode, offsets, options } = context;
|
||||
const visitor = {
|
||||
SvelteScriptElement(node) {
|
||||
offsets.setOffsetElementList(node.body, node.startTag, node.endTag, options.indentScript ? 1 : 0);
|
||||
},
|
||||
SvelteStyleElement(node) {
|
||||
node.children.forEach((n) => offsets.ignore(n));
|
||||
},
|
||||
SvelteElement(node) {
|
||||
if (node.name.type === 'Identifier' || node.name.type === 'SvelteName') {
|
||||
if (PREFORMATTED_ELEMENT_NAMES.includes(node.name.name)) {
|
||||
const startTagToken = sourceCode.getFirstToken(node);
|
||||
const endTagToken = node.endTag && sourceCode.getFirstToken(node.endTag);
|
||||
offsets.setOffsetToken(endTagToken, 0, startTagToken);
|
||||
node.children.forEach((n) => offsets.ignore(n));
|
||||
return;
|
||||
}
|
||||
if (node.name.name === 'style') {
|
||||
node.children.forEach((n) => offsets.ignore(n));
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (node.endTag) {
|
||||
offsets.setOffsetElementList(node.children.filter(isNotEmptyTextNode), node.startTag, node.endTag, 1);
|
||||
}
|
||||
},
|
||||
SvelteStartTag(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetElementList(node.attributes, openToken, closeToken, 1, options.alignAttributesVertically);
|
||||
if (node.selfClosing) {
|
||||
const slash = sourceCode.getTokenBefore(closeToken);
|
||||
if (slash.value === '/') {
|
||||
offsets.setOffsetToken(slash, 0, openToken);
|
||||
}
|
||||
}
|
||||
},
|
||||
SvelteEndTag(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetElementList([], openToken, closeToken, 1);
|
||||
},
|
||||
SvelteAttribute(node) {
|
||||
const keyToken = sourceCode.getFirstToken(node);
|
||||
const eqToken = sourceCode.getTokenAfter(node.key);
|
||||
if (eqToken != null && eqToken.range[1] <= node.range[1]) {
|
||||
offsets.setOffsetToken(eqToken, 1, keyToken);
|
||||
const valueStartToken = sourceCode.getTokenAfter(eqToken);
|
||||
if (valueStartToken != null && valueStartToken.range[1] <= node.range[1]) {
|
||||
offsets.setOffsetToken(valueStartToken, 1, keyToken);
|
||||
const values = node.type === 'SvelteAttribute' || node.type === 'SvelteStyleDirective'
|
||||
? node.value
|
||||
: [];
|
||||
let processedValues = false;
|
||||
if (valueStartToken.type === 'Punctuator') {
|
||||
const quoted = ['"', "'"].includes(valueStartToken.value);
|
||||
const mustache = !quoted && valueStartToken.value === '{';
|
||||
if (quoted || mustache) {
|
||||
const last = sourceCode.getLastToken(node);
|
||||
if (last.type === 'Punctuator' &&
|
||||
((quoted && last.value === valueStartToken.value) ||
|
||||
(mustache && last.value === '}'))) {
|
||||
offsets.setOffsetToken(last, 0, valueStartToken);
|
||||
offsets.setOffsetElementList(values, valueStartToken, last, 1);
|
||||
processedValues = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!processedValues) {
|
||||
for (const val of values) {
|
||||
const token = sourceCode.getFirstToken(val);
|
||||
offsets.setOffsetToken(token, 0, valueStartToken);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
SvelteDirective(node) {
|
||||
visitor.SvelteAttribute(node);
|
||||
},
|
||||
SvelteStyleDirective(node) {
|
||||
visitor.SvelteAttribute(node);
|
||||
},
|
||||
SvelteSpecialDirective(node) {
|
||||
visitor.SvelteAttribute(node);
|
||||
},
|
||||
SvelteShorthandAttribute(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetElementList([], openToken, closeToken, 1);
|
||||
},
|
||||
SvelteSpreadAttribute(node) {
|
||||
visitor.SvelteShorthandAttribute(node);
|
||||
},
|
||||
SvelteDirectiveKey(_node) {
|
||||
},
|
||||
SvelteSpecialDirectiveKey(_node) {
|
||||
},
|
||||
SvelteText(node) {
|
||||
const tokens = sourceCode.getTokens(node, {
|
||||
filter: ast_1.isNotWhitespace,
|
||||
includeComments: false
|
||||
});
|
||||
const first = tokens.shift();
|
||||
if (!first) {
|
||||
return;
|
||||
}
|
||||
offsets.setOffsetToken(tokens, (0, commons_2.isBeginningOfLine)(sourceCode, first) ? 0 : (0, commons_1.isBeginningOfElement)(node) ? 1 : 0, first);
|
||||
},
|
||||
SvelteLiteral(node) {
|
||||
const tokens = sourceCode.getTokens(node, {
|
||||
filter: ast_1.isNotWhitespace,
|
||||
includeComments: false
|
||||
});
|
||||
const first = tokens.shift();
|
||||
if (!first) {
|
||||
return;
|
||||
}
|
||||
offsets.setOffsetToken(tokens, (0, commons_2.isBeginningOfLine)(sourceCode, first) ? 0 : 1, first);
|
||||
},
|
||||
SvelteMustacheTag(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetElementList([node.expression], openToken, closeToken, 1);
|
||||
},
|
||||
SvelteDebugTag(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetElementList(node.identifiers, openToken, closeToken, 1);
|
||||
},
|
||||
SvelteConstTag(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
const constToken = sourceCode.getTokenAfter(openToken);
|
||||
const declarationToken = sourceCode.getFirstToken(node.declaration);
|
||||
const closeToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetToken(constToken, 1, openToken);
|
||||
offsets.setOffsetToken(declarationToken, 1, openToken);
|
||||
offsets.setOffsetToken(closeToken, 0, openToken);
|
||||
},
|
||||
SvelteIfBlock(node) {
|
||||
const [openToken, ...ifTokens] = sourceCode.getFirstTokens(node, {
|
||||
count: node.elseif ? 3 : 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(ifTokens, 1, openToken);
|
||||
const exp = (0, commons_3.getFirstAndLastTokens)(sourceCode, node.expression);
|
||||
offsets.setOffsetToken(exp.firstToken, 1, ifTokens[0]);
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(exp.lastToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
if (node.else) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.else), 0, openToken);
|
||||
if (node.else.elseif) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
const [openCloseTagToken, endIfToken, closeCloseTagToken] = sourceCode.getLastTokens(node, {
|
||||
count: 3,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(openCloseTagToken, 0, openToken);
|
||||
offsets.setOffsetToken(endIfToken, 1, openCloseTagToken);
|
||||
offsets.setOffsetToken(closeCloseTagToken, 0, openCloseTagToken);
|
||||
},
|
||||
SvelteElseBlock(node) {
|
||||
if (node.elseif) {
|
||||
return;
|
||||
}
|
||||
const [openToken, elseToken, closeToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 3,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(elseToken, 1, openToken);
|
||||
offsets.setOffsetToken(closeToken, 0, openToken);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
},
|
||||
SvelteEachBlock(node) {
|
||||
const [openToken, eachToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(eachToken, 1, openToken);
|
||||
offsets.setOffsetElementList([node.expression, node.context, node.index], eachToken, null, 1);
|
||||
if (node.key) {
|
||||
const key = (0, commons_3.getFirstAndLastTokens)(sourceCode, node.key);
|
||||
offsets.setOffsetToken(key.firstToken, 1, eachToken);
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(key.lastToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
else {
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(node.index || node.context);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
if (node.else) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.else), 0, openToken);
|
||||
}
|
||||
const [openCloseTagToken, endEachToken, closeCloseTagToken] = sourceCode.getLastTokens(node, {
|
||||
count: 3,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(openCloseTagToken, 0, openToken);
|
||||
offsets.setOffsetToken(endEachToken, 1, openCloseTagToken);
|
||||
offsets.setOffsetToken(closeCloseTagToken, 0, openCloseTagToken);
|
||||
},
|
||||
SvelteAwaitBlock(node) {
|
||||
const [openToken, awaitToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(awaitToken, 1, openToken);
|
||||
const exp = (0, commons_3.getFirstAndLastTokens)(sourceCode, node.expression);
|
||||
offsets.setOffsetToken(exp.firstToken, 1, awaitToken);
|
||||
if (node.pending) {
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(exp.lastToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.pending, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
}), 1, openToken);
|
||||
}
|
||||
if (node.then) {
|
||||
if (node.kind === 'await-then') {
|
||||
const thenToken = sourceCode.getTokenAfter(exp.lastToken);
|
||||
offsets.setOffsetToken(thenToken, 1, openToken);
|
||||
if (node.then.value) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.then.value), 1, thenToken);
|
||||
}
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(node.then.value || thenToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.then), 0, openToken);
|
||||
}
|
||||
}
|
||||
if (node.catch) {
|
||||
if (node.kind === 'await-catch') {
|
||||
const catchToken = sourceCode.getTokenAfter(exp.lastToken);
|
||||
offsets.setOffsetToken(catchToken, 1, openToken);
|
||||
if (node.catch.error) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.catch.error), 1, catchToken);
|
||||
}
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(node.catch.error || catchToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.catch), 0, openToken);
|
||||
}
|
||||
}
|
||||
const [openCloseTagToken, endAwaitToken, closeCloseTagToken] = sourceCode.getLastTokens(node, {
|
||||
count: 3,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(openCloseTagToken, 0, openToken);
|
||||
offsets.setOffsetToken(endAwaitToken, 1, openCloseTagToken);
|
||||
offsets.setOffsetToken(closeCloseTagToken, 0, openCloseTagToken);
|
||||
},
|
||||
SvelteAwaitPendingBlock(node) {
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
},
|
||||
SvelteAwaitThenBlock(node) {
|
||||
if (!node.awaitThen) {
|
||||
const [openToken, thenToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(thenToken, 1, openToken);
|
||||
if (node.value) {
|
||||
const valueToken = sourceCode.getFirstToken(node.value);
|
||||
offsets.setOffsetToken(valueToken, 1, thenToken);
|
||||
}
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(node.value || thenToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
},
|
||||
SvelteAwaitCatchBlock(node) {
|
||||
if (!node.awaitCatch) {
|
||||
const [openToken, catchToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(catchToken, 1, openToken);
|
||||
if (node.error) {
|
||||
const errorToken = sourceCode.getFirstToken(node.error);
|
||||
offsets.setOffsetToken(errorToken, 1, catchToken);
|
||||
}
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(node.error || catchToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
}
|
||||
const openToken = sourceCode.getFirstToken(node);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
},
|
||||
SvelteKeyBlock(node) {
|
||||
const [openToken, keyToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(keyToken, 1, openToken);
|
||||
const exp = (0, commons_3.getFirstAndLastTokens)(sourceCode, node.expression);
|
||||
offsets.setOffsetToken(exp.firstToken, 1, keyToken);
|
||||
const closeOpenTagToken = sourceCode.getTokenAfter(exp.lastToken);
|
||||
offsets.setOffsetToken(closeOpenTagToken, 0, openToken);
|
||||
for (const child of node.children) {
|
||||
const token = sourceCode.getFirstToken(child, {
|
||||
includeComments: false,
|
||||
filter: ast_1.isNotWhitespace
|
||||
});
|
||||
offsets.setOffsetToken(token, 1, openToken);
|
||||
}
|
||||
const [openCloseTagToken, endAwaitToken, closeCloseTagToken] = sourceCode.getLastTokens(node, {
|
||||
count: 3,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(openCloseTagToken, 0, openToken);
|
||||
offsets.setOffsetToken(endAwaitToken, 1, openCloseTagToken);
|
||||
offsets.setOffsetToken(closeCloseTagToken, 0, openCloseTagToken);
|
||||
},
|
||||
SvelteHTMLComment(_node) {
|
||||
},
|
||||
SvelteName(_node) {
|
||||
},
|
||||
SvelteMemberExpressionName(_node) {
|
||||
}
|
||||
};
|
||||
return visitor;
|
||||
}
|
||||
exports.defineVisitor = defineVisitor;
|
||||
function isNotEmptyTextNode(node) {
|
||||
return !(node.type === 'SvelteText' && node.value.trim() === '');
|
||||
}
|
||||
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ts.d.ts
generated
vendored
Normal file
5
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ts.d.ts
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
import type { IndentContext } from './commons';
|
||||
import type { TSNodeListener } from '../../types-for-node';
|
||||
type NodeListener = TSNodeListener;
|
||||
export declare function defineVisitor(context: IndentContext): NodeListener;
|
||||
export {};
|
||||
743
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ts.js
generated
vendored
Normal file
743
node_modules/eslint-plugin-svelte/lib/rules/indent-helpers/ts.js
generated
vendored
Normal file
@ -0,0 +1,743 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.defineVisitor = void 0;
|
||||
const eslint_utils_1 = require("@eslint-community/eslint-utils");
|
||||
const commons_1 = require("./commons");
|
||||
const commons_2 = require("./commons");
|
||||
function defineVisitor(context) {
|
||||
const { offsets, sourceCode } = context;
|
||||
const visitor = {
|
||||
TSTypeAnnotation(node) {
|
||||
const [colonOrArrowToken, secondToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
const baseToken = sourceCode.getFirstToken(node.parent);
|
||||
offsets.setOffsetToken([colonOrArrowToken, secondToken], 1, baseToken);
|
||||
const before = sourceCode.getTokenBefore(colonOrArrowToken);
|
||||
if (before && before.value === '?') {
|
||||
offsets.setOffsetToken(before, 1, baseToken);
|
||||
}
|
||||
},
|
||||
TSAsExpression(node) {
|
||||
const expressionTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.expression);
|
||||
const asOrSatisfiesToken = sourceCode.getTokenAfter(expressionTokens.lastToken);
|
||||
offsets.setOffsetToken([asOrSatisfiesToken, (0, commons_2.getFirstAndLastTokens)(sourceCode, node.typeAnnotation).firstToken], 1, expressionTokens.firstToken);
|
||||
},
|
||||
TSSatisfiesExpression(node) {
|
||||
visitor.TSAsExpression(node);
|
||||
},
|
||||
TSTypeReference(node) {
|
||||
if (node.typeParameters) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSInstantiationExpression(node) {
|
||||
visitor.TSTypeReference(node);
|
||||
},
|
||||
TSTypeParameterInstantiation(node) {
|
||||
offsets.setOffsetElementList(node.params, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
TSTypeParameterDeclaration(node) {
|
||||
visitor.TSTypeParameterInstantiation(node);
|
||||
},
|
||||
TSTypeAliasDeclaration(node) {
|
||||
const typeToken = sourceCode.getFirstToken(node);
|
||||
const idToken = sourceCode.getFirstToken(node.id);
|
||||
offsets.setOffsetToken(idToken, 1, typeToken);
|
||||
let eqToken;
|
||||
if (node.typeParameters) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, idToken);
|
||||
eqToken = sourceCode.getTokenAfter(node.typeParameters);
|
||||
}
|
||||
else {
|
||||
eqToken = sourceCode.getTokenAfter(node.id);
|
||||
}
|
||||
const initToken = sourceCode.getTokenAfter(eqToken);
|
||||
offsets.setOffsetToken([eqToken, initToken], 1, idToken);
|
||||
},
|
||||
TSFunctionType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
let currToken = firstToken;
|
||||
if (node.type === 'TSConstructorType') {
|
||||
currToken = sourceCode.getTokenAfter(currToken);
|
||||
offsets.setOffsetToken(currToken, 1, firstToken);
|
||||
}
|
||||
if (node.typeParameters) {
|
||||
currToken = sourceCode.getTokenAfter(node.typeParameters);
|
||||
offsets.setOffsetToken(currToken, 1, firstToken);
|
||||
}
|
||||
const leftParenToken = currToken;
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftParenToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.params, leftParenToken, rightParenToken, 1);
|
||||
const arrowToken = sourceCode.getTokenAfter(rightParenToken);
|
||||
offsets.setOffsetToken(arrowToken, 1, leftParenToken);
|
||||
},
|
||||
TSConstructorType(node) {
|
||||
visitor.TSFunctionType(node);
|
||||
},
|
||||
TSTypeLiteral(node) {
|
||||
offsets.setOffsetElementList(node.members, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
TSPropertySignature(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.key);
|
||||
let keyLast;
|
||||
if (node.computed) {
|
||||
const closeBracket = sourceCode.getTokenAfter(keyTokens.lastToken);
|
||||
offsets.setOffsetElementList([node.key], firstToken, closeBracket, 1);
|
||||
keyLast = closeBracket;
|
||||
}
|
||||
else {
|
||||
keyLast = keyTokens.lastToken;
|
||||
}
|
||||
if (node.typeAnnotation) {
|
||||
const typeAnnotationToken = sourceCode.getFirstToken(node.typeAnnotation);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, firstToken);
|
||||
}
|
||||
else if (node.optional) {
|
||||
const qToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetToken(qToken, 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSIndexSignature(node) {
|
||||
const leftBracketToken = sourceCode.getFirstToken(node);
|
||||
const rightBracketToken = sourceCode.getTokenAfter(node.parameters[node.parameters.length - 1] || leftBracketToken, { filter: eslint_utils_1.isClosingBracketToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.parameters, leftBracketToken, rightBracketToken, 1);
|
||||
const keyLast = rightBracketToken;
|
||||
if (node.typeAnnotation) {
|
||||
const typeAnnotationToken = sourceCode.getFirstToken(node.typeAnnotation);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, leftBracketToken);
|
||||
}
|
||||
},
|
||||
TSArrayType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
offsets.setOffsetToken(sourceCode.getLastTokens(node, { count: 2, includeComments: false }), 0, firstToken);
|
||||
},
|
||||
TSTupleType(node) {
|
||||
offsets.setOffsetElementList(node.elementTypes, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
TSQualifiedName(node) {
|
||||
const objectToken = sourceCode.getFirstToken(node);
|
||||
const dotToken = sourceCode.getTokenBefore(node.right);
|
||||
const propertyToken = sourceCode.getTokenAfter(dotToken);
|
||||
offsets.setOffsetToken([dotToken, propertyToken], 1, objectToken);
|
||||
},
|
||||
TSIndexedAccessType(node) {
|
||||
const objectToken = sourceCode.getFirstToken(node);
|
||||
const leftBracketToken = sourceCode.getTokenBefore(node.indexType, {
|
||||
filter: eslint_utils_1.isOpeningBracketToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightBracketToken = sourceCode.getTokenAfter(node.indexType, {
|
||||
filter: eslint_utils_1.isClosingBracketToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftBracketToken, 1, objectToken);
|
||||
offsets.setOffsetElementList([node.indexType], leftBracketToken, rightBracketToken, 1);
|
||||
},
|
||||
TSUnionType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const types = [...node.types];
|
||||
if ((0, commons_2.getFirstAndLastTokens)(sourceCode, types[0]).firstToken === firstToken) {
|
||||
types.shift();
|
||||
}
|
||||
offsets.setOffsetElementList(types, firstToken, null, (0, commons_1.isBeginningOfLine)(sourceCode, firstToken) ? 0 : 1);
|
||||
},
|
||||
TSIntersectionType(node) {
|
||||
visitor.TSUnionType(node);
|
||||
},
|
||||
TSMappedType(node) {
|
||||
const leftBraceToken = sourceCode.getFirstToken(node);
|
||||
const leftBracketToken = sourceCode.getTokenBefore(node.typeParameter);
|
||||
const rightBracketToken = sourceCode.getTokenAfter(node.nameType || node.typeParameter);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(leftBraceToken, leftBracketToken), leftBracketToken], 1, leftBraceToken);
|
||||
offsets.setOffsetElementList([node.typeParameter, node.nameType], leftBracketToken, rightBracketToken, 1);
|
||||
const rightBraceToken = sourceCode.getLastToken(node);
|
||||
if (node.typeAnnotation) {
|
||||
const typeAnnotationToken = sourceCode.getFirstToken(node.typeAnnotation);
|
||||
offsets.setOffsetToken([
|
||||
...sourceCode.getTokensBetween(rightBracketToken, typeAnnotationToken),
|
||||
typeAnnotationToken
|
||||
], 1, leftBraceToken);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(rightBracketToken, rightBraceToken)], 1, leftBraceToken);
|
||||
}
|
||||
offsets.setOffsetToken(rightBraceToken, 0, leftBraceToken);
|
||||
},
|
||||
TSTypeParameter(node) {
|
||||
const [firstToken, ...afterTokens] = sourceCode.getTokens(node);
|
||||
for (const child of [node.constraint, node.default]) {
|
||||
if (!child) {
|
||||
continue;
|
||||
}
|
||||
const [, ...removeTokens] = sourceCode.getTokens(child);
|
||||
for (const token of removeTokens) {
|
||||
const i = afterTokens.indexOf(token);
|
||||
if (i >= 0) {
|
||||
afterTokens.splice(i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
const secondToken = afterTokens.shift();
|
||||
if (!secondToken) {
|
||||
return;
|
||||
}
|
||||
offsets.setOffsetToken(secondToken, 1, firstToken);
|
||||
if (secondToken.value === 'extends') {
|
||||
let prevToken = null;
|
||||
let token = afterTokens.shift();
|
||||
while (token) {
|
||||
if (token.value === '=') {
|
||||
break;
|
||||
}
|
||||
offsets.setOffsetToken(token, 1, secondToken);
|
||||
prevToken = token;
|
||||
token = afterTokens.shift();
|
||||
}
|
||||
while (token) {
|
||||
offsets.setOffsetToken(token, 1, prevToken || secondToken);
|
||||
token = afterTokens.shift();
|
||||
}
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(afterTokens, 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSConditionalType(node) {
|
||||
const checkTypeToken = sourceCode.getFirstToken(node);
|
||||
const extendsToken = sourceCode.getTokenAfter(node.checkType);
|
||||
const extendsTypeToken = sourceCode.getFirstToken(node.extendsType);
|
||||
offsets.setOffsetToken(extendsToken, 1, checkTypeToken);
|
||||
offsets.setOffsetToken(extendsTypeToken, 1, extendsToken);
|
||||
const questionToken = sourceCode.getTokenAfter(node.extendsType, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const consequentToken = sourceCode.getTokenAfter(questionToken);
|
||||
const colonToken = sourceCode.getTokenAfter(node.trueType, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const alternateToken = sourceCode.getTokenAfter(colonToken);
|
||||
let baseNode = node;
|
||||
let parent = baseNode.parent;
|
||||
while (parent && parent.type === 'TSConditionalType' && parent.falseType === baseNode) {
|
||||
baseNode = parent;
|
||||
parent = baseNode.parent;
|
||||
}
|
||||
const baseToken = sourceCode.getFirstToken(baseNode);
|
||||
offsets.setOffsetToken([questionToken, colonToken], 1, baseToken);
|
||||
offsets.setOffsetToken(consequentToken, 1, questionToken);
|
||||
offsets.setOffsetToken(alternateToken, 1, colonToken);
|
||||
},
|
||||
TSInterfaceDeclaration(node) {
|
||||
const interfaceToken = sourceCode.getFirstToken(node);
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.id), 1, interfaceToken);
|
||||
if (node.typeParameters != null) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, sourceCode.getFirstToken(node.id));
|
||||
}
|
||||
if (node.extends != null && node.extends.length) {
|
||||
const extendsToken = sourceCode.getTokenBefore(node.extends[0]);
|
||||
offsets.setOffsetToken(extendsToken, 1, interfaceToken);
|
||||
offsets.setOffsetElementList(node.extends, extendsToken, null, 1);
|
||||
}
|
||||
const bodyToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyToken, 0, interfaceToken);
|
||||
},
|
||||
TSInterfaceBody(node) {
|
||||
offsets.setOffsetElementList(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
TSClassImplements(node) {
|
||||
if (node.typeParameters) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, sourceCode.getFirstToken(node));
|
||||
}
|
||||
},
|
||||
TSInterfaceHeritage(node) {
|
||||
visitor.TSClassImplements(node);
|
||||
},
|
||||
TSEnumDeclaration(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const idTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.id);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, idTokens.firstToken);
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
offsets.setOffsetToken(idTokens.firstToken, 1, firstToken);
|
||||
const leftBraceToken = sourceCode.getTokenAfter(idTokens.lastToken);
|
||||
const rightBraceToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetToken(leftBraceToken, 0, firstToken);
|
||||
offsets.setOffsetElementList(node.members, leftBraceToken, rightBraceToken, 1);
|
||||
},
|
||||
TSModuleDeclaration(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const idTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.id);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, idTokens.firstToken);
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
offsets.setOffsetToken(idTokens.firstToken, 1, firstToken);
|
||||
if (node.body) {
|
||||
const bodyFirstToken = sourceCode.getFirstToken(node.body);
|
||||
offsets.setOffsetToken(bodyFirstToken, (0, eslint_utils_1.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSModuleBlock(node) {
|
||||
visitor.TSInterfaceBody(node);
|
||||
},
|
||||
TSMethodSignature(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.key);
|
||||
let keyLast;
|
||||
if (node.computed) {
|
||||
const closeBracket = sourceCode.getTokenAfter(keyTokens.lastToken);
|
||||
offsets.setOffsetElementList([node.key], firstToken, closeBracket, 1);
|
||||
keyLast = closeBracket;
|
||||
}
|
||||
else {
|
||||
keyLast = keyTokens.lastToken;
|
||||
}
|
||||
const leftParenToken = sourceCode.getTokenAfter(keyLast, {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(keyLast, leftParenToken), leftParenToken], 1, firstToken);
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftParenToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.params, leftParenToken, rightParenToken, 1);
|
||||
if (node.returnType) {
|
||||
const typeAnnotationToken = sourceCode.getFirstToken(node.returnType);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSCallSignatureDeclaration(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
let currToken = firstToken;
|
||||
if (node.type === 'TSConstructSignatureDeclaration') {
|
||||
currToken = sourceCode.getTokenAfter(currToken);
|
||||
offsets.setOffsetToken(currToken, 1, firstToken);
|
||||
}
|
||||
if (node.typeParameters) {
|
||||
currToken = sourceCode.getTokenAfter(node.typeParameters);
|
||||
offsets.setOffsetToken(currToken, 1, firstToken);
|
||||
}
|
||||
const leftParenToken = currToken;
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftParenToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetElementList(node.params, leftParenToken, rightParenToken, 1);
|
||||
if (node.returnType) {
|
||||
const typeAnnotationToken = sourceCode.getFirstToken(node.returnType);
|
||||
offsets.setOffsetToken([
|
||||
...sourceCode.getTokensBetween(rightParenToken, typeAnnotationToken),
|
||||
typeAnnotationToken
|
||||
], 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSConstructSignatureDeclaration(node) {
|
||||
visitor.TSCallSignatureDeclaration(node);
|
||||
},
|
||||
TSEmptyBodyFunctionExpression(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
let leftParenToken, bodyBaseToken;
|
||||
if (firstToken.type === 'Punctuator') {
|
||||
leftParenToken = firstToken;
|
||||
bodyBaseToken = sourceCode.getFirstToken(node.parent);
|
||||
}
|
||||
else {
|
||||
let nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
let nextTokenOffset = 0;
|
||||
while (nextToken && !(0, eslint_utils_1.isOpeningParenToken)(nextToken) && nextToken.value !== '<') {
|
||||
if (nextToken.value === '*' || (node.id && nextToken.range[0] === node.id.range[0])) {
|
||||
nextTokenOffset = 1;
|
||||
}
|
||||
offsets.setOffsetToken(nextToken, nextTokenOffset, firstToken);
|
||||
nextToken = sourceCode.getTokenAfter(nextToken);
|
||||
}
|
||||
leftParenToken = nextToken;
|
||||
bodyBaseToken = firstToken;
|
||||
}
|
||||
if (!(0, eslint_utils_1.isOpeningParenToken)(leftParenToken) && node.typeParameters) {
|
||||
leftParenToken = sourceCode.getTokenAfter(node.typeParameters);
|
||||
}
|
||||
const rightParenToken = sourceCode.getTokenAfter(node.params[node.params.length - 1] || leftParenToken, { filter: eslint_utils_1.isClosingParenToken, includeComments: false });
|
||||
offsets.setOffsetToken(leftParenToken, 1, bodyBaseToken);
|
||||
offsets.setOffsetElementList(node.params, leftParenToken, rightParenToken, 1);
|
||||
},
|
||||
TSDeclareFunction(node) {
|
||||
visitor.TSEmptyBodyFunctionExpression(node);
|
||||
},
|
||||
TSTypeOperator(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
},
|
||||
TSTypeQuery(node) {
|
||||
visitor.TSTypeOperator(node);
|
||||
},
|
||||
TSInferType(node) {
|
||||
visitor.TSTypeOperator(node);
|
||||
},
|
||||
TSTypePredicate(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const opToken = sourceCode.getTokenAfter(node.parameterName, {
|
||||
filter: eslint_utils_1.isNotClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightToken = node.typeAnnotation && (0, commons_2.getFirstAndLastTokens)(sourceCode, node.typeAnnotation).firstToken;
|
||||
offsets.setOffsetToken([opToken, rightToken], 1, (0, commons_2.getFirstAndLastTokens)(sourceCode, firstToken).firstToken);
|
||||
},
|
||||
TSAbstractMethodDefinition(node) {
|
||||
const { keyNode, valueNode } = node.type === 'TSEnumMember'
|
||||
? { keyNode: node.id, valueNode: node.initializer }
|
||||
: { keyNode: node.key, valueNode: node.value };
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, keyNode);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, keyTokens.firstToken);
|
||||
if (node.computed) {
|
||||
prefixTokens.pop();
|
||||
}
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
let lastKeyToken;
|
||||
if (node.computed) {
|
||||
const leftBracketToken = sourceCode.getTokenBefore(keyTokens.firstToken);
|
||||
const rightBracketToken = (lastKeyToken = sourceCode.getTokenAfter(keyTokens.lastToken));
|
||||
offsets.setOffsetToken(leftBracketToken, 0, firstToken);
|
||||
offsets.setOffsetElementList([keyNode], leftBracketToken, rightBracketToken, 1);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(keyTokens.firstToken, 0, firstToken);
|
||||
lastKeyToken = keyTokens.lastToken;
|
||||
}
|
||||
if (valueNode != null) {
|
||||
const initToken = sourceCode.getFirstToken(valueNode);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(lastKeyToken, initToken), initToken], 1, lastKeyToken);
|
||||
}
|
||||
},
|
||||
TSAbstractPropertyDefinition(node) {
|
||||
visitor.TSAbstractMethodDefinition(node);
|
||||
},
|
||||
TSEnumMember(node) {
|
||||
visitor.TSAbstractMethodDefinition(node);
|
||||
},
|
||||
TSAbstractAccessorProperty(node) {
|
||||
visitor.TSAbstractMethodDefinition(node);
|
||||
},
|
||||
TSOptionalType(node) {
|
||||
offsets.setOffsetToken(sourceCode.getLastToken(node), 1, sourceCode.getFirstToken(node));
|
||||
},
|
||||
TSNonNullExpression(node) {
|
||||
visitor.TSOptionalType(node);
|
||||
},
|
||||
TSJSDocNonNullableType(node) {
|
||||
visitor.TSOptionalType(node);
|
||||
},
|
||||
TSTypeAssertion(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const expressionToken = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.expression).firstToken;
|
||||
offsets.setOffsetElementList([node.typeAnnotation], firstToken, sourceCode.getTokenBefore(expressionToken), 1);
|
||||
offsets.setOffsetToken(expressionToken, 1, firstToken);
|
||||
},
|
||||
TSImportType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(firstToken, {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(leftParenToken, 1, firstToken);
|
||||
const argument = node.argument ||
|
||||
node.parameter;
|
||||
const rightParenToken = sourceCode.getTokenAfter(argument, {
|
||||
filter: eslint_utils_1.isClosingParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetElementList([argument], leftParenToken, rightParenToken, 1);
|
||||
if (node.qualifier) {
|
||||
const dotToken = sourceCode.getTokenBefore(node.qualifier);
|
||||
const propertyToken = sourceCode.getTokenAfter(dotToken);
|
||||
offsets.setOffsetToken([dotToken, propertyToken], 1, firstToken);
|
||||
}
|
||||
if (node.typeParameters) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, firstToken);
|
||||
}
|
||||
},
|
||||
TSParameterProperty(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const parameterToken = sourceCode.getFirstToken(node.parameter);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(firstToken, parameterToken), parameterToken], 1, firstToken);
|
||||
},
|
||||
TSImportEqualsDeclaration(node) {
|
||||
const importToken = sourceCode.getFirstToken(node);
|
||||
const idTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.id);
|
||||
offsets.setOffsetToken(idTokens.firstToken, 1, importToken);
|
||||
const opToken = sourceCode.getTokenAfter(idTokens.lastToken);
|
||||
offsets.setOffsetToken([opToken, sourceCode.getFirstToken(node.moduleReference)], 1, idTokens.lastToken);
|
||||
},
|
||||
TSExternalModuleReference(node) {
|
||||
const requireToken = sourceCode.getFirstToken(node);
|
||||
const leftParenToken = sourceCode.getTokenAfter(requireToken, {
|
||||
filter: eslint_utils_1.isOpeningParenToken,
|
||||
includeComments: false
|
||||
});
|
||||
const rightParenToken = sourceCode.getLastToken(node);
|
||||
offsets.setOffsetToken(leftParenToken, 1, requireToken);
|
||||
offsets.setOffsetElementList([node.expression], leftParenToken, rightParenToken, 1);
|
||||
},
|
||||
TSExportAssignment(node) {
|
||||
const exportNode = sourceCode.getFirstToken(node);
|
||||
const exprTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.expression);
|
||||
const opToken = sourceCode.getTokenBefore(exprTokens.firstToken);
|
||||
offsets.setOffsetToken([opToken, exprTokens.firstToken], 1, exportNode);
|
||||
},
|
||||
TSNamedTupleMember(node) {
|
||||
const labelToken = sourceCode.getFirstToken(node);
|
||||
const elementTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.elementType);
|
||||
offsets.setOffsetToken([
|
||||
...sourceCode.getTokensBetween(labelToken, elementTokens.firstToken),
|
||||
elementTokens.firstToken
|
||||
], 1, labelToken);
|
||||
},
|
||||
TSRestType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const nextToken = sourceCode.getTokenAfter(firstToken);
|
||||
offsets.setOffsetToken(nextToken, 1, firstToken);
|
||||
},
|
||||
TSNamespaceExportDeclaration(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const idToken = sourceCode.getFirstToken(node.id);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(firstToken, idToken), idToken], 1, firstToken);
|
||||
},
|
||||
TSTemplateLiteralType(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const quasiTokens = node.quasis.slice(1).map((n) => sourceCode.getFirstToken(n));
|
||||
const expressionToken = node.quasis.slice(0, -1).map((n) => sourceCode.getTokenAfter(n));
|
||||
offsets.setOffsetToken(quasiTokens, 0, firstToken);
|
||||
offsets.setOffsetToken(expressionToken, 1, firstToken);
|
||||
},
|
||||
Decorator(node) {
|
||||
const [atToken, secondToken] = sourceCode.getFirstTokens(node, {
|
||||
count: 2,
|
||||
includeComments: false
|
||||
});
|
||||
offsets.setOffsetToken(secondToken, 0, atToken);
|
||||
const parent = node.parent;
|
||||
const { decorators } = parent;
|
||||
if (!decorators || decorators.length === 0) {
|
||||
return;
|
||||
}
|
||||
if (decorators[0] === node) {
|
||||
if (parent.range[0] === node.range[0]) {
|
||||
const startParentToken = sourceCode.getTokenAfter(decorators[decorators?.length - 1]);
|
||||
offsets.setOffsetToken(startParentToken, 0, atToken);
|
||||
}
|
||||
else {
|
||||
const startParentToken = sourceCode.getFirstToken(parent.parent &&
|
||||
(parent.parent.type === 'ExportDefaultDeclaration' ||
|
||||
parent.parent.type === 'ExportNamedDeclaration') &&
|
||||
node.range[0] < parent.parent.range[0]
|
||||
? parent.parent
|
||||
: parent);
|
||||
offsets.copyOffset(atToken.range[0], startParentToken.range[0]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(atToken, 0, sourceCode.getFirstToken(decorators[0]));
|
||||
}
|
||||
},
|
||||
AccessorProperty(node) {
|
||||
const keyNode = node.key;
|
||||
const valueNode = node.value;
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, keyNode);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, keyTokens.firstToken);
|
||||
if (node.computed) {
|
||||
prefixTokens.pop();
|
||||
}
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
let lastKeyToken;
|
||||
if (node.computed) {
|
||||
const leftBracketToken = sourceCode.getTokenBefore(keyTokens.firstToken);
|
||||
const rightBracketToken = (lastKeyToken = sourceCode.getTokenAfter(keyTokens.lastToken));
|
||||
offsets.setOffsetToken(leftBracketToken, 0, firstToken);
|
||||
offsets.setOffsetElementList([keyNode], leftBracketToken, rightBracketToken, 1);
|
||||
}
|
||||
else {
|
||||
offsets.setOffsetToken(keyTokens.firstToken, 0, firstToken);
|
||||
lastKeyToken = keyTokens.lastToken;
|
||||
}
|
||||
if (valueNode != null) {
|
||||
const initToken = sourceCode.getFirstToken(valueNode);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(lastKeyToken, initToken), initToken], 1, lastKeyToken);
|
||||
}
|
||||
},
|
||||
StaticBlock(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
let next = sourceCode.getTokenAfter(firstToken);
|
||||
while (next && (0, eslint_utils_1.isNotOpeningBraceToken)(next)) {
|
||||
offsets.setOffsetToken(next, 0, firstToken);
|
||||
next = sourceCode.getTokenAfter(next);
|
||||
}
|
||||
offsets.setOffsetToken(next, 0, firstToken);
|
||||
offsets.setOffsetElementList(node.body, next, sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
ImportAttribute(node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const keyTokens = (0, commons_2.getFirstAndLastTokens)(sourceCode, node.key);
|
||||
const prefixTokens = sourceCode.getTokensBetween(firstToken, keyTokens.firstToken);
|
||||
offsets.setOffsetToken(prefixTokens, 0, firstToken);
|
||||
offsets.setOffsetToken(keyTokens.firstToken, 0, firstToken);
|
||||
const initToken = sourceCode.getFirstToken(node.value);
|
||||
offsets.setOffsetToken([...sourceCode.getTokensBetween(keyTokens.lastToken, initToken), initToken], 1, keyTokens.lastToken);
|
||||
},
|
||||
TSAnyKeyword() {
|
||||
},
|
||||
TSBigIntKeyword() {
|
||||
},
|
||||
TSBooleanKeyword() {
|
||||
},
|
||||
TSNeverKeyword() {
|
||||
},
|
||||
TSNullKeyword() {
|
||||
},
|
||||
TSNumberKeyword() {
|
||||
},
|
||||
TSObjectKeyword() {
|
||||
},
|
||||
TSStringKeyword() {
|
||||
},
|
||||
TSSymbolKeyword() {
|
||||
},
|
||||
TSUndefinedKeyword() {
|
||||
},
|
||||
TSUnknownKeyword() {
|
||||
},
|
||||
TSVoidKeyword() {
|
||||
},
|
||||
TSAbstractKeyword() {
|
||||
},
|
||||
TSAsyncKeyword() {
|
||||
},
|
||||
TSPrivateKeyword() {
|
||||
},
|
||||
TSProtectedKeyword() {
|
||||
},
|
||||
TSPublicKeyword() {
|
||||
},
|
||||
TSReadonlyKeyword() {
|
||||
},
|
||||
TSStaticKeyword() {
|
||||
},
|
||||
TSDeclareKeyword() {
|
||||
},
|
||||
TSExportKeyword() {
|
||||
},
|
||||
TSIntrinsicKeyword() {
|
||||
},
|
||||
TSThisType() {
|
||||
},
|
||||
TSLiteralType() {
|
||||
}
|
||||
};
|
||||
const commonsVisitor = {
|
||||
['TSTypeAliasDeclaration, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSImportEqualsDeclaration,' +
|
||||
'TSAbstractMethodDefinition, TSAbstractPropertyDefinition, AccessorProperty, TSAbstractAccessorProperty, TSEnumMember,' +
|
||||
'TSPropertySignature, TSIndexSignature, TSMethodSignature,' +
|
||||
'TSAbstractClassProperty, ClassProperty'](node) {
|
||||
const firstToken = sourceCode.getFirstToken(node);
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
if ((0, eslint_utils_1.isSemicolonToken)(lastToken) && firstToken !== lastToken) {
|
||||
const next = sourceCode.getTokenAfter(lastToken);
|
||||
if (!next || lastToken.loc.start.line < next.loc.start.line) {
|
||||
offsets.setOffsetToken(lastToken, 0, firstToken);
|
||||
}
|
||||
}
|
||||
},
|
||||
'*[type=/^TS/]'(node) {
|
||||
if (node.type !== 'TSAnyKeyword' &&
|
||||
node.type !== 'TSArrayType' &&
|
||||
node.type !== 'TSBigIntKeyword' &&
|
||||
node.type !== 'TSBooleanKeyword' &&
|
||||
node.type !== 'TSConditionalType' &&
|
||||
node.type !== 'TSConstructorType' &&
|
||||
node.type !== 'TSFunctionType' &&
|
||||
node.type !== 'TSImportType' &&
|
||||
node.type !== 'TSIndexedAccessType' &&
|
||||
node.type !== 'TSInferType' &&
|
||||
node.type !== 'TSIntersectionType' &&
|
||||
node.type !== 'TSIntrinsicKeyword' &&
|
||||
node.type !== 'TSLiteralType' &&
|
||||
node.type !== 'TSMappedType' &&
|
||||
node.type !== 'TSNamedTupleMember' &&
|
||||
node.type !== 'TSNeverKeyword' &&
|
||||
node.type !== 'TSNullKeyword' &&
|
||||
node.type !== 'TSNumberKeyword' &&
|
||||
node.type !== 'TSObjectKeyword' &&
|
||||
node.type !== 'TSOptionalType' &&
|
||||
node.type !== 'TSRestType' &&
|
||||
node.type !== 'TSStringKeyword' &&
|
||||
node.type !== 'TSSymbolKeyword' &&
|
||||
node.type !== 'TSTemplateLiteralType' &&
|
||||
node.type !== 'TSThisType' &&
|
||||
node.type !== 'TSTupleType' &&
|
||||
node.type !== 'TSTypeLiteral' &&
|
||||
node.type !== 'TSTypeOperator' &&
|
||||
node.type !== 'TSTypePredicate' &&
|
||||
node.type !== 'TSTypeQuery' &&
|
||||
node.type !== 'TSTypeReference' &&
|
||||
node.type !== 'TSUndefinedKeyword' &&
|
||||
node.type !== 'TSUnionType' &&
|
||||
node.type !== 'TSUnknownKeyword' &&
|
||||
node.type !== 'TSVoidKeyword') {
|
||||
return;
|
||||
}
|
||||
const typeNode = node;
|
||||
if (typeNode.parent.type === 'TSParenthesizedType') {
|
||||
return;
|
||||
}
|
||||
let leftToken = sourceCode.getTokenBefore(typeNode);
|
||||
let rightToken = sourceCode.getTokenAfter(typeNode);
|
||||
let firstToken = sourceCode.getFirstToken(typeNode);
|
||||
while (leftToken &&
|
||||
(0, eslint_utils_1.isOpeningParenToken)(leftToken) &&
|
||||
rightToken &&
|
||||
(0, eslint_utils_1.isClosingParenToken)(rightToken)) {
|
||||
offsets.setOffsetToken(firstToken, 1, leftToken);
|
||||
offsets.setOffsetToken(rightToken, 0, leftToken);
|
||||
firstToken = leftToken;
|
||||
leftToken = sourceCode.getTokenBefore(leftToken);
|
||||
rightToken = sourceCode.getTokenAfter(rightToken);
|
||||
}
|
||||
}
|
||||
};
|
||||
const extendsESVisitor = {
|
||||
['ClassDeclaration[implements], ClassDeclaration[typeParameters], ClassDeclaration[superTypeParameters],' +
|
||||
'ClassExpression[implements], ClassExpression[typeParameters], ClassExpression[superTypeParameters]'](node) {
|
||||
if (node.typeParameters != null) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.typeParameters), 1, sourceCode.getFirstToken(node.id || node));
|
||||
}
|
||||
if (node.superTypeParameters != null && node.superClass != null) {
|
||||
offsets.setOffsetToken(sourceCode.getFirstToken(node.superTypeParameters), 1, sourceCode.getFirstToken(node.superClass));
|
||||
}
|
||||
if (node.implements != null && node.implements.length) {
|
||||
const classToken = sourceCode.getFirstToken(node);
|
||||
const implementsToken = sourceCode.getTokenBefore(node.implements[0]);
|
||||
offsets.setOffsetToken(implementsToken, 1, classToken);
|
||||
offsets.setOffsetElementList(node.implements, implementsToken, null, 1);
|
||||
}
|
||||
}
|
||||
};
|
||||
const deprecatedVisitor = {
|
||||
TSParenthesizedType(node) {
|
||||
offsets.setOffsetElementList([node.typeAnnotation], sourceCode.getFirstToken(node), sourceCode.getLastToken(node), 1);
|
||||
},
|
||||
ClassProperty(node) {
|
||||
visitor.TSAbstractMethodDefinition(node);
|
||||
},
|
||||
TSAbstractClassProperty(node) {
|
||||
visitor.TSAbstractMethodDefinition(node);
|
||||
}
|
||||
};
|
||||
const v = visitor;
|
||||
return {
|
||||
...v,
|
||||
...commonsVisitor,
|
||||
...extendsESVisitor,
|
||||
...deprecatedVisitor
|
||||
};
|
||||
}
|
||||
exports.defineVisitor = defineVisitor;
|
||||
Reference in New Issue
Block a user