eslint-plugin-mpx 0.2.9 → 0.2.10-beta

package/lib/configs/composition-api-essential.js

@@ -14,6 +14,7 @@ module.exports = {
     'mpx/valid-wx-elif': 'error',
     'mpx/valid-wx-model': 'error',
     // 'mpx/script-setup-uses-vars': 'error',
+    'mpx/valid-initdata': 'error',
     'mpx/valid-setup-define-expose': 'error',
     'mpx/no-deprecated-mpx-createfunction': 'error',
     'mpx/no-deprecated-watch-second-param': 'error',

package/lib/index.js

@@ -32,6 +32,7 @@ module.exports = {
     'valid-template-quote': require('./rules/valid-template-quote'),
     'valid-component-range': require('./rules/valid-component-range'),
     'valid-setup-define-expose': require('./rules/valid-setup-define-expose'),
+    'valid-initdata': require('./rules/valid-initdata'),
     'no-deprecated-lifecycle': require('./rules/no-deprecated-lifecycle'),
     'no-deprecated-mpx-createfunction': require('./rules/no-deprecated-mpx-createfunction'),
     'no-deprecated-watch-second-param': require('./rules/no-deprecated-watch-second-param')

package/lib/rules/valid-initdata.js

@@ -0,0 +1,270 @@
+// @ts-nocheck
+/**
+ * @fileoverview initData检测
+ * @author jvzuojing
+ */
+'use strict'
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+const utils = require('../utils')
+function commonFunction(value, list) {
+  const props = value.properties
+  props.forEach((item) => {
+    if (
+      item.type === 'SpreadElement' &&
+      item.argument &&
+      item.argument.arguments &&
+      item.argument.arguments[0] &&
+      item.argument.arguments[0].elements
+    ) {
+      const args = item.argument.arguments[0].elements
+      args.forEach((item) => {
+        list.add(item.value)
+      })
+    } else {
+      list.add(item.key.name)
+    }
+  })
+}
+function handleInitData(current, propsSet, parentName) {
+  current.forEach((item) => {
+    const currentName = item.key.name
+    if (currentName) {
+      let name = currentName
+      if (parentName) {
+        name = `${parentName}.${currentName}`
+      }
+      propsSet.add(name)
+    }
+    if (item.value.type === 'ObjectExpression' && item.value.properties) {
+      let pre = currentName
+      if (parentName) {
+        pre = `${parentName}.${currentName}`
+      }
+      handleInitData(item.value.properties, propsSet, pre)
+    }
+  })
+}
+
+function checkInInitData(
+  computedSet,
+  propsSet,
+  context,
+  node,
+  nodeName,
+  hasInitData
+) {
+  if (hasInitData === 1 && nodeName) {
+    // 属性值存在 || 说明有兜底，跳过检测
+    if (nodeName.includes('||')) return
+    // 检测当前属性值在initData 和 computedSet 导出情况，computedSet 返回不会解构出来，做一个兼容
+    if (!propsSet.has(nodeName) && computedSet.has(nodeName.split('.')[0])) {
+      context.report({
+        node,
+        messageId: 'unexpected',
+        data: {
+          name: nodeName
+        }
+      })
+    }
+  }
+}
+function checkInitData(
+  computedSet,
+  propsSet,
+  hasInitData,
+  context,
+  node,
+  nodeName
+) {
+  if (
+    computedSet.has(nodeName) &&
+    !propsSet.has(nodeName) &&
+    hasInitData === 2
+  ) {
+    context.report({
+      node,
+      messageId: 'missingValue',
+      data: {
+        name: nodeName
+      }
+    })
+  }
+}
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion', // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: 'initData检测',
+      recommended: false,
+      url: null // URL to the documentation page for this rule
+    },
+    fixable: null, // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {
+      missingValue:
+        "Missing 'initData' but the data {{name}} used for property.",
+      unexpected:
+        "The data '{{name}}' isn't expose in initData but used for property."
+    }
+  },
+  create(context) {
+    // 收集一下initData的属性
+    const propsSet = new Set([])
+    // 收集computed属性
+    const computedSet = new Set([])
+    // 忽略的标签类型
+    const ignoreElementTypes = [
+      'view',
+      'text',
+      'image',
+      'audio',
+      'video',
+      'button',
+      'input',
+      'navigator',
+      'icon',
+      'picker',
+      'picker-item',
+      'block',
+      'scroll-view',
+      'swiper',
+      'swiper-item',
+      'label',
+      'form',
+      'checkbox',
+      'checkbox-group',
+      'radio',
+      'radio-group',
+      'switch'
+    ]
+    const ignoreAttributeTypes = [
+      'wx:if',
+      'wx:else',
+      'bindtap',
+      'catchtap',
+      'wx:for',
+      'wx:ref',
+      'wx:key',
+      'wx:for-item',
+      'class',
+      'style',
+      'hover-class',
+      'src'
+    ]
+    // 全局是否有initData 初始值：0 ，存在： 1，不存在： 2
+    let hasInitData = 0
+    return utils.defineTemplateBodyVisitor(
+      context,
+      {
+        // VExpressionContainer(node) {},
+        VAttribute(node) {
+          const parent = node.parent
+          if (!ignoreElementTypes.includes(parent.name)) {
+            if (
+              !ignoreAttributeTypes.includes(node.key.name) &&
+              node.value &&
+              node.value.value &&
+              node.value.value.startsWith('{{')
+            ) {
+              const reg = /(?<={{).*?(?=}})/
+              checkInInitData(
+                computedSet,
+                propsSet,
+                context,
+                node,
+                node.value.value.match(reg)[0],
+                hasInitData
+              )
+              checkInitData(
+                computedSet,
+                propsSet,
+                hasInitData,
+                context,
+                node,
+                node.value.value.match(reg)[0]
+              )
+            }
+          }
+        }
+      },
+      {
+        Program(node) {
+          if (!utils.isScriptSetup(context)) return
+          const body = node.body
+          if (body) {
+            body.forEach((item) => {
+              if (
+                item.type === 'ExpressionStatement' &&
+                item.expression &&
+                item.expression.type === 'CallExpression' &&
+                item.expression.callee.name === 'defineOptions' &&
+                item.expression.arguments
+              ) {
+                item.expression.arguments.forEach((sub) => {
+                  if (sub.type === 'ObjectExpression' && sub.properties) {
+                    sub.properties.forEach((val) => {
+                      if (val.key.name === 'initData') {
+                        hasInitData = 1
+                      }
+                    })
+                  }
+                })
+                if (hasInitData === 0) {
+                  hasInitData = 2
+                }
+              } else {
+                hasInitData = 2
+              }
+            })
+          }
+        },
+        CallExpression(node) {
+          if (utils.isScriptSetup(context)) {
+            // setup 直接收集 defineExpose 的值
+            if (node.callee.name === 'defineExpose') {
+              commonFunction(node.arguments[0], computedSet)
+            }
+          } else {
+            if (node.callee.name !== 'createComponent') return
+            const properties = node.arguments[0].properties
+            if (!properties) return
+            properties.forEach((element) => {
+              if (element.key.name === 'initData') {
+                hasInitData = 1
+              }
+            })
+            if (hasInitData === 0) {
+              hasInitData = 2
+            }
+          }
+        },
+        ObjectExpression(node) {
+          const parent = node.parent
+          if (parent && parent.type === 'CallExpression') {
+            if (parent.callee.name === 'defineOptions') {
+              if (node.properties && Array.isArray(node.properties)) {
+                node.properties.forEach((item) => {
+                  if (item.key.name === 'initData') {
+                    handleInitData(item.value.properties, propsSet)
+                  }
+                })
+              }
+            }
+          }
+        },
+        Property(node) {
+          if (node.key.name === 'computed') {
+            commonFunction(node.value, computedSet)
+          }
+          if (node.key.name === 'initData') {
+            handleInitData(node.value.properties, propsSet)
+          }
+        }
+      }
+    )
+  }
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "eslint-plugin-mpx",
-  "version": "0.2.9",
+  "version": "0.2.10-beta",
   "description": "Official ESLint plugin for Mpx.js",
   "main": "lib/index.js",
   "scripts": {
     "start": "npm run test:base -- --watch --growl",
     "test": "mocha \"tests/lib/**/*.js\" --reporter dot",
-    "test:only": "mocha \"tests/lib/rules/valid-template-quote.js\" --reporter dot",
+    "test:only": "mocha \"tests/lib/rules/valid-initdata.js\" --reporter dot",
     "debug": "mocha --inspect \"tests/lib/**/*.js\" --reporter dot --timeout 60000",
     "cover": "npm run cover:test && npm run cover:report",
     "cover:test": "nyc npm run test -- --timeout 60000",