From 31666df09f5bf1704946d7dfad36e4a9014139c5 Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 16 Sep 2022 15:06:39 +0800
Subject: [PATCH 1/8] Add block-attributes-order rule

---
 .gitignore                                |   1 +
 lib/rules/attributes-order.js             |   8 +-
 lib/rules/block-attributes-order.js       | 317 ++++++++++++++++++++++
 tests/lib/rules/block-attributes-order.js | 234 ++++++++++++++++
 4 files changed, 556 insertions(+), 4 deletions(-)
 create mode 100644 lib/rules/block-attributes-order.js
 create mode 100644 tests/lib/rules/block-attributes-order.js

diff --git a/.gitignore b/.gitignore
index e1401b951..1333c6c46 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ yarn.lock
 yarn-error.log
 docs/.vuepress/dist
 typings/eslint/lib/rules
+.DS_Store
diff --git a/lib/rules/attributes-order.js b/lib/rules/attributes-order.js
index d88e9c934..46b634bba 100644
--- a/lib/rules/attributes-order.js
+++ b/lib/rules/attributes-order.js
@@ -382,10 +382,10 @@ module.exports = {
                 {
                   type: 'array',
                   items: {
-                    enum: Object.values(ATTRS),
-                    uniqueItems: true,
-                    additionalItems: false
-                  }
+                    enum: Object.values(ATTRS)
+                  },
+                  uniqueItems: true,
+                  additionalItems: false
                 }
               ]
             },
diff --git a/lib/rules/block-attributes-order.js b/lib/rules/block-attributes-order.js
new file mode 100644
index 000000000..43d9a1e96
--- /dev/null
+++ b/lib/rules/block-attributes-order.js
@@ -0,0 +1,317 @@
+/**
+ * @fileoverview enforce ordering of block attributes
+ * @author Wenlu Wang
+ */
+'use strict'
+const utils = require('../utils')
+
+/**
+ * @enum {string}
+ */
+const WELL_KNOWN_TEMPLATE_ATTRS = {
+  functional: 'functional',
+  lang: 'lang',
+  src: 'src'
+}
+
+/**
+ * @enum {string}
+ */
+const WELL_KNOWN_SCRIPT_ATTRS = {
+  lang: 'lang',
+  setup: 'setup',
+  src: 'src'
+}
+
+/**
+ * @enum {string}
+ */
+const WELL_KNOWN_STYLE_ATTRS = {
+  scoped: 'scoped',
+  module: 'module',
+  lang: 'lang',
+  src: 'src'
+}
+
+/**
+ * @template {string} T
+ * @typedef {T | T[]} OrderItem
+ */
+
+/**
+ * @typedef WellKnownOrders
+ * @property { OrderItem<WELL_KNOWN_TEMPLATE_ATTRS>[] } [template]
+ * @property { OrderItem<WELL_KNOWN_SCRIPT_ATTRS>[] } [script]
+ * @property { OrderItem<WELL_KNOWN_STYLE_ATTRS>[] } [style]
+ */
+
+/**
+ * @typedef UserOptions
+ * @property {WellKnownOrders & Record<string, OrderItem<string>[]>} [order]
+ */
+
+/**
+ * Normalizes a given options.
+ * @param {UserOptions?} options An option to parse.
+ * @return {WellKnownOrders & Record<string, OrderItem<string>[]>}
+ */
+function normalizeOptions(options) {
+  if (!options || !options.order) {
+    return {
+      template: [
+        WELL_KNOWN_TEMPLATE_ATTRS.functional,
+        WELL_KNOWN_TEMPLATE_ATTRS.lang,
+        WELL_KNOWN_TEMPLATE_ATTRS.src
+      ],
+      script: [
+        WELL_KNOWN_SCRIPT_ATTRS.lang,
+        WELL_KNOWN_SCRIPT_ATTRS.setup,
+        WELL_KNOWN_SCRIPT_ATTRS.src
+      ],
+      style: [
+        WELL_KNOWN_STYLE_ATTRS.lang,
+        WELL_KNOWN_STYLE_ATTRS.module,
+        WELL_KNOWN_STYLE_ATTRS.scoped,
+        WELL_KNOWN_STYLE_ATTRS.src
+      ]
+    }
+  }
+  return options.order
+}
+
+/**
+ * @param {WellKnownOrders & Record<string, OrderItem<string>[]>} order
+ */
+function normalizeAttributePositions(order) {
+  /**
+   * @type { Record<string, Record<string, number>> }
+   */
+  const attributePositions = {}
+  for (const [blockName, blockOrder] of Object.entries(order)) {
+    /**
+     * @type { Record<string, number> }
+     */
+    const attributePosition = {}
+    for (const [i, o] of blockOrder.entries()) {
+      if (Array.isArray(o)) {
+        for (const attr of o) {
+          attributePosition[attr] = i
+        }
+      } else {
+        attributePosition[o] = i
+      }
+    }
+    attributePositions[blockName] = attributePosition
+  }
+  return attributePositions
+}
+
+/**
+ * @param {VAttribute | VDirective} attribute
+ * @param { Record<string, number> } attributePosition
+ * @returns {number | null}
+ */
+function getPosition(attribute, attributePosition) {
+  if (attribute.directive) {
+    return null
+  }
+
+  return attributePosition[attribute.key.name]
+}
+
+/**
+ * @param {VStartTag} node
+ * @param {Record<string, number>} attributePosition
+ */
+function getAttributeAndPositionList(node, attributePosition) {
+  /**
+   * @type {{ attr: (VAttribute | VDirective), position: number }[]}
+   */
+  const results = []
+  for (const attr of node.attributes) {
+    const position = getPosition(attr, attributePosition)
+    if (position == null) {
+      continue
+    }
+    results.push({ attr, position })
+  }
+  return results
+}
+
+/**
+ * @param {RuleContext} context - The rule context.
+ * @returns {RuleListener} AST event handlers.
+ */
+function create(context) {
+  const sourceCode = context.getSourceCode()
+  const order = normalizeOptions(context.options[0])
+  const attributeAndPositions = normalizeAttributePositions(order)
+
+  /**
+   * @param {VAttribute | VDirective} node
+   * @param {VAttribute | VDirective} previousNode
+   */
+  function reportIssue(node, previousNode) {
+    const currentNodeText = sourceCode.getText(node.key)
+    const prevNode = sourceCode.getText(previousNode.key)
+
+    /**
+     * @param {RuleFixer} fixer
+     */
+    function fix(fixer) {
+      const attributes = node.parent.attributes
+
+      const previousNodes = attributes.slice(
+        attributes.indexOf(previousNode),
+        attributes.indexOf(node)
+      )
+      const moveNodes = [node]
+      for (const n of previousNodes) {
+        moveNodes.push(n)
+      }
+
+      return moveNodes.map((moveNode, index) => {
+        const text = sourceCode.getText(moveNode)
+        return fixer.replaceText(previousNodes[index] || node, text)
+      })
+    }
+
+    context.report({
+      node,
+      message: `Attribute "${currentNodeText}" should go before "${prevNode}".`,
+      data: {
+        currentNodeText
+      },
+      fix
+    })
+  }
+
+  /**
+   * @param {VElement} element
+   * @returns {void}
+   */
+  function verify(element) {
+    const tag = element.name
+    const attributePosition = attributeAndPositions[tag]
+    if (!attributePosition) {
+      return
+    }
+
+    const attributeAndPositionList = getAttributeAndPositionList(
+      element.startTag,
+      attributePosition
+    )
+    if (attributeAndPositionList.length <= 1) {
+      return
+    }
+
+    let { attr: previousNode, position: previousPosition } =
+      attributeAndPositionList[0]
+    for (let index = 1; index < attributeAndPositionList.length; index++) {
+      const { attr, position } = attributeAndPositionList[index]
+      if (previousPosition <= position) {
+        previousNode = attr
+        previousPosition = position
+      } else {
+        reportIssue(attr, previousNode)
+      }
+    }
+  }
+
+  return utils.defineDocumentVisitor(context, {
+    'VDocumentFragment > VElement': verify
+  })
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce order of block attributes',
+      categories: undefined,
+      url: 'https://eslint.vuejs.org/rules/block-attributes-order.html'
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          order: {
+            type: 'object',
+            properties: {
+              template: {
+                type: 'array',
+                items: {
+                  anyOf: [
+                    { enum: Object.values(WELL_KNOWN_TEMPLATE_ATTRS) },
+                    { type: 'string' },
+                    {
+                      type: 'array',
+                      items: {
+                        anyOf: [
+                          { enum: Object.values(WELL_KNOWN_TEMPLATE_ATTRS) },
+                          { type: 'string' }
+                        ]
+                      },
+                      uniqueItems: true
+                    }
+                  ]
+                },
+                uniqueItems: true
+              },
+              script: {
+                type: 'array',
+                items: {
+                  anyOf: [
+                    { enum: Object.values(WELL_KNOWN_SCRIPT_ATTRS) },
+                    { type: 'string' },
+                    {
+                      type: 'array',
+                      items: {
+                        anyOf: [
+                          { enum: Object.values(WELL_KNOWN_SCRIPT_ATTRS) },
+                          { type: 'string' }
+                        ]
+                      },
+                      uniqueItems: true
+                    }
+                  ]
+                },
+                uniqueItems: true
+              },
+              style: {
+                type: 'array',
+                items: {
+                  anyOf: [
+                    { enum: Object.values(WELL_KNOWN_STYLE_ATTRS) },
+                    { type: 'string' },
+                    {
+                      type: 'array',
+                      items: {
+                        anyOf: [
+                          { enum: Object.values(WELL_KNOWN_STYLE_ATTRS) },
+                          { type: 'string' }
+                        ]
+                      },
+                      uniqueItems: true
+                    }
+                  ]
+                },
+                uniqueItems: true
+              }
+            },
+            additionalProperties: {
+              type: 'array',
+              items: {
+                type: 'string'
+              },
+              uniqueItems: true
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create
+}
diff --git a/tests/lib/rules/block-attributes-order.js b/tests/lib/rules/block-attributes-order.js
new file mode 100644
index 000000000..0aa80d6dd
--- /dev/null
+++ b/tests/lib/rules/block-attributes-order.js
@@ -0,0 +1,234 @@
+/**
+ * @fileoverview enforce ordering of block attributes
+ * @author Wenlu Wang
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const rule = require('../../../lib/rules/block-attributes-order')
+const RuleTester = require('eslint').RuleTester
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+const tester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: { ecmaVersion: 2015 }
+})
+tester.run('block-attributes-order', rule, {
+  valid: [
+    {
+      filename: 'test-template-without-attributes.vue',
+      code: `<template><div></div><template>`
+    },
+    {
+      filename: 'test-template-with-one-attribute.vue',
+      code: `<template functional><div></div><template>`
+    },
+    {
+      filename: 'test-template-attributes.vue',
+      code: `<template functional lang="pug" src="./template.html"><template>`
+    },
+    {
+      filename: 'test-script-without-attributes.vue',
+      code: `<script></script>`
+    },
+    {
+      filename: 'test-script-with-one-attribute.vue',
+      code: `<script lang="ts"></script>`
+    },
+    {
+      filename: 'test-script-attributes.vue',
+      code: `<script lang="ts" setup src="./script.js"></script>`
+    },
+    {
+      filename: 'test-style-without-attributes.vue',
+      code: `<style><style>`
+    },
+    {
+      filename: 'test-style-with-one-attribute.vue',
+      code: `<style lang="less"><style>`
+    },
+    {
+      filename: 'test-style-attributes.vue',
+      code: `<style lang="less" module scoped src="./style.css"><style>`
+    },
+    {
+      filename: 'test-custom-block-without-attributes.vue',
+      code: `<foobarbaz><foobarbaz>`
+    },
+    {
+      filename: 'test-custom-block-with-one-attribute.vue',
+      code: `<foobarbaz foo><foobarbaz>`
+    },
+    {
+      filename: 'test-custom-block-with-attributes.vue',
+      code: `<foobarbaz foo bar baz="baz"><foobarbaz>`
+    },
+    {
+      filename: 'test-attributes-with-unknown-attribute.vue',
+      code: `<template functional foo lang="pug" src="./template.html"><template>`
+    },
+    {
+      filename: 'test-attributes-options.vue',
+      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', 'scoped', 'src', 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-with-unknown-attribute.vue',
+      code: `<template functional foo lang="pug" src="./template.html"><template>`,
+      options: [
+        {
+          order: {
+            template: ['functional', 'foo', 'lang', 'src']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-not-specify-some-attribute-1.vue',
+      code: `<style module src="./style.css" lang="less" scoped><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', 'src', 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-not-specify-some-attribute-2.vue',
+      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', 'src', 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-not-specify-some-attribute-3.vue',
+      code: `<style scoped module src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', 'src', 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-with-batch-order-1.vue',
+      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', ['scoped', 'src'], 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-attributes-options-with-batch-order-2.vue',
+      code: `<style module src="./style.css" scoped lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['module', ['scoped', 'src'], 'lang']
+          }
+        }
+      ]
+    },
+    {
+      filename: 'test-custom-block-with-attributes-options.vue',
+      code: `<foobarbaz foo bar baz="baz"><foobarbaz>`,
+      options: [
+        {
+          order: {
+            foobarbaz: ['foo', 'bar', 'baz']
+          }
+        }
+      ]
+    }
+  ],
+  invalid: [
+    {
+      filename: 'test-template-attributes-with-invalid-order.vue',
+      code: '<template src="./template.html" lang="pug" functional><template>',
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "lang" should go before "src".`
+        },
+        {
+          type: 'VAttribute',
+          message: `Attribute "functional" should go before "src".`
+        }
+      ],
+      output: `<template lang="pug" src="./template.html" functional><template>`
+    },
+    {
+      filename: 'test-script-attributes-with-invalid-order.vue',
+      code: `<script src="./script.js" setup lang="ts"></script>`,
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "setup" should go before "src".`
+        },
+        {
+          type: 'VAttribute',
+          message: `Attribute "lang" should go before "src".`
+        }
+      ],
+      output: `<script setup src="./script.js" lang="ts"></script>`
+    },
+    {
+      filename: 'test-style-attributes-with-invalid-order.vue',
+      code: `<style src="./style.css" scoped module lang="less"><style>`,
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "scoped" should go before "src".`
+        },
+        {
+          type: 'VAttribute',
+          message: `Attribute "module" should go before "src".`
+        },
+        {
+          type: 'VAttribute',
+          message: `Attribute "lang" should go before "src".`
+        }
+      ],
+      output: `<style scoped src="./style.css" module lang="less"><style>`
+    },
+    {
+      filename: 'test-attributes-options-not-default-order.vue',
+      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['scoped', 'module', 'src', 'lang']
+          }
+        }
+      ],
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "scoped" should go before "module".`
+        }
+      ],
+      output: `<style scoped module src="./style.css" lang="less"><style>`
+    }
+  ]
+})

From fd3a907909c3d2fb2962c0b1a9c0e25720ddc943 Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 16 Sep 2022 15:22:33 +0800
Subject: [PATCH 2/8] Add more tests

---
 tests/lib/rules/block-attributes-order.js | 40 +++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tests/lib/rules/block-attributes-order.js b/tests/lib/rules/block-attributes-order.js
index 0aa80d6dd..1b5609916 100644
--- a/tests/lib/rules/block-attributes-order.js
+++ b/tests/lib/rules/block-attributes-order.js
@@ -229,6 +229,46 @@ tester.run('block-attributes-order', rule, {
         }
       ],
       output: `<style scoped module src="./style.css" lang="less"><style>`
+    },
+    {
+      filename: 'test-custom-block-with-invalid-order.vue',
+      code: `<foobarbaz baz="baz" bar foo><foobarbaz>`,
+      options: [
+        {
+          order: {
+            foobarbaz: ['foo', 'bar', 'baz']
+          }
+        }
+      ],
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "bar" should go before "baz".`
+        },
+        {
+          type: 'VAttribute',
+          message: `Attribute "foo" should go before "baz".`
+        }
+      ],
+      output: `<foobarbaz bar baz="baz" foo><foobarbaz>`
+    },
+    {
+      filename: 'test-style-attributes-with-batch-order-and-invalid-order.vue',
+      code: `<style scoped src="./style.css" lang="less"><style>`,
+      options: [
+        {
+          order: {
+            style: ['lang', ['src', 'scoped']]
+          }
+        }
+      ],
+      errors: [
+        {
+          type: 'VAttribute',
+          message: `Attribute "lang" should go before "src".`
+        }
+      ],
+      output: `<style scoped lang="less" src="./style.css"><style>`
     }
   ]
 })

From d98cf6f596f558ada4df8ef88a5a766514a787dc Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 16 Sep 2022 15:55:50 +0800
Subject: [PATCH 3/8] Add docs

---
 docs/rules/README.md                 |  3 +-
 docs/rules/block-attributes-order.md | 81 ++++++++++++++++++++++++++++
 lib/index.js                         |  1 +
 3 files changed, 84 insertions(+), 1 deletion(-)
 create mode 100644 docs/rules/block-attributes-order.md

diff --git a/docs/rules/README.md b/docs/rules/README.md
index de00e7e53..e8b021fe7 100644
--- a/docs/rules/README.md
+++ b/docs/rules/README.md
@@ -197,7 +197,7 @@ For example:
 ```json
 {
   "rules": {
-    "vue/block-lang": "error"
+    "vue/block-attributes-order": "error"
   }
 }
 ```
@@ -206,6 +206,7 @@ For example:
 
 | Rule ID | Description |    |    |
 |:--------|:------------|:--:|:--:|
+| [vue/block-attributes-order](./block-attributes-order.md) | enforce order of block attributes | :wrench: | :hammer: |
 | [vue/block-lang](./block-lang.md) | disallow use other than available `lang` |  | :hammer: |
 | [vue/block-tag-newline](./block-tag-newline.md) | enforce line breaks after opening and before closing block-level tags | :wrench: | :lipstick: |
 | [vue/component-api-style](./component-api-style.md) | enforce component API style |  | :hammer: |
diff --git a/docs/rules/block-attributes-order.md b/docs/rules/block-attributes-order.md
new file mode 100644
index 000000000..42a85eb7c
--- /dev/null
+++ b/docs/rules/block-attributes-order.md
@@ -0,0 +1,81 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/block-attributes-order
+description: enforce order of block attributes
+since: v4.3.0
+---
+# vue/block-attributes-order
+
+> enforce order of block attributes
+
+- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the problems reported by this rule.
+
+## :book: Rule Details
+
+This rule aims to enforce ordering of block attributes. 
+
+### the default order
+
+<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
+
+```vue
+<template functional lang="pug" src="./template.pug"></template>
+<script lang="ts" setup src="./script.ts"></script>
+<style lang="css" module scoped src="./style.css"></style>
+```
+
+</eslint-code-block>
+
+<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
+
+```vue
+<template src="./template.pug" functional lang="pug"></template>
+<script src="./script.ts" setup lang="ts"></script>
+<style src="./style.css" scoped module lang="css"></style>
+```
+
+</eslint-code-block>
+
+
+### Custom orders
+
+<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {
+  order: {
+    template: ['src', 'lang', 'functional'],
+    script: ['src', 'setup', 'lang'],
+    style: [['src', 'scoped'], 'module', 'lang']
+  }
+}]}">
+
+```vue
+<template functional lang="pug" src="./template.pug"></template>
+<script lang="ts" setup src="./script.ts"></script>
+<style lang="css" module scoped src="./style.css"></style>
+```
+
+</eslint-code-block>
+
+### Custom blocks
+
+<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {
+  order: {
+    foobarbaz: ['foo', 'bar', 'baz']
+  }
+}]}">
+
+```vue
+<foobarbaz foo bar baz></foobarbaz>
+<foobarbaz baz bar foo></foobarbaz>
+```
+
+</eslint-code-block>
+
+## :rocket: Version
+
+This rule was introduced in eslint-plugin-vue v4.3.0
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/block-attributes-order.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/block-attributes-order.js)
diff --git a/lib/index.js b/lib/index.js
index ca3a93084..4513aa0f3 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -12,6 +12,7 @@ module.exports = {
     'arrow-spacing': require('./rules/arrow-spacing'),
     'attribute-hyphenation': require('./rules/attribute-hyphenation'),
     'attributes-order': require('./rules/attributes-order'),
+    'block-attributes-order': require('./rules/block-attributes-order'),
     'block-lang': require('./rules/block-lang'),
     'block-spacing': require('./rules/block-spacing'),
     'block-tag-newline': require('./rules/block-tag-newline'),

From 5dd0f4c10b71cd9743a7348d7ae94bc6eebf965d Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 16 Sep 2022 17:46:54 +0800
Subject: [PATCH 4/8] Make lint happy

---
 docs/rules/block-attributes-order.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/docs/rules/block-attributes-order.md b/docs/rules/block-attributes-order.md
index 42a85eb7c..9bfa2db2b 100644
--- a/docs/rules/block-attributes-order.md
+++ b/docs/rules/block-attributes-order.md
@@ -13,9 +13,9 @@ since: v4.3.0
 
 ## :book: Rule Details
 
-This rule aims to enforce ordering of block attributes. 
+This rule aims to enforce ordering of block attributes.
 
-### the default order
+### The default order
 
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
 
@@ -37,7 +37,6 @@ This rule aims to enforce ordering of block attributes.
 
 </eslint-code-block>
 
-
 ### Custom orders
 
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {

From 335075727e3604d5800ad9f0bcec6975e4982841 Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Mon, 19 Sep 2022 11:01:33 +0800
Subject: [PATCH 5/8] fix: improve docs

---
 docs/rules/block-attributes-order.md | 12 ++++++++++++
 lib/rules/block-attributes-order.js  | 18 ++++++++++++------
 2 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/docs/rules/block-attributes-order.md b/docs/rules/block-attributes-order.md
index 9bfa2db2b..c1b55e2c8 100644
--- a/docs/rules/block-attributes-order.md
+++ b/docs/rules/block-attributes-order.md
@@ -17,6 +17,18 @@ This rule aims to enforce ordering of block attributes.
 
 ### The default order
 
+#### Template
+
+`['functional', 'lang', 'src']`
+
+#### Script
+
+`['lang', 'setup', 'src']`
+
+#### Style
+
+`['lang', 'module', 'scoped', 'src']`
+
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
 
 ```vue
diff --git a/lib/rules/block-attributes-order.js b/lib/rules/block-attributes-order.js
index 43d9a1e96..d600f63dc 100644
--- a/lib/rules/block-attributes-order.js
+++ b/lib/rules/block-attributes-order.js
@@ -45,18 +45,24 @@ const WELL_KNOWN_STYLE_ATTRS = {
  * @property { OrderItem<WELL_KNOWN_STYLE_ATTRS>[] } [style]
  */
 
+/**
+ * @typedef {WellKnownOrders & Record<string, OrderItem<string>[]>} OrderOptions
+ */
+
 /**
  * @typedef UserOptions
- * @property {WellKnownOrders & Record<string, OrderItem<string>[]>} [order]
+ * @property {OrderOptions} [order]
  */
 
 /**
  * Normalizes a given options.
- * @param {UserOptions?} options An option to parse.
- * @return {WellKnownOrders & Record<string, OrderItem<string>[]>}
+ * @param {UserOptions} [options] An option to parse.
+ * @return {OrderOptions}
  */
-function normalizeOptions(options) {
+function normalizeOrderOptions(options) {
   if (!options || !options.order) {
+    // Default attribute orders.
+    // First item of the list will be the first attributes.
     return {
       template: [
         WELL_KNOWN_TEMPLATE_ATTRS.functional,
@@ -80,7 +86,7 @@ function normalizeOptions(options) {
 }
 
 /**
- * @param {WellKnownOrders & Record<string, OrderItem<string>[]>} order
+ * @param {OrderOptions} order
  */
 function normalizeAttributePositions(order) {
   /**
@@ -144,7 +150,7 @@ function getAttributeAndPositionList(node, attributePosition) {
  */
 function create(context) {
   const sourceCode = context.getSourceCode()
-  const order = normalizeOptions(context.options[0])
+  const order = normalizeOrderOptions(context.options[0])
   const attributeAndPositions = normalizeAttributePositions(order)
 
   /**

From 4be649cbe024ce6521f52307b204529cdef4d95f Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Mon, 19 Sep 2022 13:48:13 +0800
Subject: [PATCH 6/8] Fix default order

---
 docs/rules/block-attributes-order.md      | 18 +++++++++---------
 lib/rules/block-attributes-order.js       |  4 ++--
 tests/lib/rules/block-attributes-order.js |  8 ++++----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/docs/rules/block-attributes-order.md b/docs/rules/block-attributes-order.md
index c1b55e2c8..5bebb4831 100644
--- a/docs/rules/block-attributes-order.md
+++ b/docs/rules/block-attributes-order.md
@@ -23,18 +23,18 @@ This rule aims to enforce ordering of block attributes.
 
 #### Script
 
-`['lang', 'setup', 'src']`
+`['setup', 'lang', 'src']`
 
 #### Style
 
-`['lang', 'module', 'scoped', 'src']`
+`['module', 'scoped', 'lang', 'src']`
 
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
 
 ```vue
 <template functional lang="pug" src="./template.pug"></template>
-<script lang="ts" setup src="./script.ts"></script>
-<style lang="css" module scoped src="./style.css"></style>
+<script setup lang="ts" src="./script.ts"></script>
+<style module scoped lang="css" src="./style.css"></style>
 ```
 
 </eslint-code-block>
@@ -43,8 +43,8 @@ This rule aims to enforce ordering of block attributes.
 
 ```vue
 <template src="./template.pug" functional lang="pug"></template>
-<script src="./script.ts" setup lang="ts"></script>
-<style src="./style.css" scoped module lang="css"></style>
+<script src="./script.ts" lang="ts" setup></script>
+<style src="./style.css" lang="css" scoped module></style>
 ```
 
 </eslint-code-block>
@@ -54,15 +54,15 @@ This rule aims to enforce ordering of block attributes.
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {
   order: {
     template: ['src', 'lang', 'functional'],
-    script: ['src', 'setup', 'lang'],
+    script: ['src', 'lang', 'setup'],
     style: [['src', 'scoped'], 'module', 'lang']
   }
 }]}">
 
 ```vue
 <template functional lang="pug" src="./template.pug"></template>
-<script lang="ts" setup src="./script.ts"></script>
-<style lang="css" module scoped src="./style.css"></style>
+<script src="./script.ts" lang="ts" setup></script>
+<style src="./style.css" scoped module lang="css"></style>
 ```
 
 </eslint-code-block>
diff --git a/lib/rules/block-attributes-order.js b/lib/rules/block-attributes-order.js
index d600f63dc..ac54f254a 100644
--- a/lib/rules/block-attributes-order.js
+++ b/lib/rules/block-attributes-order.js
@@ -70,14 +70,14 @@ function normalizeOrderOptions(options) {
         WELL_KNOWN_TEMPLATE_ATTRS.src
       ],
       script: [
-        WELL_KNOWN_SCRIPT_ATTRS.lang,
         WELL_KNOWN_SCRIPT_ATTRS.setup,
+        WELL_KNOWN_SCRIPT_ATTRS.lang,
         WELL_KNOWN_SCRIPT_ATTRS.src
       ],
       style: [
-        WELL_KNOWN_STYLE_ATTRS.lang,
         WELL_KNOWN_STYLE_ATTRS.module,
         WELL_KNOWN_STYLE_ATTRS.scoped,
+        WELL_KNOWN_STYLE_ATTRS.lang,
         WELL_KNOWN_STYLE_ATTRS.src
       ]
     }
diff --git a/tests/lib/rules/block-attributes-order.js b/tests/lib/rules/block-attributes-order.js
index 1b5609916..2d8c644a4 100644
--- a/tests/lib/rules/block-attributes-order.js
+++ b/tests/lib/rules/block-attributes-order.js
@@ -43,7 +43,7 @@ tester.run('block-attributes-order', rule, {
     },
     {
       filename: 'test-script-attributes.vue',
-      code: `<script lang="ts" setup src="./script.js"></script>`
+      code: `<script setup lang="ts" src="./script.js"></script>`
     },
     {
       filename: 'test-style-without-attributes.vue',
@@ -55,7 +55,7 @@ tester.run('block-attributes-order', rule, {
     },
     {
       filename: 'test-style-attributes.vue',
-      code: `<style lang="less" module scoped src="./style.css"><style>`
+      code: `<style module scoped lang="less" src="./style.css"><style>`
     },
     {
       filename: 'test-custom-block-without-attributes.vue',
@@ -75,11 +75,11 @@ tester.run('block-attributes-order', rule, {
     },
     {
       filename: 'test-attributes-options.vue',
-      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      code: `<style module lang="less" scoped src="./style.css"><style>`,
       options: [
         {
           order: {
-            style: ['module', 'scoped', 'src', 'lang']
+            style: ['module', 'lang', 'scoped', 'src']
           }
         }
       ]

From b234ffad33b858e30f5439b3228dfd876d951f95 Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 14 Oct 2022 18:01:46 +0800
Subject: [PATCH 7/8] fix: cr issues

---
 docs/rules/block-attributes-order.md      |  85 +++++--
 lib/rules/block-attributes-order.js       | 283 +++++++++++-----------
 tests/lib/rules/block-attributes-order.js | 244 ++++++++++++-------
 3 files changed, 358 insertions(+), 254 deletions(-)

diff --git a/docs/rules/block-attributes-order.md b/docs/rules/block-attributes-order.md
index 5bebb4831..025faa6da 100644
--- a/docs/rules/block-attributes-order.md
+++ b/docs/rules/block-attributes-order.md
@@ -17,17 +17,35 @@ This rule aims to enforce ordering of block attributes.
 
 ### The default order
 
-#### Template
-
-`['functional', 'lang', 'src']`
-
-#### Script
-
-`['setup', 'lang', 'src']`
-
-#### Style
-
-`['module', 'scoped', 'lang', 'src']`
+```json
+[
+  {
+    "element": "style",
+    "order": [
+      "module",
+      "scoped",
+      "lang",
+      "src"
+    ]
+  },
+  {
+    "element": "script",
+    "order": [
+      "setup",
+      "lang",
+      "src"
+    ]
+  },
+  {
+    "element": "template",
+    "order": [
+      "functional",
+      "lang",
+      "src"
+    ]
+  }
+]
+```
 
 <eslint-code-block fix :rules="{'vue/block-attributes-order': ['error']}">
 
@@ -51,17 +69,32 @@ This rule aims to enforce ordering of block attributes.
 
 ### Custom orders
 
-<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {
-  order: {
-    template: ['src', 'lang', 'functional'],
-    script: ['src', 'lang', 'setup'],
-    style: [['src', 'scoped'], 'module', 'lang']
-  }
-}]}">
+<eslint-code-block fix :rules="{'vue/block-attributes-order': [
+  'error',
+  [
+    {
+      element: 'template',
+      order: ['src', 'lang', 'functional']
+    },
+    {
+      element: 'script[setup]',
+      order: ['setup', 'src|foo', 'lang']
+    },
+    {
+      element: 'script',
+      order: ['src', 'lang', 'setup']
+    },
+    {
+      element: 'style',
+      order: [['src', 'scoped'], 'module', 'lang']
+    }
+  ]
+]}">
 
 ```vue
 <template functional lang="pug" src="./template.pug"></template>
-<script src="./script.ts" lang="ts" setup></script>
+<script src="./script.ts" lang="ts"></script>
+<script src="./script.ts" lang="ts" setup foo></script>
 <style src="./style.css" scoped module lang="css"></style>
 ```
 
@@ -69,11 +102,15 @@ This rule aims to enforce ordering of block attributes.
 
 ### Custom blocks
 
-<eslint-code-block fix :rules="{'vue/block-attributes-order': ['error', {
-  order: {
-    foobarbaz: ['foo', 'bar', 'baz']
-  }
-}]}">
+<eslint-code-block fix :rules="{'vue/block-attributes-order': [
+  'error',
+  [
+    {
+      element: 'foobarbaz',
+      order: ['foo', 'bar', 'baz']
+    }
+  ]
+]}">
 
 ```vue
 <foobarbaz foo bar baz></foobarbaz>
diff --git a/lib/rules/block-attributes-order.js b/lib/rules/block-attributes-order.js
index ac54f254a..06c24c5c9 100644
--- a/lib/rules/block-attributes-order.js
+++ b/lib/rules/block-attributes-order.js
@@ -4,6 +4,7 @@
  */
 'use strict'
 const utils = require('../utils')
+const { parseSelector } = require('../utils/selector')
 
 /**
  * @enum {string}
@@ -34,108 +35,131 @@ const WELL_KNOWN_STYLE_ATTRS = {
 }
 
 /**
- * @template {string} T
- * @typedef {T | T[]} OrderItem
+ * @typedef UserOrderOption
+ * @property { string } element
+ * @property { (string | string[])[] } order
  */
 
 /**
- * @typedef WellKnownOrders
- * @property { OrderItem<WELL_KNOWN_TEMPLATE_ATTRS>[] } [template]
- * @property { OrderItem<WELL_KNOWN_SCRIPT_ATTRS>[] } [script]
- * @property { OrderItem<WELL_KNOWN_STYLE_ATTRS>[] } [style]
+ * @typedef {import('../utils/selector').VElementSelector} VElementSelector
  */
 
 /**
- * @typedef {WellKnownOrders & Record<string, OrderItem<string>[]>} OrderOptions
+ * @typedef OrderOption
+ * @property {string} element
+ * @property {(string | string[])[]} order
+ * @property {(RegExp | RegExp[])[]} regexOrder
+ * @property {VElementSelector} selector
  */
 
 /**
- * @typedef UserOptions
- * @property {OrderOptions} [order]
+ * @type {readonly UserOrderOption[]}
  */
+const defaultOptions = Object.freeze([
+  {
+    element: 'style',
+    order: [
+      WELL_KNOWN_STYLE_ATTRS.module,
+      WELL_KNOWN_STYLE_ATTRS.scoped,
+      WELL_KNOWN_STYLE_ATTRS.lang,
+      WELL_KNOWN_STYLE_ATTRS.src
+    ]
+  },
+  {
+    element: 'script',
+    order: [
+      WELL_KNOWN_SCRIPT_ATTRS.setup,
+      WELL_KNOWN_SCRIPT_ATTRS.lang,
+      WELL_KNOWN_SCRIPT_ATTRS.src
+    ]
+  },
+  {
+    element: 'template',
+    order: [
+      WELL_KNOWN_TEMPLATE_ATTRS.functional,
+      WELL_KNOWN_TEMPLATE_ATTRS.lang,
+      WELL_KNOWN_TEMPLATE_ATTRS.src
+    ]
+  }
+])
 
 /**
- * Normalizes a given options.
- * @param {UserOptions} [options] An option to parse.
- * @return {OrderOptions}
+ *
+ * @param {string | string[]} item
+ * @return {RegExp | RegExp[]}
  */
-function normalizeOrderOptions(options) {
-  if (!options || !options.order) {
-    // Default attribute orders.
-    // First item of the list will be the first attributes.
-    return {
-      template: [
-        WELL_KNOWN_TEMPLATE_ATTRS.functional,
-        WELL_KNOWN_TEMPLATE_ATTRS.lang,
-        WELL_KNOWN_TEMPLATE_ATTRS.src
-      ],
-      script: [
-        WELL_KNOWN_SCRIPT_ATTRS.setup,
-        WELL_KNOWN_SCRIPT_ATTRS.lang,
-        WELL_KNOWN_SCRIPT_ATTRS.src
-      ],
-      style: [
-        WELL_KNOWN_STYLE_ATTRS.module,
-        WELL_KNOWN_STYLE_ATTRS.scoped,
-        WELL_KNOWN_STYLE_ATTRS.lang,
-        WELL_KNOWN_STYLE_ATTRS.src
-      ]
-    }
+function ordersToRegexOrders(item) {
+  return Array.isArray(item) ? item.map((x) => new RegExp(x)) : new RegExp(item)
+}
+
+/**
+ * @param {UserOrderOption} option
+ * @param {RuleContext} context
+ * @return {OrderOption}
+ */
+function normalizeUserOrderOption(option, context) {
+  return {
+    ...option,
+    selector: parseSelector(option.element, context),
+    regexOrder: option.order.map(ordersToRegexOrders)
   }
-  return options.order
 }
 
 /**
- * @param {OrderOptions} order
+ * @param {readonly UserOrderOption[] | undefined} options
+ * @param {RuleContext} context
+ * @returns {OrderOption[]}
  */
-function normalizeAttributePositions(order) {
-  /**
-   * @type { Record<string, Record<string, number>> }
-   */
-  const attributePositions = {}
-  for (const [blockName, blockOrder] of Object.entries(order)) {
-    /**
-     * @type { Record<string, number> }
-     */
-    const attributePosition = {}
-    for (const [i, o] of blockOrder.entries()) {
-      if (Array.isArray(o)) {
-        for (const attr of o) {
-          attributePosition[attr] = i
-        }
-      } else {
-        attributePosition[o] = i
-      }
-    }
-    attributePositions[blockName] = attributePosition
+function normalizeUserOrderOptions(options, context) {
+  if (!options) {
+    return []
   }
-  return attributePositions
+  return options.map((option) => normalizeUserOrderOption(option, context))
+}
+
+/**
+ * @param {OrderOption} option
+ * @param {VElement} elementName
+ * @returns {boolean}
+ */
+function matchOrderOption(option, elementName) {
+  return option.selector.test(elementName)
 }
 
 /**
  * @param {VAttribute | VDirective} attribute
- * @param { Record<string, number> } attributePosition
- * @returns {number | null}
+ * @param {OrderOption} orderOption
+ * @returns {number | undefined}
  */
-function getPosition(attribute, attributePosition) {
+function getMatchedAttributePosition(attribute, orderOption) {
   if (attribute.directive) {
-    return null
+    return undefined
   }
 
-  return attributePosition[attribute.key.name]
+  const name = attribute.key.name
+  for (const [i, item] of orderOption.regexOrder.entries()) {
+    if (Array.isArray(item)) {
+      if (item.some((x) => x.test(name))) {
+        return i
+      }
+    } else if (item.test(name)) {
+      return i
+    }
+  }
+  return undefined
 }
 
 /**
  * @param {VStartTag} node
- * @param {Record<string, number>} attributePosition
+ * @param {OrderOption} orderOption
  */
-function getAttributeAndPositionList(node, attributePosition) {
+function getAttributeAndPositionList(node, orderOption) {
   /**
    * @type {{ attr: (VAttribute | VDirective), position: number }[]}
    */
   const results = []
   for (const attr of node.attributes) {
-    const position = getPosition(attr, attributePosition)
+    const position = getMatchedAttributePosition(attr, orderOption)
     if (position == null) {
       continue
     }
@@ -150,8 +174,30 @@ function getAttributeAndPositionList(node, attributePosition) {
  */
 function create(context) {
   const sourceCode = context.getSourceCode()
-  const order = normalizeOrderOptions(context.options[0])
-  const attributeAndPositions = normalizeAttributePositions(order)
+  const normalizedDefaultOptions = normalizeUserOrderOptions(
+    defaultOptions,
+    context
+  )
+  const normalizedOrderOptions = normalizeUserOrderOptions(
+    context.options[0],
+    context
+  )
+
+  /**
+   * @param {VElement} element
+   * @returns {OrderOption | undefined}
+   */
+  function getMatchedOrderOption(element) {
+    const matchedOption = normalizedOrderOptions.find((option) =>
+      matchOrderOption(option, element)
+    )
+    if (matchedOption) {
+      return matchedOption
+    }
+    return normalizedDefaultOptions.find((option) =>
+      matchOrderOption(option, element)
+    )
+  }
 
   /**
    * @param {VAttribute | VDirective} node
@@ -197,15 +243,14 @@ function create(context) {
    * @returns {void}
    */
   function verify(element) {
-    const tag = element.name
-    const attributePosition = attributeAndPositions[tag]
-    if (!attributePosition) {
+    const orderOption = getMatchedOrderOption(element)
+    if (!orderOption) {
       return
     }
 
     const attributeAndPositionList = getAttributeAndPositionList(
       element.startTag,
-      attributePosition
+      orderOption
     )
     if (attributeAndPositionList.length <= 1) {
       return
@@ -240,82 +285,34 @@ module.exports = {
     fixable: 'code',
     schema: [
       {
-        type: 'object',
-        properties: {
-          order: {
-            type: 'object',
-            properties: {
-              template: {
-                type: 'array',
-                items: {
-                  anyOf: [
-                    { enum: Object.values(WELL_KNOWN_TEMPLATE_ATTRS) },
-                    { type: 'string' },
-                    {
-                      type: 'array',
-                      items: {
-                        anyOf: [
-                          { enum: Object.values(WELL_KNOWN_TEMPLATE_ATTRS) },
-                          { type: 'string' }
-                        ]
-                      },
-                      uniqueItems: true
-                    }
-                  ]
-                },
-                uniqueItems: true
-              },
-              script: {
-                type: 'array',
-                items: {
-                  anyOf: [
-                    { enum: Object.values(WELL_KNOWN_SCRIPT_ATTRS) },
-                    { type: 'string' },
-                    {
-                      type: 'array',
-                      items: {
-                        anyOf: [
-                          { enum: Object.values(WELL_KNOWN_SCRIPT_ATTRS) },
-                          { type: 'string' }
-                        ]
-                      },
-                      uniqueItems: true
-                    }
-                  ]
-                },
-                uniqueItems: true
-              },
-              style: {
-                type: 'array',
-                items: {
-                  anyOf: [
-                    { enum: Object.values(WELL_KNOWN_STYLE_ATTRS) },
-                    { type: 'string' },
-                    {
-                      type: 'array',
-                      items: {
-                        anyOf: [
-                          { enum: Object.values(WELL_KNOWN_STYLE_ATTRS) },
-                          { type: 'string' }
-                        ]
-                      },
-                      uniqueItems: true
-                    }
-                  ]
-                },
-                uniqueItems: true
-              }
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            element: {
+              type: 'string'
             },
-            additionalProperties: {
+            order: {
               type: 'array',
               items: {
-                type: 'string'
-              },
-              uniqueItems: true
+                anyOf: [
+                  {
+                    type: 'string'
+                  },
+                  {
+                    type: 'array',
+                    items: {
+                      type: 'string'
+                    },
+                    uniqueItems: true
+                  }
+                ],
+                uniqueItems: true
+              }
             }
-          }
-        },
-        additionalProperties: false
+          },
+          additionalProperties: false
+        }
       }
     ]
   },
diff --git a/tests/lib/rules/block-attributes-order.js b/tests/lib/rules/block-attributes-order.js
index 2d8c644a4..dea555428 100644
--- a/tests/lib/rules/block-attributes-order.js
+++ b/tests/lib/rules/block-attributes-order.js
@@ -23,252 +23,322 @@ tester.run('block-attributes-order', rule, {
   valid: [
     {
       filename: 'test-template-without-attributes.vue',
-      code: `<template><div></div><template>`
+      code: '<template><div></div></template>'
     },
     {
       filename: 'test-template-with-one-attribute.vue',
-      code: `<template functional><div></div><template>`
+      code: '<template functional><div></div></template>'
     },
     {
       filename: 'test-template-attributes.vue',
-      code: `<template functional lang="pug" src="./template.html"><template>`
+      code: '<template functional lang="pug" src="./template.html"></template>'
     },
     {
       filename: 'test-script-without-attributes.vue',
-      code: `<script></script>`
+      code: '<script></script>'
     },
     {
       filename: 'test-script-with-one-attribute.vue',
-      code: `<script lang="ts"></script>`
+      code: '<script lang="ts"></script>'
     },
     {
       filename: 'test-script-attributes.vue',
-      code: `<script setup lang="ts" src="./script.js"></script>`
+      code: '<script setup lang="ts" src="./script.js"></script>'
     },
     {
       filename: 'test-style-without-attributes.vue',
-      code: `<style><style>`
+      code: '<style></style>'
     },
     {
       filename: 'test-style-with-one-attribute.vue',
-      code: `<style lang="less"><style>`
+      code: '<style lang="less"></style>'
     },
     {
       filename: 'test-style-attributes.vue',
-      code: `<style module scoped lang="less" src="./style.css"><style>`
+      code: '<style module scoped lang="less" src="./style.css"></style>'
     },
     {
       filename: 'test-custom-block-without-attributes.vue',
-      code: `<foobarbaz><foobarbaz>`
+      code: '<foobarbaz><foobarbaz>'
     },
     {
       filename: 'test-custom-block-with-one-attribute.vue',
-      code: `<foobarbaz foo><foobarbaz>`
+      code: '<foobarbaz foo><foobarbaz>'
     },
     {
       filename: 'test-custom-block-with-attributes.vue',
-      code: `<foobarbaz foo bar baz="baz"><foobarbaz>`
+      code: '<foobarbaz foo bar baz="baz"><foobarbaz>'
     },
     {
       filename: 'test-attributes-with-unknown-attribute.vue',
-      code: `<template functional foo lang="pug" src="./template.html"><template>`
+      code: '<template functional foo lang="pug" src="./template.html"></template>'
     },
     {
       filename: 'test-attributes-options.vue',
-      code: `<style module lang="less" scoped src="./style.css"><style>`,
+      code: '<style module lang="less" scoped src="./style.css"></style>',
       options: [
-        {
-          order: {
-            style: ['module', 'lang', 'scoped', 'src']
+        [
+          {
+            element: 'style',
+            order: ['module', 'lang', 'scoped', 'src']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-with-unknown-attribute.vue',
-      code: `<template functional foo lang="pug" src="./template.html"><template>`,
+      code: '<template functional foo lang="pug" src="./template.html"></template>',
       options: [
-        {
-          order: {
-            template: ['functional', 'foo', 'lang', 'src']
+        [
+          {
+            element: 'template',
+            order: ['functional', 'foo', 'lang', 'src']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-not-specify-some-attribute-1.vue',
-      code: `<style module src="./style.css" lang="less" scoped><style>`,
+      code: '<style module src="./style.css" lang="less" scoped></style>',
       options: [
-        {
-          order: {
-            style: ['module', 'src', 'lang']
+        [
+          {
+            element: 'style',
+            order: ['module', 'src', 'lang']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-not-specify-some-attribute-2.vue',
-      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      code: '<style module scoped src="./style.css" lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['module', 'src', 'lang']
+        [
+          {
+            element: 'style',
+            order: ['module', 'src', 'lang']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-not-specify-some-attribute-3.vue',
-      code: `<style scoped module src="./style.css" lang="less"><style>`,
+      code: '<style scoped module src="./style.css" lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['module', 'src', 'lang']
+        [
+          {
+            element: 'style',
+            order: ['module', 'src', 'lang']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-with-batch-order-1.vue',
-      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      code: '<style module scoped src="./style.css" lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['module', ['scoped', 'src'], 'lang']
+        [
+          {
+            element: 'style',
+            order: ['module', ['scoped', 'src'], 'lang']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-attributes-options-with-batch-order-2.vue',
-      code: `<style module src="./style.css" scoped lang="less"><style>`,
+      code: '<style module src="./style.css" scoped lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['module', ['scoped', 'src'], 'lang']
+        [
+          {
+            element: 'style',
+            order: ['module', ['scoped', 'src'], 'lang']
           }
-        }
+        ]
       ]
     },
     {
       filename: 'test-custom-block-with-attributes-options.vue',
-      code: `<foobarbaz foo bar baz="baz"><foobarbaz>`,
+      code: '<foobarbaz foo bar baz="baz"><foobarbaz>',
       options: [
-        {
-          order: {
-            foobarbaz: ['foo', 'bar', 'baz']
+        [
+          {
+            element: 'foobarbaz',
+            order: ['foo', 'bar', 'baz']
           }
-        }
+        ]
+      ]
+    },
+    {
+      filename: 'test-using-element-selector-1.vue',
+      code: '<script lang="ts" setup functional></script>',
+      options: [
+        [
+          {
+            element: 'script[setup]',
+            order: ['lang', 'setup', 'functional']
+          }
+        ]
+      ]
+    },
+    {
+      filename: 'test-using-element-selector-2.vue',
+      code: '<script functional lang="ts"></script>',
+      options: [
+        [
+          {
+            element: 'script[setup]',
+            order: ['lang', 'setup', 'functional']
+          },
+          {
+            element: 'script:not([setup])',
+            order: ['functional', 'lang']
+          }
+        ]
+      ]
+    },
+    {
+      filename: 'test-using-regex-order-1.vue',
+      code: '<style scoped module lang="less" src="./style.css"></style>',
+      options: [
+        [
+          {
+            element: 'style',
+            order: ['^(?!(src|lang)$).*', 'lang', 'src']
+          }
+        ]
       ]
     }
   ],
   invalid: [
     {
       filename: 'test-template-attributes-with-invalid-order.vue',
-      code: '<template src="./template.html" lang="pug" functional><template>',
+      code: '<template src="./template.html" lang="pug" functional></template>',
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "lang" should go before "src".`
+          message: 'Attribute "lang" should go before "src".'
         },
         {
           type: 'VAttribute',
-          message: `Attribute "functional" should go before "src".`
+          message: 'Attribute "functional" should go before "src".'
         }
       ],
-      output: `<template lang="pug" src="./template.html" functional><template>`
+      output: '<template lang="pug" src="./template.html" functional></template>'
     },
     {
       filename: 'test-script-attributes-with-invalid-order.vue',
-      code: `<script src="./script.js" setup lang="ts"></script>`,
+      code: '<script src="./script.js" setup lang="ts"></script>',
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "setup" should go before "src".`
+          message: 'Attribute "setup" should go before "src".'
         },
         {
           type: 'VAttribute',
-          message: `Attribute "lang" should go before "src".`
+          message: 'Attribute "lang" should go before "src".'
         }
       ],
-      output: `<script setup src="./script.js" lang="ts"></script>`
+      output: '<script setup src="./script.js" lang="ts"></script>'
     },
     {
       filename: 'test-style-attributes-with-invalid-order.vue',
-      code: `<style src="./style.css" scoped module lang="less"><style>`,
+      code: '<style src="./style.css" scoped module lang="less"></style>',
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "scoped" should go before "src".`
+          message: 'Attribute "scoped" should go before "src".'
         },
         {
           type: 'VAttribute',
-          message: `Attribute "module" should go before "src".`
+          message: 'Attribute "module" should go before "src".'
         },
         {
           type: 'VAttribute',
-          message: `Attribute "lang" should go before "src".`
+          message: 'Attribute "lang" should go before "src".'
         }
       ],
-      output: `<style scoped src="./style.css" module lang="less"><style>`
+      output: '<style scoped src="./style.css" module lang="less"></style>'
     },
     {
       filename: 'test-attributes-options-not-default-order.vue',
-      code: `<style module scoped src="./style.css" lang="less"><style>`,
+      code: '<style module scoped src="./style.css" lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['scoped', 'module', 'src', 'lang']
+        [
+          {
+            element: 'style',
+            order: ['scoped', 'module', 'src', 'lang']
           }
-        }
+        ]
       ],
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "scoped" should go before "module".`
+          message: 'Attribute "scoped" should go before "module".'
         }
       ],
-      output: `<style scoped module src="./style.css" lang="less"><style>`
+      output: '<style scoped module src="./style.css" lang="less"></style>'
     },
     {
       filename: 'test-custom-block-with-invalid-order.vue',
-      code: `<foobarbaz baz="baz" bar foo><foobarbaz>`,
+      code: '<foobarbaz baz="baz" bar foo><foobarbaz>',
       options: [
-        {
-          order: {
-            foobarbaz: ['foo', 'bar', 'baz']
+        [
+          {
+            element: 'foobarbaz',
+            order: ['foo', 'bar', 'baz']
           }
-        }
+        ]
       ],
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "bar" should go before "baz".`
+          message: 'Attribute "bar" should go before "baz".'
         },
         {
           type: 'VAttribute',
-          message: `Attribute "foo" should go before "baz".`
+          message: 'Attribute "foo" should go before "baz".'
         }
       ],
-      output: `<foobarbaz bar baz="baz" foo><foobarbaz>`
+      output: '<foobarbaz bar baz="baz" foo><foobarbaz>'
     },
     {
       filename: 'test-style-attributes-with-batch-order-and-invalid-order.vue',
-      code: `<style scoped src="./style.css" lang="less"><style>`,
+      code: '<style scoped src="./style.css" lang="less"></style>',
       options: [
-        {
-          order: {
-            style: ['lang', ['src', 'scoped']]
+        [
+          {
+            element: 'style',
+            order: ['lang', ['src', 'scoped']]
           }
+        ]
+      ],
+      errors: [
+        {
+          type: 'VAttribute',
+          message: 'Attribute "lang" should go before "src".'
         }
       ],
+      output: '<style scoped lang="less" src="./style.css"></style>'
+    },
+    {
+      filename: 'test-using-regex-order-2.vue',
+      code: '<style scoped module lang="less" fooo src="./style.css"></style>',
+      options: [
+        [
+          {
+            element: 'style',
+            order: ['^(?!(src|lang)$).*', 'lang', 'src']
+          }
+        ]
+      ],
       errors: [
         {
           type: 'VAttribute',
-          message: `Attribute "lang" should go before "src".`
+          message: 'Attribute "fooo" should go before "lang".'
         }
       ],
-      output: `<style scoped lang="less" src="./style.css"><style>`
+      output: '<style scoped module fooo lang="less" src="./style.css"></style>'
     }
   ]
 })

From e775173f3c27966ed62c99913124e084f84827e1 Mon Sep 17 00:00:00 2001
From: kingwl <kingwenlu@gmail.com>
Date: Fri, 14 Oct 2022 18:07:02 +0800
Subject: [PATCH 8/8] fix: make lint happy

---
 tests/lib/rules/block-attributes-order.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/lib/rules/block-attributes-order.js b/tests/lib/rules/block-attributes-order.js
index dea555428..f2ac82baa 100644
--- a/tests/lib/rules/block-attributes-order.js
+++ b/tests/lib/rules/block-attributes-order.js
@@ -224,7 +224,8 @@ tester.run('block-attributes-order', rule, {
           message: 'Attribute "functional" should go before "src".'
         }
       ],
-      output: '<template lang="pug" src="./template.html" functional></template>'
+      output:
+        '<template lang="pug" src="./template.html" functional></template>'
     },
     {
       filename: 'test-script-attributes-with-invalid-order.vue',