stylelint-order 3.1.1 → 4.0.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## 4.0.0
+
+* Breaking change: Dropped Node.js 8 support. Node.js 10 or greater is now required.
+* Breaking change: Always remove empty line before the first property if this property has any `emptyLineBefore*` option targeting it in `properties-order`. Even if option set to `always` empty line before the first property will be removed.
+* Fixed false positives for `emptyLineBeforeUnspecified`.
+
 ## 3.1.1
 
 * Added `stylelint@11` as a peer dependency.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-order",
-  "version": "3.1.1",
+  "version": "4.0.0",
   "description": "A collection of order related linting rules for stylelint.",
   "keywords": [
     "stylelint-plugin",
@@ -16,9 +16,6 @@
     "url": "https://github.com/hudochenkov/stylelint-order/issues"
   },
   "homepage": "https://github.com/hudochenkov/stylelint-order",
-  "engines": {
-    "node": ">=8.7.0"
-  },
   "files": [
     "rules",
     "utils",
@@ -29,21 +26,21 @@
   "main": "index.js",
   "dependencies": {
     "lodash": "^4.17.15",
-    "postcss": "^7.0.17",
+    "postcss": "^7.0.26",
     "postcss-sorting": "^5.0.1"
   },
   "peerDependencies": {
-    "stylelint": ">=10.0.1"
+    "stylelint": "^10.0.1 || ^11.0.0 || ^12.0.0 || ^13.0.0"
   },
   "devDependencies": {
-    "eslint": "^6.2.2",
+    "eslint": "^6.8.0",
     "eslint-config-hudochenkov": "^3.0.1",
-    "eslint-config-prettier": "^6.1.0",
-    "husky": "^3.0.4",
+    "eslint-config-prettier": "^6.9.0",
+    "husky": "^3.1.0",
     "jest": "^24.9.0",
-    "lint-staged": "^9.2.5",
-    "prettier": "~1.18.2",
-    "stylelint": "^11.0.0"
+    "lint-staged": "^9.5.0",
+    "prettier": "~1.19.1",
+    "stylelint": "^12.0.1"
   },
   "scripts": {
     "pretest": "eslint .",

package/rules/order/checkNode.js

@@ -1,10 +1,9 @@
 const stylelint = require('stylelint');
-const _ = require('lodash');
 const checkOrder = require('./checkOrder');
 const getOrderData = require('./getOrderData');
 
 module.exports = function checkNode(node, sharedInfo) {
-	const allNodesData = [];
+	let allNodesData = [];
 
 	node.each(function processEveryNode(child) {
 		// Skip comments
@@ -13,27 +12,24 @@ module.exports = function checkNode(node, sharedInfo) {
 		}
 
 		// Receive node description and expectedPosition
-		const nodeOrderData = getOrderData(sharedInfo.expectedOrder, child);
+		let nodeOrderData = getOrderData(sharedInfo.orderInfo, child);
 
-		const nodeData = {
-			description: nodeOrderData.description,
+		let nodeData = {
 			node: child,
+			description: nodeOrderData.description,
+			expectedPosition: nodeOrderData.expectedPosition,
 		};
 
-		if (nodeOrderData.expectedPosition) {
-			nodeData.expectedPosition = nodeOrderData.expectedPosition;
-		}
-
-		const previousNodeData = _.last(allNodesData);
-
 		allNodesData.push(nodeData);
 
+		let previousNodeData = allNodesData[allNodesData.length - 2];
+
 		// Skip first node
 		if (!previousNodeData) {
 			return;
 		}
 
-		const isCorrectOrder = checkOrder(previousNodeData, nodeData, allNodesData, sharedInfo);
+		let isCorrectOrder = checkOrder(previousNodeData, nodeData, allNodesData, sharedInfo);
 
 		if (isCorrectOrder) {
 			return;

package/rules/order/checkOrder.js

@@ -1,19 +1,19 @@
-const stylelint = require('stylelint');
-const _ = require('lodash');
+let stylelint = require('stylelint');
+let _ = require('lodash');
 
 module.exports = function checkOrder(firstNodeData, secondNodeData, allNodesData, sharedInfo) {
-	const firstNodeIsUnspecified = !firstNodeData.expectedPosition;
-	const secondNodeIsUnspecified = !secondNodeData.expectedPosition;
+	let firstNodeIsSpecified = Boolean(firstNodeData.expectedPosition);
+	let secondNodeIsSpecified = Boolean(secondNodeData.expectedPosition);
 
 	// If both nodes have their position
-	if (!firstNodeIsUnspecified && !secondNodeIsUnspecified) {
+	if (firstNodeIsSpecified && secondNodeIsSpecified) {
 		return firstNodeData.expectedPosition <= secondNodeData.expectedPosition;
 	}
 
-	if (firstNodeIsUnspecified && !secondNodeIsUnspecified) {
-		// If first node is unspecified, look for a specified node before it to
-		// compare to the current node
-		const priorSpecifiedNodeData = _.findLast(allNodesData.slice(0, -1), d =>
+	if (!firstNodeIsSpecified && secondNodeIsSpecified) {
+		// If first node is unspecified, look for a specified node before it
+		// to compare to the current node
+		let priorSpecifiedNodeData = _.findLast(allNodesData.slice(0, -1), d =>
 			Boolean(d.expectedPosition)
 		);
 
@@ -43,29 +43,29 @@ module.exports = function checkOrder(firstNodeData, secondNodeData, allNodesData
 		}
 	}
 
-	if (firstNodeIsUnspecified && secondNodeIsUnspecified) {
+	if (!firstNodeIsSpecified && !secondNodeIsSpecified) {
 		return true;
 	}
 
-	const { unspecified } = sharedInfo;
+	let { unspecified } = sharedInfo;
 
-	if (unspecified === 'ignore' && (firstNodeIsUnspecified || secondNodeIsUnspecified)) {
+	if (unspecified === 'ignore' && (!firstNodeIsSpecified || !secondNodeIsSpecified)) {
 		return true;
 	}
 
-	if (unspecified === 'top' && firstNodeIsUnspecified) {
+	if (unspecified === 'top' && !firstNodeIsSpecified) {
 		return true;
 	}
 
-	if (unspecified === 'top' && secondNodeIsUnspecified) {
+	if (unspecified === 'top' && !secondNodeIsSpecified) {
 		return false;
 	}
 
-	if (unspecified === 'bottom' && secondNodeIsUnspecified) {
+	if (unspecified === 'bottom' && !secondNodeIsSpecified) {
 		return true;
 	}
 
-	if (unspecified === 'bottom' && firstNodeIsUnspecified) {
+	if (unspecified === 'bottom' && !firstNodeIsSpecified) {
 		return false;
 	}
 };

package/rules/order/{createExpectedOrder.js → createOrderInfo.js}

@@ -1,34 +1,27 @@
 const _ = require('lodash');
 const getDescription = require('./getDescription');
 
-module.exports = function createExpectedOrder(input) {
-	const order = {};
+module.exports = function createOrderInfo(input) {
+	let order = {};
 	let expectedPosition = 0;
 
 	input.forEach(item => {
 		expectedPosition += 1;
 
-		if ((_.isString(item) && item !== 'at-rules' && item !== 'rules') || item === 'less-mixins') {
-			order[item] = {
-				expectedPosition,
-				description: getDescription(item),
+		// Convert 'rules' into extended pattern
+		if (item === 'rules') {
+			item = {
+				type: 'rule',
 			};
 		}
 
-		if (item === 'rules' || item.type === 'rule') {
-			// Convert 'rules' into extended pattern
-			if (item === 'rules') {
-				item = {
-					type: 'rule',
-				};
-			}
-
+		if (item.type === 'rule') {
 			// It there are no nodes like that create array for them
 			if (!order[item.type]) {
 				order[item.type] = [];
 			}
 
-			const nodeData = {
+			let nodeData = {
 				expectedPosition,
 				description: getDescription(item),
 			};
@@ -44,20 +37,20 @@ module.exports = function createExpectedOrder(input) {
 			order[item.type].push(nodeData);
 		}
 
-		if (item === 'at-rules' || item.type === 'at-rule') {
-			// Convert 'at-rules' into extended pattern
-			if (item === 'at-rules') {
-				item = {
-					type: 'at-rule',
-				};
-			}
+		// Convert 'at-rules' into extended pattern
+		if (item === 'at-rules') {
+			item = {
+				type: 'at-rule',
+			};
+		}
 
+		if (item.type === 'at-rule') {
 			// It there are no nodes like that create array for them
 			if (!order[item.type]) {
 				order[item.type] = [];
 			}
 
-			const nodeData = {
+			let nodeData = {
 				expectedPosition,
 				description: getDescription(item),
 			};
@@ -80,6 +73,13 @@ module.exports = function createExpectedOrder(input) {
 
 			order[item.type].push(nodeData);
 		}
+
+		if (_.isString(item)) {
+			order[item] = {
+				expectedPosition,
+				description: getDescription(item),
+			};
+		}
 	});
 
 	return order;

package/rules/order/getOrderData.js

@@ -3,7 +3,7 @@ const calcAtRulePatternPriority = require('./calcAtRulePatternPriority');
 const calcRulePatternPriority = require('./calcRulePatternPriority');
 const getDescription = require('./getDescription');
 
-module.exports = function getOrderData(expectedOrder, node) {
+module.exports = function getOrderData(orderInfo, node) {
 	let nodeType;
 
 	if (utils.isAtVariable(node)) {
@@ -24,7 +24,7 @@ module.exports = function getOrderData(expectedOrder, node) {
 			selector: node.selector,
 		};
 
-		const rules = expectedOrder.rule;
+		const rules = orderInfo.rule;
 
 		// Looking for most specified pattern, because it can match many patterns
 		if (rules && rules.length) {
@@ -59,7 +59,7 @@ module.exports = function getOrderData(expectedOrder, node) {
 			nodeType.parameter = node.params;
 		}
 
-		const atRules = expectedOrder['at-rule'];
+		const atRules = orderInfo['at-rule'];
 
 		// Looking for most specified pattern, because it can match many patterns
 		if (atRules && atRules.length) {
@@ -81,8 +81,8 @@ module.exports = function getOrderData(expectedOrder, node) {
 		}
 	}
 
-	if (expectedOrder[nodeType]) {
-		return expectedOrder[nodeType];
+	if (orderInfo[nodeType]) {
+		return orderInfo[nodeType];
 	}
 
 	// Return only description if there no patterns for that node

package/rules/order/index.js

@@ -1,26 +1,24 @@
 const stylelint = require('stylelint');
 const _ = require('lodash');
 const postcssSorting = require('postcss-sorting');
-const utils = require('../../utils');
+const { namespace, getContainingNode, isRuleWithNodes } = require('../../utils');
 const checkNode = require('./checkNode');
-const createExpectedOrder = require('./createExpectedOrder');
+const createOrderInfo = require('./createOrderInfo');
 const validatePrimaryOption = require('./validatePrimaryOption');
 
-const ruleName = utils.namespace('order');
+const ruleName = namespace('order');
 
 const messages = stylelint.utils.ruleMessages(ruleName, {
 	expected: (first, second) => `Expected ${first} to come before ${second}`,
 });
 
-function rule(expectation, options, context) {
-	context = context || {};
-
+function rule(primaryOption, options = {}, context = {}) {
 	return function(root, result) {
-		const validOptions = stylelint.utils.validateOptions(
+		let validOptions = stylelint.utils.validateOptions(
 			result,
 			ruleName,
 			{
-				actual: expectation,
+				actual: primaryOption,
 				possible: validatePrimaryOption,
 			},
 			{
@@ -37,17 +35,13 @@ function rule(expectation, options, context) {
 			return;
 		}
 
-		const disableFix = _.get(options, 'disableFix', false);
-		const isFixEnabled = context.fix && !disableFix;
-
-		const expectedOrder = createExpectedOrder(expectation);
-
-		// By default, ignore unspecified properties
-		const unspecified = _.get(options, 'unspecified', 'ignore');
+		let disableFix = options.disableFix || false;
+		let isFixEnabled = context.fix && !disableFix;
 
-		const sharedInfo = {
-			expectedOrder,
-			unspecified,
+		// Contains information which will be shared in many files and this info would be mutated to share state between them
+		let sharedInfo = {
+			orderInfo: createOrderInfo(primaryOption),
+			unspecified: options.unspecified || 'ignore',
 			messages,
 			ruleName,
 			result,
@@ -55,7 +49,7 @@ function rule(expectation, options, context) {
 			shouldFix: false,
 		};
 
-		const processedParents = [];
+		let processedParents = [];
 
 		// Check all rules and at-rules recursively
 		root.walk(function processRulesAndAtrules(input) {
@@ -64,28 +58,28 @@ function rule(expectation, options, context) {
 				return;
 			}
 
-			const node = utils.getContainingNode(input);
+			let node = getContainingNode(input);
 
-			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `utils.getContainingNode()`
+			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `getContainingNode()`
 			if (processedParents.includes(node)) {
 				return;
 			}
 
 			processedParents.push(node);
 
-			if (utils.isRuleWithNodes(node)) {
+			if (isRuleWithNodes(node)) {
 				checkNode(node, sharedInfo);
 			}
 		});
 
 		if (sharedInfo.shouldFix) {
-			postcssSorting({ order: expectation })(root);
+			postcssSorting({ order: primaryOption })(root);
 		}
 	};
 }
 
+rule.ruleName = ruleName;
+rule.messages = messages;
 rule.primaryOptionArray = true;
 
 module.exports = rule;
-module.exports.ruleName = ruleName;
-module.exports.messages = messages;

package/rules/order/validatePrimaryOption.js

@@ -11,18 +11,15 @@ module.exports = function validatePrimaryOption(actualOptions) {
 	if (
 		!actualOptions.every(item => {
 			if (_.isString(item)) {
-				return _.includes(
-					[
-						'custom-properties',
-						'dollar-variables',
-						'at-variables',
-						'declarations',
-						'rules',
-						'at-rules',
-						'less-mixins',
-					],
-					item
-				);
+				return [
+					'custom-properties',
+					'dollar-variables',
+					'at-variables',
+					'declarations',
+					'rules',
+					'at-rules',
+					'less-mixins',
+				].includes(item);
 			}
 
 			return _.isPlainObject(item) && !_.isUndefined(item.type);

package/rules/properties-alphabetical-order/checkNode.js

@@ -0,0 +1,62 @@
+let stylelint = require('stylelint');
+let _ = require('lodash');
+let postcss = require('postcss');
+let checkAlphabeticalOrder = require('../checkAlphabeticalOrder');
+let { isStandardSyntaxProperty, isCustomProperty } = require('../../utils');
+
+module.exports = function checkNode(node, result, ruleName, messages) {
+	let allPropData = [];
+
+	node.each(function processEveryNode(child) {
+		if (child.type !== 'decl') {
+			return;
+		}
+
+		let { prop } = child;
+
+		if (!isStandardSyntaxProperty(prop)) {
+			return;
+		}
+
+		if (isCustomProperty(prop)) {
+			return;
+		}
+
+		let unprefixedPropName = postcss.vendor.unprefixed(prop);
+
+		// Hack to allow -moz-osx-font-smoothing to be understood
+		// just like -webkit-font-smoothing
+		if (unprefixedPropName.startsWith('osx-')) {
+			unprefixedPropName = unprefixedPropName.slice(4);
+		}
+
+		let propData = {
+			name: prop,
+			unprefixedName: unprefixedPropName,
+			index: allPropData.length,
+			node: child,
+		};
+
+		let previousPropData = _.last(allPropData);
+
+		allPropData.push(propData);
+
+		// Skip first decl
+		if (!previousPropData) {
+			return;
+		}
+
+		let isCorrectOrder = checkAlphabeticalOrder(previousPropData, propData);
+
+		if (isCorrectOrder) {
+			return;
+		}
+
+		stylelint.utils.report({
+			message: messages.expected(propData.name, previousPropData.name),
+			node: child,
+			result,
+			ruleName,
+		});
+	});
+};

package/rules/properties-alphabetical-order/index.js

@@ -1,31 +1,27 @@
-const stylelint = require('stylelint');
-const _ = require('lodash');
-const postcss = require('postcss');
-const postcssSorting = require('postcss-sorting');
-const checkAlphabeticalOrder = require('../checkAlphabeticalOrder');
-const utils = require('../../utils');
+let stylelint = require('stylelint');
+let postcssSorting = require('postcss-sorting');
+let { namespace, getContainingNode, isRuleWithNodes } = require('../../utils');
+let checkNode = require('./checkNode');
 
-const ruleName = utils.namespace('properties-alphabetical-order');
+let ruleName = namespace('properties-alphabetical-order');
 
-const messages = stylelint.utils.ruleMessages(ruleName, {
+let messages = stylelint.utils.ruleMessages(ruleName, {
 	expected: (first, second) => `Expected ${first} to come before ${second}`,
 });
 
-function rule(actual, options, context) {
-	context = context || {};
-
+function rule(actual, options = {}, context = {}) {
 	return function(root, result) {
-		const validOptions = stylelint.utils.validateOptions(
+		let validOptions = stylelint.utils.validateOptions(
 			result,
 			ruleName,
 			{
 				actual,
-				possible: _.isBoolean,
+				possible: Boolean,
 			},
 			{
 				actual: options,
 				possible: {
-					disableFix: _.isBoolean,
+					disableFix: Boolean,
 				},
 				optional: true,
 			}
@@ -35,7 +31,7 @@ function rule(actual, options, context) {
 			return;
 		}
 
-		const disableFix = _.get(options, ['disableFix'], false);
+		let disableFix = options.disableFix || false;
 
 		if (context.fix && !disableFix) {
 			postcssSorting({ 'properties-order': 'alphabetical' })(root);
@@ -43,82 +39,26 @@ function rule(actual, options, context) {
 			return;
 		}
 
-		const processedParents = [];
+		let processedParents = [];
 
 		root.walk(function processRulesAndAtrules(input) {
-			const node = utils.getContainingNode(input);
+			let node = getContainingNode(input);
 
-			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `utils.getContainingNode()`
+			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `getContainingNode()`
 			if (processedParents.includes(node)) {
 				return;
 			}
 
 			processedParents.push(node);
 
-			if (utils.isRuleWithNodes(node)) {
-				checkNode(node, result);
+			if (isRuleWithNodes(node)) {
+				checkNode(node, result, ruleName, messages);
 			}
 		});
 	};
 }
 
-module.exports = rule;
-module.exports.ruleName = ruleName;
-module.exports.messages = messages;
-
-function checkNode(node, result) {
-	const allPropData = [];
-
-	node.each(function processEveryNode(child) {
-		if (child.type !== 'decl') {
-			return;
-		}
-
-		const { prop } = child;
-
-		if (!utils.isStandardSyntaxProperty(prop)) {
-			return;
-		}
-
-		if (utils.isCustomProperty(prop)) {
-			return;
-		}
-
-		let unprefixedPropName = postcss.vendor.unprefixed(prop);
-
-		// Hack to allow -moz-osx-font-smoothing to be understood
-		// just like -webkit-font-smoothing
-		if (unprefixedPropName.indexOf('osx-') === 0) {
-			unprefixedPropName = unprefixedPropName.slice(4);
-		}
+rule.ruleName = ruleName;
+rule.messages = messages;
 
-		const propData = {
-			name: prop,
-			unprefixedName: unprefixedPropName,
-			index: allPropData.length,
-			node: child,
-		};
-
-		const previousPropData = _.last(allPropData);
-
-		allPropData.push(propData);
-
-		// Skip first decl
-		if (!previousPropData) {
-			return;
-		}
-
-		const isCorrectOrder = checkAlphabeticalOrder(previousPropData, propData);
-
-		if (isCorrectOrder) {
-			return;
-		}
-
-		stylelint.utils.report({
-			message: messages.expected(propData.name, previousPropData.name),
-			node: child,
-			result,
-			ruleName,
-		});
-	});
-}
+module.exports = rule;

package/rules/properties-order/README.md

@@ -35,7 +35,14 @@ Within an order array, you can include
 * group objects with these properties:
 	* `order: "flexible"`: If property isn't set (the default), the properties in this group must come in the order specified. If `"flexible"`, the properties can be in any order as long as they are grouped correctly.
 	* `properties (array of strings)`: The properties in this group.
-	* `emptyLineBefore ("always"|"never"|"threshold")`: If `always`, this group must be separated from other properties by an empty newline. If emptyLineBefore is `never`, the group must have no empty lines separating it from other properties. By default this property isn't set. Rule will check empty lines between properties _only_. However, shared-line comments ignored by rule. Shared-line comment is a comment on the same line as declaration before this comment. For `threshold`, refer to the [`emptyLineMinimumPropertyThreshold` documentation](#emptylineminimumpropertythreshold-number).
+	* `emptyLineBefore ("always"|"never"|"threshold")`: If `always`, this group must be separated from other properties by an empty newline. If emptyLineBefore is `never`, the group must have no empty lines separating it from other properties. By default this property isn't set.
+
+		Rule will check empty lines between properties _only_. However, shared-line comments ignored by rule. Shared-line comment is a comment on the same line as declaration before this comment.
+
+		If `emptyLineBefore` specified, regardless of it's value, the first property in a rule would be forced to not have an empty line before it.
+
+		For `threshold`, refer to the [`emptyLineMinimumPropertyThreshold` documentation](#emptylineminimumpropertythreshold-number).
+
 	* `noEmptyLineBetween`: If `true`, properties within group should not have empty lines between them.
 	* `groupName`: An optional name for the group. This will be used in error messages.
 
@@ -600,11 +607,13 @@ a {
 
 Default behavior does not enforce the presence of an empty line before an unspecified block of properties.
 
-If `"always"`, the unspecified group must be separated from other properties by an empty newline. 
+If `"always"`, the unspecified group must be separated from other properties by an empty newline.
 If `"never"`, the unspecified group must have no empty lines separating it from other properties.
 
 For `"threshold"`, see the [`emptyLineMinimumPropertyThreshold` documentation](#emptylineminimumpropertythreshold-number) for more information.
 
+If `emptyLineBeforeUnspecified` specified, regardless of it's value, if the first property in a rule is target of this option, that property would be forced to not have an empty line before it.
+
 Given:
 
 ```js

package/rules/properties-order/checkEmptyLineBefore.js

@@ -1,8 +1,8 @@
-const stylelint = require('stylelint');
-const _ = require('lodash');
-const addEmptyLineBefore = require('./addEmptyLineBefore');
-const hasEmptyLineBefore = require('./hasEmptyLineBefore');
-const removeEmptyLinesBefore = require('./removeEmptyLinesBefore');
+let stylelint = require('stylelint');
+let _ = require('lodash');
+let addEmptyLineBefore = require('./addEmptyLineBefore');
+let hasEmptyLineBefore = require('./hasEmptyLineBefore');
+let removeEmptyLinesBefore = require('./removeEmptyLinesBefore');
 
 module.exports = function checkEmptyLineBefore(
 	firstPropData,
@@ -10,45 +10,40 @@ module.exports = function checkEmptyLineBefore(
 	sharedInfo,
 	propsCount
 ) {
-	const firstPropIsUnspecified = !firstPropData.orderData;
-	const secondPropIsUnspecified = !secondPropData.orderData;
+	let firstPropIsSpecified = Boolean(firstPropData.orderData);
+	let secondPropIsSpecified = Boolean(secondPropData.orderData);
 
 	// Check newlines between groups
-	const firstPropSeparatedGroup = !firstPropIsUnspecified
+	let firstPropGroup = firstPropIsSpecified
 		? firstPropData.orderData.separatedGroup
 		: sharedInfo.lastKnownSeparatedGroup;
-	const secondPropSeparatedGroup = !secondPropIsUnspecified
+	let secondPropGroup = secondPropIsSpecified
 		? secondPropData.orderData.separatedGroup
 		: sharedInfo.lastKnownSeparatedGroup;
 
-	sharedInfo.lastKnownSeparatedGroup = secondPropSeparatedGroup;
+	sharedInfo.lastKnownSeparatedGroup = secondPropGroup;
 
-	const betweenGroupsInSpecified =
-		firstPropSeparatedGroup !== secondPropSeparatedGroup && !secondPropIsUnspecified;
-	const startOfUnspecifiedGroup = !firstPropIsUnspecified && secondPropIsUnspecified;
+	let startOfSpecifiedGroup = secondPropIsSpecified && firstPropGroup !== secondPropGroup;
+	let startOfUnspecifiedGroup = firstPropIsSpecified && !secondPropIsSpecified;
 
-	// Line threshold logic
-	const belowEmptyLineThreshold = propsCount < sharedInfo.emptyLineMinimumPropertyThreshold;
-
-	if (betweenGroupsInSpecified || startOfUnspecifiedGroup) {
+	if (startOfSpecifiedGroup || startOfUnspecifiedGroup) {
 		// Get an array of just the property groups, remove any solo properties
-		const groups = _.reject(sharedInfo.expectation, _.isString);
+		let groups = _.reject(sharedInfo.primaryOption, _.isString);
+
+		let emptyLineBefore = _.get(groups[secondPropGroup - 2], 'emptyLineBefore');
 
-		const emptyLineBefore = !startOfUnspecifiedGroup
-			? // secondProp seperatedGroups start at 2 so we minus 2 to get the
-			  // 1st item from our groups array
-			  _.get(groups[secondPropSeparatedGroup - 2], 'emptyLineBefore')
-			: sharedInfo.emptyLineBeforeUnspecified;
+		if (startOfUnspecifiedGroup) {
+			emptyLineBefore = sharedInfo.emptyLineBeforeUnspecified;
+		}
 
 		// Threshold logic
-		const emptyLineThresholdInsertLines =
-			!belowEmptyLineThreshold && emptyLineBefore === 'threshold';
-		const emptyLineThresholdRemoveLines =
-			belowEmptyLineThreshold && emptyLineBefore === 'threshold';
+		let belowEmptyLineThreshold = propsCount < sharedInfo.emptyLineMinimumPropertyThreshold;
+		let emptyLineThresholdInsertLines = emptyLineBefore === 'threshold' && !belowEmptyLineThreshold;
+		let emptyLineThresholdRemoveLines = emptyLineBefore === 'threshold' && belowEmptyLineThreshold;
 
 		if (
-			!hasEmptyLineBefore(secondPropData.node) &&
-			(emptyLineBefore === 'always' || emptyLineThresholdInsertLines)
+			(emptyLineBefore === 'always' || emptyLineThresholdInsertLines) &&
+			!hasEmptyLineBefore(secondPropData.node)
 		) {
 			if (sharedInfo.isFixEnabled) {
 				addEmptyLineBefore(secondPropData.node, sharedInfo.context.newline);
@@ -61,8 +56,8 @@ module.exports = function checkEmptyLineBefore(
 				});
 			}
 		} else if (
-			hasEmptyLineBefore(secondPropData.node) &&
-			(emptyLineBefore === 'never' || emptyLineThresholdRemoveLines)
+			(emptyLineBefore === 'never' || emptyLineThresholdRemoveLines) &&
+			hasEmptyLineBefore(secondPropData.node)
 		) {
 			if (sharedInfo.isFixEnabled) {
 				removeEmptyLinesBefore(secondPropData.node, sharedInfo.context.newline);
@@ -79,13 +74,14 @@ module.exports = function checkEmptyLineBefore(
 
 	// Check newlines between properties inside a group
 	if (
-		!firstPropIsUnspecified &&
-		!secondPropIsUnspecified &&
+		firstPropIsSpecified &&
+		secondPropIsSpecified &&
 		firstPropData.orderData.groupPosition === secondPropData.orderData.groupPosition
 	) {
-		const noEmptyLineBefore = secondPropData.orderData.noEmptyLineBeforeInsideGroup;
-
-		if (hasEmptyLineBefore(secondPropData.node) && noEmptyLineBefore) {
+		if (
+			secondPropData.orderData.noEmptyLineBeforeInsideGroup &&
+			hasEmptyLineBefore(secondPropData.node)
+		) {
 			if (sharedInfo.isFixEnabled) {
 				removeEmptyLinesBefore(secondPropData.node, sharedInfo.context.newline);
 			} else {

package/rules/properties-order/checkEmptyLineBeforeFirstProp.js

@@ -0,0 +1,30 @@
+const stylelint = require('stylelint');
+const _ = require('lodash');
+const hasEmptyLineBefore = require('./hasEmptyLineBefore');
+const removeEmptyLinesBefore = require('./removeEmptyLinesBefore');
+
+module.exports = function checkEmptyLineBeforeFirstProp(propData, sharedInfo) {
+	let emptyLineBefore = false;
+
+	if (propData.orderData) {
+		// Get an array of just the property groups, remove any solo properties
+		let groups = _.reject(sharedInfo.primaryOption, _.isString);
+
+		emptyLineBefore = _.get(groups[propData.orderData.separatedGroup - 2], 'emptyLineBefore');
+	} else if (sharedInfo.emptyLineBeforeUnspecified) {
+		emptyLineBefore = true;
+	}
+
+	if (emptyLineBefore && hasEmptyLineBefore(propData.node)) {
+		if (sharedInfo.isFixEnabled) {
+			removeEmptyLinesBefore(propData.node, sharedInfo.context.newline);
+		} else {
+			stylelint.utils.report({
+				message: sharedInfo.messages.rejectedEmptyLineBefore(propData.name),
+				node: propData.node,
+				result: sharedInfo.result,
+				ruleName: sharedInfo.ruleName,
+			});
+		}
+	}
+};

package/rules/properties-order/checkNode.js

@@ -1,16 +1,16 @@
 const stylelint = require('stylelint');
 const postcss = require('postcss');
 const postcssSorting = require('postcss-sorting');
-const utils = require('../../utils');
+const { isProperty } = require('../../utils');
 const checkEmptyLineBefore = require('./checkEmptyLineBefore');
+const checkEmptyLineBeforeFirstProp = require('./checkEmptyLineBeforeFirstProp');
 const checkOrder = require('./checkOrder');
 const getNodeData = require('./getNodeData');
 const createFlatOrder = require('./createFlatOrder');
 
 module.exports = function checkNode(node, sharedInfo, originalNode) {
 	// First, check order
-	const allPropData = getAllPropData(node);
-	const propsCount = node.nodes.filter(item => utils.isProperty(item)).length;
+	let allPropData = getAllPropData(node);
 
 	if (!sharedInfo.isFixEnabled) {
 		allPropData.forEach(checkEveryPropForOrder);
@@ -19,6 +19,7 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 	if (sharedInfo.isFixEnabled) {
 		let shouldFixOrder = false;
 
+		// Check if there order violation to avoid running re-ordering unnecessery
 		allPropData.forEach(function checkEveryPropForOrder2(propData, index) {
 			// Skip first decl
 			if (index === 0) {
@@ -30,9 +31,9 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 				return;
 			}
 
-			const previousPropData = allPropData[index - 1];
+			let previousPropData = allPropData[index - 1];
 
-			const checkedOrder = checkOrder({
+			let checkedOrder = checkOrder({
 				firstPropData: previousPropData,
 				secondPropData: propData,
 				unspecified: sharedInfo.unspecified,
@@ -45,19 +46,19 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 		});
 
 		if (shouldFixOrder) {
-			const sortingOptions = {
-				'properties-order': createFlatOrder(sharedInfo.expectation),
+			let sortingOptions = {
+				'properties-order': createFlatOrder(sharedInfo.primaryOption),
 				'unspecified-properties-position':
 					sharedInfo.unspecified === 'ignore' ? 'bottom' : sharedInfo.unspecified,
 			};
 
 			// creating PostCSS Root node with current node as a child,
 			// so PostCSS Sorting can process it
-			const tempRoot = postcss.root({ nodes: [originalNode] });
+			let tempRoot = postcss.root({ nodes: [originalNode] });
 
 			postcssSorting(sortingOptions)(tempRoot);
 
-			const allPropData2 = getAllPropData(node);
+			let allPropData2 = getAllPropData(node);
 
 			allPropData2.forEach(checkEveryPropForOrder);
 		}
@@ -66,7 +67,8 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 	// Second, check emptyLineBefore
 	sharedInfo.lastKnownSeparatedGroup = 1;
 
-	const allNodesData = node.nodes.map(function collectDataForEveryNode(child) {
+	let propsCount = node.nodes.filter(item => isProperty(item)).length;
+	let allNodesData = node.nodes.map(function collectDataForEveryNode(child) {
 		return getNodeData(child, sharedInfo.expectedOrder);
 	});
 
@@ -77,7 +79,7 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 		if (
 			previousNodeData &&
 			previousNodeData.node.type === 'comment' &&
-			previousNodeData.node.raw('before').indexOf('\n') === -1
+			!previousNodeData.node.raw('before').includes('\n')
 		) {
 			previousNodeData = allNodesData[index - 2];
 		}
@@ -87,14 +89,19 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 			return;
 		}
 
-		// previous node should be a standard declaration
-		if (!utils.isProperty(previousNodeData.node)) {
+		// Nodes should be standard declarations
+		if (!isProperty(previousNodeData.node) || !isProperty(nodeData.node)) {
 			return;
 		}
 
 		checkEmptyLineBefore(previousNodeData, nodeData, sharedInfo, propsCount);
 	});
 
+	// Check if empty line before first prop should be removed
+	if (isProperty(allNodesData[0].node)) {
+		checkEmptyLineBeforeFirstProp(allNodesData[0], sharedInfo);
+	}
+
 	function checkEveryPropForOrder(propData, index, listOfProps) {
 		// Skip first decl
 		if (index === 0) {
@@ -128,7 +135,7 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 
 	function getAllPropData(inputNode) {
 		return inputNode.nodes
-			.filter(item => utils.isProperty(item))
+			.filter(item => isProperty(item))
 			.map(item => getNodeData(item, sharedInfo.expectedOrder));
 	}
 };

package/rules/properties-order/{createExpectedOrder.js → createOrderInfo.js}

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 
-module.exports = function createExpectedOrder(input) {
-	const order = {};
+module.exports = function createOrderInfo(input) {
+	let order = {};
 	let expectedPosition = 0;
 	let separatedGroup = 1;
 	let groupPosition = -1;
@@ -38,7 +38,7 @@ module.exports = function createExpectedOrder(input) {
 			separatedGroup += 1;
 		}
 
-		if (item.order && item.order === 'flexible') {
+		if (item.order === 'flexible') {
 			expectedPosition += 1;
 			groupPosition += 1;
 

package/rules/properties-order/getNodeData.js

@@ -1,18 +1,18 @@
 const postcss = require('postcss');
-const utils = require('../../utils');
+const { isProperty } = require('../../utils');
 
 module.exports = function getNodeData(node, expectedOrder) {
-	const nodeData = {
+	let nodeData = {
 		node,
 	};
 
-	if (utils.isProperty(node)) {
-		const { prop } = node;
+	if (isProperty(node)) {
+		let { prop } = node;
 		let unprefixedPropName = postcss.vendor.unprefixed(prop);
 
 		// Hack to allow -moz-osx-font-smoothing to be understood
 		// just like -webkit-font-smoothing
-		if (unprefixedPropName.indexOf('osx-') === 0) {
+		if (unprefixedPropName.startsWith('osx-')) {
 			unprefixedPropName = unprefixedPropName.slice(4);
 		}
 

package/rules/properties-order/index.js

@@ -1,11 +1,11 @@
 const stylelint = require('stylelint');
 const _ = require('lodash');
-const utils = require('../../utils');
+const { namespace, getContainingNode, isRuleWithNodes } = require('../../utils');
 const checkNode = require('./checkNode');
-const createExpectedOrder = require('./createExpectedOrder');
+const createOrderInfo = require('./createOrderInfo');
 const validatePrimaryOption = require('./validatePrimaryOption');
 
-const ruleName = utils.namespace('properties-order');
+const ruleName = namespace('properties-order');
 
 const messages = stylelint.utils.ruleMessages(ruleName, {
 	expected: (first, second, groupName) =>
@@ -14,13 +14,13 @@ const messages = stylelint.utils.ruleMessages(ruleName, {
 	rejectedEmptyLineBefore: property => `Unexpected empty line before property "${property}"`,
 });
 
-const rule = function(expectation, options, context = {}) {
+function rule(primaryOption, options = {}, context = {}) {
 	return function(root, result) {
-		const validOptions = stylelint.utils.validateOptions(
+		let validOptions = stylelint.utils.validateOptions(
 			result,
 			ruleName,
 			{
-				actual: expectation,
+				actual: primaryOption,
 				possible: validatePrimaryOption,
 			},
 			{
@@ -39,54 +39,43 @@ const rule = function(expectation, options, context = {}) {
 			return;
 		}
 
-		// By default, ignore unspecified properties
-		const unspecified = _.get(options, 'unspecified', 'ignore');
-		const emptyLineBeforeUnspecified = _.get(options, 'emptyLineBeforeUnspecified', '');
-		const emptyLineMinimumPropertyThreshold = _.get(
-			options,
-			'emptyLineMinimumPropertyThreshold',
-			0
-		);
-		const disableFix = _.get(options, 'disableFix', false);
-		const isFixEnabled = context.fix && !disableFix;
-
-		const expectedOrder = createExpectedOrder(expectation);
+		let disableFix = options.disableFix || false;
 
-		const sharedInfo = {
-			expectedOrder,
-			expectation,
-			unspecified,
-			emptyLineBeforeUnspecified,
-			emptyLineMinimumPropertyThreshold,
+		let sharedInfo = {
+			context,
+			emptyLineBeforeUnspecified: options.emptyLineBeforeUnspecified,
+			emptyLineMinimumPropertyThreshold: options.emptyLineMinimumPropertyThreshold || 0,
+			expectedOrder: createOrderInfo(primaryOption),
+			isFixEnabled: context.fix && !disableFix,
 			messages,
-			ruleName,
+			primaryOption,
 			result,
-			context,
-			isFixEnabled,
+			ruleName,
+			unspecified: options.unspecified || 'ignore',
 		};
 
-		const processedParents = [];
+		let processedParents = [];
 
 		// Check all rules and at-rules recursively
 		root.walk(function processRulesAndAtrules(input) {
-			const node = utils.getContainingNode(input);
+			let node = getContainingNode(input);
 
-			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `utils.getContainingNode()`
+			// Avoid warnings duplication, caused by interfering in `root.walk()` algorigthm with `getContainingNode()`
 			if (processedParents.includes(node)) {
 				return;
 			}
 
 			processedParents.push(node);
 
-			if (utils.isRuleWithNodes(node)) {
+			if (isRuleWithNodes(node)) {
 				checkNode(node, sharedInfo, input);
 			}
 		});
 	};
-};
+}
 
 rule.primaryOptionArray = true;
-
 rule.ruleName = ruleName;
 rule.messages = messages;
+
 module.exports = rule;

package/rules/properties-order/validatePrimaryOption.js

@@ -42,7 +42,7 @@ module.exports = function validatePrimaryOption(actualOptions) {
 				return true;
 			}
 
-			return _.includes(['always', 'never', 'threshold'], item.emptyLineBefore);
+			return ['always', 'never', 'threshold'].includes(item.emptyLineBefore);
 		})
 	) {
 		return false;

package/utils/isCustomProperty.js

@@ -6,5 +6,5 @@
  */
 
 module.exports = function isCustomProperty(property) {
-	return property.slice(0, 2) === '--';
+	return property.startsWith('--');
 };

package/utils/isDollarVariable.js

@@ -6,5 +6,5 @@
  */
 
 module.exports = function isDollarVariable(property) {
-	return property[0] === '$';
+	return property.startsWith('$');
 };

package/utils/isStandardSyntaxProperty.js

@@ -7,12 +7,12 @@
 
 module.exports = function isStandardSyntaxProperty(property) {
 	// SCSS var (e.g. $var: x), list (e.g. $list: (x)) or map (e.g. $map: (key:value))
-	if (property[0] === '$') {
+	if (property.startsWith('$')) {
 		return false;
 	}
 
 	// Less var (e.g. @var: x)
-	if (property[0] === '@') {
+	if (property.startsWith('@')) {
 		return false;
 	}