eslint-plugin-mpx 0.0.21 → 0.2.0

package/lib/rules/no-empty-component-block.js

@@ -1,109 +0,0 @@
-/**
- * @author tyankatsu <https://github.com/tyankatsu0105>
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const { isVElement } = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-/**
- * check whether has attribute `src`
- * @param {VElement} componentBlock
- */
-function hasAttributeSrc(componentBlock) {
-  const hasAttribute = componentBlock.startTag.attributes.length > 0
-
-  const hasSrc =
-    componentBlock.startTag.attributes.filter(
-      (attribute) =>
-        !attribute.directive &&
-        attribute.key.name === 'src' &&
-        attribute.value &&
-        attribute.value.value !== ''
-    ).length > 0
-
-  return hasAttribute && hasSrc
-}
-
-/**
- * check whether value under the component block is only whitespaces or break lines
- * @param {VElement} componentBlock
- */
-function isValueOnlyWhiteSpacesOrLineBreaks(componentBlock) {
-  return (
-    componentBlock.children.length === 1 &&
-    componentBlock.children[0].type === 'VText' &&
-    !componentBlock.children[0].value.trim()
-  )
-}
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'disallow the `<template>` `<script>` `<style>` block to be empty',
-      categories: undefined,
-      url: 'https://eslint.vuejs.org/rules/no-empty-component-block.html'
-    },
-    fixable: null,
-    schema: [],
-    messages: {
-      unexpected: '`<{{ blockName }}>` is empty. Empty block is not allowed.'
-    }
-  },
-
-  /**
-   * @param {RuleContext} context - The rule context.
-   * @returns {RuleListener} AST event handlers.
-   */
-  create(context) {
-    if (!context.parserServices.getDocumentFragment) {
-      return {}
-    }
-    const documentFragment = context.parserServices.getDocumentFragment()
-    if (!documentFragment) {
-      return {}
-    }
-
-    const componentBlocks = documentFragment.children.filter(isVElement)
-
-    return {
-      Program() {
-        for (const componentBlock of componentBlocks) {
-          if (
-            componentBlock.name !== 'template' &&
-            componentBlock.name !== 'script' &&
-            componentBlock.name !== 'style'
-          )
-            continue
-
-          // https://vue-loader.vuejs.org/spec.html#src-imports
-          if (hasAttributeSrc(componentBlock)) continue
-
-          if (
-            isValueOnlyWhiteSpacesOrLineBreaks(componentBlock) ||
-            componentBlock.children.length === 0
-          ) {
-            context.report({
-              node: componentBlock,
-              loc: componentBlock.loc,
-              messageId: 'unexpected',
-              data: {
-                blockName: componentBlock.name
-              }
-            })
-          }
-        }
-      }
-    }
-  }
-}

package/lib/rules/no-empty-pattern.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/no-empty-pattern'))

package/lib/rules/no-extra-parens.js

@@ -1,182 +0,0 @@
-/**
- * @author Yosuke Ota
- */
-'use strict'
-
-const { isParenthesized } = require('eslint-utils')
-const { wrapCoreRule } = require('../utils')
-
-// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
-module.exports = wrapCoreRule(require('eslint/lib/rules/no-extra-parens'), {
-  skipDynamicArguments: true,
-  create: createForVueSyntax
-})
-
-/**
- * Check whether the given token is a left parenthesis.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a left parenthesis.
- */
-function isLeftParen(token) {
-  return token.type === 'Punctuator' && token.value === '('
-}
-
-/**
- * Check whether the given token is a right parenthesis.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a right parenthesis.
- */
-function isRightParen(token) {
-  return token.type === 'Punctuator' && token.value === ')'
-}
-
-/**
- * Check whether the given token is a left brace.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a left brace.
- */
-function isLeftBrace(token) {
-  return token.type === 'Punctuator' && token.value === '{'
-}
-
-/**
- * Check whether the given token is a right brace.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a right brace.
- */
-function isRightBrace(token) {
-  return token.type === 'Punctuator' && token.value === '}'
-}
-
-/**
- * Check whether the given token is a left bracket.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a left bracket.
- */
-function isLeftBracket(token) {
-  return token.type === 'Punctuator' && token.value === '['
-}
-
-/**
- * Check whether the given token is a right bracket.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a right bracket.
- */
-function isRightBracket(token) {
-  return token.type === 'Punctuator' && token.value === ']'
-}
-
-/**
- * Determines if a given expression node is an IIFE
- * @param {Expression} node The node to check
- * @returns {node is CallExpression & { callee: FunctionExpression } } `true` if the given node is an IIFE
- */
-function isIIFE(node) {
-  return (
-    node.type === 'CallExpression' && node.callee.type === 'FunctionExpression'
-  )
-}
-
-/**
- * @param {RuleContext} context - The rule context.
- * @returns {TemplateListener} AST event handlers.
- */
-function createForVueSyntax(context) {
-  if (!context.parserServices.getTemplateBodyTokenStore) {
-    return {}
-  }
-  const tokenStore = context.parserServices.getTemplateBodyTokenStore()
-
-  /**
-   * Checks if the given node turns into a filter when unwraped.
-   * @param {Expression} expression node to evaluate
-   * @returns {boolean} `true` if the given node turns into a filter when unwraped.
-   */
-  function isUnwrapChangeToFilter(expression) {
-    let parenStack = null
-    for (const token of tokenStore.getTokens(expression)) {
-      if (!parenStack) {
-        if (token.value === '|') {
-          return true
-        }
-      } else {
-        if (parenStack.isUpToken(token)) {
-          parenStack = parenStack.upper
-          continue
-        }
-      }
-      if (isLeftParen(token)) {
-        parenStack = { isUpToken: isRightParen, upper: parenStack }
-      } else if (isLeftBracket(token)) {
-        parenStack = { isUpToken: isRightBracket, upper: parenStack }
-      } else if (isLeftBrace(token)) {
-        parenStack = { isUpToken: isRightBrace, upper: parenStack }
-      }
-    }
-    return false
-  }
-  /**
-   * @param {VExpressionContainer & { expression: Expression | VFilterSequenceExpression | null }} node
-   */
-  function verify(node) {
-    if (!node.expression) {
-      return
-    }
-
-    const expression =
-      node.expression.type === 'VFilterSequenceExpression'
-        ? node.expression.expression
-        : node.expression
-
-    if (!isParenthesized(expression, tokenStore)) {
-      return
-    }
-
-    if (!isParenthesized(2, expression, tokenStore)) {
-      if (
-        isIIFE(expression) &&
-        !isParenthesized(expression.callee, tokenStore)
-      ) {
-        return
-      }
-      if (isUnwrapChangeToFilter(expression)) {
-        return
-      }
-    }
-    report(expression)
-  }
-
-  /**
-   * Report the node
-   * @param {Expression} node node to evaluate
-   * @returns {void}
-   * @private
-   */
-  function report(node) {
-    const sourceCode = context.getSourceCode()
-    const leftParenToken = tokenStore.getTokenBefore(node)
-    const rightParenToken = tokenStore.getTokenAfter(node)
-
-    context.report({
-      node,
-      loc: leftParenToken.loc,
-      messageId: 'unexpected',
-      fix(fixer) {
-        const parenthesizedSource = sourceCode.text.slice(
-          leftParenToken.range[1],
-          rightParenToken.range[0]
-        )
-
-        return fixer.replaceTextRange(
-          [leftParenToken.range[0], rightParenToken.range[1]],
-          parenthesizedSource
-        )
-      }
-    })
-  }
-
-  return {
-    "VAttribute[directive=true][key.name.name='bind'] > VExpressionContainer": verify,
-    'VElement > VExpressionContainer': verify
-  }
-}

package/lib/rules/no-irregular-whitespace.js

@@ -1,251 +0,0 @@
-/**
- * @author Yosuke Ota
- * @fileoverview Rule to disalow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
- */
-
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Constants
-// ------------------------------------------------------------------------------
-
-const ALL_IRREGULARS = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u
-const IRREGULAR_WHITESPACE = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gmu
-const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gmu
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'problem',
-
-    docs: {
-      description: 'disallow irregular whitespace',
-      categories: undefined,
-      url: 'https://eslint.vuejs.org/rules/no-irregular-whitespace.html',
-      extensionRule: true,
-      coreRuleUrl: 'https://eslint.org/docs/rules/no-irregular-whitespace'
-    },
-
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          skipComments: {
-            type: 'boolean',
-            default: false
-          },
-          skipStrings: {
-            type: 'boolean',
-            default: true
-          },
-          skipTemplates: {
-            type: 'boolean',
-            default: false
-          },
-          skipRegExps: {
-            type: 'boolean',
-            default: false
-          },
-          skipHTMLAttributeValues: {
-            type: 'boolean',
-            default: false
-          },
-          skipHTMLTextContents: {
-            type: 'boolean',
-            default: false
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      disallow: 'Irregular whitespace not allowed.'
-    }
-  },
-  /**
-   * @param {RuleContext} context - The rule context.
-   * @returns {RuleListener} AST event handlers.
-   */
-  create(context) {
-    // Module store of error indexes that we have found
-    /** @type {number[]} */
-    let errorIndexes = []
-
-    // Lookup the `skipComments` option, which defaults to `false`.
-    const options = context.options[0] || {}
-    const skipComments = !!options.skipComments
-    const skipStrings = options.skipStrings !== false
-    const skipRegExps = !!options.skipRegExps
-    const skipTemplates = !!options.skipTemplates
-    const skipHTMLAttributeValues = !!options.skipHTMLAttributeValues
-    const skipHTMLTextContents = !!options.skipHTMLTextContents
-
-    const sourceCode = context.getSourceCode()
-
-    /**
-     * Removes errors that occur inside a string node
-     * @param {ASTNode | Token} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeWhitespaceError(node) {
-      const [startIndex, endIndex] = node.range
-
-      errorIndexes = errorIndexes.filter(
-        (errorIndex) => errorIndex < startIndex || endIndex <= errorIndex
-      )
-    }
-
-    /**
-     * Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {Literal} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrorsInLiteral(node) {
-      const shouldCheckStrings = skipStrings && typeof node.value === 'string'
-      const shouldCheckRegExps = skipRegExps && Boolean(node.regex)
-
-      if (shouldCheckStrings || shouldCheckRegExps) {
-        // If we have irregular characters remove them from the errors list
-        if (ALL_IRREGULARS.test(sourceCode.getText(node))) {
-          removeWhitespaceError(node)
-        }
-      }
-    }
-
-    /**
-     * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {TemplateElement} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrorsInTemplateLiteral(node) {
-      if (ALL_IRREGULARS.test(node.value.raw)) {
-        removeWhitespaceError(node)
-      }
-    }
-
-    /**
-     * Checks HTML attribute value nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {VLiteral} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrorsInHTMLAttributeValue(node) {
-      if (ALL_IRREGULARS.test(sourceCode.getText(node))) {
-        removeWhitespaceError(node)
-      }
-    }
-
-    /**
-     * Checks HTML text content nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {VText} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrorsInHTMLTextContent(node) {
-      if (ALL_IRREGULARS.test(sourceCode.getText(node))) {
-        removeWhitespaceError(node)
-      }
-    }
-
-    /**
-     * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {Comment | HTMLComment | HTMLBogusComment} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrorsInComment(node) {
-      if (ALL_IRREGULARS.test(node.value)) {
-        removeWhitespaceError(node)
-      }
-    }
-
-    /**
-     * Checks the program source for irregular whitespaces and irregular line terminators
-     * @returns {void}
-     * @private
-     */
-    function checkForIrregularWhitespace() {
-      const source = sourceCode.getText()
-      let match
-      while ((match = IRREGULAR_WHITESPACE.exec(source)) !== null) {
-        errorIndexes.push(match.index)
-      }
-      while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
-        errorIndexes.push(match.index)
-      }
-    }
-
-    checkForIrregularWhitespace()
-
-    if (!errorIndexes.length) {
-      return {}
-    }
-    const bodyVisitor = utils.defineTemplateBodyVisitor(context, {
-      ...(skipHTMLAttributeValues
-        ? {
-            'VAttribute[directive=false] > VLiteral': removeInvalidNodeErrorsInHTMLAttributeValue
-          }
-        : {}),
-      ...(skipHTMLTextContents
-        ? { VText: removeInvalidNodeErrorsInHTMLTextContent }
-        : {}),
-
-      // inline scripts
-      Literal: removeInvalidNodeErrorsInLiteral,
-      ...(skipTemplates
-        ? { TemplateElement: removeInvalidNodeErrorsInTemplateLiteral }
-        : {})
-    })
-    return {
-      ...bodyVisitor,
-      Literal: removeInvalidNodeErrorsInLiteral,
-      ...(skipTemplates
-        ? { TemplateElement: removeInvalidNodeErrorsInTemplateLiteral }
-        : {}),
-      'Program:exit'(node) {
-        if (bodyVisitor['Program:exit']) {
-          bodyVisitor['Program:exit'](node)
-        }
-        const templateBody = node.templateBody
-        if (skipComments) {
-          // First strip errors occurring in comment nodes.
-          sourceCode.getAllComments().forEach(removeInvalidNodeErrorsInComment)
-          if (templateBody) {
-            templateBody.comments.forEach(removeInvalidNodeErrorsInComment)
-          }
-        }
-
-        // Removes errors that occur outside script and template
-        const [scriptStart, scriptEnd] = node.range
-        const [templateStart, templateEnd] = templateBody
-          ? templateBody.range
-          : [0, 0]
-        errorIndexes = errorIndexes.filter(
-          (errorIndex) =>
-            (scriptStart <= errorIndex && errorIndex < scriptEnd) ||
-            (templateStart <= errorIndex && errorIndex < templateEnd)
-        )
-
-        // If we have any errors remaining report on them
-        errorIndexes.forEach((errorIndex) => {
-          context.report({
-            loc: sourceCode.getLocFromIndex(errorIndex),
-            messageId: 'disallow'
-          })
-        })
-      }
-    }
-  }
-}

package/lib/rules/no-lifecycle-after-await.js

@@ -1,133 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-const { ReferenceTracker } = require('eslint-utils')
-const utils = require('../utils')
-
-/**
- * @typedef {import('eslint-utils').TYPES.TraceMap} TraceMap
- */
-
-const LIFECYCLE_HOOKS = [
-  'onBeforeMount',
-  'onBeforeUnmount',
-  'onBeforeUpdate',
-  'onErrorCaptured',
-  'onMounted',
-  'onRenderTracked',
-  'onRenderTriggered',
-  'onUnmounted',
-  'onUpdated',
-  'onActivated',
-  'onDeactivated'
-]
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'disallow asynchronously registered lifecycle hooks',
-      categories: ['vue3-essential'],
-      url: 'https://eslint.vuejs.org/rules/no-lifecycle-after-await.html'
-    },
-    fixable: null,
-    schema: [],
-    messages: {
-      forbidden: 'The lifecycle hooks after `await` expression are forbidden.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    /**
-     * @typedef {object} SetupFunctionData
-     * @property {Property} setupProperty
-     * @property {boolean} afterAwait
-     */
-    /**
-     * @typedef {object} ScopeStack
-     * @property {ScopeStack | null} upper
-     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} functionNode
-     */
-    /** @type {Set<ESNode>} */
-    const lifecycleHookCallNodes = new Set()
-    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, SetupFunctionData>} */
-    const setupFunctions = new Map()
-
-    /** @type {ScopeStack | null} */
-    let scopeStack = null
-
-    return Object.assign(
-      {
-        Program() {
-          const tracker = new ReferenceTracker(context.getScope())
-          const traceMap = {
-            /** @type {TraceMap} */
-            vue: {
-              [ReferenceTracker.ESM]: true
-            }
-          }
-          for (const lifecycleHook of LIFECYCLE_HOOKS) {
-            traceMap.vue[lifecycleHook] = {
-              [ReferenceTracker.CALL]: true
-            }
-          }
-
-          for (const { node } of tracker.iterateEsmReferences(traceMap)) {
-            lifecycleHookCallNodes.add(node)
-          }
-        }
-      },
-      utils.defineVueVisitor(context, {
-        ':function'(node) {
-          scopeStack = {
-            upper: scopeStack,
-            functionNode: node
-          }
-        },
-        onSetupFunctionEnter(node) {
-          setupFunctions.set(node, {
-            setupProperty: node.parent,
-            afterAwait: false
-          })
-        },
-        AwaitExpression() {
-          if (!scopeStack) {
-            return
-          }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData) {
-            return
-          }
-          setupFunctionData.afterAwait = true
-        },
-        CallExpression(node) {
-          if (!scopeStack) {
-            return
-          }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData || !setupFunctionData.afterAwait) {
-            return
-          }
-
-          if (lifecycleHookCallNodes.has(node)) {
-            if (node.arguments.length >= 2) {
-              // Has target instance. e.g. `onMounted(() => {}, instance)`
-              return
-            }
-            context.report({
-              node,
-              messageId: 'forbidden'
-            })
-          }
-        },
-        ':function:exit'(node) {
-          scopeStack = scopeStack && scopeStack.upper
-
-          setupFunctions.delete(node)
-        }
-      })
-    )
-  }
-}