237 lines
9.5 KiB
JavaScript
237 lines
9.5 KiB
JavaScript
'use strict';
|
|
|
|
const require_runtime = require('../_virtual/_rolldown/runtime.js');
|
|
const require_index = require('../utils/index.js');
|
|
|
|
//#region lib/rules/padding-lines-in-component-definition.js
|
|
/**
|
|
* @author ItMaga <https://github.com/ItMaga>
|
|
* See LICENSE file in root directory for full license.
|
|
*/
|
|
var require_padding_lines_in_component_definition = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
|
|
/**
|
|
* @typedef {import('../utils').ComponentProp} ComponentProp
|
|
* @typedef {import('../utils').ComponentEmit} ComponentEmit
|
|
* @typedef {import('../utils').GroupName} GroupName
|
|
*/
|
|
const utils = require_index.default;
|
|
const { isCommentToken } = require("@eslint-community/eslint-utils");
|
|
const AvailablePaddingOptions = {
|
|
Never: "never",
|
|
Always: "always",
|
|
Ignore: "ignore"
|
|
};
|
|
const OptionKeys = {
|
|
BetweenOptions: "betweenOptions",
|
|
WithinOption: "withinOption",
|
|
BetweenItems: "betweenItems",
|
|
WithinEach: "withinEach",
|
|
GroupSingleLineProperties: "groupSingleLineProperties"
|
|
};
|
|
/**
|
|
* @param {Token} node
|
|
*/
|
|
function isComma(node) {
|
|
return node.type === "Punctuator" && node.value === ",";
|
|
}
|
|
/**
|
|
* @typedef {Exclude<ComponentProp | ComponentEmit, {type:'infer-type'}> & { node: {type: 'Property' | 'SpreadElement'} }} ValidComponentPropOrEmit
|
|
*/
|
|
/**
|
|
* @template {ComponentProp | ComponentEmit} T
|
|
* @param {T} propOrEmit
|
|
* @returns {propOrEmit is ValidComponentPropOrEmit & T}
|
|
*/
|
|
function isValidProperties(propOrEmit) {
|
|
return Boolean(propOrEmit.type !== "infer-type" && propOrEmit.node && ["Property", "SpreadElement"].includes(propOrEmit.node.type));
|
|
}
|
|
/**
|
|
* Split the source code into multiple lines based on the line delimiters.
|
|
* @param {string} text Source code as a string.
|
|
* @returns {string[]} Array of source code lines.
|
|
*/
|
|
function splitLines(text) {
|
|
return text.split(/\r\n|[\r\n\u2028\u2029]/gu);
|
|
}
|
|
/**
|
|
* @param {any} initialOption
|
|
* @param {string} optionKey
|
|
* @private
|
|
* */
|
|
function parseOption(initialOption, optionKey) {
|
|
return typeof initialOption === "string" ? initialOption : initialOption[optionKey];
|
|
}
|
|
/**
|
|
* @param {any} initialOption
|
|
* @param {string} optionKey
|
|
* @private
|
|
* */
|
|
function parseBooleanOption(initialOption, optionKey) {
|
|
if (typeof initialOption === "string") {
|
|
if (initialOption === AvailablePaddingOptions.Always) return true;
|
|
if (initialOption === AvailablePaddingOptions.Never) return false;
|
|
}
|
|
return initialOption[optionKey];
|
|
}
|
|
/**
|
|
* @param {(Property | SpreadElement)} currentProperty
|
|
* @param {(Property | SpreadElement)} nextProperty
|
|
* @param {boolean} option
|
|
* @returns {boolean}
|
|
* @private
|
|
* */
|
|
function needGroupSingleLineProperties(currentProperty, nextProperty, option) {
|
|
const isSingleCurrentProperty = currentProperty.loc.start.line === currentProperty.loc.end.line;
|
|
const isSingleNextProperty = nextProperty.loc.start.line === nextProperty.loc.end.line;
|
|
return isSingleCurrentProperty && isSingleNextProperty && option;
|
|
}
|
|
module.exports = {
|
|
meta: {
|
|
type: "layout",
|
|
docs: {
|
|
description: "require or disallow padding lines in component definition",
|
|
categories: void 0,
|
|
url: "https://eslint.vuejs.org/rules/padding-lines-in-component-definition.html"
|
|
},
|
|
fixable: "whitespace",
|
|
schema: [{ oneOf: [{ enum: [AvailablePaddingOptions.Always, AvailablePaddingOptions.Never] }, {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
[OptionKeys.BetweenOptions]: { enum: Object.values(AvailablePaddingOptions) },
|
|
[OptionKeys.WithinOption]: { oneOf: [{ enum: Object.values(AvailablePaddingOptions) }, {
|
|
type: "object",
|
|
patternProperties: { "^[a-zA-Z]*$": { oneOf: [{ enum: Object.values(AvailablePaddingOptions) }, {
|
|
type: "object",
|
|
properties: {
|
|
[OptionKeys.BetweenItems]: { enum: Object.values(AvailablePaddingOptions) },
|
|
[OptionKeys.WithinEach]: { enum: Object.values(AvailablePaddingOptions) }
|
|
},
|
|
additionalProperties: false
|
|
}] } },
|
|
minProperties: 1,
|
|
additionalProperties: false
|
|
}] },
|
|
[OptionKeys.GroupSingleLineProperties]: { type: "boolean" }
|
|
}
|
|
}] }],
|
|
messages: {
|
|
never: "Unexpected blank line before this definition.",
|
|
always: "Expected blank line before this definition.",
|
|
groupSingleLineProperties: "Unexpected blank line between single line properties."
|
|
}
|
|
},
|
|
create(context) {
|
|
const options = context.options[0] || AvailablePaddingOptions.Always;
|
|
const sourceCode = context.sourceCode;
|
|
/**
|
|
* @param {(Property | SpreadElement)} currentProperty
|
|
* @param {(Property | SpreadElement | Token)} nextProperty
|
|
* @param {RuleFixer} fixer
|
|
* */
|
|
function replaceLines(currentProperty, nextProperty, fixer) {
|
|
const commaToken = sourceCode.getTokenAfter(currentProperty, isComma);
|
|
const start = commaToken ? commaToken.range[1] : currentProperty.range[1];
|
|
const end = nextProperty.range[0];
|
|
const newText = `\n${splitLines(sourceCode.text.slice(start, end)).pop()}`;
|
|
return fixer.replaceTextRange([start, end], newText);
|
|
}
|
|
/**
|
|
* @param {(Property | SpreadElement)} currentProperty
|
|
* @param {(Property | SpreadElement | Token)} nextProperty
|
|
* @param {RuleFixer} fixer
|
|
* @param {number} betweenLinesRange
|
|
* */
|
|
function insertLines(currentProperty, nextProperty, fixer, betweenLinesRange) {
|
|
const commaToken = sourceCode.getTokenAfter(currentProperty, isComma);
|
|
const lineBeforeNextProperty = sourceCode.lines[nextProperty.loc.start.line - 1];
|
|
const lastSpaces = /^\s*/.exec(lineBeforeNextProperty)[0];
|
|
const newText = betweenLinesRange === 0 ? `\n\n${lastSpaces}` : "\n";
|
|
return fixer.insertTextAfter(commaToken || currentProperty, newText);
|
|
}
|
|
/**
|
|
* @param {(Property | SpreadElement)[]} properties
|
|
* @param {any} option
|
|
* @param {any} nextOption
|
|
* */
|
|
function verify(properties, option, nextOption) {
|
|
const groupSingleLineProperties = parseBooleanOption(options, OptionKeys.GroupSingleLineProperties);
|
|
for (const [i, currentProperty] of properties.entries()) {
|
|
const nextProperty = properties[i + 1];
|
|
if (nextProperty && option !== AvailablePaddingOptions.Ignore) {
|
|
const tokenBeforeNext = sourceCode.getTokenBefore(nextProperty, { includeComments: true });
|
|
const reportNode = isCommentToken(tokenBeforeNext) ? tokenBeforeNext : nextProperty;
|
|
const betweenLinesRange = reportNode.loc.start.line - currentProperty.loc.end.line;
|
|
if (needGroupSingleLineProperties(currentProperty, nextProperty, groupSingleLineProperties)) {
|
|
if (betweenLinesRange > 1) context.report({
|
|
node: reportNode,
|
|
messageId: "groupSingleLineProperties",
|
|
loc: reportNode.loc,
|
|
fix(fixer) {
|
|
return replaceLines(currentProperty, reportNode, fixer);
|
|
}
|
|
});
|
|
continue;
|
|
}
|
|
if (betweenLinesRange <= 1 && option === AvailablePaddingOptions.Always) context.report({
|
|
node: reportNode,
|
|
messageId: "always",
|
|
loc: reportNode.loc,
|
|
fix(fixer) {
|
|
return insertLines(currentProperty, reportNode, fixer, betweenLinesRange);
|
|
}
|
|
});
|
|
else if (betweenLinesRange > 1 && option === AvailablePaddingOptions.Never) context.report({
|
|
node: reportNode,
|
|
messageId: "never",
|
|
loc: reportNode.loc,
|
|
fix(fixer) {
|
|
return replaceLines(currentProperty, reportNode, fixer);
|
|
}
|
|
});
|
|
}
|
|
if (!nextOption) return;
|
|
const name = currentProperty.type === "Property" && utils.getStaticPropertyName(currentProperty);
|
|
if (!name) continue;
|
|
const propertyOption = parseOption(nextOption, name);
|
|
if (!propertyOption) continue;
|
|
const nestedProperties = currentProperty.type === "Property" && currentProperty.value.type === "ObjectExpression" && currentProperty.value.properties;
|
|
if (!nestedProperties) continue;
|
|
verify(nestedProperties, parseOption(propertyOption, OptionKeys.BetweenItems), parseOption(propertyOption, OptionKeys.WithinEach));
|
|
}
|
|
}
|
|
return utils.compositingVisitors(utils.defineVueVisitor(context, { onVueObjectEnter(node) {
|
|
verify(node.properties, parseOption(options, OptionKeys.BetweenOptions), parseOption(options, OptionKeys.WithinOption));
|
|
} }), utils.defineScriptSetupVisitor(context, {
|
|
onDefinePropsEnter(_, props) {
|
|
const propNodes = props.filter(isValidProperties).map((prop) => prop.node);
|
|
const withinOption = parseOption(options, OptionKeys.WithinOption);
|
|
const propsOption = withinOption && parseOption(withinOption, "props");
|
|
if (!propsOption) return;
|
|
verify(propNodes, parseOption(propsOption, OptionKeys.BetweenItems), parseOption(propsOption, OptionKeys.WithinEach));
|
|
},
|
|
onDefineEmitsEnter(_, emits) {
|
|
const emitNodes = emits.filter(isValidProperties).map((emit) => emit.node);
|
|
const withinOption = parseOption(options, OptionKeys.WithinOption);
|
|
const emitsOption = withinOption && parseOption(withinOption, "emits");
|
|
if (!emitsOption) return;
|
|
verify(emitNodes, parseOption(emitsOption, OptionKeys.BetweenItems), parseOption(emitsOption, OptionKeys.WithinEach));
|
|
},
|
|
onDefineOptionsEnter(node) {
|
|
if (node.arguments.length === 0) return;
|
|
const define = node.arguments[0];
|
|
if (define.type !== "ObjectExpression") return;
|
|
verify(define.properties, parseOption(options, OptionKeys.BetweenOptions), parseOption(options, OptionKeys.WithinOption));
|
|
}
|
|
}));
|
|
}
|
|
};
|
|
}));
|
|
|
|
//#endregion
|
|
Object.defineProperty(exports, 'default', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return require_padding_lines_in_component_definition();
|
|
}
|
|
}); |