250 lines
11 KiB
JavaScript
250 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
const require_runtime = require('../_virtual/_rolldown/runtime.js');
|
|
const require_index = require('../utils/index.js');
|
|
|
|
//#region lib/rules/valid-v-slot.js
|
|
/**
|
|
* @author Toru Nagashima
|
|
* See LICENSE file in root directory for full license.
|
|
*/
|
|
var require_valid_v_slot = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
|
|
const utils = require_index.default;
|
|
/**
|
|
* @typedef { { expr: VForExpression, variables: VVariable[] } } VSlotVForVariables
|
|
*/
|
|
/**
|
|
* Get all `v-slot` directives on a given element.
|
|
* @param {VElement} node The VElement node to check.
|
|
* @returns {VDirective[]} The array of `v-slot` directives.
|
|
*/
|
|
function getSlotDirectivesOnElement(node) {
|
|
return utils.getDirectives(node, "slot");
|
|
}
|
|
/**
|
|
* Get all `v-slot` directives on the children of a given element.
|
|
* @param {VElement} node The VElement node to check.
|
|
* @returns {VDirective[][]}
|
|
* The array of the group of `v-slot` directives.
|
|
* The group bundles `v-slot` directives of element sequence which is connected
|
|
* by `v-if`/`v-else-if`/`v-else`.
|
|
*/
|
|
function getSlotDirectivesOnChildren(node) {
|
|
/** @type {VDirective[][]} */
|
|
const groups = [];
|
|
for (const group of utils.iterateChildElementsChains(node)) {
|
|
const slotDirs = group.map((childElement) => childElement.name === "template" ? utils.getDirective(childElement, "slot") : null).filter(utils.isDef);
|
|
if (slotDirs.length > 0) groups.push(slotDirs);
|
|
}
|
|
return groups;
|
|
}
|
|
/**
|
|
* Get the normalized name of a given `v-slot` directive node with modifiers after `v-slot:` directive.
|
|
* @param {VDirective} node The `v-slot` directive node.
|
|
* @param {SourceCode} sourceCode The source code.
|
|
* @returns {string} The normalized name.
|
|
*/
|
|
function getNormalizedName(node, sourceCode) {
|
|
if (node.key.argument == null) return "default";
|
|
return node.key.modifiers.length === 0 ? sourceCode.getText(node.key.argument) : sourceCode.text.slice(node.key.argument.range[0], node.key.range[1]);
|
|
}
|
|
/**
|
|
* Get all `v-slot` directives which are distributed to the same slot as a given `v-slot` directive node.
|
|
* @param {VDirective[][]} vSlotGroups The result of `getAllNamedSlotElements()`.
|
|
* @param {VDirective} currentVSlot The current `v-slot` directive node.
|
|
* @param {VSlotVForVariables | null} currentVSlotVForVars The current `v-for` variables.
|
|
* @param {SourceCode} sourceCode The source code.
|
|
* @param {ParserServices.TokenStore} tokenStore The token store.
|
|
* @returns {VDirective[][]} The array of the group of `v-slot` directives.
|
|
*/
|
|
function filterSameSlot(vSlotGroups, currentVSlot, currentVSlotVForVars, sourceCode, tokenStore) {
|
|
const currentName = getNormalizedName(currentVSlot, sourceCode);
|
|
return vSlotGroups.map((vSlots) => vSlots.filter((vSlot) => {
|
|
if (getNormalizedName(vSlot, sourceCode) !== currentName) return false;
|
|
const vForExpr = getVSlotVForVariableIfUsingIterationVars(vSlot, utils.getDirective(vSlot.parent.parent, "for"));
|
|
if (!currentVSlotVForVars || !vForExpr) return !currentVSlotVForVars && !vForExpr;
|
|
if (!equalVSlotVForVariables(currentVSlotVForVars, vForExpr, tokenStore)) return false;
|
|
return true;
|
|
})).filter((slots) => slots.length > 0);
|
|
}
|
|
/**
|
|
* Determines whether the two given `v-slot` variables are considered to be equal.
|
|
* @param {VSlotVForVariables} a First element.
|
|
* @param {VSlotVForVariables} b Second element.
|
|
* @param {ParserServices.TokenStore} tokenStore The token store.
|
|
* @returns {boolean} `true` if the elements are considered to be equal.
|
|
*/
|
|
function equalVSlotVForVariables(a, b, tokenStore) {
|
|
if (a.variables.length !== b.variables.length) return false;
|
|
if (!equal(a.expr.right, b.expr.right)) return false;
|
|
const checkedVarNames = /* @__PURE__ */ new Set();
|
|
const len = Math.min(a.expr.left.length, b.expr.left.length);
|
|
for (let index = 0; index < len; index++) {
|
|
const aPtn = a.expr.left[index];
|
|
const bPtn = b.expr.left[index];
|
|
const aVar = a.variables.find((v) => aPtn.range[0] <= v.id.range[0] && v.id.range[1] <= aPtn.range[1]);
|
|
const bVar = b.variables.find((v) => bPtn.range[0] <= v.id.range[0] && v.id.range[1] <= bPtn.range[1]);
|
|
if (aVar && bVar) {
|
|
if (aVar.id.name !== bVar.id.name) return false;
|
|
if (!equal(aPtn, bPtn)) return false;
|
|
checkedVarNames.add(aVar.id.name);
|
|
} else if (aVar || bVar) return false;
|
|
}
|
|
return a.variables.every((v) => checkedVarNames.has(v.id.name) || b.variables.some((bv) => v.id.name === bv.id.name));
|
|
/**
|
|
* Determines whether the two given nodes are considered to be equal.
|
|
* @param {ASTNode} a First node.
|
|
* @param {ASTNode} b Second node.
|
|
* @returns {boolean} `true` if the nodes are considered to be equal.
|
|
*/
|
|
function equal(a, b) {
|
|
if (a.type !== b.type) return false;
|
|
return utils.equalTokens(a, b, tokenStore);
|
|
}
|
|
}
|
|
/**
|
|
* Gets the `v-for` directive and variable that provide the variables used by the given` v-slot` directive.
|
|
* @param {VDirective} vSlot The current `v-slot` directive node.
|
|
* @param {VDirective | null} [vFor] The current `v-for` directive node.
|
|
* @returns { VSlotVForVariables | null } The VSlotVForVariable.
|
|
*/
|
|
function getVSlotVForVariableIfUsingIterationVars(vSlot, vFor) {
|
|
const expr = vFor && vFor.value && vFor.value.expression;
|
|
const variables = expr && getUsingIterationVars(vSlot.key.argument, vSlot.parent.parent);
|
|
return expr && variables && variables.length > 0 ? {
|
|
expr,
|
|
variables
|
|
} : null;
|
|
}
|
|
/**
|
|
* Gets iterative variables if a given argument node is using iterative variables that the element defined.
|
|
* @param {VExpressionContainer|VIdentifier|null} argument The argument node to check.
|
|
* @param {VElement} element The element node which has the argument.
|
|
* @returns {VVariable[]} The argument node is using iteration variables.
|
|
*/
|
|
function getUsingIterationVars(argument, element) {
|
|
const vars = [];
|
|
if (argument && argument.type === "VExpressionContainer") {
|
|
for (const { variable } of argument.references) if (variable != null && variable.kind === "v-for" && variable.id.range[0] > element.startTag.range[0] && variable.id.range[1] < element.startTag.range[1]) vars.push(variable);
|
|
}
|
|
return vars;
|
|
}
|
|
/**
|
|
* Check whether a given argument node is using an scope variable that the directive defined.
|
|
* @param {VDirective} vSlot The `v-slot` directive to check.
|
|
* @returns {boolean} `true` if that argument node is using a scope variable the directive defined.
|
|
*/
|
|
function isUsingScopeVar(vSlot) {
|
|
const argument = vSlot.key.argument;
|
|
const value = vSlot.value;
|
|
if (argument && value && argument.type === "VExpressionContainer") {
|
|
for (const { variable } of argument.references) if (variable != null && variable.kind === "scope" && variable.id.range[0] > value.range[0] && variable.id.range[1] < value.range[1]) return true;
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* If `allowModifiers` option is set to `true`, check whether a given argument node has invalid modifiers like `v-slot.foo`.
|
|
* Otherwise, check whether a given argument node has at least one modifier.
|
|
* @param {VDirective} vSlot The `v-slot` directive to check.
|
|
* @param {boolean} allowModifiers `allowModifiers` option in context.
|
|
* @return {boolean} `true` if that argument node has invalid modifiers like `v-slot.foo`.
|
|
*/
|
|
function hasInvalidModifiers(vSlot, allowModifiers) {
|
|
return allowModifiers ? vSlot.key.argument == null && vSlot.key.modifiers.length > 0 : vSlot.key.modifiers.length > 0;
|
|
}
|
|
module.exports = {
|
|
meta: {
|
|
type: "problem",
|
|
docs: {
|
|
description: "enforce valid `v-slot` directives",
|
|
categories: ["vue3-essential", "vue2-essential"],
|
|
url: "https://eslint.vuejs.org/rules/valid-v-slot.html"
|
|
},
|
|
fixable: null,
|
|
schema: [{
|
|
type: "object",
|
|
properties: { allowModifiers: { type: "boolean" } },
|
|
additionalProperties: false
|
|
}],
|
|
messages: {
|
|
ownerMustBeCustomElement: "'v-slot' directive must be owned by a custom element, but '{{name}}' is not.",
|
|
namedSlotMustBeOnTemplate: "Named slots must use '<template>' on a custom element.",
|
|
defaultSlotMustBeOnTemplate: "Default slot must use '<template>' on a custom element when there are other named slots.",
|
|
disallowDuplicateSlotsOnElement: "An element cannot have multiple 'v-slot' directives.",
|
|
disallowDuplicateSlotsOnChildren: "An element cannot have multiple '<template>' elements which are distributed to the same slot.",
|
|
disallowArgumentUseSlotParams: "Dynamic argument of 'v-slot' directive cannot use that slot parameter.",
|
|
disallowAnyModifier: "'v-slot' directive doesn't support any modifier.",
|
|
requireAttributeValue: "'v-slot' directive on a custom element requires that attribute value."
|
|
}
|
|
},
|
|
create(context) {
|
|
const sourceCode = context.sourceCode;
|
|
const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore && sourceCode.parserServices.getTemplateBodyTokenStore();
|
|
const allowModifiers = (context.options[0] || {}).allowModifiers === true;
|
|
return utils.defineTemplateBodyVisitor(context, { "VAttribute[directive=true][key.name.name='slot']"(node) {
|
|
const isDefaultSlot = node.key.argument == null || node.key.argument.type === "VIdentifier" && node.key.argument.name === "default";
|
|
const element = node.parent.parent;
|
|
const parentElement = element.parent;
|
|
const ownerElement = element.name === "template" ? parentElement : element;
|
|
if (ownerElement.type === "VDocumentFragment") return;
|
|
const vSlotsOnElement = getSlotDirectivesOnElement(element);
|
|
const vSlotGroupsOnChildren = getSlotDirectivesOnChildren(ownerElement);
|
|
if (!utils.isCustomComponent(ownerElement)) context.report({
|
|
node,
|
|
messageId: "ownerMustBeCustomElement",
|
|
data: { name: ownerElement.rawName }
|
|
});
|
|
if (!isDefaultSlot && element.name !== "template") context.report({
|
|
node,
|
|
messageId: "namedSlotMustBeOnTemplate"
|
|
});
|
|
if (ownerElement === element && vSlotGroupsOnChildren.length > 0) context.report({
|
|
node,
|
|
messageId: "defaultSlotMustBeOnTemplate"
|
|
});
|
|
if (vSlotsOnElement.length >= 2 && vSlotsOnElement[0] !== node) context.report({
|
|
node,
|
|
messageId: "disallowDuplicateSlotsOnElement"
|
|
});
|
|
if (ownerElement === parentElement) {
|
|
const vFor = utils.getDirective(element, "for");
|
|
const vSlotVForVar = getVSlotVForVariableIfUsingIterationVars(node, vFor);
|
|
const vSlotGroupsOfSameSlot = filterSameSlot(vSlotGroupsOnChildren, node, vSlotVForVar, sourceCode, tokenStore);
|
|
if (vSlotGroupsOfSameSlot.length >= 2 && !vSlotGroupsOfSameSlot[0].includes(node)) context.report({
|
|
node,
|
|
messageId: "disallowDuplicateSlotsOnChildren"
|
|
});
|
|
if (vFor && !vSlotVForVar) context.report({
|
|
node,
|
|
messageId: "disallowDuplicateSlotsOnChildren"
|
|
});
|
|
}
|
|
if (isUsingScopeVar(node)) context.report({
|
|
node,
|
|
messageId: "disallowArgumentUseSlotParams"
|
|
});
|
|
const lastModifier = node.key.modifiers.at(-1);
|
|
if (hasInvalidModifiers(node, allowModifiers) && lastModifier) context.report({
|
|
node,
|
|
loc: {
|
|
start: node.key.modifiers[0].loc.start,
|
|
end: lastModifier.loc.end
|
|
},
|
|
messageId: "disallowAnyModifier"
|
|
});
|
|
if (ownerElement === element && isDefaultSlot && (!node.value || utils.isEmptyValueDirective(node, context) || utils.isEmptyExpressionValueDirective(node, context))) context.report({
|
|
node,
|
|
messageId: "requireAttributeValue"
|
|
});
|
|
} });
|
|
}
|
|
};
|
|
}));
|
|
|
|
//#endregion
|
|
Object.defineProperty(exports, 'default', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return require_valid_v_slot();
|
|
}
|
|
}); |