Supports ES2022

.vscode/settings.json

@@ -9,5 +9,9 @@
         "vue"
     ],
     "typescript.tsdk": "node_modules/typescript/lib",
-    "vetur.validation.script": false
+    "vetur.validation.script": false,
+    "[typescript]": {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
 }

lib/rules/require-slots-as-functions.js

@@ -34,7 +34,7 @@ module.exports = {
     /**
      * Verify the given node
      * @param {MemberExpression | Identifier | ChainExpression} node The node to verify
-     * @param {Expression} reportNode The node to report
+     * @param {Expression | PrivateIdentifier} reportNode The node to report
      */
     function verify(node, reportNode) {
       const parent = node.parent
@@ -83,7 +83,7 @@ module.exports = {
     /**
      * Verify the references of the given node.
      * @param {Identifier} node The node to verify
-     * @param {Expression} reportNode The node to report
+     * @param {Expression | PrivateIdentifier} reportNode The node to report
      */
     function verifyReferences(node, reportNode) {
       const variable = findVariable(context.getScope(), node)

lib/utils/index.js

@@ -1798,23 +1798,24 @@ function skipChainExpression(node) {
  */
 function getStaticPropertyName(node) {
   if (node.type === 'Property' || node.type === 'MethodDefinition') {
-    const key = node.key
-
     if (!node.computed) {
+      const key = node.key
       if (key.type === 'Identifier') {
         return key.name
       }
     }
+    const key = node.key
     // @ts-expect-error
     return getStringLiteralValue(key)
   } else if (node.type === 'MemberExpression') {
-    const property = node.property
     if (!node.computed) {
+      const property = node.property
       if (property.type === 'Identifier') {
         return property.name
       }
       return null
     }
+    const property = node.property
     // @ts-expect-error
     return getStringLiteralValue(property)
   }

typings/eslint-plugin-vue/global.d.ts

@@ -71,6 +71,7 @@ declare global {
   // ---- ES Nodes ----
 
   type Identifier = VAST.Identifier
+  type PrivateIdentifier = VAST.PrivateIdentifier
   type Literal = VAST.Literal
   type Program = VAST.Program
   type SwitchCase = VAST.SwitchCase
@@ -135,6 +136,7 @@ declare global {
   type AssignmentPattern = VAST.AssignmentPattern
   type ClassBody = VAST.ClassBody
   type MethodDefinition = VAST.MethodDefinition
+  type PropertyDefinition = VAST.PropertyDefinition
   type ModuleDeclaration = VAST.ModuleDeclaration
   type ImportDeclaration = VAST.ImportDeclaration
   type ExportNamedDeclaration = VAST.ExportNamedDeclaration

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

@@ -9,6 +9,7 @@ import * as TS from './ts-ast'
 import * as JSX from './jsx-ast'
 
 export type ESNode =
+  | PrivateIdentifier
   | Identifier
   | Literal
   | Program
@@ -25,6 +26,7 @@ export type ESNode =
   | Pattern
   | ClassBody
   | MethodDefinition
+  | PropertyDefinition
   | ModuleDeclaration
   | ModuleSpecifier
 
@@ -185,16 +187,61 @@ export interface ClassDeclaration extends HasParentNode {
 }
 export interface ClassBody extends HasParentNode {
   type: 'ClassBody'
-  body: MethodDefinition[]
+  body: (MethodDefinition | PropertyDefinition)[]
 }
-export interface MethodDefinition extends HasParentNode {
+interface BaseMethodDefinition extends HasParentNode {
   type: 'MethodDefinition'
+  // computed: boolean
+  static: boolean
+  // key: Expression
+  value: FunctionExpression
+  parent: ClassBody
+}
+export interface MethodDefinitionNonComputedName extends BaseMethodDefinition {
+  kind: 'constructor' | 'method' | 'get' | 'set'
+  computed: false
+  key: Identifier | Literal
+}
+export interface MethodDefinitionComputedName extends BaseMethodDefinition {
   kind: 'constructor' | 'method' | 'get' | 'set'
-  computed: boolean
+  computed: true
+  key: Expression
+}
+export interface MethodDefinitionPrivate extends BaseMethodDefinition {
+  kind: 'constructor'
+  computed: false
+  key: PrivateIdentifier
+}
+export type MethodDefinition =
+  | MethodDefinitionNonComputedName
+  | MethodDefinitionComputedName
+  | MethodDefinitionPrivate
+interface BasePropertyDefinition extends HasParentNode {
+  type: 'PropertyDefinition'
+  // key: Expression | PrivateIdentifier
+  value: Expression | null
+  // computed: boolean
   static: boolean
+  parent: ClassBody
+}
+export interface PropertyDefinitionNonComputedName
+  extends BasePropertyDefinition {
+  computed: false
+  key: Identifier | Literal
+}
+export interface PropertyDefinitionComputedName extends BasePropertyDefinition {
+  computed: true
   key: Expression
-  value: FunctionExpression
 }
+export interface PropertyDefinitionPrivate extends BasePropertyDefinition {
+  computed: false
+  key: PrivateIdentifier
+}
+export type PropertyDefinition =
+  | PropertyDefinitionNonComputedName
+  | PropertyDefinitionComputedName
+  | PropertyDefinitionPrivate
+
 export type ModuleDeclaration =
   | ImportDeclaration
   | ExportNamedDeclaration
@@ -284,6 +331,10 @@ export interface Identifier extends HasParentNode {
   type: 'Identifier'
   name: string
 }
+export interface PrivateIdentifier extends HasParentNode {
+  type: 'PrivateIdentifier'
+  name: string
+}
 export interface Literal extends HasParentNode {
   type: 'Literal'
   value: string | boolean | null | number | RegExp | BigInt
@@ -304,16 +355,25 @@ export interface ObjectExpression extends HasParentNode {
   type: 'ObjectExpression'
   properties: (Property | SpreadElement)[]
 }
-export interface Property extends HasParentNode {
+interface BaseProperty extends HasParentNode {
   type: 'Property'
   kind: 'init' | 'get' | 'set'
   method: boolean
   shorthand: boolean
-  computed: boolean
-  key: Expression
+  // computed: boolean
+  // key: Expression
   value: Expression
   parent: ObjectExpression
 }
+export interface PropertyNonComputedName extends BaseProperty {
+  computed: false
+  key: Identifier | Literal
+}
+export interface PropertyComputedName extends BaseProperty {
+  computed: true
+  key: Expression
+}
+export type Property = PropertyNonComputedName | PropertyComputedName
 export interface FunctionExpression extends HasParentNode {
   type: 'FunctionExpression'
   async: boolean
@@ -444,13 +504,32 @@ export interface NewExpression extends HasParentNode {
   callee: Expression
   arguments: (Expression | SpreadElement)[]
 }
-export interface MemberExpression extends HasParentNode {
+interface BaseMemberExpression extends HasParentNode {
   type: 'MemberExpression'
-  computed: boolean
+  // computed: boolean
+  // object: Expression | Super
+  // property: Expression
+  optional: boolean
+}
+export interface MemberExpressionNonComputedName extends BaseMemberExpression {
+  computed: false
+  object: Expression | Super
+  property: Identifier
+}
+export interface MemberExpressionComputedName extends BaseMemberExpression {
+  computed: true
   object: Expression | Super
   property: Expression
-  optional: boolean
 }
+export interface MemberExpressionPrivate extends BaseMemberExpression {
+  computed: false
+  object: Expression
+  property: PrivateIdentifier
+}
+export type MemberExpression =
+  | MemberExpressionNonComputedName
+  | MemberExpressionComputedName
+  | MemberExpressionPrivate
 export interface ChainExpression extends HasParentNode {
   type: 'ChainExpression'
   expression: ChainElement
@@ -506,16 +585,28 @@ export interface ObjectPattern extends HasParentNode {
   type: 'ObjectPattern'
   properties: (AssignmentProperty | RestElement)[]
 }
-export interface AssignmentProperty extends HasParentNode {
+interface BaseAssignmentProperty extends HasParentNode {
   type: 'Property'
   kind: 'init'
   method: false
   shorthand: boolean
-  computed: boolean
-  key: Expression
+  // computed: boolean
+  // key: Expression
   value: Pattern
   parent: ObjectPattern
 }
+export interface AssignmentPropertyNonComputedName
+  extends BaseAssignmentProperty {
+  computed: false
+  key: Identifier | Literal
+}
+export interface AssignmentPropertyComputedName extends BaseAssignmentProperty {
+  computed: true
+  key: Expression
+}
+export type AssignmentProperty =
+  | AssignmentPropertyNonComputedName
+  | AssignmentPropertyComputedName
 export interface ArrayPattern extends HasParentNode {
   type: 'ArrayPattern'
   elements: Pattern[]