eslint-plugin-mpx 0.0.21 → 0.2.0

package/lib/rules/no-lone-template.js

@@ -1,129 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-// https://github.com/vuejs/vue-next/blob/64e2f4643602c5980361e66674141e61ba60ef70/packages/compiler-core/src/parse.ts#L405
-const SPECIAL_TEMPLATE_DIRECTIVES = new Set([
-  'if',
-  'else',
-  'else-if',
-  'for',
-  'slot'
-])
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'disallow unnecessary `<template>`',
-      categories: ['vue3-recommended', 'recommended'],
-      url: 'https://eslint.vuejs.org/rules/no-lone-template.html'
-    },
-    fixable: null,
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreAccessible: {
-            type: 'boolean'
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      requireDirective: '`<template>` require directive.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const options = context.options[0] || {}
-    const ignoreAccessible = options.ignoreAccessible === true
-
-    /**
-     * @param {VAttribute | VDirective} attr
-     */
-    function getKeyName(attr) {
-      if (attr.directive) {
-        if (attr.key.name.name !== 'bind') {
-          // no v-bind
-          return null
-        }
-        if (
-          !attr.key.argument ||
-          attr.key.argument.type === 'VExpressionContainer'
-        ) {
-          // unknown
-          return null
-        }
-        return attr.key.argument.name
-      }
-      return attr.key.name
-    }
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VStartTag} node */
-      "VElement[name='template'][parent.type='VElement'] > VStartTag"(node) {
-        if (
-          node.attributes.some((attr) => {
-            if (attr.directive) {
-              const directiveName = attr.key.name.name
-              if (SPECIAL_TEMPLATE_DIRECTIVES.has(directiveName)) {
-                return true
-              }
-              if (directiveName === 'slot-scope') {
-                // `slot-scope` is deprecated in Vue.js 2.6
-                return true
-              }
-              if (directiveName === 'scope') {
-                // `scope` is deprecated in Vue.js 2.5
-                return true
-              }
-            }
-
-            const keyName = getKeyName(attr)
-            if (keyName === 'slot') {
-              // `slot` is deprecated in Vue.js 2.6
-              return true
-            }
-
-            return false
-          })
-        ) {
-          return
-        }
-
-        if (
-          ignoreAccessible &&
-          node.attributes.some((attr) => {
-            const keyName = getKeyName(attr)
-            return keyName === 'id' || keyName === 'ref'
-          })
-        ) {
-          return
-        }
-
-        context.report({
-          node,
-          messageId: 'requireDirective'
-        })
-      }
-    })
-  }
-}

package/lib/rules/no-multi-spaces.js

@@ -1,107 +0,0 @@
-/**
- * @fileoverview This rule warns about the usage of extra whitespaces between attributes
- * @author Armano
- */
-'use strict'
-
-const path = require('path')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-/**
- * @param {RuleContext} context
- * @param {Token} node
- */
-const isProperty = (context, node) => {
-  const sourceCode = context.getSourceCode()
-  return node.type === 'Punctuator' && sourceCode.getText(node) === ':'
-}
-
-module.exports = {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: 'disallow multiple spaces',
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url: 'https://eslint.vuejs.org/rules/no-multi-spaces.html'
-    },
-    fixable: 'whitespace', // or "code" or "whitespace"
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreProperties: {
-            type: 'boolean'
-          }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-
-  /**
-   * @param {RuleContext} context - The rule context.
-   * @returns {RuleListener} AST event handlers.
-   */
-  create(context) {
-    const options = context.options[0] || {}
-    const ignoreProperties = options.ignoreProperties === true
-
-    return {
-      Program(node) {
-        if (context.parserServices.getTemplateBodyTokenStore == null) {
-          const filename = context.getFilename()
-          if (path.extname(filename) === '.mpx') {
-            context.report({
-              loc: { line: 1, column: 0 },
-              message:
-                'Use the latest vue-eslint-parser. See also https://eslint.vuejs.org/user-guide/#what-is-the-use-the-latest-vue-eslint-parser-error.'
-            })
-          }
-          return
-        }
-        if (!node.templateBody) {
-          return
-        }
-        const sourceCode = context.getSourceCode()
-        const tokenStore = context.parserServices.getTemplateBodyTokenStore()
-        const tokens = tokenStore.getTokens(node.templateBody, {
-          includeComments: true
-        })
-
-        let prevToken = /** @type {Token} */ (tokens.shift())
-        for (const token of tokens) {
-          const spaces = token.range[0] - prevToken.range[1]
-          const shouldIgnore =
-            ignoreProperties &&
-            (isProperty(context, token) || isProperty(context, prevToken))
-          if (
-            spaces > 1 &&
-            token.loc.start.line === prevToken.loc.start.line &&
-            !shouldIgnore
-          ) {
-            context.report({
-              node: token,
-              loc: {
-                start: prevToken.loc.end,
-                end: token.loc.start
-              },
-              message: "Multiple spaces found before '{{displayValue}}'.",
-              fix: (fixer) =>
-                fixer.replaceTextRange(
-                  [prevToken.range[1], token.range[0]],
-                  ' '
-                ),
-              data: {
-                displayValue: sourceCode.getText(token)
-              }
-            })
-          }
-          prevToken = token
-        }
-      }
-    }
-  }
-}

package/lib/rules/no-multiple-objects-in-class.js

@@ -1,59 +0,0 @@
-/**
- * @author tyankatsu <https://github.com/tyankatsu0105>
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const { defineTemplateBodyVisitor } = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-/**
- * count ObjectExpression element
- * @param {VDirective & {value: VExpressionContainer & {expression: ArrayExpression}}} node
- * @return {number}
- */
-function countObjectExpression(node) {
-  return node.value.expression.elements.filter(
-    (element) => element && element.type === 'ObjectExpression'
-  ).length
-}
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'disallow to pass multiple objects into array to class',
-      categories: undefined,
-      url: 'https://eslint.vuejs.org/rules/no-multiple-objects-in-class.html'
-    },
-    fixable: null,
-    schema: [],
-    messages: {
-      unexpected: 'Unexpected multiple objects. Merge objects.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    return defineTemplateBodyVisitor(context, {
-      /** @param {VDirective & {value: VExpressionContainer & {expression: ArrayExpression}}} node */
-      'VAttribute[directive=true][key.argument.name="class"][key.name.name="bind"][value.expression.type="ArrayExpression"]'(
-        node
-      ) {
-        if (countObjectExpression(node) > 1) {
-          context.report({
-            node,
-            loc: node.loc,
-            messageId: 'unexpected'
-          })
-        }
-      }
-    })
-  }
-}

package/lib/rules/no-multiple-slot-args.js

@@ -1,118 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-const { findVariable } = require('eslint-utils')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'disallow to pass multiple arguments to scoped slots',
-      categories: ['vue3-recommended', 'recommended'],
-      url: 'https://eslint.vuejs.org/rules/no-multiple-slot-args.html'
-    },
-    fixable: null,
-    schema: [],
-    messages: {
-      unexpected: 'Unexpected multiple arguments.',
-      unexpectedSpread: 'Unexpected spread argument.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    /**
-     * Verify the given node
-     * @param {MemberExpression | Identifier} node The node to verify
-     */
-    function verify(node) {
-      const parent = node.parent
-
-      if (
-        parent.type === 'VariableDeclarator' &&
-        parent.id.type === 'Identifier'
-      ) {
-        // const foo = this.$scopedSlots.foo
-        verifyReferences(parent.id)
-        return
-      }
-
-      if (
-        parent.type === 'AssignmentExpression' &&
-        parent.right === node &&
-        parent.left.type === 'Identifier'
-      ) {
-        // foo = this.$scopedSlots.foo
-        verifyReferences(parent.left)
-        return
-      }
-
-      if (parent.type !== 'CallExpression' || parent.arguments.includes(node)) {
-        return
-      }
-
-      if (!parent.arguments.length) {
-        return
-      }
-      if (parent.arguments.length > 1) {
-        context.report({
-          node: parent.arguments[1],
-          messageId: 'unexpected'
-        })
-      }
-      if (parent.arguments[0].type === 'SpreadElement') {
-        context.report({
-          node: parent.arguments[0],
-          messageId: 'unexpectedSpread'
-        })
-      }
-    }
-    /**
-     * Verify the references of the given node.
-     * @param {Identifier} node The node to verify
-     */
-    function verifyReferences(node) {
-      const variable = findVariable(context.getScope(), node)
-      if (!variable) {
-        return
-      }
-      for (const reference of variable.references) {
-        if (!reference.isRead()) {
-          continue
-        }
-        /** @type {Identifier} */
-        const id = reference.identifier
-        verify(id)
-      }
-    }
-
-    return utils.defineVueVisitor(context, {
-      /** @param {MemberExpression} node */
-      MemberExpression(node) {
-        const object = utils.skipChainExpression(node.object)
-        if (object.type !== 'MemberExpression') {
-          return
-        }
-        const name = utils.getStaticPropertyName(object)
-        if (!name || (name !== '$slots' && name !== '$scopedSlots')) {
-          return
-        }
-        if (!utils.isThis(object.object, context)) {
-          return
-        }
-        verify(node)
-      }
-    })
-  }
-}

package/lib/rules/no-multiple-template-root.js

@@ -1,101 +0,0 @@
-/**
- * @fileoverview disallow adding multiple root nodes to the template
- * @author Przemyslaw Falowski (@przemkow)
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'disallow adding multiple root nodes to the template',
-      categories: ['essential'],
-      url: 'https://eslint.vuejs.org/rules/no-multiple-template-root.html'
-    },
-    fixable: null,
-    schema: []
-  },
-  /**
-   * @param {RuleContext} context - The rule context.
-   * @returns {RuleListener} AST event handlers.
-   */
-  create(context) {
-    const sourceCode = context.getSourceCode()
-
-    return {
-      Program(program) {
-        const element = program.templateBody
-        if (element == null) {
-          return
-        }
-
-        const rootElements = []
-        let extraText = null
-        let extraElement = null
-        let vIf = false
-        for (const child of element.children) {
-          if (child.type === 'VElement') {
-            if (rootElements.length === 0) {
-              rootElements.push(child)
-              vIf = utils.hasDirective(child, 'if')
-            } else if (vIf && utils.hasDirective(child, 'else-if')) {
-              rootElements.push(child)
-            } else if (vIf && utils.hasDirective(child, 'else')) {
-              rootElements.push(child)
-              vIf = false
-            } else {
-              extraElement = child
-            }
-          } else if (sourceCode.getText(child).trim() !== '') {
-            extraText = child
-          }
-        }
-
-        if (extraText != null) {
-          context.report({
-            node: extraText,
-            loc: extraText.loc,
-            message: 'The template root requires an element rather than texts.'
-          })
-        } else if (extraElement != null) {
-          context.report({
-            node: extraElement,
-            loc: extraElement.loc,
-            message: 'The template root requires exactly one element.'
-          })
-        } else {
-          for (const element of rootElements) {
-            const tag = element.startTag
-            const name = element.name
-
-            if (name === 'template' || name === 'slot') {
-              context.report({
-                node: tag,
-                loc: tag.loc,
-                message: "The template root disallows '<{{name}}>' elements.",
-                data: { name }
-              })
-            }
-            if (utils.hasDirective(element, 'for')) {
-              context.report({
-                node: tag,
-                loc: tag.loc,
-                message: "The template root disallows 'v-for' directives."
-              })
-            }
-          }
-        }
-      }
-    }
-  }
-}