rewrite force-types-on-object-props

Author: przemyslawjanpietrzak

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

@@ -4,6 +4,12 @@
  */
 'use strict'
 
+const { type } = require('os')
+const utils = require('../utils')
+/**
+ * @typedef {import('../utils').ComponentProp} ComponentProp
+ */
+
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -29,6 +35,98 @@ const isLooksLike = (a, b) =>
       : isLooksLike(aVal, bVal)
   })
 
+/**
+ * @param {ComponentProp} property
+ * @param {RuleContext} context
+ */
+const checkProperty = (property, context) => {
+  console.log(property.node.value)
+  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
 //------------------------------------------------------------------------------
@@ -47,6 +145,23 @@ module.exports = {
   },
   /** @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)
+        }
+      })
+    )
+
     return {
       /** @param {ExportDefaultDeclaration} node */
       ExportDefaultDeclaration(node) {