eslint-plugin-mpx 0.2.8 → 0.2.10-beta

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

@@ -12,8 +12,12 @@ module.exports = {
     'mpx/valid-wx-if': 'error',
     'mpx/valid-wx-else': 'error',
     'mpx/valid-wx-elif': 'error',
-    // 'mpx/valid-wx-model': 'error',
+    'mpx/valid-wx-model': 'error',
     // 'mpx/script-setup-uses-vars': 'error',
-    'mpx/valid-setup-define-expose': 'error'
+    'mpx/valid-initdata': 'error',
+    'mpx/valid-setup-define-expose': 'error',
+    'mpx/no-deprecated-mpx-createfunction': 'error',
+    'mpx/no-deprecated-watch-second-param': 'error',
+    'mpx/no-deprecated-lifecycle': 'error'
   }
 }

package/lib/configs/mpx-essential.js

@@ -18,8 +18,7 @@ module.exports = {
     'mpx/valid-wx-if': 'error',
     'mpx/valid-wx-else': 'error',
     'mpx/valid-wx-elif': 'error',
-    // 'mpx/valid-wx-for': 'error',
-    // 'mpx/valid-wx-model': 'error',
+    'mpx/valid-wx-model': 'error',
     'mpx/valid-swiper-item-style': 'error',
     'mpx/valid-wx-key': 'error',
     'mpx/valid-attribute-value': 'error',

package/lib/index.js

@@ -31,7 +31,11 @@ module.exports = {
     'valid-attribute-value': require('./rules/valid-attribute-value'),
     '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-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')
   },
   configs: {
     base: require('./configs/base'),

package/lib/rules/no-deprecated-lifecycle.js

@@ -0,0 +1,46 @@
+/**
+ * @author pagnkelly
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const utils = require('../utils')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'pageShow/pageHide废弃的生命周期',
+      categories: ['composition-api-essential'],
+      url: 'https://mpx-ecology.github.io/eslint-plugin-mpx/rules/no-deprecated-lifecycle.html'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      deprecatedPageShow:
+        'The `pageShow` lifecycle hook is deprecated. Use `pageLifetimes.show` instead.',
+      deprecatedPageHide:
+        'The `pageHide` lifecycle hook is deprecated. Use `pageLifetimes.hide` instead.'
+    }
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    return utils.executeOnMpx(context, (obj) => {
+      const pageShow = utils.findProperty(obj, 'pageShow')
+      if (pageShow) {
+        context.report({
+          node: pageShow.key,
+          messageId: 'deprecatedPageShow'
+        })
+      }
+
+      const pageHide = utils.findProperty(obj, 'pageHide')
+      if (pageHide) {
+        context.report({
+          node: pageHide.key,
+          messageId: 'deprecatedPageHide'
+        })
+      }
+    })
+  }
+}

package/lib/rules/no-deprecated-mpx-createfunction.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+/**
+ * @author pagnkelly
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'mpx.create*调用方式已经被废弃',
+      categories: ['composition-api-essential'],
+      url: 'https://mpx-ecology.github.io/eslint-plugin-mpx/rules/no-deprecated-mpx-createfunction'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    return {
+      /** @param {import("mpx-eslint-parser/ast").ESLintStatement} node */
+      ExpressionStatement(node) {
+        if (
+          node.expression.callee &&
+          node.expression.callee.object &&
+          node.expression.callee.object.name === 'mpx' &&
+          node.expression.callee.property &&
+          [
+            'createApp',
+            'createStore',
+            'createPage',
+            'createComponent'
+          ].includes(node.expression.callee.property.name)
+        ) {
+          context.report({
+            node,
+            message:
+              'The Mpx object of default export is no longer attached to the {{name}} runtime method.',
+            data: { name: node.expression.callee.property.name }
+          })
+        }
+      }
+    }
+  }
+}

package/lib/rules/no-deprecated-watch-second-param.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+/**
+ * @author pagnkelly
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'watch第二个参数统一为函数，不再提供对象',
+      categories: ['composition-api-essential'],
+      url: 'https://mpx-ecology.github.io/eslint-plugin-mpx/rules/no-deprecated-watch-second-param'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    return {
+      /** @param {import("mpx-eslint-parser/ast").ESLintStatement} node */
+      ExpressionStatement(node) {
+        if (
+          node.expression &&
+          node.expression.type === 'CallExpression' &&
+          node.expression.callee.name === 'watch' &&
+          node.expression.arguments[1] &&
+          node.expression.arguments[1].type === 'ObjectExpression'
+        ) {
+          context.report({
+            node,
+            message:
+              'The watch API no longer accepts the second parameter as an object with the handler attribute.'
+          })
+        }
+      }
+    }
+  }
+}

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/lib/rules/valid-setup-define-expose.js

@@ -61,7 +61,7 @@ function handleProperties(properties, exposeSet, scriptVariableNames) {
 /**
  * @param {String} name - 展开节点
  * @param {Set<String>} exposeSet 存储定义的expose变量
- * @param {Object} scriptVariableNames 用于解析定义的展开的expose变量
+ * @param {any} scriptVariableNames 用于解析定义的展开的expose变量
  */
 function handleIdentifier(name, exposeSet, scriptVariableNames) {
   const props = scriptVariableNames[name]
@@ -77,10 +77,9 @@ module.exports = {
     docs: {
       description:
         'prevent `<script setup>` variables used in `<template>` to be marked as unused', // eslint-disable-line eslint-plugin/require-meta-docs-description
-      categories: undefined,
+      categories: ['composition-api-essential'],
       url: 'https://eslint.vuejs.org/rules/script-setup-uses-vars.html'
     },
-    categories: ['composition-api-essential'],
     schema: [],
     messages: {
       unexpected: "The variable '{{name}}' isn't expose in setup scripts."

package/lib/rules/valid-wx-model.js

@@ -33,7 +33,7 @@ module.exports = {
     type: 'problem',
     docs: {
       description: 'enforce valid `wx:model` directives',
-      categories: [],
+      categories: ['mpx-essential'],
       url: 'https://mpx-ecology.github.io/eslint-plugin-mpx/rules/valid-wx-model.html'
     },
     fixable: null,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "eslint-plugin-mpx",
-  "version": "0.2.8",
+  "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",

package/lib/rules/valid-wx-for.js

@@ -1,189 +0,0 @@
-/**
- * @author pagnkelly
- * @copyright 2020 pagnkelly. All rights reserved.
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Check whether the given attribute is using the variables which are defined by `wx:for` directives.
- * @param {VDirective} vFor The attribute node of `wx:for` to check.
- * @param {VDirective} vBindKey The attribute node of `wx:bind:key` to check.
- * @returns {boolean} `true` if the node is using the variables which are defined by `wx:for` directives.
- */
-function isUsingIterationVar(vFor, vBindKey) {
-  if (vBindKey.value == null) {
-    return false
-  }
-  const references = vBindKey.value.references
-  return references.some((reference) =>
-    ['item', '*this'].includes(reference.id.name)
-  )
-}
-
-/**
- * Check the child element in tempalte wx:for about `wx:bind:key` attributes.
- * @param {RuleContext} context The rule context to report.
- * @param {VDirective} vFor The attribute node of `wx:for` to check.
- * @param {VElement} child The child node to check.
- */
-function checkChildKey(context, vFor, child) {
-  const childFor = utils.getDirective(child, 'for')
-  // if child has wx:for, check if parent iterator is used in wx:for
-  if (childFor != null) {
-    const childForRefs = (childFor.value && childFor.value.references) || []
-    const variables = vFor.parent.parent.variables
-    const usedInFor = childForRefs.some((cref) =>
-      variables.some(
-        (variable) =>
-          cref.id.name === variable.id.name && variable.kind === 'wx:for'
-      )
-    )
-    // if parent iterator is used, skip other checks
-    // iterator usage will be checked later by child wx:for
-    if (usedInFor) {
-      return
-    }
-  }
-  // otherwise, check if parent iterator is directly used in child's key
-  checkKey(context, vFor, child)
-}
-
-/**
- * Check the given element about `wx:bind:key` attributes.
- * @param {RuleContext} context The rule context to report.
- * @param {VDirective} vFor The attribute node of `wx:for` to check.
- * @param {VElement} element The element node to check.
- */
-function checkKey(context, vFor, element) {
-  if (element.name === 'template') {
-    for (const child of element.children) {
-      if (child.type === 'VElement') {
-        checkChildKey(context, vFor, child)
-      }
-    }
-    return
-  }
-
-  const vBindKey = utils.getDirective(element, 'key')
-  if (utils.isCustomComponent(element) && vBindKey == null) {
-    context.report({
-      node: element.startTag,
-      loc: element.startTag.loc,
-      message: "Custom elements in iteration require 'wx:key' directives."
-    })
-  }
-  if (vBindKey != null && !isUsingIterationVar(vFor, vBindKey)) {
-    context.report({
-      node: vBindKey,
-      loc: vBindKey.loc,
-      message:
-        "Expected 'wx:key' directive to use the variables which are defined by the 'wx:for' directive."
-    })
-  }
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'enforce valid `wx:for` directives',
-      categories: [],
-      url: 'https://mpx-ecology.github.io/eslint-plugin-mpx/rules/valid-wx-for.html'
-    },
-    fixable: null,
-    schema: []
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const sourceCode = context.getSourceCode()
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VDirective} node */
-      "VAttribute[directive=true][key.name.name='for']"(node) {
-        const element = node.parent.parent
-
-        checkKey(context, node, element)
-
-        if (node.key.argument) {
-          context.report({
-            node,
-            loc: node.loc,
-            message: "'wx:for' directives require no argument."
-          })
-        }
-        if (node.key.modifiers.length > 0) {
-          context.report({
-            node,
-            loc: node.loc,
-            message: "'wx:for' directives require no modifier."
-          })
-        }
-        if (!node.value || utils.isEmptyValueDirective(node, context)) {
-          context.report({
-            node,
-            loc: node.loc,
-            message: "'wx:for' directives require that attribute value."
-          })
-          return
-        }
-
-        const expr = node.value.expression
-        if (expr == null) {
-          return
-        }
-        if (expr.type !== 'VForExpression') {
-          context.report({
-            node: node.value,
-            loc: node.value.loc,
-            message:
-              "'wx:for' directives require the special syntax '<alias> in <expression>'."
-          })
-          return
-        }
-
-        const lhs = expr.left
-        const value = lhs[0]
-        const key = lhs[1]
-        const index = lhs[2]
-
-        if (value === null) {
-          context.report({
-            node: expr,
-            message: "Invalid alias ''."
-          })
-        }
-        if (key !== undefined && (!key || key.type !== 'Identifier')) {
-          context.report({
-            node: key || expr,
-            loc: key && key.loc,
-            message: "Invalid alias '{{text}}'.",
-            data: { text: key ? sourceCode.getText(key) : '' }
-          })
-        }
-        if (index !== undefined && (!index || index.type !== 'Identifier')) {
-          context.report({
-            node: index || expr,
-            loc: index && index.loc,
-            message: "Invalid alias '{{text}}'.",
-            data: { text: index ? sourceCode.getText(index) : '' }
-          })
-        }
-      }
-    })
-  }
-}