eslint-plugin-mpx 0.0.21 → 0.2.0

package/lib/rules/multiline-html-element-content-newline.js

@@ -1,246 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-const casing = require('../utils/casing')
-const INLINE_ELEMENTS = require('../utils/inline-non-void-elements.json')
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * @param {VElement & { endTag: VEndTag }} element
- */
-function isMultilineElement(element) {
-  return element.loc.start.line < element.endTag.loc.start.line
-}
-
-/**
- * @param {any} options
- */
-function parseOptions(options) {
-  return Object.assign(
-    {
-      ignores: ['pre', 'textarea'].concat(INLINE_ELEMENTS),
-      ignoreWhenEmpty: true,
-      allowEmptyLines: false
-    },
-    options
-  )
-}
-
-/**
- * @param {number} lineBreaks
- */
-function getPhrase(lineBreaks) {
-  switch (lineBreaks) {
-    case 0:
-      return 'no'
-    default:
-      return `${lineBreaks}`
-  }
-}
-/**
- * Check whether the given element is empty or not.
- * This ignores whitespaces, doesn't ignore comments.
- * @param {VElement & { endTag: VEndTag }} node The element node to check.
- * @param {SourceCode} sourceCode The source code object of the current context.
- * @returns {boolean} `true` if the element is empty.
- */
-function isEmpty(node, sourceCode) {
-  const start = node.startTag.range[1]
-  const end = node.endTag.range[0]
-  return sourceCode.text.slice(start, end).trim() === ''
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'layout',
-    docs: {
-      description:
-        'require a line break before and after the contents of a multiline element',
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url:
-        'https://eslint.vuejs.org/rules/multiline-html-element-content-newline.html'
-    },
-    fixable: 'whitespace',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreWhenEmpty: {
-            type: 'boolean'
-          },
-          ignores: {
-            type: 'array',
-            items: { type: 'string' },
-            uniqueItems: true,
-            additionalItems: false
-          },
-          allowEmptyLines: {
-            type: 'boolean'
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      unexpectedAfterClosingBracket:
-        'Expected 1 line break after opening tag (`<{{name}}>`), but {{actual}} line breaks found.',
-      unexpectedBeforeOpeningBracket:
-        'Expected 1 line break before closing tag (`</{{name}}>`), but {{actual}} line breaks found.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const options = parseOptions(context.options[0])
-    const ignores = options.ignores
-    const ignoreWhenEmpty = options.ignoreWhenEmpty
-    const allowEmptyLines = options.allowEmptyLines
-    const template =
-      context.parserServices.getTemplateBodyTokenStore &&
-      context.parserServices.getTemplateBodyTokenStore()
-    const sourceCode = context.getSourceCode()
-
-    /** @type {VElement | null} */
-    let inIgnoreElement = null
-
-    /**
-     * @param {VElement} node
-     */
-    function isIgnoredElement(node) {
-      return (
-        ignores.includes(node.name) ||
-        ignores.includes(casing.pascalCase(node.rawName)) ||
-        ignores.includes(casing.kebabCase(node.rawName))
-      )
-    }
-
-    /**
-     * @param {number} lineBreaks
-     */
-    function isInvalidLineBreaks(lineBreaks) {
-      if (allowEmptyLines) {
-        return lineBreaks === 0
-      } else {
-        return lineBreaks !== 1
-      }
-    }
-
-    return utils.defineTemplateBodyVisitor(context, {
-      VElement(node) {
-        if (inIgnoreElement) {
-          return
-        }
-        if (isIgnoredElement(node)) {
-          // ignore element name
-          inIgnoreElement = node
-          return
-        }
-        if (node.startTag.selfClosing || !node.endTag) {
-          // self closing
-          return
-        }
-
-        const element = /** @type {VElement & { endTag: VEndTag }} */ (node)
-
-        if (!isMultilineElement(element)) {
-          return
-        }
-
-        /**
-         * @type {SourceCode.CursorWithCountOptions}
-         */
-        const getTokenOption = {
-          includeComments: true,
-          filter: (token) => token.type !== 'HTMLWhitespace'
-        }
-        if (
-          ignoreWhenEmpty &&
-          element.children.length === 0 &&
-          template.getFirstTokensBetween(
-            element.startTag,
-            element.endTag,
-            getTokenOption
-          ).length === 0
-        ) {
-          return
-        }
-
-        const contentFirst = /** @type {Token} */ (template.getTokenAfter(
-          element.startTag,
-          getTokenOption
-        ))
-        const contentLast = /** @type {Token} */ (template.getTokenBefore(
-          element.endTag,
-          getTokenOption
-        ))
-
-        const beforeLineBreaks =
-          contentFirst.loc.start.line - element.startTag.loc.end.line
-        const afterLineBreaks =
-          element.endTag.loc.start.line - contentLast.loc.end.line
-        if (isInvalidLineBreaks(beforeLineBreaks)) {
-          context.report({
-            node: template.getLastToken(element.startTag),
-            loc: {
-              start: element.startTag.loc.end,
-              end: contentFirst.loc.start
-            },
-            messageId: 'unexpectedAfterClosingBracket',
-            data: {
-              name: element.rawName,
-              actual: getPhrase(beforeLineBreaks)
-            },
-            fix(fixer) {
-              /** @type {Range} */
-              const range = [element.startTag.range[1], contentFirst.range[0]]
-              return fixer.replaceTextRange(range, '\n')
-            }
-          })
-        }
-
-        if (isEmpty(element, sourceCode)) {
-          return
-        }
-
-        if (isInvalidLineBreaks(afterLineBreaks)) {
-          context.report({
-            node: template.getFirstToken(element.endTag),
-            loc: {
-              start: contentLast.loc.end,
-              end: element.endTag.loc.start
-            },
-            messageId: 'unexpectedBeforeOpeningBracket',
-            data: {
-              name: element.name,
-              actual: getPhrase(afterLineBreaks)
-            },
-            fix(fixer) {
-              /** @type {Range} */
-              const range = [contentLast.range[1], element.endTag.range[0]]
-              return fixer.replaceTextRange(range, '\n')
-            }
-          })
-        }
-      },
-      'VElement:exit'(node) {
-        if (inIgnoreElement === node) {
-          inIgnoreElement = null
-        }
-      }
-    })
-  }
-}

package/lib/rules/mustache-interpolation-spacing.js

@@ -1,107 +0,0 @@
-/**
- * @fileoverview enforce unified spacing in mustache interpolations.
- * @author Armano
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: 'enforce unified spacing in mustache interpolations',
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url: 'https://eslint.vuejs.org/rules/mustache-interpolation-spacing.html'
-    },
-    fixable: 'whitespace',
-    schema: [
-      {
-        enum: ['always', 'never']
-      }
-    ]
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const options = context.options[0] || 'always'
-    const template =
-      context.parserServices.getTemplateBodyTokenStore &&
-      context.parserServices.getTemplateBodyTokenStore()
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VExpressionContainer} node */
-      'VExpressionContainer[expression!=null]'(node) {
-        const openBrace = template.getFirstToken(node)
-        const closeBrace = template.getLastToken(node)
-
-        if (
-          !openBrace ||
-          !closeBrace ||
-          openBrace.type !== 'VExpressionStart' ||
-          closeBrace.type !== 'VExpressionEnd'
-        ) {
-          return
-        }
-
-        const firstToken = template.getTokenAfter(openBrace, {
-          includeComments: true
-        })
-        const lastToken = template.getTokenBefore(closeBrace, {
-          includeComments: true
-        })
-
-        if (options === 'always') {
-          if (openBrace.range[1] === firstToken.range[0]) {
-            context.report({
-              node: openBrace,
-              message: "Expected 1 space after '{{', but not found.",
-              fix: (fixer) => fixer.insertTextAfter(openBrace, ' ')
-            })
-          }
-          if (closeBrace.range[0] === lastToken.range[1]) {
-            context.report({
-              node: closeBrace,
-              message: "Expected 1 space before '}}', but not found.",
-              fix: (fixer) => fixer.insertTextBefore(closeBrace, ' ')
-            })
-          }
-        } else {
-          if (openBrace.range[1] !== firstToken.range[0]) {
-            context.report({
-              loc: {
-                start: openBrace.loc.start,
-                end: firstToken.loc.start
-              },
-              message: "Expected no space after '{{', but found.",
-              fix: (fixer) =>
-                fixer.removeRange([openBrace.range[1], firstToken.range[0]])
-            })
-          }
-          if (closeBrace.range[0] !== lastToken.range[1]) {
-            context.report({
-              loc: {
-                start: lastToken.loc.end,
-                end: closeBrace.loc.end
-              },
-              message: "Expected no space before '}}', but found.",
-              fix: (fixer) =>
-                fixer.removeRange([lastToken.range[1], closeBrace.range[0]])
-            })
-          }
-        }
-      }
-    })
-  }
-}

package/lib/rules/name-property-casing.js

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Requires specific casing for the name property in Vue components
- * @author Armano
- */
-'use strict'
-
-const utils = require('../utils')
-const casing = require('../utils/casing')
-const allowedCaseOptions = ['PascalCase', 'kebab-case']
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'enforce specific casing for the name property in Vue components',
-      categories: ['vue3-strongly-recommended', 'strongly-recommended'],
-      url: 'https://eslint.vuejs.org/rules/name-property-casing.html',
-      replacedBy: ['component-definition-name-casing']
-    },
-    deprecated: true,
-    fixable: 'code', // or "code" or "whitespace"
-    schema: [
-      {
-        enum: allowedCaseOptions
-      }
-    ]
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    const options = context.options[0]
-    const caseType =
-      allowedCaseOptions.indexOf(options) !== -1 ? options : 'PascalCase'
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    return utils.executeOnVue(context, (obj) => {
-      const node = utils.findProperty(obj, 'name')
-
-      if (!node) return
-      const valueNode = node.value
-      if (valueNode.type !== 'Literal') return
-
-      if (!casing.getChecker(caseType)(`${valueNode.value}`)) {
-        const value = casing.getExactConverter(caseType)(`${valueNode.value}`)
-        context.report({
-          node: valueNode,
-          message: 'Property name "{{value}}" is not {{caseType}}.',
-          data: {
-            value: `${valueNode.value}`,
-            caseType
-          },
-          fix: (fixer) =>
-            fixer.replaceText(
-              valueNode,
-              context
-                .getSourceCode()
-                .getText(valueNode)
-                .replace(`${valueNode.value}`, value)
-            )
-        })
-      }
-    })
-  }
-}

package/lib/rules/no-bare-strings-in-template.js

@@ -1,275 +0,0 @@
-/**
- * @author Yosuke Ota
- * See LICENSE file in root directory for full license.
- */
-'use strict'
-
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-const regexp = require('../utils/regexp')
-const casing = require('../utils/casing')
-
-/**
- * @typedef { { names: { [tagName in string]: Set<string> }, regexps: { name: RegExp, attrs: Set<string> }[], cache: { [tagName in string]: Set<string> } } } TargetAttrs
- */
-
-// ------------------------------------------------------------------------------
-// Constants
-// ------------------------------------------------------------------------------
-
-// https://dev.w3.org/html5/html-author/charref
-const DEFAULT_ALLOWLIST = [
-  '(',
-  ')',
-  ',',
-  '.',
-  '&',
-  '+',
-  '-',
-  '=',
-  '*',
-  '/',
-  '#',
-  '%',
-  '!',
-  '?',
-  ':',
-  '[',
-  ']',
-  '{',
-  '}',
-  '<',
-  '>',
-  '\u00b7', // "·"
-  '\u2022', // "•"
-  '\u2010', // "‐"
-  '\u2013', // "–"
-  '\u2014', // "—"
-  '\u2212', // "−"
-  '|'
-]
-
-const DEFAULT_ATTRIBUTES = {
-  '/.+/': [
-    'title',
-    'aria-label',
-    'aria-placeholder',
-    'aria-roledescription',
-    'aria-valuetext'
-  ],
-  input: ['placeholder'],
-  img: ['alt']
-}
-
-const DEFAULT_DIRECTIVES = ['v-text']
-
-// --------------------------------------------------------------------------
-// Helpers
-// --------------------------------------------------------------------------
-
-/**
- * Parse attributes option
- * @param {any} options
- * @returns {TargetAttrs}
- */
-function parseTargetAttrs(options) {
-  /** @type {TargetAttrs} */
-  const result = { names: {}, regexps: [], cache: {} }
-  for (const tagName of Object.keys(options)) {
-    /** @type { Set<string> } */
-    const attrs = new Set(options[tagName])
-    if (regexp.isRegExp(tagName)) {
-      result.regexps.push({
-        name: regexp.toRegExp(tagName),
-        attrs
-      })
-    } else {
-      result.names[tagName] = attrs
-    }
-  }
-  return result
-}
-
-/**
- * Get a string from given expression container node
- * @param {VExpressionContainer} value
- * @returns { string | null }
- */
-function getStringValue(value) {
-  const expression = value.expression
-  if (!expression) {
-    return null
-  }
-  if (expression.type !== 'Literal') {
-    return null
-  }
-  if (typeof expression.value === 'string') {
-    return expression.value
-  }
-  return null
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'disallow the use of bare strings in `<template>`',
-      categories: undefined,
-      url: 'https://eslint.vuejs.org/rules/no-bare-strings-in-template.html'
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowlist: {
-            type: 'array',
-            items: { type: 'string' },
-            uniqueItems: true
-          },
-          attributes: {
-            type: 'object',
-            patternProperties: {
-              '^(?:\\S+|/.*/[a-z]*)$': {
-                type: 'array',
-                items: { type: 'string' },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          },
-          directives: {
-            type: 'array',
-            items: { type: 'string', pattern: '^v-' },
-            uniqueItems: true
-          }
-        }
-      }
-    ],
-    messages: {
-      unexpected: 'Unexpected non-translated string used.',
-      unexpectedInAttr: 'Unexpected non-translated string used in `{{attr}}`.'
-    }
-  },
-  /** @param {RuleContext} context */
-  create(context) {
-    /**
-     * @typedef { { upper: ElementStack | null, name: string, attrs: Set<string> } } ElementStack
-     */
-    const opts = context.options[0] || {}
-    /** @type {string[]} */
-    const allowlist = opts.allowlist || DEFAULT_ALLOWLIST
-    const attributes = parseTargetAttrs(opts.attributes || DEFAULT_ATTRIBUTES)
-    const directives = opts.directives || DEFAULT_DIRECTIVES
-
-    const allowlistRe = new RegExp(
-      allowlist.map((w) => regexp.escape(w)).join('|'),
-      'gu'
-    )
-
-    /** @type {ElementStack | null} */
-    let elementStack = null
-    /**
-     * Gets the bare string from given string
-     * @param {string} str
-     */
-    function getBareString(str) {
-      return str.trim().replace(allowlistRe, '').trim()
-    }
-
-    /**
-     * Get the attribute to be verified from the element name.
-     * @param {string} tagName
-     * @returns {Set<string>}
-     */
-    function getTargetAttrs(tagName) {
-      if (attributes.cache[tagName]) {
-        return attributes.cache[tagName]
-      }
-      /** @type {string[]} */
-      const result = []
-      if (attributes.names[tagName]) {
-        result.push(...attributes.names[tagName])
-      }
-      for (const { name, attrs } of attributes.regexps) {
-        name.lastIndex = 0
-        if (name.test(tagName)) {
-          result.push(...attrs)
-        }
-      }
-      if (casing.isKebabCase(tagName)) {
-        result.push(...getTargetAttrs(casing.pascalCase(tagName)))
-      }
-
-      return (attributes.cache[tagName] = new Set(result))
-    }
-
-    return utils.defineTemplateBodyVisitor(context, {
-      /** @param {VText} node */
-      VText(node) {
-        if (getBareString(node.value)) {
-          context.report({
-            node,
-            messageId: 'unexpected'
-          })
-        }
-      },
-      /**
-       * @param {VElement} node
-       */
-      VElement(node) {
-        elementStack = {
-          upper: elementStack,
-          name: node.rawName,
-          attrs: getTargetAttrs(node.rawName)
-        }
-      },
-      'VElement:exit'() {
-        elementStack = elementStack && elementStack.upper
-      },
-      /** @param {VAttribute|VDirective} node */
-      VAttribute(node) {
-        if (!node.value || !elementStack) {
-          return
-        }
-        if (node.directive === false) {
-          const attrs = elementStack.attrs
-          if (!attrs.has(node.key.rawName)) {
-            return
-          }
-
-          if (getBareString(node.value.value)) {
-            context.report({
-              node: node.value,
-              messageId: 'unexpectedInAttr',
-              data: {
-                attr: node.key.rawName
-              }
-            })
-          }
-        } else {
-          const directive = `v-${node.key.name.name}`
-          if (!directives.includes(directive)) {
-            return
-          }
-          const str = getStringValue(node.value)
-          if (str && getBareString(str)) {
-            context.report({
-              node: node.value,
-              messageId: 'unexpectedInAttr',
-              data: {
-                attr: directive
-              }
-            })
-          }
-        }
-      }
-    })
-  }
-}