/**
* The actual check for are there (un)necessary whitespaces
*/
function checkSpaces(_ref) {
var string = _ref.string,
globalIndex = _ref.globalIndex,
startIndex = _ref.startIndex,
endIndex = _ref.endIndex,
node = _ref.node,
result = _ref.result;
var symbol = string.substring(startIndex, endIndex + 1);
var beforeOk = string[startIndex - 1] === " " && !(0, _utils.isWhitespace)(string[startIndex - 2]) || newlineBefore(string, startIndex - 1);
if (!beforeOk) {
_stylelint.utils.report({
ruleName: ruleName,
result: result,
node: node,
message: messages.expectedBefore(symbol),
index: startIndex + globalIndex
});
}
var afterOk = string[endIndex + 1] === " " && !(0, _utils.isWhitespace)(string[endIndex + 2]) || string[endIndex + 1] === "\n" || string.substr(endIndex + 1, 2) === "\r\n";
if (!afterOk) {
_stylelint.utils.report({
ruleName: ruleName,
result: result,
node: node,
message: messages.expectedAfter(symbol),
index: endIndex + globalIndex
});
}
}
warningCandidates[namespace].forEach(candidate => {
if (candidate.nested === true) {
if (exceptIfOnlyOfNs) {
// If there is only one prop inside a nested prop - warn (reverse "always")
if (
candidate.nested === true &&
candidate.node.nodes.length === 1
) {
utils.report({
message: messages.rejected(namespace),
node: candidate.node,
result,
ruleName
});
}
}
} else {
// Don't warn on non-nested namespaced props if there are
// less than 2 of them, and except: "only-of-namespace" is set
if (exceptIfOnlyOfNs && !moreThanOneProp) {
return;
}
utils.report({
message: messages.expected(candidate.node.prop),
node: candidate.node,
result,
ruleName
});
}
});
args.forEach(arg => {
switch (expectation) {
case "never": {
if (!arg.key) {
return;
}
utils.report({
message: messages.rejected,
node: decl,
result,
ruleName
});
break;
}
case "always": {
if (arg.key && isScssVarRegExp.test(arg.key)) {
return;
}
utils.report({
message: messages.expected,
node: decl,
result,
ruleName
});
break;
}
}
});
/**
* The checker function: whether there is a newline before THAT operator.
*/
function checkNewlineBefore(_ref) {
var string = _ref.string,
globalIndex = _ref.globalIndex,
startIndex = _ref.startIndex,
endIndex = _ref.endIndex,
node = _ref.node,
result = _ref.result;
var symbol = string.substring(startIndex, endIndex + 1);
var newLineBefore = false;
var index = endIndex + 1;
while (index && (0, _utils.isWhitespace)(string[index])) {
if (string[index] === "\n") {
newLineBefore = true;
break;
}
index++;
}
if (newLineBefore) {
_stylelint.utils.report({
ruleName: ruleName,
result: result,
node: node,
message: messages.rejected(symbol),
index: endIndex + globalIndex
});
}
}
root.walkDecls(decl => {
// not variable
if (decl.prop[0] !== "$") {
return;
}
// "ignore" options
if (
optionsHaveIgnored(secondaryOptions, "local") &&
decl.parent.type !== "root"
) {
return;
}
if (decl.value.toLowerCase().indexOf("!default") !== -1) {
return;
}
utils.report({
message: messages.expected(decl.prop),
node: decl,
result,
ruleName
});
});
return function(root, result) {
var validOptions = stylelint.utils.validateOptions({
ruleName: ruleName,
result: result,
actual: options,
});
if (!validOptions) {
return;
}
root.walkDecls(function(statement) {
if (checkProp(statement.prop, statement.value, options) && checkPresentVariable(statement.value) && !checkValue(statement.value)) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: statement,
message: messages.expectedPresent(statement.prop, checkPresentVariable(statement.value))
});
} else if (checkProp(statement.prop, statement.value, options) && !checkValue(statement.value)) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: statement,
message: messages.expected(statement.prop)
});
}
});
};
function checkPathForUnderscore(path, decl) {
// Stripping trailing quotes and whitespaces, if any
var pathStripped = path.replace(/^\s*?("|')\s*/, "").replace(/\s*("|')\s*?$/, "");
var extension = _path2.default.extname(pathStripped).slice(1);
// If the extension is not empty
if (!extension) {
return;
}
// Skipping importing CSS: url(), ".css", URI with a protocol, media
if (pathStripped.slice(0, 4) === "url(" || pathStripped.slice(-4) === ".css" || pathStripped.search("//") !== -1 || pathStripped.search(/(?:\s|[,)"'])\w+$/) !== -1) {
return;
}
if (options && options.ignoreExtensions) {
// Return if...
if (options.ignoreExtensions.some(function (ignoredExt) {
// the extension matches one of the ignored strings or Regexps
return (0, _lodash.isString)(ignoredExt) && ignoredExt === extension || (0, _lodash.isRegExp)(ignoredExt) && extension.search(ignoredExt) !== -1;
})) {
return;
}
}
_stylelint.utils.report({
message: messages.expected,
node: decl,
result: result,
ruleName: ruleName
});
}
function checkPathForUnderscore(path, decl) {
// Stripping trailing quotes and whitespaces, if any
const pathStripped = path.replace(/^\s*?("|')\s*/, "").replace(/\s*("|')\s*?$/, "")
const extension = nodeJsPath.extname(pathStripped).slice(1)
// Save this separately to be able to pass the original string to report()
const extensionNormalized = extension.toLowerCase()
// If the extension is empty
if (!extension) { return }
// Skipping importing CSS: url(), ".css", URI with a protocol, media
if (pathStripped.slice(0, 4) === "url(" ||
pathStripped.slice(-4) === ".css" ||
pathStripped.search("//") !== -1 ||
pathStripped.search(/(?:\s|[,)"'])\w+$/) !== -1
) {
return
}
if (whitelist.some(ext => {
return isString(ext) && extensionNormalized === ext ||
isRegExp(ext) && extensionNormalized.search(ext) !== -1
})) { return }
utils.report({
message: messages.rejected(extension),
node: decl,
word: extension,
result,
ruleName,
})
}
return function (root, result) {
var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
actual: expectation,
possible: ["never"]
});
if (!validOptions) {
return;
}
root.walkAtRules(function (atrule) {
if (atrule.name !== "else") {
return;
}
// Don't need to ignore "the first rule in a stylesheet", etc, cases
// because @else should always go after @if
if (!(0, _utils.hasEmptyLine)(atrule.raws.before)) {
return;
}
_stylelint.utils.report({
message: messages.rejected,
node: atrule,
result: result,
ruleName: ruleName
});
});
};
root.walkDecls(decl => {
const prop = decl.prop;
if (!isStandardSyntaxProperty(prop)) {
return;
}
if (!isStandardSyntaxDeclaration(decl)) {
return;
}
if (isCustomProperty(prop)) {
return;
}
if (isExportBlock(decl.parent)) {
return;
}
if (optionsMatches(options, "ignoreProperties", prop)) {
return;
}
if (props.indexOf(prop.toLowerCase()) !== -1) {
return;
}
utils.report({
message: messages.rejected(prop),
node: decl,
result,
ruleName
});
});
cssRoot.walkDecls('box-shadow', ( decl ) => {
const list = [];
valueParser(decl.value).walk(( node ) => {
if ( node.type === 'function' ) {
return false;
}
if ( node.value === 'inset' || node.value === ',' ) {
list.push(node.value);
}
});
const inputOrder = list.map(( item ) => {
if ( item === ',' ) {
return 'normal';
}
return item;
});
const correctOrder = [].concat(inputOrder).sort();
if ( !_.isEqual(inputOrder, correctOrder) ) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: decl,
message: messages.expected
});
}
});
root.walkDecls(decl => {
const { prop } = decl;
if (prop[0] !== "$") {
return;
}
// If local or global variables need to be ignored
if (
(optionsHaveIgnored(options, "global") &&
decl.parent.type === "root") ||
(optionsHaveIgnored(options, "local") && decl.parent.type !== "root")
) {
return;
}
if (regexpPattern.test(prop.slice(1))) {
return;
}
utils.report({
message: messages.expected,
node: decl,
result,
ruleName
});
});
resolvedNestedSelector(selector, rule).forEach((resolvedSelector) => {
let classNames = [];
try {
// Remove ampersand from inner sass mixins and parse the class names
classNames = extractCssClasses(resolvedSelector.replace(/&\s*/ig, ''));
} catch (e) {
stylelint.utils.report({
ruleName,
result,
node: rule,
message: e.message,
});
}
classNames.forEach((className) => {
if (classNameErrorCache[className] === undefined) {
classNameErrorCache[className] = getClassNameErrors(className, namespaces, rule);
}
if (classNameErrorCache[className]) {
stylelint.utils.report({
ruleName,
result,
node: rule,
message: messages.expected(className, classNameErrorCache[className]),
});
}
});
});
return function (root, result) {
var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
actual: pattern,
possible: [_lodash.isRegExp, _lodash.isString]
});
if (!validOptions) {
return;
}
var regexpPattern = (0, _lodash.isString)(pattern) ? new RegExp(pattern) : pattern;
root.walkAtRules(function (decl) {
if (decl.name !== "function") {
return;
}
// Stripping the function of its arguments
var funcName = decl.params.replace(/(\s*?)\((?:\s|\S)*\)/g, "");
if (regexpPattern.test(funcName)) {
return;
}
_stylelint.utils.report({
message: messages.expected,
node: decl,
result: result,
ruleName: ruleName
});
});
};
(root, result) => {
const validOptions = stylelint.utils.validateOptions(result, ruleName, { actual });
const checkForPaddingAuto = (decl) => {
const property = decl.prop;
const value = decl.value;
if (
// Check for value 'auto'
value.indexOf('auto') > -1 &&
// Check if prop is a padding prop
(property === 'padding' ||
property === 'padding-top' ||
property === 'padding-right' ||
property === 'padding-bottom' ||
property === 'padding-left')) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: decl,
message: messages.rejected
});
}
};
if (!validOptions) {
return;
}
root.walkDecls(checkForPaddingAuto);
}
root.walkAtRules(rule => {
if (needsPrefix.atRule(rule.name)) {
stylelint.utils.report({
result,
ruleName,
message: messages.atRule(rule.name),
node: rule
});
} else if (needsPrefix.mediaFeature(rule.params)) {
stylelint.utils.report({
result,
ruleName,
message: messages.mediaFeature(rule.name),
node: rule
});
}
});
root.walkDecls(function(statement) {
if (checkProp(statement.prop, statement.value, options) && checkPresentVariable(statement.value) && !checkValue(statement.value)) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: statement,
message: messages.expectedPresent(statement.prop, checkPresentVariable(statement.value))
});
} else if (checkProp(statement.prop, statement.value, options) && !checkValue(statement.value)) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
node: statement,
message: messages.expected(statement.prop)
});
}
});
function complain(node, message, index) {
_stylelint.utils.report({
result: result,
ruleName: ruleName,
node: node,
message: message,
index: index
});
}
root.walkDecls(decl => {
if (needsPrefix.property(decl.prop)) {
stylelint.utils.report({
result,
ruleName,
message: messages.property(decl.prop),
node: decl,
index: (decl.raws.before || '').length
});
} else if (needsPrefix.value(decl.prop, decl.value)) {
stylelint.utils.report({
result,
ruleName,
message: messages.value(decl.prop, decl.value),
node: decl,
index: (decl.raws.before || '').length
});
}
});
doiuseResult.warnings().forEach(function reportWarning(doiuseWarning) {
stylelint.utils.report({
ruleName: ruleName,
result: result,
message: messages.rejected(cleanWarningText(doiuseWarning.text)),
node: doiuseWarning.node,
line: doiuseWarning.line,
column: doiuseWarning.column
})
})
return function(root, result) {
const validOptions = utils.validateOptions(
result,
ruleName,
{
actual
},
{
actual: options,
possible: {
ignoreProperties: [isString]
},
optional: true
}
);
if (!validOptions) {
return;
}
root.walkDecls(decl => {
const prop = decl.prop;
if (!isStandardSyntaxProperty(prop)) {
return;
}
if (!isStandardSyntaxDeclaration(decl)) {
return;
}
if (isCustomProperty(prop)) {
return;
}
if (isExportBlock(decl.parent)) {
return;
}
if (optionsMatches(options, "ignoreProperties", prop)) {
return;
}
if (props.indexOf(prop.toLowerCase()) !== -1) {
return;
}
utils.report({
message: messages.rejected(prop),
node: decl,
result,
ruleName
});
});
};
selectorTree.walkPseudos(pseudoNode => {
if (needsPrefix.selector(pseudoNode.value)) {
stylelint.utils.report({
result,
ruleName,
message: messages.selector(pseudoNode.value),
node: rule,
index: (rule.raws.before || '').length + pseudoNode.sourceIndex,
});
}
});
function report(node, value) {
const { name, prop, type } = node
const nodeName = isAtRule(type) ? "@" + name : prop
utils.report({
ruleName,
result,
node,
message: messages.rejected(nodeName, value),
})
}
root.walkRules(rule => {
if (rule.selector.toLowerCase().indexOf(':root') === -1 || rule.selector.toLowerCase().trim() === ':root') {
return;
}
stylelint.utils.report({
message: messages.rejected,
node: rule,
result,
ruleName,
});
});
stylehacksResult.warnings().forEach((stylehacksWarning) => {
const message = messages.rejected(stylehacksWarning.identifier, stylehacksWarning.hack);
stylelint.utils.report({
ruleName: ruleName,
result: postcssResult,
message: message,
node: stylehacksWarning.node,
line: stylehacksWarning.line,
column: stylehacksWarning.column
});
});
root.walkAtRules("include", mixinCall => {
// If is is "No parens in argumentless calls"
if (value === "never" && mixinCall.params.search(/\(\s*?\)\s*?$/) === -1) { return }
// If is is "Always use parens"
if (value === "always" && mixinCall.params.search(/\(/) !== -1) { return }
utils.report({
message: messages.expected,
node: mixinCall,
result,
ruleName,
})
})
root.walkAtRules("extend", atrule => {
const isPlaceholder = atrule.params.trim()[0] === "%"
const isInterpolation = (/^#{.+}/).test(atrule.params.trim())
if (!isPlaceholder && !isInterpolation) {
utils.report({
ruleName,
result,
node: atrule,
message: messages.rejected,
})
}
})
classNames.forEach((className) => {
if (classNameErrorCache[className] === undefined) {
classNameErrorCache[className] = getClassNameErrors(className, namespaces, rule);
}
if (classNameErrorCache[className]) {
stylelint.utils.report({
ruleName,
result,
node: rule,
message: messages.expected(className, classNameErrorCache[className]),
});
}
});
blacklist.forEach(ext => {
if (isString(ext) && extensionNormalized === ext ||
isRegExp(ext) && extensionNormalized.search(ext) !== -1
) {
utils.report({
message: messages.rejected(extension),
node: decl,
word: extension,
result,
ruleName,
})
}
})
return function (root, result) {
var validOptions = _stylelint.utils.validateOptions(result, ruleName, {
actual: expectation
});
if (!validOptions) {
return;
}
calculationOperatorSpaceChecker({
root: root,
result: result,
checker: checkSpaces
});
};