eslint-plugin-stylistic-compat
Version:
Compatibility version of @stylistic/eslint-plugin for Node.js >= 12 and ESLint v8
753 lines (748 loc) • 33.3 kB
JavaScript
'use strict';
var _Array$isArray = require('@babel/runtime-corejs3/core-js/array/is-array');
var _sliceInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/slice');
var _atInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/at');
var _repeatInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/repeat');
var _includesInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/includes');
var _concatInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/concat');
var _filterInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/filter');
var utils = require('../utils.js');
var vendor = require('../vendor.js');
var _reduceInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/reduce');
var _mapInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/map');
var _forEachInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/for-each');
require('@babel/runtime-corejs3/core-js/object/from-entries');
require('@babel/runtime-corejs3/core-js/object/entries');
require('@babel/runtime-corejs3/core-js/set');
require('@babel/runtime-corejs3/core-js/instance/flags');
require('@babel/runtime-corejs3/core-js/instance/starts-with');
require('@babel/runtime-corejs3/core-js/array/from');
require('@babel/runtime-corejs3/core-js/object/keys');
require('@babel/runtime-corejs3/core-js/object/assign');
require('@babel/runtime-corejs3/core-js/instance/keys');
require('@babel/runtime-corejs3/core-js/instance/find');
require('@babel/runtime-corejs3/core-js/instance/reverse');
require('@babel/runtime-corejs3/core-js/object/define-property');
require('@babel/runtime-corejs3/core-js/object/create');
require('@babel/runtime-corejs3/core-js/object/freeze');
require('@babel/runtime-corejs3/core-js/instance/last-index-of');
require('@babel/runtime-corejs3/core-js/object/define-properties');
require('@babel/runtime-corejs3/core-js/instance/index-of');
require('@babel/runtime-corejs3/core-js/symbol');
require('@babel/runtime-corejs3/core-js/symbol/iterator');
require('@babel/runtime-corejs3/core-js/parse-int');
require('@babel/runtime-corejs3/core-js/parse-float');
require('@babel/runtime-corejs3/core-js/weak-map');
require('@babel/runtime-corejs3/core-js/global-this');
require('eslint/use-at-your-own-risk');
require('eslint');
require('@babel/runtime-corejs3/core-js/object/get-own-property-descriptor');
require('@babel/runtime-corejs3/core-js/map');
require('@babel/runtime-corejs3/core-js/instance/some');
require('@babel/runtime-corejs3/core-js/instance/every');
require('@babel/runtime-corejs3/core-js/instance/sort');
require('@babel/runtime-corejs3/core-js/array/of');
require('@babel/runtime-corejs3/core-js/instance/entries');
require('@babel/runtime-corejs3/core-js/instance/find-index');
require('@babel/runtime-corejs3/core-js/instance/flat');
require('@babel/runtime-corejs3/core-js/instance/values');
require('@babel/runtime-corejs3/core-js/object/get-own-property-names');
require('@babel/runtime-corejs3/core-js/number/is-finite');
require('@babel/runtime-corejs3/core-js/number/is-nan');
require('@babel/runtime-corejs3/core-js/number/parse-float');
require('@babel/runtime-corejs3/core-js/number/parse-int');
require('@babel/runtime-corejs3/core-js/object/is');
require('@babel/runtime-corejs3/core-js/object/is-extensible');
require('@babel/runtime-corejs3/core-js/object/is-frozen');
require('@babel/runtime-corejs3/core-js/object/is-sealed');
require('@babel/runtime-corejs3/core-js/object/values');
require('@babel/runtime-corejs3/core-js/string/from-code-point');
require('@babel/runtime-corejs3/core-js/string/raw');
require('@babel/runtime-corejs3/core-js/instance/code-point-at');
require('@babel/runtime-corejs3/core-js/instance/ends-with');
require('@babel/runtime-corejs3/core-js/instance/pad-end');
require('@babel/runtime-corejs3/core-js/instance/pad-start');
require('@babel/runtime-corejs3/core-js/instance/trim');
require('@babel/runtime-corejs3/core-js/instance/trim-end');
require('@babel/runtime-corejs3/core-js/instance/trim-left');
require('@babel/runtime-corejs3/core-js/instance/trim-right');
require('@babel/runtime-corejs3/core-js/instance/trim-start');
require('@babel/runtime-corejs3/core-js/symbol/for');
require('@babel/runtime-corejs3/core-js/symbol/key-for');
require('@babel/runtime-corejs3/core-js/object/prevent-extensions');
require('@babel/runtime-corejs3/core-js/object/seal');
require('@babel/runtime-corejs3/core-js/object/get-prototype-of');
require('@babel/runtime-corejs3/core-js/symbol/replace');
require('@babel/runtime-corejs3/core-js/instance/bind');
require('@babel/runtime-corejs3/core-js/instance/splice');
const listeningNodes = ["ObjectExpression", "ObjectPattern", "ImportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "TSTypeLiteral", "TSInterfaceBody", "ClassBody"];
function containsLineTerminator(str) {
return utils.LINEBREAK_MATCHER.test(str);
}
function last(arr) {
return arr[arr.length - 1];
}
function isSingleLine(node) {
return node.loc.end.line === node.loc.start.line;
}
function isSingleLineImportAttributes(node, sourceCode) {
const openingBrace = sourceCode.getTokenBefore(node.attributes[0], utils.isOpeningBraceToken);
const closingBrace = sourceCode.getTokenAfter(node.attributes[node.attributes.length - 1], utils.isClosingBraceToken);
return closingBrace.loc.end.line === openingBrace.loc.start.line;
}
function isSingleLineProperties(properties) {
const [firstProp] = properties;
const lastProp = last(properties);
return firstProp.loc.start.line === lastProp.loc.end.line;
}
function initOptionProperty(toOptions, fromOptions) {
toOptions.mode = fromOptions.mode || "strict";
if (typeof fromOptions.beforeColon !== "undefined") toOptions.beforeColon = +fromOptions.beforeColon;else toOptions.beforeColon = 0;
if (typeof fromOptions.afterColon !== "undefined") toOptions.afterColon = +fromOptions.afterColon;else toOptions.afterColon = 1;
if (typeof fromOptions.align !== "undefined") {
if (typeof fromOptions.align === "object") {
toOptions.align = fromOptions.align;
} else {
toOptions.align = {
on: fromOptions.align,
mode: toOptions.mode,
beforeColon: toOptions.beforeColon,
afterColon: toOptions.afterColon
};
}
}
return toOptions;
}
function initOptions(toOptions, fromOptions) {
if (typeof fromOptions.align === "object") {
toOptions.align = initOptionProperty({}, fromOptions.align);
toOptions.align.on = fromOptions.align.on || "colon";
toOptions.align.mode = fromOptions.align.mode || "strict";
toOptions.multiLine = initOptionProperty({}, fromOptions.multiLine || fromOptions);
toOptions.singleLine = initOptionProperty({}, fromOptions.singleLine || fromOptions);
} else {
toOptions.multiLine = initOptionProperty({}, fromOptions.multiLine || fromOptions);
toOptions.singleLine = initOptionProperty({}, fromOptions.singleLine || fromOptions);
if (toOptions.multiLine.align) {
toOptions.align = {
on: toOptions.multiLine.align.on,
mode: toOptions.multiLine.align.mode || toOptions.multiLine.mode,
beforeColon: toOptions.multiLine.align.beforeColon,
afterColon: toOptions.multiLine.align.afterColon
};
}
}
toOptions.ignoredNodes = fromOptions.ignoredNodes || [];
return toOptions;
}
var _baseRule = utils.createRule({
name: "key-spacing",
package: "js",
meta: {
type: "layout",
docs: {
description: "Enforce consistent spacing between keys and values in object literal properties"
},
fixable: "whitespace",
schema: [{
anyOf: [{
type: "object",
properties: {
align: {
anyOf: [{
type: "string",
enum: ["colon", "value"]
}, {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
on: {
type: "string",
enum: ["colon", "value"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
}]
},
mode: {
type: "string",
enum: ["strict", "minimum"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
},
ignoredNodes: {
type: "array",
items: {
type: "string",
enum: listeningNodes
}
}
},
additionalProperties: false
}, {
type: "object",
properties: {
singleLine: {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
},
multiLine: {
type: "object",
properties: {
align: {
anyOf: [{
type: "string",
enum: ["colon", "value"]
}, {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
on: {
type: "string",
enum: ["colon", "value"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
}]
},
mode: {
type: "string",
enum: ["strict", "minimum"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
}
},
additionalProperties: false
}, {
type: "object",
properties: {
singleLine: {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
},
multiLine: {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
},
align: {
type: "object",
properties: {
mode: {
type: "string",
enum: ["strict", "minimum"]
},
on: {
type: "string",
enum: ["colon", "value"]
},
beforeColon: {
type: "boolean"
},
afterColon: {
type: "boolean"
}
},
additionalProperties: false
}
},
additionalProperties: false
}]
}],
messages: {
extraKey: "Extra space after {{computed}}key '{{key}}'.",
extraValue: "Extra space before value for {{computed}}key '{{key}}'.",
missingKey: "Missing space after {{computed}}key '{{key}}'.",
missingValue: "Missing space before value for {{computed}}key '{{key}}'."
}
},
create(context) {
const options = context.options[0] || {};
const ruleOptions = initOptions({}, options);
const multiLineOptions = ruleOptions.multiLine;
const singleLineOptions = ruleOptions.singleLine;
const alignmentOptions = ruleOptions.align || null;
const ignoredNodes = ruleOptions.ignoredNodes;
const sourceCode = context.sourceCode;
function isKeyValueProperty(property) {
if (property.type === "ImportAttribute") return true;
return !("method" in property && property.method || "shorthand" in property && property.shorthand || "kind" in property && property.kind !== "init" || property.type !== "Property");
}
function getNextColon(node) {
return sourceCode.getTokenAfter(node, utils.isColonToken);
}
function getLastTokenBeforeColon(node) {
const colonToken = getNextColon(node);
return sourceCode.getTokenBefore(colonToken);
}
function getFirstTokenAfterColon(node) {
const colonToken = getNextColon(node);
return sourceCode.getTokenAfter(colonToken);
}
function continuesPropertyGroup(lastMember, candidate) {
const groupEndLine = lastMember.loc.start.line;
const candidateValueStartLine = (isKeyValueProperty(candidate) ? getFirstTokenAfterColon(candidate.key) : candidate).loc.start.line;
if (candidateValueStartLine - groupEndLine <= 1) return true;
const leadingComments = sourceCode.getCommentsBefore(candidate);
if (leadingComments.length && leadingComments[0].loc.start.line - groupEndLine <= 1 && candidateValueStartLine - last(leadingComments).loc.end.line <= 1) {
for (let i = 1; i < leadingComments.length; i++) {
if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) return false;
}
return true;
}
return false;
}
function getKey(property) {
var _context;
const key = property.key;
if (property.type !== "ImportAttribute" && property.computed) return _sliceInstanceProperty(_context = sourceCode.getText()).call(_context, key.range[0], key.range[1]);
return utils.getStaticPropertyName(property);
}
function report(property, side, whitespace, expected, mode) {
const diff = whitespace.length - expected;
if ((diff && mode === "strict" || diff < 0 && mode === "minimum" || diff > 0 && !expected && mode === "minimum") && !(expected && containsLineTerminator(whitespace))) {
const nextColon = getNextColon(property.key);
const tokenBeforeColon = sourceCode.getTokenBefore(nextColon, {
includeComments: true
});
const tokenAfterColon = sourceCode.getTokenAfter(nextColon, {
includeComments: true
});
const isKeySide = side === "key";
const isExtra = diff > 0;
const diffAbs = Math.abs(diff);
const spaces = new Array(diffAbs + 1).join(" ");
const locStart = isKeySide ? tokenBeforeColon.loc.end : nextColon.loc.start;
const locEnd = isKeySide ? nextColon.loc.start : tokenAfterColon.loc.start;
const missingLoc = isKeySide ? tokenBeforeColon.loc : tokenAfterColon.loc;
const loc = isExtra ? {
start: locStart,
end: locEnd
} : missingLoc;
let fix;
if (isExtra) {
let range;
if (isKeySide) range = [tokenBeforeColon.range[1], tokenBeforeColon.range[1] + diffAbs];else range = [tokenAfterColon.range[0] - diffAbs, tokenAfterColon.range[0]];
fix = function (fixer) {
return fixer.removeRange(range);
};
} else {
if (isKeySide) {
fix = function (fixer) {
return fixer.insertTextAfter(tokenBeforeColon, spaces);
};
} else {
fix = function (fixer) {
return fixer.insertTextBefore(tokenAfterColon, spaces);
};
}
}
let messageId;
if (isExtra) messageId = side === "key" ? "extraKey" : "extraValue";else messageId = side === "key" ? "missingKey" : "missingValue";
context.report({
node: property[side],
loc,
messageId,
data: {
computed: property.type !== "ImportAttribute" && property.computed ? "computed " : "",
key: getKey(property)
},
fix
});
}
}
function getKeyWidth(property) {
var _context2;
const startToken = sourceCode.getFirstToken(property);
const endToken = getLastTokenBeforeColon(property.key);
return utils.getStringLength(_sliceInstanceProperty(_context2 = sourceCode.getText()).call(_context2, startToken.range[0], endToken.range[1]));
}
function getPropertyWhitespace(property) {
var _context3;
const whitespace = /(\s*):(\s*)/u.exec(_sliceInstanceProperty(_context3 = sourceCode.getText()).call(_context3, property.key.range[1], property.value.range[0]));
if (whitespace) {
return {
beforeColon: whitespace[1],
afterColon: whitespace[2]
};
}
return null;
}
function createGroups(properties) {
if (properties.length === 1) return [properties];
return _reduceInstanceProperty(properties).call(properties, (groups, property) => {
const currentGroup = last(groups);
const prev = last(currentGroup);
if (!prev || continuesPropertyGroup(prev, property)) currentGroup.push(property);else groups.push([property]);
return groups;
}, [[]]);
}
function verifyGroupAlignment(properties) {
const length = properties.length;
const widths = _mapInstanceProperty(properties).call(properties, getKeyWidth);
const align = alignmentOptions.on;
let targetWidth = Math.max(...widths);
let beforeColon;
let afterColon;
let mode;
if (alignmentOptions && length > 1) {
beforeColon = alignmentOptions.beforeColon;
afterColon = alignmentOptions.afterColon;
mode = alignmentOptions.mode;
} else {
beforeColon = multiLineOptions.beforeColon;
afterColon = multiLineOptions.afterColon;
mode = alignmentOptions.mode;
}
targetWidth += align === "colon" ? beforeColon : afterColon;
for (let i = 0; i < length; i++) {
const property = properties[i];
const whitespace = getPropertyWhitespace(property);
if (whitespace) {
const width = widths[i];
if (align === "value") {
report(property, "key", whitespace.beforeColon, beforeColon, mode);
report(property, "value", whitespace.afterColon, targetWidth - width, mode);
} else {
report(property, "key", whitespace.beforeColon, targetWidth - width, mode);
report(property, "value", whitespace.afterColon, afterColon, mode);
}
}
}
}
function verifySpacing(node, lineOptions) {
if (_includesInstanceProperty(ignoredNodes).call(ignoredNodes, node.parent.type)) return;
const actual = getPropertyWhitespace(node);
if (actual) {
report(node, "key", actual.beforeColon, lineOptions.beforeColon, lineOptions.mode);
report(node, "value", actual.afterColon, lineOptions.afterColon, lineOptions.mode);
}
}
function verifyListSpacing(properties, lineOptions) {
const length = properties.length;
for (let i = 0; i < length; i++) verifySpacing(properties[i], lineOptions);
}
function verifyAlignment(properties) {
var _context4;
_forEachInstanceProperty(_context4 = createGroups(properties)).call(_context4, group => {
const properties2 = _filterInstanceProperty(group).call(group, isKeyValueProperty);
if (properties2.length > 0 && isSingleLineProperties(properties2)) verifyListSpacing(properties2, multiLineOptions);else verifyGroupAlignment(properties2);
});
}
function verifyImportAttributes(node) {
if (_includesInstanceProperty(ignoredNodes).call(ignoredNodes, node.type)) return;
if (!node.attributes) return;
if (!node.attributes.length) return;
if (isSingleLineImportAttributes(node, sourceCode)) verifyListSpacing(node.attributes, singleLineOptions);else verifyAlignment(node.attributes);
}
if (alignmentOptions) {
return {
ObjectExpression(node) {
var _context5;
if (_includesInstanceProperty(ignoredNodes).call(ignoredNodes, node.type)) return;
if (isSingleLine(node)) verifyListSpacing(_filterInstanceProperty(_context5 = node.properties).call(_context5, isKeyValueProperty), singleLineOptions);else verifyAlignment(node.properties);
},
ImportDeclaration(node) {
verifyImportAttributes(node);
},
ExportNamedDeclaration(node) {
verifyImportAttributes(node);
},
ExportAllDeclaration(node) {
verifyImportAttributes(node);
}
};
}
return {
Property(node) {
verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
},
ImportAttribute(node) {
const parent = node.parent;
verifySpacing(node, isSingleLineImportAttributes(parent, sourceCode) ? singleLineOptions : multiLineOptions);
}
};
}
});
const baseRule = /* @__PURE__ */utils.castRuleModule(_baseRule);
const baseSchema = _Array$isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
var keySpacing = utils.createRule({
name: "key-spacing",
package: "ts",
meta: {
type: "layout",
docs: {
description: "Enforce consistent spacing between property names and type annotations in types and interfaces"
},
fixable: "whitespace",
hasSuggestions: baseRule.meta.hasSuggestions,
schema: [baseSchema],
messages: baseRule.meta.messages
},
defaultOptions: [{}],
create(context, [_options]) {
const options = _options || {};
const ignoredNodes = options.ignoredNodes || [];
const sourceCode = context.sourceCode;
const baseRules = baseRule.create(context);
function adjustedColumn(position) {
var _context, _context2;
const line = position.line - 1;
return utils.getStringLength(_sliceInstanceProperty(_context = _atInstanceProperty(_context2 = sourceCode.lines).call(_context2, line)).call(_context, 0, position.column));
}
function getLastTokenBeforeColon(node) {
const colonToken = sourceCode.getTokenAfter(node, vendor.astUtilsExports.isColonToken);
return sourceCode.getTokenBefore(colonToken);
}
function isKeyTypeNode(node) {
return (node.type === vendor.distExports.AST_NODE_TYPES.TSPropertySignature || node.type === vendor.distExports.AST_NODE_TYPES.TSIndexSignature || node.type === vendor.distExports.AST_NODE_TYPES.PropertyDefinition) && !!node.typeAnnotation;
}
function isApplicable(node) {
return isKeyTypeNode(node) && node.typeAnnotation.loc.start.line === node.loc.end.line;
}
function getKeyText(node) {
var _context3;
if (node.type !== vendor.distExports.AST_NODE_TYPES.TSIndexSignature) return sourceCode.getText(node.key);
const code = sourceCode.getText(node);
return _sliceInstanceProperty(code).call(code, 0, sourceCode.getTokenAfter(_atInstanceProperty(_context3 = node.parameters).call(_context3, -1), vendor.astUtilsExports.isClosingBracketToken).range[1] - node.range[0]);
}
function getKeyLocEnd(node) {
var _context4;
return getLastTokenBeforeColon(node.type !== vendor.distExports.AST_NODE_TYPES.TSIndexSignature ? node.key : _atInstanceProperty(_context4 = node.parameters).call(_context4, -1)).loc.end;
}
function checkBeforeColon(node, expectedWhitespaceBeforeColon, mode) {
const {
typeAnnotation
} = node;
const colon = typeAnnotation.loc.start.column;
const keyEnd = getKeyLocEnd(node);
const difference = colon - keyEnd.column - expectedWhitespaceBeforeColon;
if (mode === "strict" ? difference : difference < 0) {
context.report({
node,
messageId: difference > 0 ? "extraKey" : "missingKey",
fix: fixer => {
var _context5;
if (difference > 0) {
return fixer.removeRange([typeAnnotation.range[0] - difference, typeAnnotation.range[0]]);
}
return fixer.insertTextBefore(typeAnnotation, _repeatInstanceProperty(_context5 = " ").call(_context5, -difference));
},
data: {
computed: "",
key: getKeyText(node)
}
});
}
}
function checkAfterColon(node, expectedWhitespaceAfterColon, mode) {
const {
typeAnnotation
} = node;
const colonToken = sourceCode.getFirstToken(typeAnnotation);
const typeStart = sourceCode.getTokenAfter(colonToken, {
includeComments: true
}).loc.start.column;
const difference = typeStart - colonToken.loc.start.column - 1 - expectedWhitespaceAfterColon;
if (mode === "strict" ? difference : difference < 0) {
context.report({
node,
messageId: difference > 0 ? "extraValue" : "missingValue",
fix: fixer => {
var _context6;
if (difference > 0) {
return fixer.removeRange([colonToken.range[1], colonToken.range[1] + difference]);
}
return fixer.insertTextAfter(colonToken, _repeatInstanceProperty(_context6 = " ").call(_context6, -difference));
},
data: {
computed: "",
key: getKeyText(node)
}
});
}
}
function continuesAlignGroup(lastMember, candidate) {
const groupEndLine = lastMember.loc.start.line;
const candidateValueStartLine = (isKeyTypeNode(candidate) ? candidate.typeAnnotation : candidate).loc.start.line;
if (candidateValueStartLine === groupEndLine) return false;
if (candidateValueStartLine - groupEndLine === 1) return true;
const leadingComments = sourceCode.getCommentsBefore(candidate);
if (leadingComments.length && leadingComments[0].loc.start.line - groupEndLine <= 1 && candidateValueStartLine - _atInstanceProperty(leadingComments).call(leadingComments, -1).loc.end.line <= 1) {
for (let i = 1; i < leadingComments.length; i++) {
if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
return false;
}
}
return true;
}
return false;
}
function checkAlignGroup(group) {
var _ref, _options$multiLine, _options$multiLine$al, _options$multiLine2, _ref2, _ref3, _ref4, _options$multiLine$al2;
let alignColumn = 0;
const align = (_ref = typeof options.align === "object" ? options.align.on : typeof ((_options$multiLine = options.multiLine) == null ? undefined : _options$multiLine.align) === "object" ? options.multiLine.align.on : (_options$multiLine$al = (_options$multiLine2 = options.multiLine) == null ? undefined : _options$multiLine2.align) != null ? _options$multiLine$al : options.align) != null ? _ref : "colon";
const beforeColon = (_ref2 = typeof options.align === "object" ? options.align.beforeColon : options.multiLine ? typeof options.multiLine.align === "object" ? options.multiLine.align.beforeColon : options.multiLine.beforeColon : options.beforeColon) != null ? _ref2 : false;
const expectedWhitespaceBeforeColon = beforeColon ? 1 : 0;
const afterColon = (_ref3 = typeof options.align === "object" ? options.align.afterColon : options.multiLine ? typeof options.multiLine.align === "object" ? options.multiLine.align.afterColon : options.multiLine.afterColon : options.afterColon) != null ? _ref3 : true;
const expectedWhitespaceAfterColon = afterColon ? 1 : 0;
const mode = (_ref4 = typeof options.align === "object" ? options.align.mode : options.multiLine ? typeof options.multiLine.align === "object" ? (_options$multiLine$al2 = options.multiLine.align.mode) != null ? _options$multiLine$al2 : options.multiLine.mode : options.multiLine.mode : options.mode) != null ? _ref4 : "strict";
for (const node of group) {
if (isKeyTypeNode(node)) {
const keyEnd = adjustedColumn(getKeyLocEnd(node));
alignColumn = Math.max(alignColumn, align === "colon" ? keyEnd + expectedWhitespaceBeforeColon : keyEnd + ":".length + expectedWhitespaceAfterColon + expectedWhitespaceBeforeColon);
}
}
for (const node of group) {
if (!isApplicable(node)) continue;
const {
typeAnnotation
} = node;
const toCheck = align === "colon" ? typeAnnotation : typeAnnotation.typeAnnotation;
const difference = adjustedColumn(toCheck.loc.start) - alignColumn;
if (difference) {
context.report({
node,
messageId: difference > 0 ? align === "colon" ? "extraKey" : "extraValue" : align === "colon" ? "missingKey" : "missingValue",
fix: fixer => {
var _context7;
if (difference > 0) {
return fixer.removeRange([toCheck.range[0] - difference, toCheck.range[0]]);
}
return fixer.insertTextBefore(toCheck, _repeatInstanceProperty(_context7 = " ").call(_context7, -difference));
},
data: {
computed: "",
key: getKeyText(node)
}
});
}
if (align === "colon") checkAfterColon(node, expectedWhitespaceAfterColon, mode);else checkBeforeColon(node, expectedWhitespaceBeforeColon, mode);
}
}
function checkIndividualNode(node, {
singleLine
}) {
var _ref5, _ref6, _ref7;
const beforeColon = (_ref5 = singleLine ? options.singleLine ? options.singleLine.beforeColon : options.beforeColon : options.multiLine ? options.multiLine.beforeColon : options.beforeColon) != null ? _ref5 : false;
const expectedWhitespaceBeforeColon = beforeColon ? 1 : 0;
const afterColon = (_ref6 = singleLine ? options.singleLine ? options.singleLine.afterColon : options.afterColon : options.multiLine ? options.multiLine.afterColon : options.afterColon) != null ? _ref6 : true;
const expectedWhitespaceAfterColon = afterColon ? 1 : 0;
const mode = (_ref7 = singleLine ? options.singleLine ? options.singleLine.mode : options.mode : options.multiLine ? options.multiLine.mode : options.mode) != null ? _ref7 : "strict";
if (isApplicable(node)) {
checkBeforeColon(node, expectedWhitespaceBeforeColon, mode);
checkAfterColon(node, expectedWhitespaceAfterColon, mode);
}
}
function validateBody(body) {
var _options$multiLine3;
if (_includesInstanceProperty(ignoredNodes).call(ignoredNodes, body.type)) return;
const isSingleLine = body.loc.start.line === body.loc.end.line;
const members = body.type === vendor.distExports.AST_NODE_TYPES.TSTypeLiteral ? body.members : body.body;
let alignGroups = [];
let unalignedElements = [];
if (options.align || (_options$multiLine3 = options.multiLine) != null && _options$multiLine3.align) {
let currentAlignGroup = [];
alignGroups.push(currentAlignGroup);
let prevNode;
for (const node of members) {
var _prevNode;
let prevAlignedNode = _atInstanceProperty(currentAlignGroup).call(currentAlignGroup, -1);
if (prevAlignedNode !== prevNode) prevAlignedNode = undefined;
if (prevAlignedNode && continuesAlignGroup(prevAlignedNode, node)) {
currentAlignGroup.push(node);
} else if (((_prevNode = prevNode) == null ? undefined : _prevNode.loc.start.line) === node.loc.start.line) {
if (prevAlignedNode) {
unalignedElements.push(prevAlignedNode);
currentAlignGroup.pop();
}
unalignedElements.push(node);
} else {
currentAlignGroup = [node];
alignGroups.push(currentAlignGroup);
}
prevNode = node;
}
unalignedElements = _concatInstanceProperty(unalignedElements).call(unalignedElements, ..._filterInstanceProperty(alignGroups).call(alignGroups, group => group.length === 1));
alignGroups = _filterInstanceProperty(alignGroups).call(alignGroups, group => group.length >= 2);
} else {
unalignedElements = members;
}
for (const group of alignGroups) checkAlignGroup(group);
for (const node of unalignedElements) checkIndividualNode(node, {
singleLine: isSingleLine
});
}
return {
...baseRules,
TSTypeLiteral: validateBody,
TSInterfaceBody: validateBody,
ClassBody: validateBody
};
}
});
module.exports = keySpacing;