eslint-plugin-mpx 0.0.21 → 0.2.0

package/lib/rules/custom-event-name-casing.js

@@ -1,214 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const { findVariable } = require('eslint-utils')
-const utils = require('../utils')
-const { isKebabCase } = require('../utils/casing')
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Check whether the given event name is valid.
- * @param {string} name The name to check.
- * @returns {boolean} `true` if the given event name is valid.
- */
-function isValidEventName(name) {
-  return isKebabCase(name) || name.startsWith('update:')
-}
-
-/**
- * Get the name param node from the given CallExpression
- * @param {CallExpression} node CallExpression
- * @returns { Literal & { value: string } | null }
- */
-function getNameParamNode(node) {
-  const nameLiteralNode = node.arguments[0]
-  if (
-    !nameLiteralNode ||
-    nameLiteralNode.type !== 'Literal' ||
-    typeof nameLiteralNode.value !== 'string'
-  ) {
-    // cannot check
-    return null
-  }
-
-  return /** @type {Literal & { value: string }} */ (nameLiteralNode)
-}
-/**
- * Get the callee member node from the given CallExpression
- * @param {CallExpression} node CallExpression
- */
-function getCalleeMemberNode(node) {
-  const callee = utils.skipChainExpression(node.callee)
-
-  if (callee.type === 'MemberExpression') {
-    const name = utils.getStaticPropertyName(callee)
-    if (name) {
-      return { name, member: callee }
-    }
-  }
-  return null
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'enforce custom event names always use "kebab-case"',
-      categories: ['vue3-essential', 'essential'],
-      url: 'https://eslint.vuejs.org/rules/custom-event-name-casing.html'
-    },
-    fixable: null,
-    schema: [],
-    messages: {
-      unexpected: "Custom event name '{{name}}' must be kebab-case."
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const setupContexts = new Map()
-
-    /**
-     * @param { Literal & { value: string } } nameLiteralNode
-     */
-    function verify(nameLiteralNode) {
-      const name = nameLiteralNode.value
-      if (isValidEventName(name)) {
-        return
-      }
-      context.report({
-        node: nameLiteralNode,
-        messageId: 'unexpected',
-        data: {
-          name
-        }
-      })
-    }
-
-    return utils.defineTemplateBodyVisitor(
-      context,
-      {
-        CallExpression(node) {
-          const callee = node.callee
-          const nameLiteralNode = getNameParamNode(node)
-          if (!nameLiteralNode) {
-            // cannot check
-            return
-          }
-          if (callee.type === 'Identifier' && callee.name === '$emit') {
-            verify(nameLiteralNode)
-          }
-        }
-      },
-      utils.compositingVisitors(
-        utils.defineVueVisitor(context, {
-          onSetupFunctionEnter(node, { node: vueNode }) {
-            const contextParam = utils.skipDefaultParamValue(node.params[1])
-            if (!contextParam) {
-              // no arguments
-              return
-            }
-            if (
-              contextParam.type === 'RestElement' ||
-              contextParam.type === 'ArrayPattern'
-            ) {
-              // cannot check
-              return
-            }
-            const contextReferenceIds = new Set()
-            const emitReferenceIds = new Set()
-            if (contextParam.type === 'ObjectPattern') {
-              const emitProperty = utils.findAssignmentProperty(
-                contextParam,
-                'emit'
-              )
-              if (!emitProperty || emitProperty.value.type !== 'Identifier') {
-                return
-              }
-              const emitParam = emitProperty.value
-              // `setup(props, {emit})`
-              const variable = findVariable(context.getScope(), emitParam)
-              if (!variable) {
-                return
-              }
-              for (const reference of variable.references) {
-                emitReferenceIds.add(reference.identifier)
-              }
-            } else {
-              // `setup(props, context)`
-              const variable = findVariable(context.getScope(), contextParam)
-              if (!variable) {
-                return
-              }
-              for (const reference of variable.references) {
-                contextReferenceIds.add(reference.identifier)
-              }
-            }
-            setupContexts.set(vueNode, {
-              contextReferenceIds,
-              emitReferenceIds
-            })
-          },
-          CallExpression(node, { node: vueNode }) {
-            const nameLiteralNode = getNameParamNode(node)
-            if (!nameLiteralNode) {
-              // cannot check
-              return
-            }
-
-            // verify setup context
-            const setupContext = setupContexts.get(vueNode)
-            if (setupContext) {
-              const { contextReferenceIds, emitReferenceIds } = setupContext
-              if (emitReferenceIds.has(node.callee)) {
-                // verify setup(props,{emit}) {emit()}
-                verify(nameLiteralNode)
-              } else {
-                const emit = getCalleeMemberNode(node)
-                if (
-                  emit &&
-                  emit.name === 'emit' &&
-                  contextReferenceIds.has(emit.member.object)
-                ) {
-                  // verify setup(props,context) {context.emit()}
-                  verify(nameLiteralNode)
-                }
-              }
-            }
-          },
-          onVueObjectExit(node) {
-            setupContexts.delete(node)
-          }
-        }),
-        {
-          CallExpression(node) {
-            const nameLiteralNode = getNameParamNode(node)
-            if (!nameLiteralNode) {
-              // cannot check
-              return
-            }
-            const emit = getCalleeMemberNode(node)
-            // verify $emit
-            if (emit && emit.name === '$emit') {
-              // verify this.$emit()
-              verify(nameLiteralNode)
-            }
-          }
-        }
-      )
-    )
-  }
-}

package/lib/rules/dot-location.js

@@ -1,9 +0,0 @@
-/**
- * @author Yosuke Ota
- */
-'use strict'
-
-const { wrapCoreRule } = require('../utils')
-
-// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
-module.exports = wrapCoreRule(require('eslint/lib/rules/dot-location'))

package/lib/rules/dot-notation.js

@@ -1,9 +0,0 @@
-/**
- * @author Yosuke Ota
- */
-'use strict'
-
-const { wrapCoreRule } = require('../utils')
-
-// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
-module.exports = wrapCoreRule(require('eslint/lib/rules/dot-notation'))

package/lib/rules/func-call-spacing.js

@@ -1,11 +0,0 @@
-/**
- * @author Yosuke Ota
- */
-'use strict'
-
-const { wrapCoreRule } = require('../utils')
-
-// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
-module.exports = wrapCoreRule(require('eslint/lib/rules/func-call-spacing'), {
-  skipDynamicArguments: true
-})

package/lib/rules/html-closing-bracket-newline.js

@@ -1,115 +0,0 @@
-/**
- * @author Toru Nagashima
- * @copyright 2016 Toru Nagashima. All rights reserved.
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * @param {number} lineBreaks
- */
-function getPhrase(lineBreaks) {
-  switch (lineBreaks) {
-    case 0:
-      return 'no line breaks'
-    case 1:
-      return '1 line break'
-    default:
-      return `${lineBreaks} line breaks`
-  }
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'layout',
-    docs: {
-      description:
-        "require or disallow a line break before tag's closing brackets",
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url: 'https://eslint.vuejs.org/rules/html-closing-bracket-newline.html'
-    },
-    fixable: 'whitespace',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          singleline: { enum: ['always', 'never'] },
-          multiline: { enum: ['always', 'never'] }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const options = Object.assign(
-      {},
-      {
-        singleline: 'never',
-        multiline: 'always'
-      },
-      context.options[0] || {}
-    )
-    const template =
-      context.parserServices.getTemplateBodyTokenStore &&
-      context.parserServices.getTemplateBodyTokenStore()
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VStartTag | VEndTag} node */
-      'VStartTag, VEndTag'(node) {
-        const closingBracketToken = template.getLastToken(node)
-        if (
-          closingBracketToken.type !== 'HTMLSelfClosingTagClose' &&
-          closingBracketToken.type !== 'HTMLTagClose'
-        ) {
-          return
-        }
-
-        const prevToken = template.getTokenBefore(closingBracketToken)
-        const type =
-          node.loc.start.line === prevToken.loc.end.line
-            ? 'singleline'
-            : 'multiline'
-        const expectedLineBreaks = options[type] === 'always' ? 1 : 0
-        const actualLineBreaks =
-          closingBracketToken.loc.start.line - prevToken.loc.end.line
-
-        if (actualLineBreaks !== expectedLineBreaks) {
-          context.report({
-            node,
-            loc: {
-              start: prevToken.loc.end,
-              end: closingBracketToken.loc.start
-            },
-            message:
-              'Expected {{expected}} before closing bracket, but {{actual}} found.',
-            data: {
-              expected: getPhrase(expectedLineBreaks),
-              actual: getPhrase(actualLineBreaks)
-            },
-            fix(fixer) {
-              /** @type {Range} */
-              const range = [prevToken.range[1], closingBracketToken.range[0]]
-              const text = '\n'.repeat(expectedLineBreaks)
-              return fixer.replaceTextRange(range, text)
-            }
-          })
-        }
-      }
-    })
-  }
-}

package/lib/rules/html-closing-bracket-spacing.js

@@ -1,137 +0,0 @@
-/**
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-'use strict'
-
-// -----------------------------------------------------------------------------
-// Requirements
-// -----------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// -----------------------------------------------------------------------------
-// Helpers
-// -----------------------------------------------------------------------------
-
-/**
- * @typedef { {startTag?:"always"|"never",endTag?:"always"|"never",selfClosingTag?:"always"|"never"} } Options
- */
-
-/**
- * Normalize options.
- * @param {Options} options The options user configured.
- * @param {ParserServices.TokenStore} tokens The token store of template body.
- * @returns {Options & { detectType: (node: VStartTag | VEndTag) => 'never' | 'always' | null }} The normalized options.
- */
-function parseOptions(options, tokens) {
-  const opts = Object.assign(
-    {
-      startTag: 'never',
-      endTag: 'never',
-      selfClosingTag: 'always'
-    },
-    options
-  )
-  return Object.assign(opts, {
-    /**
-     * @param {VStartTag | VEndTag} node
-     * @returns {'never' | 'always' | null}
-     */
-    detectType(node) {
-      const openType = tokens.getFirstToken(node).type
-      const closeType = tokens.getLastToken(node).type
-
-      if (openType === 'HTMLEndTagOpen' && closeType === 'HTMLTagClose') {
-        return opts.endTag
-      }
-      if (openType === 'HTMLTagOpen' && closeType === 'HTMLTagClose') {
-        return opts.startTag
-      }
-      if (
-        openType === 'HTMLTagOpen' &&
-        closeType === 'HTMLSelfClosingTagClose'
-      ) {
-        return opts.selfClosingTag
-      }
-      return null
-    }
-  })
-}
-
-// -----------------------------------------------------------------------------
-// Rule Definition
-// -----------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: "require or disallow a space before tag's closing brackets",
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url: 'https://eslint.vuejs.org/rules/html-closing-bracket-spacing.html'
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          startTag: { enum: ['always', 'never'] },
-          endTag: { enum: ['always', 'never'] },
-          selfClosingTag: { enum: ['always', 'never'] }
-        },
-        additionalProperties: false
-      }
-    ],
-    fixable: 'whitespace'
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const sourceCode = context.getSourceCode()
-    const tokens =
-      context.parserServices.getTemplateBodyTokenStore &&
-      context.parserServices.getTemplateBodyTokenStore()
-    const options = parseOptions(context.options[0], tokens)
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VStartTag | VEndTag} node */
-      'VStartTag, VEndTag'(node) {
-        const type = options.detectType(node)
-        const lastToken = tokens.getLastToken(node)
-        const prevToken = tokens.getLastToken(node, 1)
-
-        // Skip if EOF exists in the tag or linebreak exists before `>`.
-        if (
-          type == null ||
-          prevToken == null ||
-          prevToken.loc.end.line !== lastToken.loc.start.line
-        ) {
-          return
-        }
-
-        // Check and report.
-        const hasSpace = prevToken.range[1] !== lastToken.range[0]
-        if (type === 'always' && !hasSpace) {
-          context.report({
-            node,
-            loc: lastToken.loc,
-            message: "Expected a space before '{{bracket}}', but not found.",
-            data: { bracket: sourceCode.getText(lastToken) },
-            fix: (fixer) => fixer.insertTextBefore(lastToken, ' ')
-          })
-        } else if (type === 'never' && hasSpace) {
-          context.report({
-            node,
-            loc: {
-              start: prevToken.loc.end,
-              end: lastToken.loc.end
-            },
-            message: "Expected no space before '{{bracket}}', but found.",
-            data: { bracket: sourceCode.getText(lastToken) },
-            fix: (fixer) =>
-              fixer.removeRange([prevToken.range[1], lastToken.range[0]])
-          })
-        }
-      }
-    })
-  }
-}