Add vue/require-typed-object-prop rule

docs/rules/force-types-on-object-props.md

@@ -0,0 +1,53 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/force-types-on-object-props
+description: enforce adding type declarations to object props
+---
+# vue/force-types-on-object-props
+
+> enforce adding type declarations to object props
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- :gear: This rule is included in all of `"plugin:vue/base"`, `"plugin:vue/essential"`, `"plugin:vue/vue3-essential"`, `"plugin:vue/strongly-recommended"`, `"plugin:vue/vue3-strongly-recommended"`, `"plugin:vue/recommended"` and `"plugin:vue/vue3-recommended"`.
+
+## :book: Rule Details
+
+Prevent missing type declarations for non-primitive object props in TypeScript projects.
+
+<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+
+```ts
+export default {
+  props: {
+    prop: {
+      // ✗ BAD
+      type: Object,
+      type: Array,
+
+      // ✓ GOOD
+      type: Object as Props<Anything>,
+      type: String, // or any other primitive type
+    }
+  }
+}
+```
+
+</eslint-code-block>
+
+### Options
+
+Nothing.
+
+## :mute: When Not To Use It
+
+When you're not using TypeScript in the project.
+
+## :books: Further Reading
+
+Nothing
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/force-types-on-object-props.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/force-types-on-object-props.js)

docs/rules/index.md

@@ -28,6 +28,7 @@ Rules in this category are enabled for all presets provided by eslint-plugin-vue
 | Rule ID | Description |    |    |
 |:--------|:------------|:--:|:--:|
 | [vue/comment-directive](./comment-directive.md) | support comment-directives in `<template>` |  | :warning: |
+| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/jsx-uses-vars](./jsx-uses-vars.md) | prevent variables used in JSX to be marked as unused |  | :warning: |
 
 </rules-table>

lib/configs/base.js

@@ -16,6 +16,7 @@ module.exports = {
   plugins: ['vue'],
   rules: {
     'vue/comment-directive': 'error',
+    'vue/force-types-on-object-props': 'error',
     'vue/jsx-uses-vars': 'error'
   }
 }

lib/index.js

@@ -35,6 +35,7 @@ module.exports = {
     'dot-notation': require('./rules/dot-notation'),
     eqeqeq: require('./rules/eqeqeq'),
     'first-attribute-linebreak': require('./rules/first-attribute-linebreak'),
+    'force-types-on-object-props': require('./rules/force-types-on-object-props'),
     'func-call-spacing': require('./rules/func-call-spacing'),
     'html-button-has-type': require('./rules/html-button-has-type'),
     'html-closing-bracket-newline': require('./rules/html-closing-bracket-newline'),

lib/rules/force-types-on-object-props.js

@@ -0,0 +1,163 @@
+/**
+ * @author Przemysław Jan Beigert
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const utils = require('../utils')
+/**
+ * @typedef {import('../utils').ComponentProp} ComponentProp
+ */
+
+// ------------------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * Check if all keys and values from second object are resent in first object
+ *
+ * @param {{ [key: string]: any }} a object to
+ * @param {{ [key: string]: any }} b The string to escape.
+ * @returns {boolean} Returns the escaped string.
+ */
+const isLooksLike = (a, b) =>
+  a &&
+  b &&
+  Object.keys(b).every((bKey) => {
+    const bVal = b[bKey]
+    const aVal = a[bKey]
+    if (typeof bVal === 'function') {
+      return bVal(aVal)
+    }
+    return bVal == null || /^[bns]/.test(typeof bVal)
+      ? bVal === aVal
+      : isLooksLike(aVal, bVal)
+  })
+
+/**
+ * @param {ComponentProp} property
+ * @param {RuleContext} context
+ */
+const checkProperty = (property, context) => {
+  if (!property.value) {
+    return
+  }
+
+  if (
+    isLooksLike(property.value, { type: 'Identifier', name: 'Object' }) &&
+    property.node.value.type !== 'TSAsExpression'
+  ) {
+    context.report({
+      node: property.node,
+      message: 'Expected type annotation on object prop.'
+    })
+  }
+
+  if (
+    property.type === 'object' &&
+    property.value.type === 'ObjectExpression' &&
+    property.node.value.type === 'ObjectExpression'
+  ) {
+    const typePropert = property.node.value.properties.find(
+      (prop) =>
+        prop.type === 'Property' &&
+        prop.key.type === 'Identifier' &&
+        prop.key.name === 'type'
+    )
+    if (
+      typePropert &&
+      typePropert.type === 'Property' &&
+      isLooksLike(typePropert.value, { type: 'Identifier', name: 'Object' })
+    ) {
+      context.report({
+        node: property.node,
+        message: 'Expected type annotation on object prop.'
+      })
+    }
+  }
+
+  if (property.node.value.type === 'ObjectExpression') {
+    for (const prop of property.node.value.properties) {
+      if (prop.type !== 'Property') {
+        continue
+      }
+      if (prop.key.type !== 'Identifier' || prop.key.name !== 'type') {
+        continue
+      }
+      if (prop.value.type !== 'TSAsExpression') {
+        continue
+      }
+
+      const { typeAnnotation } = prop.value
+      if (
+        ['TSAnyKeyword', 'TSUnknownKeyword'].includes(typeAnnotation.type) ||
+        !typeAnnotation.typeName ||
+        !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
+      ) {
+        context.report({
+          node: property.node,
+          message: 'Expected type annotation on object prop.'
+        })
+      }
+    }
+  }
+
+  if (property.node.value.type === 'TSAsExpression') {
+    const { typeAnnotation } = property.node.value
+    if (typeAnnotation.type === 'TSFunctionType') {
+      return
+    }
+    if (
+      [
+        'TSAnyKeyword',
+        'TSTypeLiteral',
+        'TSUnknownKeyword',
+        'TSObjectKeyword'
+      ].includes(typeAnnotation.type) ||
+      !typeAnnotation.typeName ||
+      !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
+    ) {
+      context.report({
+        node: property.node,
+        message: 'Expected type annotation on object prop.'
+      })
+    }
+  }
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce adding type declarations to object props',
+      categories: ['base'],
+      recommended: false,
+      url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
+    },
+    fixable: null,
+    schema: []
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          for (const prop of props) {
+            checkProperty(prop, context)
+          }
+        }
+      }),
+      utils.executeOnVue(context, (obj) => {
+        const props = utils.getComponentPropsFromOptions(obj)
+
+        for (const prop of props) {
+          checkProperty(prop, context)
+        }
+      })
+    )
+  }
+}