stylelint-order 2.2.1 → 3.1.1

package/CHANGELOG.md

@@ -2,9 +2,28 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## 3.1.1
+
+* Added `stylelint@11` as a peer dependency.
+
+## 3.1.0
+
+* Added `emptyLineBefore: "threshold"` option, and related options (`emptyLineMinimumPropertyThreshold`, `emptyLineBeforeUnspecified: "threshold"`) to `properties-order`.
+
+## 3.0.1
+
+* Fixed `properties-order` not report warnings, if autofix didn't fix them.
+* Fixed `properties-alphabetical-order` now puts shorthands before their longhand forms even if that isn't alphabetical to avoid broken CSS. E. g. `border-color` will be before `border-bottom-color`.
+
+## 3.0.0
+
+* Dropped Node.js 6 support. Node.js 8.7.0 or greater is now required.
+* Removed stylelint@9 as a peer dependency. stylelint 10 or greater is now required.
+* Added `emptyLineBeforeUnspecified` option for `properties-order`.
+
 ## 2.2.1
 
-* Fix false negatives with `noEmptyLineBetween` in combination with the `order: "flexible"`.
+* Fixed false negatives with `noEmptyLineBetween` in combination with the `order: "flexible"`.
 
 ## 2.2.0
 
@@ -20,7 +39,7 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 This is a major release, because this plugin requires stylelint@9.8.0+ to work correctly with Less files.
 
-* Add optional groupName property for properties-order.
+* Added optional groupName property for properties-order.
 * Adopted `postcss-less@3` parser changes, which is dependency of `stylelint@9.7.0+`.
 * Fixed incorrect fixing when properties order and empty lines should be changed at the same time.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-order",
-  "version": "2.2.1",
+  "version": "3.1.1",
   "description": "A collection of order related linting rules for stylelint.",
   "keywords": [
     "stylelint-plugin",
@@ -17,7 +17,7 @@
   },
   "homepage": "https://github.com/hudochenkov/stylelint-order",
   "engines": {
-    "node": ">=6"
+    "node": ">=8.7.0"
   },
   "files": [
     "rules",
@@ -28,22 +28,22 @@
   ],
   "main": "index.js",
   "dependencies": {
-    "lodash": "^4.17.10",
-    "postcss": "^7.0.2",
-    "postcss-sorting": "^4.1.0"
+    "lodash": "^4.17.15",
+    "postcss": "^7.0.17",
+    "postcss-sorting": "^5.0.1"
   },
   "peerDependencies": {
-    "stylelint": "^9.10.1 || ^10.0.0"
+    "stylelint": ">=10.0.1"
   },
   "devDependencies": {
-    "eslint": "~5.15.0",
-    "eslint-config-hudochenkov": "~3.0.0",
-    "eslint-config-prettier": "~4.1.0",
-    "husky": "^1.1.3",
-    "jest": "^24.1.0",
-    "lint-staged": "^8.0.4",
-    "prettier": "~1.16.4",
-    "stylelint": "^9.10.1"
+    "eslint": "^6.2.2",
+    "eslint-config-hudochenkov": "^3.0.1",
+    "eslint-config-prettier": "^6.1.0",
+    "husky": "^3.0.4",
+    "jest": "^24.9.0",
+    "lint-staged": "^9.2.5",
+    "prettier": "~1.18.2",
+    "stylelint": "^11.0.0"
   },
   "scripts": {
     "pretest": "eslint .",

package/rules/checkAlphabeticalOrder.js

@@ -1,6 +1,23 @@
 const postcss = require('postcss');
+const shorthandData = require('./shorthandData');
+
+function isShorthand(a, b) {
+	const longhands = shorthandData[a] || [];
+
+	return longhands.includes(b);
+}
 
 module.exports = function checkAlphabeticalOrder(firstPropData, secondPropData) {
+	// OK if the first is shorthand for the second:
+	if (isShorthand(firstPropData.unprefixedName, secondPropData.unprefixedName)) {
+		return true;
+	}
+
+	// Not OK if the second is shorthand for the first:
+	if (isShorthand(secondPropData.unprefixedName, firstPropData.unprefixedName)) {
+		return false;
+	}
+
 	// If unprefixed prop names are the same, compare the prefixed versions
 	if (firstPropData.unprefixedName === secondPropData.unprefixedName) {
 		// If first property has no prefix and second property has prefix

package/rules/properties-alphabetical-order/README.md

@@ -11,6 +11,9 @@ a {
  * These properties */
 ```
 
+Shorthand properties *must always* precede their longhand counterparts, even if that means they are not alphabetized.
+(See also [`declaration-block-no-shorthand-property-overrides`](https://stylelint.io/user-guide/rules/declaration-block-no-shorthand-property-overrides/).)
+
 Prefixed properties *must always* precede the unprefixed version.
 
 This rule ignores variables (`$sass`, `@less`, `--custom-property`).
@@ -28,6 +31,13 @@ a {
 }
 ```
 
+```css
+a {
+	border-bottom-color: pink;
+	border-color: transparent;
+}
+```
+
 ```css
 a {
 	-moz-transform: scale(1);
@@ -45,6 +55,13 @@ a {
 }
 ```
 
+```css
+a {
+	border-color: transparent;
+	border-bottom-color: pink;
+}
+```
+
 ```css
 a {
 	-webkit-transform: scale(1);

package/rules/properties-order/README.md

@@ -18,6 +18,8 @@ This rule ignores variables (`$sass`, `@less`, `--custom-property`).
 * Options
 * Optional secondary options
 	* [`unspecified: "top"|"bottom"|"bottomAlphabetical"|"ignore"`](#unspecified-topbottombottomalphabeticalignore)
+	* [`emptyLineBeforeUnspecified: "always"|"never"|"threshold"`](#emptyLineBeforeUnspecified-alwaysneverthreshold)
+	* [`emptyLineMinimumPropertyThreshold: <number>`](#emptylineminimumpropertythreshold-number)
 	* [`disableFix: true`](#disablefix-true)
 * [Autofixing caveats](#autofixing-caveats)
 
@@ -33,7 +35,7 @@ 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")`: 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.
+	* `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).
 	* `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.
 
@@ -458,7 +460,7 @@ These options only apply if you've defined your own array of properties.
 
 Default behavior is the same as `"ignore"`: an unspecified property can appear before or after any other property.
 
-With `"top"`, unspecified properties are expected *before* any specified properties. With `"bottom"`, unspecified properties are expected *after* any specified properties. With `"bottomAlphabetical"`, unspecified properties are expected *after* any specified properties, and the unspecified properties are expected to be in alphabetical order.
+With `"top"`, unspecified properties are expected *before* any specified properties. With `"bottom"`, unspecified properties are expected *after* any specified properties. With `"bottomAlphabetical"`, unspecified properties are expected *after* any specified properties, and the unspecified properties are expected to be in alphabetical order. (See [properties-alphabetical-order](../properties-alphabetical-order/README.md) more more details on the alphabetization rules.)
 
 Given:
 
@@ -594,13 +596,184 @@ a {
 }
 ```
 
+### `emptyLineBeforeUnspecified: "always"|"never"|"threshold"`
+
+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 `"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.
+
+Given:
+
+```js
+[
+    [
+        "height",
+        "width",
+    ],
+    {
+        unspecified: "bottom",
+        emptyLineBeforeUnspecified: "always"
+    }
+]
+```
+
+The following pattern is considered warnings:
+
+```css
+a {
+	height: 1px;
+	width: 2px;
+	color: blue;
+}
+```
+
+The following patterns is *not* considered warnings:
+
+```css
+a {
+	height: 1px;
+	width: 2px;
+
+	color: blue;
+}
+```
+
+### `emptyLineMinimumPropertyThreshold: <number>`
+
+If a group is configured with `emptyLineBefore: 'threshold'`, the empty line behaviour toggles based on the number of properties in the rule.
+
+When the configured minimum property threshold is reached, empty lines are **inserted**.  When the number of properties is **less than** the minimum property threshold, empty lines are **removed**.
+
+ _e.g. threshold set to **3**, and there are **5** properties in total, then groups set to `'threshold'` will have an empty line inserted._
+
+The same behaviour is applied to unspecified groups when `emptyLineBeforeUnspecified: "threshold"`
+
+Given:
+
+```js
+[
+    [
+        {
+            emptyLineBefore: 'threshold',
+            properties: ['display'],
+        },
+        {
+            emptyLineBefore: 'threshold',
+            properties: ['height', 'width'],
+        },
+        {
+            emptyLineBefore: 'always',
+            properties: ['border'],
+        },
+        {
+            emptyLineBefore: 'never',
+            properties: ['transform'],
+        },
+    ],
+    {
+       unspecified: 'bottom',
+       emptyLineBeforeUnspecified: 'threshold',
+       emptyLineMinimumPropertyThreshold: 4,
+    }
+]
+```
+
+The following patterns are considered warnings:
+
+```css
+a {
+    display: block;
+
+	height: 1px;
+    width: 2px;
+    color: blue;
+}
+
+a {
+    display: block;
+
+    height: 1px;
+    width: 2px;
+    border: 0;
+    color: blue;
+}
+
+a {
+    display: block;
+
+    height: 1px;
+    width: 2px;
+    border: 0;
+
+    transform: none;
+    color: blue;
+}
+```
+
+The following patterns are *not* considered warnings:
+
+```css
+a {
+    display: block;
+    height: 1px;
+    width: 2px;
+}
+
+a {
+    display: block;
+
+    height: 1px;
+    width: 2px;
+
+    border: 0;
+}
+
+a {
+    display: block;
+
+    height: 1px;
+    width: 2px;
+
+    border: 0;
+    transform: none;
+}
+
+a {
+    display: block;
+    height: 1px;
+
+    border: 0;
+}
+
+a {
+    border: 0;
+    transform: none;
+    color: blue;
+}
+
+a {
+    display: block;
+
+    height: 1px;
+    width: 2px;
+
+    border: 0;
+    transform: none;
+
+    color: blue;
+}
+```
+
 ### `disableFix: true`
 
 Disable autofixing. Autofixing is enabled by default if it's enabled in stylelint configuration.
 
 ## Autofixing caveats
 
-Properties will be grouped together, if other node types between them (except comments). They will be groupped with the first found property. E. g.:
+Properties will be grouped together, if other node types between them (except comments). They will be grouped with the first found property. E.g.:
 
 ```css
 /* Before: */

package/rules/properties-order/checkEmptyLineBefore.js

@@ -4,7 +4,12 @@ const addEmptyLineBefore = require('./addEmptyLineBefore');
 const hasEmptyLineBefore = require('./hasEmptyLineBefore');
 const removeEmptyLinesBefore = require('./removeEmptyLinesBefore');
 
-module.exports = function checkEmptyLineBefore(firstPropData, secondPropData, sharedInfo) {
+module.exports = function checkEmptyLineBefore(
+	firstPropData,
+	secondPropData,
+	sharedInfo,
+	propsCount
+) {
 	const firstPropIsUnspecified = !firstPropData.orderData;
 	const secondPropIsUnspecified = !secondPropData.orderData;
 
@@ -18,15 +23,33 @@ module.exports = function checkEmptyLineBefore(firstPropData, secondPropData, sh
 
 	sharedInfo.lastKnownSeparatedGroup = secondPropSeparatedGroup;
 
-	if (firstPropSeparatedGroup !== secondPropSeparatedGroup && !secondPropIsUnspecified) {
+	const betweenGroupsInSpecified =
+		firstPropSeparatedGroup !== secondPropSeparatedGroup && !secondPropIsUnspecified;
+	const startOfUnspecifiedGroup = !firstPropIsUnspecified && secondPropIsUnspecified;
+
+	// Line threshold logic
+	const belowEmptyLineThreshold = propsCount < sharedInfo.emptyLineMinimumPropertyThreshold;
+
+	if (betweenGroupsInSpecified || startOfUnspecifiedGroup) {
 		// Get an array of just the property groups, remove any solo properties
 		const groups = _.reject(sharedInfo.expectation, _.isString);
 
-		// secondProp seperatedGroups start at 2 so we minus 2 to get the 1st item
-		// from our groups array
-		const emptyLineBefore = _.get(groups[secondPropSeparatedGroup - 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;
+
+		// Threshold logic
+		const emptyLineThresholdInsertLines =
+			!belowEmptyLineThreshold && emptyLineBefore === 'threshold';
+		const emptyLineThresholdRemoveLines =
+			belowEmptyLineThreshold && emptyLineBefore === 'threshold';
 
-		if (!hasEmptyLineBefore(secondPropData.node) && emptyLineBefore === 'always') {
+		if (
+			!hasEmptyLineBefore(secondPropData.node) &&
+			(emptyLineBefore === 'always' || emptyLineThresholdInsertLines)
+		) {
 			if (sharedInfo.isFixEnabled) {
 				addEmptyLineBefore(secondPropData.node, sharedInfo.context.newline);
 			} else {
@@ -37,7 +60,10 @@ module.exports = function checkEmptyLineBefore(firstPropData, secondPropData, sh
 					ruleName: sharedInfo.ruleName,
 				});
 			}
-		} else if (hasEmptyLineBefore(secondPropData.node) && emptyLineBefore === 'never') {
+		} else if (
+			hasEmptyLineBefore(secondPropData.node) &&
+			(emptyLineBefore === 'never' || emptyLineThresholdRemoveLines)
+		) {
 			if (sharedInfo.isFixEnabled) {
 				removeEmptyLinesBefore(secondPropData.node, sharedInfo.context.newline);
 			} else {

package/rules/properties-order/checkNode.js

@@ -8,28 +8,30 @@ const getNodeData = require('./getNodeData');
 const createFlatOrder = require('./createFlatOrder');
 
 module.exports = function checkNode(node, sharedInfo, originalNode) {
-	let shouldFixOrder = false;
+	// First, check order
+	const allPropData = getAllPropData(node);
+	const propsCount = node.nodes.filter(item => utils.isProperty(item)).length;
 
-	const allPropData = node.nodes
-		.filter(item => utils.isProperty(item))
-		.map(item => getNodeData(item, sharedInfo.expectedOrder));
+	if (!sharedInfo.isFixEnabled) {
+		allPropData.forEach(checkEveryPropForOrder);
+	}
 
-	// First, check order
-	allPropData.forEach(function checkEveryPropForOrder(propData, index) {
-		// return early if we know there is a violation and auto fix should be applied
-		if (shouldFixOrder && sharedInfo.isFixEnabled) {
-			return;
-		}
+	if (sharedInfo.isFixEnabled) {
+		let shouldFixOrder = false;
 
-		// current node should be a standard declaration
-		if (!utils.isProperty(propData.node)) {
-			return;
-		}
+		allPropData.forEach(function checkEveryPropForOrder2(propData, index) {
+			// Skip first decl
+			if (index === 0) {
+				return;
+			}
+
+			// return early if we know there is a violation and auto fix should be applied
+			if (shouldFixOrder) {
+				return;
+			}
 
-		const previousPropData = allPropData[index - 1];
+			const previousPropData = allPropData[index - 1];
 
-		// Skip first decl
-		if (previousPropData) {
 			const checkedOrder = checkOrder({
 				firstPropData: previousPropData,
 				secondPropData: propData,
@@ -37,48 +39,37 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 				allPropData: allPropData.slice(0, index),
 			});
 
-			if (!checkedOrder.result) {
-				if (sharedInfo.isFixEnabled) {
-					shouldFixOrder = true;
-				} else {
-					const { orderData } = checkedOrder.secondNode;
-
-					stylelint.utils.report({
-						message: sharedInfo.messages.expected(
-							checkedOrder.secondNode.name,
-							checkedOrder.firstNode.name,
-							orderData && orderData.groupName
-						),
-						node: checkedOrder.secondNode.node,
-						result: sharedInfo.result,
-						ruleName: sharedInfo.ruleName,
-					});
-				}
+			if (!checkedOrder.isCorrect) {
+				shouldFixOrder = true;
 			}
-		}
-	});
+		});
+
+		if (shouldFixOrder) {
+			const sortingOptions = {
+				'properties-order': createFlatOrder(sharedInfo.expectation),
+				'unspecified-properties-position':
+					sharedInfo.unspecified === 'ignore' ? 'bottom' : sharedInfo.unspecified,
+			};
 
-	if (shouldFixOrder && sharedInfo.isFixEnabled) {
-		const sortingOptions = {
-			'properties-order': createFlatOrder(sharedInfo.expectation),
-			'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] });
 
-		// creating PostCSS Root node with current node as a child,
-		// so PostCSS Sorting can process it
-		const tempRoot = postcss.root({ nodes: [originalNode] });
+			postcssSorting(sortingOptions)(tempRoot);
 
-		postcssSorting(sortingOptions)(tempRoot);
+			const allPropData2 = getAllPropData(node);
+
+			allPropData2.forEach(checkEveryPropForOrder);
+		}
 	}
 
+	// Second, check emptyLineBefore
 	sharedInfo.lastKnownSeparatedGroup = 1;
 
 	const allNodesData = node.nodes.map(function collectDataForEveryNode(child) {
 		return getNodeData(child, sharedInfo.expectedOrder);
 	});
 
-	// Second, check emptyLineBefore
 	allNodesData.forEach(function checkEveryPropForEmptyLine(nodeData, index) {
 		let previousNodeData = allNodesData[index - 1];
 
@@ -101,6 +92,43 @@ module.exports = function checkNode(node, sharedInfo, originalNode) {
 			return;
 		}
 
-		checkEmptyLineBefore(previousNodeData, nodeData, sharedInfo);
+		checkEmptyLineBefore(previousNodeData, nodeData, sharedInfo, propsCount);
 	});
+
+	function checkEveryPropForOrder(propData, index, listOfProps) {
+		// Skip first decl
+		if (index === 0) {
+			return;
+		}
+
+		const previousPropData = listOfProps[index - 1];
+
+		const checkedOrder = checkOrder({
+			firstPropData: previousPropData,
+			secondPropData: propData,
+			unspecified: sharedInfo.unspecified,
+			allPropData: listOfProps.slice(0, index),
+		});
+
+		if (!checkedOrder.isCorrect) {
+			const { orderData } = checkedOrder.secondNode;
+
+			stylelint.utils.report({
+				message: sharedInfo.messages.expected(
+					checkedOrder.secondNode.name,
+					checkedOrder.firstNode.name,
+					orderData && orderData.groupName
+				),
+				node: checkedOrder.secondNode.node,
+				result: sharedInfo.result,
+				ruleName: sharedInfo.ruleName,
+			});
+		}
+	}
+
+	function getAllPropData(inputNode) {
+		return inputNode.nodes
+			.filter(item => utils.isProperty(item))
+			.map(item => getNodeData(item, sharedInfo.expectedOrder));
+	}
 };

package/rules/properties-order/checkOrder.js

@@ -3,9 +3,9 @@ const _ = require('lodash');
 const checkAlphabeticalOrder = require('../checkAlphabeticalOrder');
 
 module.exports = function checkOrder({ firstPropData, secondPropData, allPropData, unspecified }) {
-	function report(result, firstNode = firstPropData, secondNode = secondPropData) {
+	function report(isCorrect, firstNode = firstPropData, secondNode = secondPropData) {
 		return {
-			result,
+			isCorrect,
 			firstNode,
 			secondNode,
 		};
@@ -23,17 +23,17 @@ module.exports = function checkOrder({ firstPropData, secondPropData, allPropDat
 		return report(true);
 	}
 
-	const firstPropIsUnspecified = !firstPropData.orderData;
-	const secondPropIsUnspecified = !secondPropData.orderData;
+	const firstPropIsSpecified = Boolean(firstPropData.orderData);
+	const secondPropIsSpecified = Boolean(secondPropData.orderData);
 
 	// Check actual known properties
-	if (!firstPropIsUnspecified && !secondPropIsUnspecified) {
+	if (firstPropIsSpecified && secondPropIsSpecified) {
 		return report(
 			firstPropData.orderData.expectedPosition <= secondPropData.orderData.expectedPosition
 		);
 	}
 
-	if (firstPropIsUnspecified && !secondPropIsUnspecified) {
+	if (!firstPropIsSpecified && secondPropIsSpecified) {
 		// If first prop is unspecified, look for a specified prop before it to
 		// compare to the current prop
 		const priorSpecifiedPropData = _.findLast(allPropData.slice(0, -1), d => Boolean(d.orderData));
@@ -49,11 +49,11 @@ module.exports = function checkOrder({ firstPropData, secondPropData, allPropDat
 
 	// Now deal with unspecified props
 	// Starting with bottomAlphabetical as it requires more specific conditionals
-	if (unspecified === 'bottomAlphabetical' && !firstPropIsUnspecified && secondPropIsUnspecified) {
+	if (unspecified === 'bottomAlphabetical' && firstPropIsSpecified && !secondPropIsSpecified) {
 		return report(true);
 	}
 
-	if (unspecified === 'bottomAlphabetical' && firstPropIsUnspecified && secondPropIsUnspecified) {
+	if (unspecified === 'bottomAlphabetical' && !firstPropIsSpecified && !secondPropIsSpecified) {
 		if (checkAlphabeticalOrder(firstPropData, secondPropData)) {
 			return report(true);
 		}
@@ -61,31 +61,31 @@ module.exports = function checkOrder({ firstPropData, secondPropData, allPropDat
 		return report(false);
 	}
 
-	if (unspecified === 'bottomAlphabetical' && firstPropIsUnspecified) {
+	if (unspecified === 'bottomAlphabetical' && !firstPropIsSpecified) {
 		return report(false);
 	}
 
-	if (firstPropIsUnspecified && secondPropIsUnspecified) {
+	if (!firstPropIsSpecified && !secondPropIsSpecified) {
 		return report(true);
 	}
 
-	if (unspecified === 'ignore' && (firstPropIsUnspecified || secondPropIsUnspecified)) {
+	if (unspecified === 'ignore' && (!firstPropIsSpecified || !secondPropIsSpecified)) {
 		return report(true);
 	}
 
-	if (unspecified === 'top' && firstPropIsUnspecified) {
+	if (unspecified === 'top' && !firstPropIsSpecified) {
 		return report(true);
 	}
 
-	if (unspecified === 'top' && secondPropIsUnspecified) {
+	if (unspecified === 'top' && !secondPropIsSpecified) {
 		return report(false);
 	}
 
-	if (unspecified === 'bottom' && secondPropIsUnspecified) {
+	if (unspecified === 'bottom' && !secondPropIsSpecified) {
 		return report(true);
 	}
 
-	if (unspecified === 'bottom' && firstPropIsUnspecified) {
+	if (unspecified === 'bottom' && !firstPropIsSpecified) {
 		return report(false);
 	}
 };

package/rules/properties-order/index.js

@@ -8,10 +8,10 @@ const validatePrimaryOption = require('./validatePrimaryOption');
 const ruleName = utils.namespace('properties-order');
 
 const messages = stylelint.utils.ruleMessages(ruleName, {
-	expected: (first, second, groupName) => `
-	  Expected "${first}" to come before "${second}"${groupName ? ` in group "${groupName}"` : ''}`,
+	expected: (first, second, groupName) =>
+		`Expected "${first}" to come before "${second}"${groupName ? ` in group "${groupName}"` : ''}`,
 	expectedEmptyLineBefore: property => `Expected an empty line before property "${property}"`,
-	rejectedEmptyLineBefore: property => `Unexpected an empty line before property "${property}"`,
+	rejectedEmptyLineBefore: property => `Unexpected empty line before property "${property}"`,
 });
 
 const rule = function(expectation, options, context = {}) {
@@ -27,7 +27,9 @@ const rule = function(expectation, options, context = {}) {
 				actual: options,
 				possible: {
 					unspecified: ['top', 'bottom', 'ignore', 'bottomAlphabetical'],
+					emptyLineBeforeUnspecified: ['always', 'never', 'threshold'],
 					disableFix: _.isBoolean,
+					emptyLineMinimumPropertyThreshold: _.isNumber,
 				},
 				optional: true,
 			}
@@ -39,6 +41,12 @@ const rule = function(expectation, options, context = {}) {
 
 		// 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;
 
@@ -48,6 +56,8 @@ const rule = function(expectation, options, context = {}) {
 			expectedOrder,
 			expectation,
 			unspecified,
+			emptyLineBeforeUnspecified,
+			emptyLineMinimumPropertyThreshold,
 			messages,
 			ruleName,
 			result,

package/rules/properties-order/validatePrimaryOption.js

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

package/rules/shorthandData.js

@@ -0,0 +1,144 @@
+'use strict';
+
+// See https://github.com/stylelint/stylelint/blob/10.1.0/lib/reference/shorthandData.js
+module.exports = {
+	margin: ['margin-top', 'margin-bottom', 'margin-left', 'margin-right'],
+	padding: ['padding-top', 'padding-bottom', 'padding-left', 'padding-right'],
+	background: [
+		'background-image',
+		'background-size',
+		'background-position',
+		'background-repeat',
+		'background-origin',
+		'background-clip',
+		'background-attachment',
+		'background-color',
+	],
+	font: [
+		'font-style',
+		'font-variant',
+		'font-weight',
+		'font-stretch',
+		'font-size',
+		'font-family',
+		'line-height',
+	],
+	border: [
+		'border-top-width',
+		'border-bottom-width',
+		'border-left-width',
+		'border-right-width',
+		'border-top-style',
+		'border-bottom-style',
+		'border-left-style',
+		'border-right-style',
+		'border-top-color',
+		'border-bottom-color',
+		'border-left-color',
+		'border-right-color',
+	],
+	'border-top': ['border-top-width', 'border-top-style', 'border-top-color'],
+	'border-bottom': ['border-bottom-width', 'border-bottom-style', 'border-bottom-color'],
+	'border-left': ['border-left-width', 'border-left-style', 'border-left-color'],
+	'border-right': ['border-right-width', 'border-right-style', 'border-right-color'],
+	'border-width': [
+		'border-top-width',
+		'border-bottom-width',
+		'border-left-width',
+		'border-right-width',
+	],
+	'border-style': [
+		'border-top-style',
+		'border-bottom-style',
+		'border-left-style',
+		'border-right-style',
+	],
+	'border-color': [
+		'border-top-color',
+		'border-bottom-color',
+		'border-left-color',
+		'border-right-color',
+	],
+	'list-style': ['list-style-type', 'list-style-position', 'list-style-image'],
+	'border-radius': [
+		'border-top-right-radius',
+		'border-top-left-radius',
+		'border-bottom-right-radius',
+		'border-bottom-left-radius',
+	],
+	transition: [
+		'transition-delay',
+		'transition-duration',
+		'transition-property',
+		'transition-timing-function',
+	],
+	animation: [
+		'animation-name',
+		'animation-duration',
+		'animation-timing-function',
+		'animation-delay',
+		'animation-iteration-count',
+		'animation-direction',
+		'animation-fill-mode',
+		'animation-play-state',
+	],
+	'border-block-end': [
+		'border-block-end-width',
+		'border-block-end-style',
+		'border-block-end-color',
+	],
+	'border-block-start': [
+		'border-block-start-width',
+		'border-block-start-style',
+		'border-block-start-color',
+	],
+	'border-image': [
+		'border-image-source',
+		'border-image-slice',
+		'border-image-width',
+		'border-image-outset',
+		'border-image-repeat',
+	],
+	'border-inline-end': [
+		'border-inline-end-width',
+		'border-inline-end-style',
+		'border-inline-end-color',
+	],
+	'border-inline-start': [
+		'border-inline-start-width',
+		'border-inline-start-style',
+		'border-inline-start-color',
+	],
+	'column-rule': ['column-rule-width', 'column-rule-style', 'column-rule-color'],
+	columns: ['column-width', 'column-count'],
+	flex: ['flex-grow', 'flex-shrink', 'flex-basis'],
+	'flex-flow': ['flex-direction', 'flex-wrap'],
+	grid: [
+		'grid-template-rows',
+		'grid-template-columns',
+		'grid-template-areas',
+		'grid-auto-rows',
+		'grid-auto-columns',
+		'grid-auto-flow',
+		'grid-column-gap',
+		'grid-row-gap',
+	],
+	'grid-area': ['grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end'],
+	'grid-column': ['grid-column-start', 'grid-column-end'],
+	'grid-gap': ['grid-row-gap', 'grid-column-gap'],
+	'grid-row': ['grid-row-start', 'grid-row-end'],
+	'grid-template': ['grid-template-columns', 'grid-template-rows', 'grid-template-areas'],
+	outline: ['outline-color', 'outline-style', 'outline-width'],
+	'text-decoration': ['text-decoration-color', 'text-decoration-style', 'text-decoration-line'],
+	'text-emphasis': ['text-emphasis-style', 'text-emphasis-color'],
+	mask: [
+		'mask-image',
+		'mask-mode',
+		'mask-position',
+		'mask-size',
+		'mask-repeat',
+		'mask-origin',
+		'mask-clip',
+		'mask-composite',
+	],
+};