add types to vue/sort-keys

Author: ota-meshi

lib/rules/sort-keys.js

@@ -3,7 +3,6 @@
  * @author Loren Klingman
  * Original ESLint sort-keys by Toru Nagashima
  */
-// @ts-nocheck
 'use strict'
 
 // ------------------------------------------------------------------------------
@@ -121,14 +120,22 @@ module.exports = {
         },
         additionalProperties: false
       }
-    ]
+    ],
+    messages: {
+      sortKeys:
+        "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'."
+    }
   },
-  /** @param {RuleContext} context */
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     // Parse options.
     const options = context.options[1]
     const order = context.options[0] || 'asc'
 
+    /** @type {string[]} */
     const ignoreGrandchildrenOf = (options &&
       options.ignoreGrandchildrenOf) || [
       'computed',
@@ -137,127 +144,128 @@ module.exports = {
       'props',
       'watch'
     ]
+    /** @type {string[]} */
     const ignoreChildrenOf = (options && options.ignoreChildrenOf) || ['model']
     const insensitive = options && options.caseSensitive === false
     const minKeys = options && options.minKeys
     const natural = options && options.natural
     const isValidOrder =
       isValidOrders[order + (insensitive ? 'I' : '') + (natural ? 'N' : '')]
 
-    // The stack to save the previous property's name for each object literals.
-    let stack = null
-
-    let errors = []
-    const names = {}
-
     /**
-     * @param {boolean} isVue
+     * @typedef {object} ObjectStack
+     * @property {ObjectStack} upper
+     * @property {string | null} prevName
+     * @property {number} numKeys
+     * @property {Property | null} currentProperty
+     * @property {boolean} isVueObject
+     * @property {boolean} withinVueObject
+     * @property {string | null} withinVuePropName
+     * @property {number} withinVuePropChainLevel
+     * @property {boolean} ignore
      */
-    const reportErrors = (isVue) => {
-      if (isVue) {
-        errors = errors.filter((error) => {
-          let parentIsRoot = !error.hasUpper
-          let grandParentIsRoot = !error.grandparent
-          let greatGrandparentIsRoot = !error.greatGrandparent
 
-          const stackPrevChar = stack && stack.prevChar
-          if (stackPrevChar) {
-            parentIsRoot = stackPrevChar === error.parent
-            grandParentIsRoot = stackPrevChar === error.grandparent
-            greatGrandparentIsRoot = stackPrevChar === error.greatGrandparent
-          }
+    /**
+     * The stack to save the previous property's name for each object literals.
+     * @type {ObjectStack}
+     */
+    let stack
 
-          if (parentIsRoot) {
-            return false
-          } else if (grandParentIsRoot) {
-            return (
-              !error.parentIsProperty ||
-              !ignoreChildrenOf.includes(names[error.parent])
-            )
-          } else if (greatGrandparentIsRoot) {
-            return (
-              !error.parentIsProperty ||
-              !ignoreGrandchildrenOf.includes(names[error.grandparent])
-            )
-          }
-          return true
-        })
+    /**
+     * @param {Property | null} prop
+     * @param {Expression} expr
+     */
+    function isPropertyChain(prop, expr) {
+      let value = expr
+      while (value.parent.type === 'TSAsExpression') {
+        value = value.parent
       }
-      errors.forEach((error) => error.errors.forEach((e) => context.report(e)))
-      errors = []
+      return prop === value.parent && prop.value === value
     }
 
-    const sortTests = {
-      /** @param {ObjectExpression} node */
+    return {
       ObjectExpression(node) {
-        if (!stack) {
-          reportErrors(false)
+        const isVueObject = utils.getVueObjectType(context, node) != null
+        let withinVueObject = isVueObject
+        /** @type {string | null} */
+        let withinVuePropName = null
+        let withinVuePropChainLevel = NaN
+        if (!isVueObject && stack) {
+          if (stack.withinVueObject && stack.currentProperty) {
+            const isChain = isPropertyChain(stack.currentProperty, node)
+            if (isChain) {
+              if (stack.isVueObject) {
+                withinVuePropName = utils.getStaticPropertyName(
+                  stack.currentProperty
+                )
+                withinVuePropChainLevel = 1
+              } else {
+                withinVuePropName = stack.withinVuePropName
+                withinVuePropChainLevel = stack.withinVuePropChainLevel + 1
+              }
+              withinVueObject = true
+            } else {
+              withinVueObject = false
+            }
+          }
+        }
+
+        let ignore = isVueObject
+
+        if (withinVueObject && withinVuePropName != null) {
+          if (withinVuePropChainLevel === 1) {
+            if (ignoreChildrenOf.includes(withinVuePropName)) {
+              ignore = true
+            }
+          } else if (withinVuePropChainLevel === 2) {
+            if (ignoreGrandchildrenOf.includes(withinVuePropName)) {
+              ignore = true
+            }
+          }
         }
         stack = {
           upper: stack,
-          prevChar: null,
           prevName: null,
           numKeys: node.properties.length,
-          parentIsProperty: node.parent.type === 'Property',
-          errors: []
+          currentProperty: null,
+          isVueObject,
+          withinVueObject,
+          withinVuePropName,
+          withinVuePropChainLevel,
+          ignore
         }
       },
-      /** @param {ObjectExpression} node */
-      'ObjectExpression:exit'(node) {
-        errors.push({
-          errors: stack.errors,
-          hasUpper: !!stack.upper,
-          parentIsProperty: node.parent.type === 'Property',
-          parent: stack.upper && stack.upper.prevChar,
-          grandparent:
-            stack.upper && stack.upper.upper && stack.upper.upper.prevChar,
-          greatGrandparent:
-            stack.upper &&
-            stack.upper.upper &&
-            stack.upper.upper.upper &&
-            stack.upper.upper.upper.prevChar
-        })
+      'ObjectExpression:exit'() {
         stack = stack.upper
       },
-      /** @param {SpreadElement} node */
       SpreadElement(node) {
         if (node.parent.type === 'ObjectExpression') {
           stack.prevName = null
-          stack.prevChar = null
         }
       },
-      'Program:exit'() {
-        reportErrors(false)
-      },
-      /** @param {Property} node */
-      Property(node) {
-        if (node.parent.type === 'ObjectPattern') {
+      'ObjectExpression > Property'(node) {
+        stack.currentProperty = node
+
+        if (stack.ignore) {
           return
         }
-
         const prevName = stack.prevName
         const numKeys = stack.numKeys
         const thisName = getPropertyName(node)
 
         if (thisName !== null) {
           stack.prevName = thisName
-          stack.prevChar = node.range[0]
-          if (Object.prototype.hasOwnProperty.call(names, node.range[0])) {
-            throw new Error('Name clash')
-          }
-          names[node.range[0]] = thisName
         }
 
         if (prevName === null || thisName === null || numKeys < minKeys) {
           return
         }
 
         if (!isValidOrder(prevName, thisName)) {
-          stack.errors.push({
+          context.report({
             node,
             loc: node.key.loc,
-            message:
-              "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'.",
+            messageId: 'sortKeys',
             data: {
               thisName,
               prevName,
@@ -269,11 +277,5 @@ module.exports = {
         }
       }
     }
-
-    const execOnVue = utils.executeOnVue(context, () => {
-      reportErrors(true)
-    })
-
-    return utils.compositingVisitors(sortTests, execOnVue)
   }
 }

typings/eslint-plugin-vue/util-types/ast/es-ast.d.ts

@@ -298,6 +298,7 @@ export interface Property extends HasParentNode {
   computed: boolean
   key: Expression
   value: Expression
+  parent: ObjectExpression
 }
 export interface FunctionExpression extends HasParentNode {
   type: 'FunctionExpression'
@@ -483,6 +484,7 @@ export interface AssignmentProperty extends HasParentNode {
   computed: boolean
   key: Expression
   value: Pattern
+  parent: ObjectPattern
 }
 export interface ArrayPattern extends HasParentNode {
   type: 'ArrayPattern'