eslint-plugin-yml 0.12.0 → 0.15.0

package/README.md

@@ -146,6 +146,18 @@ Example **.vscode/settings.json**:
 }
 ```
 
+### JetBrains WebStorm IDEs
+
+In any of the JetBrains IDEs you can [configure the linting scope](https://www.jetbrains.com/help/webstorm/eslint.html#ws_eslint_configure_scope).
+Following the steps in their help document, you can add YAML files to the scope like so:
+
+1. Open the **Settings/Preferences** dialog, go to **Languages and Frameworks** | **JavaScript** | **Code Quality Tools** | **ESLint**, and select **Automatic ESLint configuration** or **Manual ESLint configuration**.
+2. In the **Run for files** field, update the pattern that defines the set of files to be linted to include YAML files as well:
+```
+{**/*,*}.{js,ts,jsx,tsx,html,vue,yaml,yml}
+                                 ^^^^ ^^^
+```
+
 <!--USAGE_GUIDE_END-->
 <!--USAGE_SECTION_END-->
 
@@ -176,6 +188,8 @@ The rules with the following star :star: are included in the config.
 | [yml/plain-scalar](https://ota-meshi.github.io/eslint-plugin-yml/rules/plain-scalar.html) | require or disallow plain style scalar. | :wrench: |  | :star: |
 | [yml/quotes](https://ota-meshi.github.io/eslint-plugin-yml/rules/quotes.html) | enforce the consistent use of either double, or single quotes | :wrench: |  | :star: |
 | [yml/require-string-key](https://ota-meshi.github.io/eslint-plugin-yml/rules/require-string-key.html) | disallow mapping keys other than strings |  |  |  |
+| [yml/sort-keys](https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-keys.html) | require mapping keys to be sorted | :wrench: |  |  |
+| [yml/sort-sequence-values](https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-sequence-values.html) | require sequence values to be sorted | :wrench: |  |  |
 | [yml/vue-custom-block/no-parsing-error](https://ota-meshi.github.io/eslint-plugin-yml/rules/vue-custom-block/no-parsing-error.html) | disallow parsing errors in Vue custom blocks |  | :star: | :star: |
 
 ### Extension Rules
@@ -189,7 +203,6 @@ The rules with the following star :star: are included in the config.
 | [yml/key-spacing](https://ota-meshi.github.io/eslint-plugin-yml/rules/key-spacing.html) | enforce consistent spacing between keys and values in mapping pairs | :wrench: |  | :star: |
 | [yml/no-irregular-whitespace](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-irregular-whitespace.html) | disallow irregular whitespace |  | :star: | :star: |
 | [yml/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-multiple-empty-lines.html) | disallow multiple empty lines | :wrench: |  |  |
-| [yml/sort-keys](https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-keys.html) | require mapping keys to be sorted | :wrench: |  |  |
 | [yml/spaced-comment](https://ota-meshi.github.io/eslint-plugin-yml/rules/spaced-comment.html) | enforce consistent spacing after the `#` in a comment | :wrench: |  | :star: |
 
 <!--RULES_TABLE_END-->

package/lib/rules/indent.js

@@ -37,6 +37,7 @@ exports.default = (0, utils_1.createRule)("indent", {
         const sourceCode = context.getSourceCode();
         const offsets = new Map();
         const marks = new Set();
+        const blockLiteralMarks = new Set();
         const scalars = new Map();
         function setOffset(token, offset, baseToken, options) {
             var _a;
@@ -224,6 +225,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                     const literal = sourceCode.getLastToken(node);
                     setOffset(literal, 1, mark);
                     scalars.set(literal, node);
+                    blockLiteralMarks.add(mark);
                 }
                 else {
                     scalars.set(sourceCode.getFirstToken(node), node);
@@ -283,6 +285,10 @@ exports.default = (0, utils_1.createRule)("indent", {
                         1,
                     actualOffset: nextToken.range[0] - token.range[1],
                 });
+                if (blockLiteralMarks.has(nextToken)) {
+                    lineTokens.unshift(nextToken);
+                    break;
+                }
                 token = nextToken;
                 expectedIndent = nextExpectedIndent;
                 cacheExpectedIndent = expectedIndent;

package/lib/rules/sort-keys.js

@@ -23,6 +23,35 @@ function getPropertyName(node, sourceCode) {
     }
     return sourceCode.text.slice(...target.range);
 }
+class YAMLPairData {
+    constructor(mapping, node, index, anchorAlias) {
+        this.cachedName = null;
+        this.mapping = mapping;
+        this.node = node;
+        this.index = index;
+        this.anchorAlias = anchorAlias;
+    }
+    get reportLoc() {
+        var _a, _b;
+        return (_b = (_a = this.node.key) === null || _a === void 0 ? void 0 : _a.loc) !== null && _b !== void 0 ? _b : this.node.loc;
+    }
+    get name() {
+        var _a;
+        return ((_a = this.cachedName) !== null && _a !== void 0 ? _a : (this.cachedName = getPropertyName(this.node, this.mapping.sourceCode)));
+    }
+}
+class YAMLMappingData {
+    constructor(node, sourceCode, anchorAliasMap) {
+        this.cachedProperties = null;
+        this.node = node;
+        this.sourceCode = sourceCode;
+        this.anchorAliasMap = anchorAliasMap;
+    }
+    get pairs() {
+        var _a;
+        return ((_a = this.cachedProperties) !== null && _a !== void 0 ? _a : (this.cachedProperties = this.node.pairs.map((e, index) => new YAMLPairData(this, e, index, this.anchorAliasMap.get(e)))));
+    }
+}
 function isCompatibleWithESLintOptions(options) {
     if (options.length === 0) {
         return true;
@@ -44,7 +73,7 @@ function buildValidatorFromType(order, insensitive, natural) {
         const baseCompare = compare;
         compare = (args) => baseCompare(args.reverse());
     }
-    return (a, b) => compare([a, b]);
+    return (a, b) => compare([a.name, b.name]);
 }
 function parseOptions(options, sourceCode) {
     var _a, _b, _c;
@@ -56,16 +85,15 @@ function parseOptions(options, sourceCode) {
         const minKeys = (_c = obj.minKeys) !== null && _c !== void 0 ? _c : 2;
         return [
             {
-                isTargetMapping: () => true,
+                isTargetMapping: (data) => data.node.pairs.length >= minKeys,
                 ignore: () => false,
                 isValidOrder: buildValidatorFromType(type, insensitive, natural),
-                minKeys,
                 orderText: `${natural ? "natural " : ""}${insensitive ? "insensitive " : ""}${type}ending`,
             },
         ];
     }
     return options.map((opt) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const order = opt.order;
         const pathPattern = new RegExp(opt.pathPattern);
         const hasProperties = (_a = opt.hasProperties) !== null && _a !== void 0 ? _a : [];
@@ -78,30 +106,65 @@ function parseOptions(options, sourceCode) {
                 isTargetMapping,
                 ignore: () => false,
                 isValidOrder: buildValidatorFromType(type, insensitive, natural),
-                minKeys,
                 orderText: `${natural ? "natural " : ""}${insensitive ? "insensitive " : ""}${type}ending`,
             };
         }
+        const parsedOrder = [];
+        for (const o of order) {
+            if (typeof o === "string") {
+                parsedOrder.push({
+                    test: (data) => data.name === o,
+                    isValidNestOrder: () => true,
+                });
+            }
+            else {
+                const keyPattern = o.keyPattern
+                    ? new RegExp(o.keyPattern)
+                    : null;
+                const nestOrder = (_d = o.order) !== null && _d !== void 0 ? _d : {};
+                const type = (_e = nestOrder.type) !== null && _e !== void 0 ? _e : "asc";
+                const insensitive = nestOrder.caseSensitive === false;
+                const natural = Boolean(nestOrder.natural);
+                parsedOrder.push({
+                    test: (data) => keyPattern ? keyPattern.test(data.name) : true,
+                    isValidNestOrder: buildValidatorFromType(type, insensitive, natural),
+                });
+            }
+        }
         return {
             isTargetMapping,
-            ignore: (s) => !order.includes(s),
+            ignore: (data) => parsedOrder.every((p) => !p.test(data)),
             isValidOrder(a, b) {
-                const aIndex = order.indexOf(a);
-                const bIndex = order.indexOf(b);
-                return aIndex <= bIndex;
+                for (const p of parsedOrder) {
+                    const matchA = p.test(a);
+                    const matchB = p.test(b);
+                    if (!matchA || !matchB) {
+                        if (matchA) {
+                            return true;
+                        }
+                        if (matchB) {
+                            return false;
+                        }
+                        continue;
+                    }
+                    return p.isValidNestOrder(a, b);
+                }
+                return false;
             },
-            minKeys,
             orderText: "specified",
         };
-        function isTargetMapping(node) {
+        function isTargetMapping(data) {
+            if (data.node.pairs.length < minKeys) {
+                return false;
+            }
             if (hasProperties.length > 0) {
-                const names = new Set(node.pairs.map((p) => getPropertyName(p, sourceCode)));
+                const names = new Set(data.pairs.map((p) => p.name));
                 if (!hasProperties.every((name) => names.has(name))) {
                     return false;
                 }
             }
             let path = "";
-            let curr = node;
+            let curr = data.node;
             let p = curr.parent;
             while (p) {
                 if (p.type === "YAMLPair") {
@@ -127,13 +190,28 @@ function parseOptions(options, sourceCode) {
         }
     });
 }
-const allowOrderTypes = ["asc", "desc"];
+const ALLOW_ORDER_TYPES = ["asc", "desc"];
+const ORDER_OBJECT_SCHEMA = {
+    type: "object",
+    properties: {
+        type: {
+            enum: ALLOW_ORDER_TYPES,
+        },
+        caseSensitive: {
+            type: "boolean",
+        },
+        natural: {
+            type: "boolean",
+        },
+    },
+    additionalProperties: false,
+};
 exports.default = (0, utils_1.createRule)("sort-keys", {
     meta: {
         docs: {
             description: "require mapping keys to be sorted",
             categories: null,
-            extensionRule: "sort-keys",
+            extensionRule: false,
             layout: false,
         },
         fixable: "code",
@@ -153,24 +231,24 @@ exports.default = (0, utils_1.createRule)("sort-keys", {
                                 oneOf: [
                                     {
                                         type: "array",
-                                        items: { type: "string" },
-                                        uniqueItems: true,
-                                    },
-                                    {
-                                        type: "object",
-                                        properties: {
-                                            type: {
-                                                enum: allowOrderTypes,
-                                            },
-                                            caseSensitive: {
-                                                type: "boolean",
-                                            },
-                                            natural: {
-                                                type: "boolean",
-                                            },
+                                        items: {
+                                            anyOf: [
+                                                { type: "string" },
+                                                {
+                                                    type: "object",
+                                                    properties: {
+                                                        keyPattern: {
+                                                            type: "string",
+                                                        },
+                                                        order: ORDER_OBJECT_SCHEMA,
+                                                    },
+                                                    additionalProperties: false,
+                                                },
+                                            ],
                                         },
-                                        additionalProperties: false,
+                                        uniqueItems: true,
                                     },
+                                    ORDER_OBJECT_SCHEMA,
                                 ],
                             },
                             minKeys: {
@@ -187,7 +265,7 @@ exports.default = (0, utils_1.createRule)("sort-keys", {
                     type: "array",
                     items: [
                         {
-                            enum: allowOrderTypes,
+                            enum: ALLOW_ORDER_TYPES,
                         },
                         {
                             type: "object",
@@ -216,51 +294,81 @@ exports.default = (0, utils_1.createRule)("sort-keys", {
         type: "suggestion",
     },
     create(context) {
-        const sourceCode = context.getSourceCode();
         if (!context.parserServices.isYAML) {
             return {};
         }
+        const sourceCode = context.getSourceCode();
         const parsedOptions = parseOptions(context.options, sourceCode);
-        let mappingStack = {
-            upper: null,
-            prevList: [],
-            numKeys: 0,
-            option: null,
-        };
-        let pairStack = {
-            upper: null,
-            anchors: new Set(),
-            aliases: new Set(),
-        };
         function isValidOrder(prevData, thisData, option) {
-            if (option.isValidOrder(prevData.name, thisData.name)) {
+            if (option.isValidOrder(prevData, thisData)) {
                 return true;
             }
-            for (const aliasName of thisData.aliases) {
-                if (prevData.anchors.has(aliasName)) {
+            for (const aliasName of thisData.anchorAlias.aliases) {
+                if (prevData.anchorAlias.anchors.has(aliasName)) {
                     return true;
                 }
             }
-            for (const anchorName of thisData.anchors) {
-                if (prevData.aliases.has(anchorName)) {
+            for (const anchorName of thisData.anchorAlias.anchors) {
+                if (prevData.anchorAlias.aliases.has(anchorName)) {
                     return true;
                 }
             }
             return false;
         }
+        function ignore(data, option) {
+            if (!data.node.key && !data.node.value) {
+                return true;
+            }
+            return option.ignore(data);
+        }
+        function verifyPair(data, option) {
+            if (ignore(data, option)) {
+                return;
+            }
+            const prevList = data.mapping.pairs
+                .slice(0, data.index)
+                .reverse()
+                .filter((d) => !ignore(d, option));
+            if (prevList.length === 0) {
+                return;
+            }
+            const prev = prevList[0];
+            if (!isValidOrder(prev, data, option)) {
+                context.report({
+                    loc: data.reportLoc,
+                    messageId: "sortKeys",
+                    data: {
+                        thisName: data.name,
+                        prevName: prev.name,
+                        orderText: option.orderText,
+                    },
+                    *fix(fixer) {
+                        let moveTarget = prevList[0];
+                        for (const prev of prevList) {
+                            if (isValidOrder(prev, data, option)) {
+                                break;
+                            }
+                            else {
+                                moveTarget = prev;
+                            }
+                        }
+                        if (data.mapping.node.style === "flow") {
+                            yield* fixForFlow(fixer, data, moveTarget);
+                        }
+                        else {
+                            yield* fixForBlock(fixer, data, moveTarget);
+                        }
+                    },
+                });
+            }
+        }
+        let pairStack = {
+            upper: null,
+            anchors: new Set(),
+            aliases: new Set(),
+        };
+        const anchorAliasMap = new Map();
         return {
-            YAMLMapping(node) {
-                mappingStack = {
-                    upper: mappingStack,
-                    prevList: [],
-                    numKeys: node.pairs.length,
-                    option: parsedOptions.find((o) => o.isTargetMapping(node)) ||
-                        null,
-                };
-            },
-            "YAMLMapping:exit"() {
-                mappingStack = mappingStack.upper;
-            },
             YAMLPair() {
                 pairStack = {
                     upper: pairStack,
@@ -279,69 +387,28 @@ exports.default = (0, utils_1.createRule)("sort-keys", {
                 }
             },
             "YAMLPair:exit"(node) {
-                var _a, _b;
+                anchorAliasMap.set(node, pairStack);
                 const { anchors, aliases } = pairStack;
                 pairStack = pairStack.upper;
                 pairStack.anchors = new Set([...pairStack.anchors, ...anchors]);
                 pairStack.aliases = new Set([...pairStack.aliases, ...aliases]);
-                if (!node.key && !node.value) {
-                    return;
-                }
-                const option = mappingStack.option;
+            },
+            "YAMLMapping:exit"(node) {
+                const data = new YAMLMappingData(node, sourceCode, anchorAliasMap);
+                const option = parsedOptions.find((o) => o.isTargetMapping(data));
                 if (!option) {
                     return;
                 }
-                const thisName = getPropertyName(node, sourceCode);
-                if (option.ignore(thisName)) {
-                    return;
-                }
-                const prevList = mappingStack.prevList;
-                const numKeys = mappingStack.numKeys;
-                const thisData = {
-                    name: thisName,
-                    node,
-                    anchors,
-                    aliases,
-                };
-                mappingStack.prevList = [thisData, ...prevList];
-                if (prevList.length === 0 || numKeys < option.minKeys) {
-                    return;
-                }
-                if (!isValidOrder(prevList[0], thisData, option)) {
-                    context.report({
-                        loc: (_b = (_a = node.key) === null || _a === void 0 ? void 0 : _a.loc) !== null && _b !== void 0 ? _b : node.loc,
-                        messageId: "sortKeys",
-                        data: {
-                            thisName,
-                            prevName: prevList[0].name,
-                            orderText: option.orderText,
-                        },
-                        *fix(fixer) {
-                            let moveTarget = prevList[0].node;
-                            for (const prev of prevList) {
-                                if (isValidOrder(prev, thisData, option)) {
-                                    break;
-                                }
-                                else {
-                                    moveTarget = prev.node;
-                                }
-                            }
-                            if (node.parent.style === "flow") {
-                                yield* fixForFlow(fixer, node, moveTarget);
-                            }
-                            else {
-                                yield* fixForBlock(fixer, node, moveTarget);
-                            }
-                        },
-                    });
+                for (const pair of data.pairs) {
+                    verifyPair(pair, option);
                 }
             },
         };
-        function* fixForFlow(fixer, node, moveTarget) {
-            const beforeCommaToken = sourceCode.getTokenBefore(node);
+        function* fixForFlow(fixer, data, moveTarget) {
+            const beforeCommaToken = sourceCode.getTokenBefore(data.node);
             let insertCode, removeRange, insertTargetToken;
-            const afterCommaToken = sourceCode.getTokenAfter(node);
-            const moveTargetBeforeToken = sourceCode.getTokenBefore(moveTarget);
+            const afterCommaToken = sourceCode.getTokenAfter(data.node);
+            const moveTargetBeforeToken = sourceCode.getTokenBefore(moveTarget.node);
             if ((0, ast_utils_1.isComma)(afterCommaToken)) {
                 removeRange = [
                     beforeCommaToken.range[1],
@@ -351,22 +418,22 @@ exports.default = (0, utils_1.createRule)("sort-keys", {
                 insertTargetToken = moveTargetBeforeToken;
             }
             else {
-                removeRange = [beforeCommaToken.range[0], node.range[1]];
+                removeRange = [beforeCommaToken.range[0], data.node.range[1]];
                 if ((0, ast_utils_1.isComma)(moveTargetBeforeToken)) {
                     insertCode = sourceCode.text.slice(...removeRange);
                     insertTargetToken = sourceCode.getTokenBefore(moveTargetBeforeToken);
                 }
                 else {
-                    insertCode = `${sourceCode.text.slice(beforeCommaToken.range[1], node.range[1])},`;
+                    insertCode = `${sourceCode.text.slice(beforeCommaToken.range[1], data.node.range[1])},`;
                     insertTargetToken = moveTargetBeforeToken;
                 }
             }
             yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
             yield fixer.removeRange(removeRange);
         }
-        function* fixForBlock(fixer, node, moveTarget) {
-            const nodeLocs = getPairRangeForBlock(node);
-            const moveTargetLocs = getPairRangeForBlock(moveTarget);
+        function* fixForBlock(fixer, data, moveTarget) {
+            const nodeLocs = getPairRangeForBlock(data.node);
+            const moveTargetLocs = getPairRangeForBlock(moveTarget.node);
             if (moveTargetLocs.loc.start.column === 0) {
                 const removeRange = [
                     getNewlineStartIndex(nodeLocs.range[0]),

package/lib/rules/sort-sequence-values.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export default _default;

package/lib/rules/sort-sequence-values.js

@@ -0,0 +1,512 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const natural_compare_1 = __importDefault(require("natural-compare"));
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const yaml_eslint_parser_1 = require("yaml-eslint-parser");
+class YAMLEntryData {
+    constructor(sequence, node, index, anchorAlias) {
+        this.cached = null;
+        this.cachedRange = null;
+        this.cachedAroundTokens = null;
+        this.sequence = sequence;
+        this.node = node;
+        this.index = index;
+        this.anchorAlias = anchorAlias;
+    }
+    get reportLoc() {
+        if (this.node) {
+            return this.node.loc;
+        }
+        const aroundTokens = this.aroundTokens;
+        return {
+            start: aroundTokens.before.loc.end,
+            end: aroundTokens.after.loc.start,
+        };
+    }
+    get range() {
+        if (this.node) {
+            return this.node.range;
+        }
+        if (this.cachedRange) {
+            return this.cachedRange;
+        }
+        const aroundTokens = this.aroundTokens;
+        return (this.cachedRange = [
+            aroundTokens.before.range[1],
+            aroundTokens.after.range[0],
+        ]);
+    }
+    get aroundTokens() {
+        if (this.cachedAroundTokens) {
+            return this.cachedAroundTokens;
+        }
+        const sourceCode = this.sequence.sourceCode;
+        if (this.node) {
+            return (this.cachedAroundTokens = {
+                before: sourceCode.getTokenBefore(this.node),
+                after: sourceCode.getTokenAfter(this.node),
+            });
+        }
+        const before = this.index > 0
+            ? this.sequence.entries[this.index - 1].aroundTokens.after
+            : sourceCode.getFirstToken(this.sequence.node);
+        const after = sourceCode.getTokenAfter(before);
+        return (this.cachedAroundTokens = { before, after });
+    }
+    get value() {
+        var _a;
+        return ((_a = this.cached) !== null && _a !== void 0 ? _a : (this.cached = {
+            value: this.node == null ? null : (0, yaml_eslint_parser_1.getStaticYAMLValue)(this.node),
+        })).value;
+    }
+}
+class YAMLSequenceData {
+    constructor(node, sourceCode, anchorAliasMap) {
+        this.cachedEntries = null;
+        this.node = node;
+        this.sourceCode = sourceCode;
+        this.anchorAliasMap = anchorAliasMap;
+    }
+    get entries() {
+        var _a;
+        return ((_a = this.cachedEntries) !== null && _a !== void 0 ? _a : (this.cachedEntries = this.node.entries.map((e, index) => new YAMLEntryData(this, e, index, this.anchorAliasMap.get(e)))));
+    }
+}
+function buildValidatorFromType(order, insensitive, natural) {
+    let compareValue = ([a, b]) => a <= b;
+    let compareText = compareValue;
+    if (natural) {
+        compareText = ([a, b]) => (0, natural_compare_1.default)(a, b) <= 0;
+    }
+    if (insensitive) {
+        const baseCompareText = compareText;
+        compareText = ([a, b]) => baseCompareText([a.toLowerCase(), b.toLowerCase()]);
+    }
+    if (order === "desc") {
+        const baseCompareText = compareText;
+        compareText = (args) => baseCompareText(args.reverse());
+        const baseCompareValue = compareValue;
+        compareValue = (args) => baseCompareValue(args.reverse());
+    }
+    return (a, b) => {
+        if (typeof a.value === "string" && typeof b.value === "string") {
+            return compareText([a.value, b.value]);
+        }
+        const type = getYAMLPrimitiveType(a.value);
+        if (type && type === getYAMLPrimitiveType(b.value)) {
+            return compareValue([a.value, b.value]);
+        }
+        return true;
+    };
+}
+function parseOptions(options, sourceCode) {
+    return options.map((opt) => {
+        var _a, _b, _c, _d;
+        const order = opt.order;
+        const pathPattern = new RegExp(opt.pathPattern);
+        const minValues = (_a = opt.minValues) !== null && _a !== void 0 ? _a : 2;
+        if (!Array.isArray(order)) {
+            const type = (_b = order.type) !== null && _b !== void 0 ? _b : "asc";
+            const insensitive = order.caseSensitive === false;
+            const natural = Boolean(order.natural);
+            return {
+                isTargetArray,
+                ignore: () => false,
+                isValidOrder: buildValidatorFromType(type, insensitive, natural),
+                orderText(data) {
+                    if (typeof data.value === "string") {
+                        return `${natural ? "natural " : ""}${insensitive ? "insensitive " : ""}${type}ending`;
+                    }
+                    return `${type}ending`;
+                },
+            };
+        }
+        const parsedOrder = [];
+        for (const o of order) {
+            if (typeof o === "string") {
+                parsedOrder.push({
+                    test: (v) => v.value === o,
+                    isValidNestOrder: () => true,
+                });
+            }
+            else {
+                const valuePattern = o.valuePattern
+                    ? new RegExp(o.valuePattern)
+                    : null;
+                const nestOrder = (_c = o.order) !== null && _c !== void 0 ? _c : {};
+                const type = (_d = nestOrder.type) !== null && _d !== void 0 ? _d : "asc";
+                const insensitive = nestOrder.caseSensitive === false;
+                const natural = Boolean(nestOrder.natural);
+                parsedOrder.push({
+                    test: (v) => valuePattern
+                        ? Boolean(getYAMLPrimitiveType(v.value)) &&
+                            valuePattern.test(String(v.value))
+                        : true,
+                    isValidNestOrder: buildValidatorFromType(type, insensitive, natural),
+                });
+            }
+        }
+        return {
+            isTargetArray,
+            ignore: (v) => parsedOrder.every((p) => !p.test(v)),
+            isValidOrder(a, b) {
+                for (const p of parsedOrder) {
+                    const matchA = p.test(a);
+                    const matchB = p.test(b);
+                    if (!matchA || !matchB) {
+                        if (matchA) {
+                            return true;
+                        }
+                        if (matchB) {
+                            return false;
+                        }
+                        continue;
+                    }
+                    return p.isValidNestOrder(a, b);
+                }
+                return false;
+            },
+            orderText: () => "specified",
+        };
+        function isTargetArray(data) {
+            if (data.node.entries.length < minValues) {
+                return false;
+            }
+            let path = "";
+            let curr = data.node;
+            let p = curr.parent;
+            while (p) {
+                if (p.type === "YAMLPair") {
+                    const name = getPropertyName(p);
+                    if (/^[$_a-z][\w$]*$/iu.test(name)) {
+                        path = `.${name}${path}`;
+                    }
+                    else {
+                        path = `[${JSON.stringify(name)}]${path}`;
+                    }
+                }
+                else if (p.type === "YAMLSequence") {
+                    const index = p.entries.indexOf(curr);
+                    path = `[${index}]${path}`;
+                }
+                curr = p;
+                p = curr.parent;
+            }
+            if (path.startsWith(".")) {
+                path = path.slice(1);
+            }
+            return pathPattern.test(path);
+        }
+    });
+    function getPropertyName(node) {
+        const prop = node.key;
+        if (prop == null) {
+            return "";
+        }
+        const target = prop.type === "YAMLWithMeta" ? prop.value : prop;
+        if (target == null) {
+            return "";
+        }
+        if (target.type === "YAMLScalar" && typeof target.value === "string") {
+            return target.value;
+        }
+        return sourceCode.text.slice(...target.range);
+    }
+}
+function getYAMLPrimitiveType(val) {
+    const t = typeof val;
+    if (t === "string" || t === "number" || t === "boolean" || t === "bigint") {
+        return t;
+    }
+    if (val === null) {
+        return "null";
+    }
+    if (val === undefined) {
+        return "undefined";
+    }
+    if (val instanceof RegExp) {
+        return "regexp";
+    }
+    return null;
+}
+const ALLOW_ORDER_TYPES = ["asc", "desc"];
+const ORDER_OBJECT_SCHEMA = {
+    type: "object",
+    properties: {
+        type: {
+            enum: ALLOW_ORDER_TYPES,
+        },
+        caseSensitive: {
+            type: "boolean",
+        },
+        natural: {
+            type: "boolean",
+        },
+    },
+    additionalProperties: false,
+};
+exports.default = (0, utils_1.createRule)("sort-sequence-values", {
+    meta: {
+        docs: {
+            description: "require sequence values to be sorted",
+            categories: null,
+            extensionRule: false,
+            layout: false,
+        },
+        fixable: "code",
+        schema: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    pathPattern: { type: "string" },
+                    order: {
+                        oneOf: [
+                            {
+                                type: "array",
+                                items: {
+                                    anyOf: [
+                                        { type: "string" },
+                                        {
+                                            type: "object",
+                                            properties: {
+                                                valuePattern: {
+                                                    type: "string",
+                                                },
+                                                order: ORDER_OBJECT_SCHEMA,
+                                            },
+                                            additionalProperties: false,
+                                        },
+                                    ],
+                                },
+                                uniqueItems: true,
+                            },
+                            ORDER_OBJECT_SCHEMA,
+                        ],
+                    },
+                    minValues: {
+                        type: "integer",
+                        minimum: 2,
+                    },
+                },
+                required: ["pathPattern", "order"],
+                additionalProperties: false,
+            },
+            minItems: 1,
+        },
+        messages: {
+            sortValues: "Expected sequence values to be in {{orderText}} order. '{{thisValue}}' should be before '{{prevValue}}'.",
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isYAML) {
+            return {};
+        }
+        const sourceCode = context.getSourceCode();
+        const parsedOptions = parseOptions(context.options, sourceCode);
+        function isValidOrder(prevData, thisData, option) {
+            if (option.isValidOrder(prevData, thisData)) {
+                return true;
+            }
+            for (const aliasName of thisData.anchorAlias.aliases) {
+                if (prevData.anchorAlias.anchors.has(aliasName)) {
+                    return true;
+                }
+            }
+            for (const anchorName of thisData.anchorAlias.anchors) {
+                if (prevData.anchorAlias.aliases.has(anchorName)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function verifyArrayElement(data, option) {
+            if (option.ignore(data)) {
+                return;
+            }
+            const prevList = data.sequence.entries
+                .slice(0, data.index)
+                .reverse()
+                .filter((d) => !option.ignore(d));
+            if (prevList.length === 0) {
+                return;
+            }
+            const prev = prevList[0];
+            if (!isValidOrder(prev, data, option)) {
+                const reportLoc = data.reportLoc;
+                context.report({
+                    loc: reportLoc,
+                    messageId: "sortValues",
+                    data: {
+                        thisValue: toText(data),
+                        prevValue: toText(prev),
+                        orderText: option.orderText(data),
+                    },
+                    *fix(fixer) {
+                        let moveTarget = prevList[0];
+                        for (const prev of prevList) {
+                            if (isValidOrder(prev, data, option)) {
+                                break;
+                            }
+                            else {
+                                moveTarget = prev;
+                            }
+                        }
+                        if (data.sequence.node.style === "flow") {
+                            yield* fixForFlow(fixer, data, moveTarget);
+                        }
+                        else {
+                            yield* fixForBlock(fixer, data, moveTarget);
+                        }
+                    },
+                });
+            }
+        }
+        function toText(data) {
+            if (getYAMLPrimitiveType(data.value)) {
+                return String(data.value);
+            }
+            return sourceCode.getText(data.node);
+        }
+        let entryStack = {
+            upper: null,
+            anchors: new Set(),
+            aliases: new Set(),
+        };
+        const anchorAliasMap = new Map();
+        return {
+            "YAMLSequence > *"(node) {
+                if (!node.parent.entries.includes(node)) {
+                    return;
+                }
+                entryStack = {
+                    upper: entryStack,
+                    anchors: new Set(),
+                    aliases: new Set(),
+                };
+                if (node.type === "YAMLAlias") {
+                    entryStack.aliases.add(node.name);
+                }
+            },
+            YAMLAnchor(node) {
+                if (entryStack) {
+                    entryStack.anchors.add(node.name);
+                }
+            },
+            YAMLAlias(node) {
+                if (entryStack) {
+                    entryStack.aliases.add(node.name);
+                }
+            },
+            "YAMLSequence > *:exit"(node) {
+                if (!node.parent.entries.includes(node)) {
+                    return;
+                }
+                anchorAliasMap.set(node, entryStack);
+                const { anchors, aliases } = entryStack;
+                entryStack = entryStack.upper;
+                entryStack.anchors = new Set([
+                    ...entryStack.anchors,
+                    ...anchors,
+                ]);
+                entryStack.aliases = new Set([
+                    ...entryStack.aliases,
+                    ...aliases,
+                ]);
+            },
+            "YAMLSequence:exit"(node) {
+                const data = new YAMLSequenceData(node, sourceCode, anchorAliasMap);
+                const option = parsedOptions.find((o) => o.isTargetArray(data));
+                if (!option) {
+                    return;
+                }
+                for (const element of data.entries) {
+                    verifyArrayElement(element, option);
+                }
+            },
+        };
+        function* fixForFlow(fixer, data, moveTarget) {
+            const beforeToken = data.aroundTokens.before;
+            const afterToken = data.aroundTokens.after;
+            let insertCode, removeRange, insertTargetToken;
+            if ((0, ast_utils_1.isComma)(afterToken)) {
+                removeRange = [beforeToken.range[1], afterToken.range[1]];
+                insertCode = sourceCode.text.slice(...removeRange);
+                insertTargetToken = moveTarget.aroundTokens.before;
+            }
+            else {
+                removeRange = [beforeToken.range[0], data.range[1]];
+                if ((0, ast_utils_1.isComma)(moveTarget.aroundTokens.before)) {
+                    insertCode = sourceCode.text.slice(...removeRange);
+                    insertTargetToken = sourceCode.getTokenBefore(moveTarget.aroundTokens.before);
+                }
+                else {
+                    insertCode = `${sourceCode.text.slice(beforeToken.range[1], data.range[1])},`;
+                    insertTargetToken = moveTarget.aroundTokens.before;
+                }
+            }
+            yield fixer.insertTextAfterRange(insertTargetToken.range, insertCode);
+            yield fixer.removeRange(removeRange);
+        }
+        function* fixForBlock(fixer, data, moveTarget) {
+            const moveDataList = data.sequence.entries.slice(moveTarget.index, data.index + 1);
+            let replacementCodeRange = getBlockEntryRange(data);
+            for (const target of moveDataList) {
+                const range = getBlockEntryRange(target);
+                yield fixer.replaceTextRange(range, sourceCode.text.slice(...replacementCodeRange));
+                replacementCodeRange = range;
+            }
+        }
+        function getBlockEntryRange(data) {
+            return [
+                getBlockEntryStartOffset(data),
+                getBlockEntryEndOffset(data),
+            ];
+        }
+        function getBlockEntryStartOffset(data) {
+            const beforeHyphenToken = sourceCode.getTokenBefore(data.aroundTokens.before);
+            if (!beforeHyphenToken) {
+                const comment = sourceCode.getTokenBefore(data.aroundTokens.before, {
+                    includeComments: true,
+                });
+                if (comment &&
+                    data.aroundTokens.before.loc.start.column <=
+                        comment.loc.start.column) {
+                    return comment.range[0];
+                }
+                return data.aroundTokens.before.range[0];
+            }
+            let next = sourceCode.getTokenAfter(beforeHyphenToken, {
+                includeComments: true,
+            });
+            while (beforeHyphenToken.loc.end.line === next.loc.start.line &&
+                next.range[1] < data.aroundTokens.before.range[0]) {
+                next = sourceCode.getTokenAfter(next, {
+                    includeComments: true,
+                });
+            }
+            return next.range[0];
+        }
+        function getBlockEntryEndOffset(data) {
+            var _a;
+            const valueEndToken = (_a = data.node) !== null && _a !== void 0 ? _a : data.aroundTokens.before;
+            let last = valueEndToken;
+            let afterToken = sourceCode.getTokenAfter(last, {
+                includeComments: true,
+            });
+            while (afterToken &&
+                valueEndToken.loc.end.line === afterToken.loc.start.line) {
+                last = afterToken;
+                afterToken = sourceCode.getTokenAfter(last, {
+                    includeComments: true,
+                });
+            }
+            return last.range[1];
+        }
+    },
+});

package/lib/utils/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/lib/utils/rules.js

@@ -26,6 +26,7 @@ const plain_scalar_1 = __importDefault(require("../rules/plain-scalar"));
 const quotes_1 = __importDefault(require("../rules/quotes"));
 const require_string_key_1 = __importDefault(require("../rules/require-string-key"));
 const sort_keys_1 = __importDefault(require("../rules/sort-keys"));
+const sort_sequence_values_1 = __importDefault(require("../rules/sort-sequence-values"));
 const spaced_comment_1 = __importDefault(require("../rules/spaced-comment"));
 const no_parsing_error_1 = __importDefault(require("../rules/vue-custom-block/no-parsing-error"));
 exports.rules = [
@@ -51,6 +52,7 @@ exports.rules = [
     quotes_1.default,
     require_string_key_1.default,
     sort_keys_1.default,
+    sort_sequence_values_1.default,
     spaced_comment_1.default,
     no_parsing_error_1.default,
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-yml",
-    "version": "0.12.0",
+    "version": "0.15.0",
     "description": "This ESLint plugin provides linting rules for YAML.",
     "main": "lib/index.js",
     "files": [
@@ -42,6 +42,7 @@
         "yml"
     ],
     "author": "Yosuke Ota",
+    "funding": "https://github.com/sponsors/ota-meshi",
     "license": "MIT",
     "bugs": {
         "url": "https://github.com/ota-meshi/eslint-plugin-yml/issues"
@@ -62,7 +63,7 @@
         "@types/eslint": "^8.0.0",
         "@types/eslint-scope": "^3.7.0",
         "@types/eslint-visitor-keys": "^1.0.0",
-        "@types/estree": "^0.0.50",
+        "@types/estree": "^0.0.51",
         "@types/lodash": "^4.14.158",
         "@types/mocha": "^9.0.0",
         "@types/natural-compare": "^1.4.0",
@@ -80,27 +81,27 @@
         "eslint-plugin-jsonc": "^2.0.0",
         "eslint-plugin-markdown": "^2.0.0-0",
         "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-node-dependencies": "^0.6.0",
+        "eslint-plugin-node-dependencies": "^0.8.0",
         "eslint-plugin-prettier": "^4.0.0",
         "eslint-plugin-regexp": "^1.0.0",
         "eslint-plugin-vue": "^8.0.0",
-        "eslint-plugin-yml": "^0.11.0",
+        "eslint-plugin-yml": "^0.14.0",
         "eslint4b": "^7.3.1",
         "espree": "^9.0.0",
-        "mocha": "^9.0.0",
-        "monaco-editor": "^0.30.0",
+        "mocha": "^10.0.0",
+        "monaco-editor": "^0.33.0",
         "nyc": "^15.1.0",
         "prettier": "^2.2.1",
         "raw-loader": "^4.0.1",
         "semver": "^7.3.2",
         "stylelint": "^14.0.0",
         "stylelint-config-recommended-vue": "^1.0.0",
-        "stylelint-config-standard": "^24.0.0",
+        "stylelint-config-standard": "^25.0.0",
         "stylelint-plugin-stylus": "^0.13.0",
         "ts-node": "^10.0.0",
-        "typescript": "~4.5.0",
+        "typescript": "~4.6.0",
         "vue-eslint-editor": "^1.1.0",
-        "vue-eslint-parser": "^8.0.0",
+        "vue-eslint-parser": "^9.0.0",
         "vuepress": "^1.5.2"
     }
 }