eslint-plugin-formatjs 4.2.0 → 4.2.2

package/rules/no-literal-string-in-jsx.ts

@@ -1,213 +0,0 @@
-import picomatch from 'picomatch'
-import type {Rule} from 'eslint'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-
-type PropMatcher = readonly [TagNamePattern: string, PropNamePattern: string][]
-
-type CompiledPropMatcher = readonly [
-  TagNamePattern: RegExp,
-  PropNamePattern: RegExp
-][]
-
-type Config = {
-  props?: {
-    include?: PropMatcher
-    exclude?: PropMatcher
-  }
-}
-
-const propMatcherSchema = {
-  type: 'array',
-  items: {
-    type: 'array',
-    items: [{type: 'string'}, {type: 'string'}],
-  },
-} as const
-
-const defaultPropIncludePattern: PropMatcher = [
-  ['*', 'aria-{label,description,details,errormessage}'],
-  ['[a-z]*([a-z0-9])', '(placeholder|title)'],
-  ['img', 'alt'],
-]
-
-const defaultPropExcludePattern: PropMatcher = []
-
-function stringifyJsxTagName(tagName: TSESTree.JSXTagNameExpression): string {
-  switch (tagName.type) {
-    case TSESTree.AST_NODE_TYPES.JSXIdentifier:
-      return tagName.name
-    case TSESTree.AST_NODE_TYPES.JSXMemberExpression:
-      return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`
-    case TSESTree.AST_NODE_TYPES.JSXNamespacedName:
-      return `${tagName.namespace.name}:${tagName.name.name}`
-  }
-}
-
-function compilePropMatcher(propMatcher: PropMatcher): CompiledPropMatcher {
-  return propMatcher.map(([tagNamePattern, propNamePattern]) => {
-    return [
-      picomatch.makeRe(tagNamePattern, {contains: false}),
-      picomatch.makeRe(propNamePattern, {contains: false}),
-    ]
-  })
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow untranslated literal strings without translation.',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#no-literal-string-in-jsx',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          props: {
-            type: 'object',
-            properties: {
-              include: {
-                ...propMatcherSchema,
-              },
-              exclude: {
-                ...propMatcherSchema,
-              },
-            },
-          },
-        },
-      },
-    ],
-  },
-  // TODO: Vue support
-  create(context) {
-    const userConfig: Config = context.options[0] || {}
-
-    const propIncludePattern: CompiledPropMatcher = compilePropMatcher([
-      ...defaultPropIncludePattern,
-      ...(userConfig.props?.include ?? []),
-    ])
-
-    const propExcludePattern: CompiledPropMatcher = compilePropMatcher([
-      ...defaultPropExcludePattern,
-      ...(userConfig.props?.exclude ?? []),
-    ])
-
-    const lexicalJsxStack: (TSESTree.JSXElement | TSESTree.JSXFragment)[] = []
-
-    const shouldSkipCurrentJsxAttribute = (node: TSESTree.JSXAttribute) => {
-      const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1]!
-      if (currentJsxNode.type === 'JSXFragment') {
-        return false
-      }
-
-      const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name)
-      const attributeName =
-        typeof node.name.name === 'string'
-          ? node.name.name
-          : node.name.name.name
-
-      // match exclude
-      for (const [tagNamePattern, propNamePattern] of propExcludePattern) {
-        if (
-          tagNamePattern.test(nameString) &&
-          propNamePattern.test(attributeName)
-        ) {
-          return true
-        }
-      }
-
-      // match include
-      for (const [tagNamePattern, propNamePattern] of propIncludePattern) {
-        if (
-          tagNamePattern.test(nameString) &&
-          propNamePattern.test(attributeName)
-        ) {
-          return false
-        }
-      }
-
-      return true
-    }
-
-    const checkJSXExpression = (
-      node: TSESTree.Expression | TSESTree.PrivateIdentifier
-    ) => {
-      // Check if this is either a string literal / template literal, or the concat of them.
-      if (
-        (node.type === 'Literal' && typeof node.value === 'string') ||
-        node.type === 'TemplateLiteral'
-      ) {
-        context.report({
-          node: node as any,
-          message: 'Cannot have untranslated text in JSX',
-        })
-      } else if (node.type === 'BinaryExpression' && node.operator === '+') {
-        checkJSXExpression(node.left)
-        checkJSXExpression(node.right)
-      }
-    }
-
-    return {
-      JSXElement: (node: TSESTree.Node) => {
-        lexicalJsxStack.push(node as TSESTree.JSXElement)
-      },
-      'JSXElement:exit': () => {
-        lexicalJsxStack.pop()
-      },
-
-      JSXFragment: (node: TSESTree.Node) => {
-        lexicalJsxStack.push(node as TSESTree.JSXFragment)
-      },
-      'JSXFragment:exit': () => {
-        lexicalJsxStack.pop()
-      },
-
-      JSXAttribute: (node: TSESTree.JSXAttribute) => {
-        if (shouldSkipCurrentJsxAttribute(node)) {
-          return
-        }
-
-        if (!node.value) {
-          return
-        }
-
-        if (node.value.type === 'Literal') {
-          context.report({
-            node: node as any,
-            message: 'Cannot have untranslated text in JSX',
-          })
-        } else if (
-          node.value.type === 'JSXExpressionContainer' &&
-          node.value.expression.type !== 'JSXEmptyExpression'
-        ) {
-          checkJSXExpression(node.value.expression)
-        }
-      },
-
-      JSXText: (node: TSESTree.JSXText) => {
-        // Ignore purely spacing fragments
-        if (!node.value.replace(/\s*/gm, '')) {
-          return
-        }
-
-        context.report({
-          node: node as any,
-          message: 'Cannot have untranslated text in JSX',
-        })
-      },
-
-      // Children expression container
-      'JSXElement > JSXExpressionContainer': (
-        node: TSESTree.JSXExpressionContainer
-      ) => {
-        if (node.expression.type !== 'JSXEmptyExpression') {
-          checkJSXExpression(node.expression)
-        }
-      },
-    } as any
-  },
-}
-
-export default rule

package/rules/no-multiple-plurals.ts

@@ -1,89 +0,0 @@
-import {Rule} from 'eslint'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-import {extractMessages, getSettings} from '../util'
-import {
-  parse,
-  isPluralElement,
-  MessageFormatElement,
-} from '@formatjs/icu-messageformat-parser'
-
-class MultiplePlurals extends Error {
-  public message = 'Cannot specify more than 1 plural rules'
-}
-
-function verifyAst(ast: MessageFormatElement[], pluralCount = {count: 0}) {
-  for (const el of ast) {
-    if (isPluralElement(el)) {
-      pluralCount.count++
-      if (pluralCount.count > 1) {
-        throw new MultiplePlurals()
-      }
-      const {options} = el
-      for (const selector of Object.keys(options)) {
-        verifyAst(options[selector].value, pluralCount)
-      }
-    }
-  }
-}
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const settings = getSettings(context)
-  const msgs = extractMessages(node, settings)
-
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-  ] of msgs) {
-    if (!defaultMessage || !messageNode) {
-      continue
-    }
-    try {
-      verifyAst(
-        parse(defaultMessage, {
-          ignoreTag: settings.ignoreTag,
-        })
-      )
-    } catch (e) {
-      context.report({
-        node: messageNode as any,
-        message: e instanceof Error ? e.message : String(e),
-      })
-    }
-  }
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow multiple plural rules in the same message',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#no-multiple-plurals',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const callExpressionVisitor = (node: TSESTree.Node) =>
-      checkNode(context, node)
-
-    if (context.parserServices.defineTemplateBodyVisitor) {
-      return context.parserServices.defineTemplateBodyVisitor(
-        {
-          CallExpression: callExpressionVisitor,
-        },
-        {
-          CallExpression: callExpressionVisitor,
-        }
-      )
-    }
-    return {
-      JSXOpeningElement: (node: TSESTree.Node) => checkNode(context, node),
-      CallExpression: callExpressionVisitor,
-    }
-  },
-}
-
-export default rule

package/rules/no-multiple-whitespaces.ts

@@ -1,194 +0,0 @@
-import {
-  LiteralElement,
-  MessageFormatElement,
-  parse,
-  TYPE,
-} from '@formatjs/icu-messageformat-parser'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-import {Rule} from 'eslint'
-import {extractMessages, getSettings} from '../util'
-
-function isAstValid(ast: MessageFormatElement[]): boolean {
-  for (const element of ast) {
-    switch (element.type) {
-      case TYPE.literal:
-        if (/\s{2,}/gm.test(element.value)) {
-          return false
-        }
-        break
-      case TYPE.argument:
-      case TYPE.date:
-      case TYPE.literal:
-      case TYPE.number:
-      case TYPE.pound:
-      case TYPE.tag:
-      case TYPE.time:
-        break
-      case TYPE.plural:
-      case TYPE.select: {
-        for (const option of Object.values(element.options)) {
-          if (!isAstValid(option.value)) {
-            return false
-          }
-        }
-        break
-      }
-    }
-  }
-  return true
-}
-
-function trimMultiWhitespaces(
-  message: string,
-  ast: MessageFormatElement[]
-): string {
-  const literalElements: LiteralElement[] = []
-
-  const collectLiteralElements = (elements: MessageFormatElement[]) => {
-    for (const element of elements) {
-      switch (element.type) {
-        case TYPE.literal:
-          literalElements.push(element)
-          break
-        case TYPE.argument:
-        case TYPE.date:
-        case TYPE.literal:
-        case TYPE.number:
-        case TYPE.pound:
-        case TYPE.tag:
-        case TYPE.time:
-          break
-        case TYPE.plural:
-        case TYPE.select: {
-          for (const option of Object.values(element.options)) {
-            collectLiteralElements(option.value)
-          }
-          break
-        }
-      }
-    }
-  }
-  collectLiteralElements(ast)
-
-  // Surgically trim whitespaces in the literal element ranges.
-  // This is to preserve the original whitespaces and newlines info that are lost to parsing.
-  let trimmedFragments: string[] = []
-  let currentOffset = 0
-
-  for (const literal of literalElements) {
-    const {start, end} = literal.location!
-    const startOffset = start.offset
-    const endOffset = end.offset
-
-    trimmedFragments.push(message.slice(currentOffset, startOffset))
-    trimmedFragments.push(
-      message.slice(startOffset, endOffset).replace(/\s{2,}/gm, ' ')
-    )
-
-    currentOffset = endOffset
-  }
-
-  trimmedFragments.push(message.slice(currentOffset))
-
-  return trimmedFragments.join('')
-}
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const msgs = extractMessages(node, getSettings(context))
-
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-  ] of msgs) {
-    if (!defaultMessage || !messageNode) {
-      continue
-    }
-
-    let ast: MessageFormatElement[]
-    try {
-      ast = parse(defaultMessage, {captureLocation: true})
-    } catch (e) {
-      context.report({
-        node: messageNode as any,
-        message: e instanceof Error ? e.message : String(e),
-      })
-      return
-    }
-
-    if (!isAstValid(ast)) {
-      const reportObject: Parameters<typeof context['report']>[0] = {
-        node: messageNode as any,
-        message: 'Multiple consecutive whitespaces are not allowed',
-      }
-
-      if (
-        messageNode.type === 'Literal' &&
-        messageNode.value &&
-        typeof messageNode.value === 'string'
-      ) {
-        reportObject.fix = function (fixer) {
-          return fixer.replaceText(
-            messageNode as any,
-            JSON.stringify(
-              trimMultiWhitespaces(messageNode.value as string, ast)
-            )
-          )
-        }
-      } else if (
-        messageNode.type === 'TemplateLiteral' &&
-        messageNode.quasis.length === 1 &&
-        messageNode.expressions.length === 0
-      ) {
-        reportObject.fix = function (fixer) {
-          return fixer.replaceText(
-            messageNode as any,
-            '`' +
-              trimMultiWhitespaces(messageNode.quasis[0].value.cooked, ast)
-                .replace(/\\/g, '\\\\')
-                .replace(/`/g, '\\`') +
-              '`'
-          )
-        }
-      }
-
-      context.report(reportObject)
-    }
-  }
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Prevents usage of multiple consecutive whitespaces in message',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#no-multiple-whitespaces',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const callExpressionVisitor = (node: TSESTree.Node) =>
-      checkNode(context, node)
-
-    if (context.parserServices.defineTemplateBodyVisitor) {
-      return context.parserServices.defineTemplateBodyVisitor(
-        {
-          CallExpression: callExpressionVisitor,
-        },
-        {
-          CallExpression: callExpressionVisitor,
-        }
-      )
-    }
-    return {
-      JSXOpeningElement: (node: TSESTree.Node) => checkNode(context, node),
-      CallExpression: callExpressionVisitor,
-    }
-  },
-}
-
-export default rule

package/rules/no-offset.ts

@@ -1,88 +0,0 @@
-import {Rule} from 'eslint'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-import {extractMessages, getSettings} from '../util'
-import {
-  parse,
-  isPluralElement,
-  MessageFormatElement,
-} from '@formatjs/icu-messageformat-parser'
-
-class NoOffsetError extends Error {
-  public message = 'offset are not allowed in plural rules'
-}
-
-function verifyAst(ast: MessageFormatElement[]) {
-  for (const el of ast) {
-    if (isPluralElement(el)) {
-      if (el.offset) {
-        throw new NoOffsetError()
-      }
-      const {options} = el
-      for (const selector of Object.keys(options)) {
-        verifyAst(options[selector].value)
-      }
-    }
-  }
-}
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const settings = getSettings(context)
-  const msgs = extractMessages(node, settings)
-
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-  ] of msgs) {
-    if (!defaultMessage || !messageNode) {
-      continue
-    }
-    try {
-      verifyAst(
-        parse(defaultMessage, {
-          ignoreTag: settings.ignoreTag,
-        })
-      )
-    } catch (e) {
-      context.report({
-        node: messageNode as any,
-        message: (e as Error).message,
-      })
-    }
-  }
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow offset in plural rules',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#no-offset',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const callExpressionVisitor = (node: TSESTree.Node) =>
-      checkNode(context, node)
-
-    if (context.parserServices.defineTemplateBodyVisitor) {
-      return context.parserServices.defineTemplateBodyVisitor(
-        {
-          CallExpression: callExpressionVisitor,
-        },
-        {
-          CallExpression: callExpressionVisitor,
-        }
-      )
-    }
-    return {
-      JSXOpeningElement: (node: TSESTree.Node) => checkNode(context, node),
-      CallExpression: callExpressionVisitor,
-    }
-  },
-}
-
-export default rule

package/tests/blocklist-elements.test.ts

@@ -1,120 +0,0 @@
-import blocklistElements from '../rules/blocklist-elements'
-import {dynamicMessage, emptyFnCall, noMatch, spreadJsx} from './fixtures'
-import {ruleTester, vueRuleTester} from './util'
-
-ruleTester.run('blocklist-elements', blocklistElements, {
-  valid: [
-    {
-      code: `import {defineMessage} from 'react-intl'
-  defineMessage({
-      defaultMessage: '{count, plural, one {#} other {# more}}'
-  })`,
-      options: [['selectordinal']],
-    },
-    {
-      code: `import {defineMessage} from 'react-intl'
-  defineMessage({
-      defaultMessage: '{count, plural, one {#} other {# more}} <a href="asd"></a>'
-  })`,
-      options: [['selectordinal']],
-      settings: {
-        formatjs: {
-          ignoreTag: true,
-        },
-      },
-    },
-    {
-      code: `
-  $t({
-      defaultMessage: '{count, plural, one {#} other {# more}}'
-  })`,
-      options: [['selectordinal']],
-      settings: {
-        formatjs: {
-          additionalFunctionNames: ['$t'],
-        },
-      },
-    },
-    dynamicMessage,
-    noMatch,
-    spreadJsx,
-    emptyFnCall,
-  ],
-  invalid: [
-    {
-      code: `
-              import {defineMessage} from 'react-intl'
-              defineMessage({
-                  defaultMessage: '{count, selectordinal, offset:1 one {#} other {# more}}'
-              })`,
-      options: [['selectordinal']],
-      errors: [
-        {
-          message: 'selectordinal element is blocklisted',
-        },
-      ],
-    },
-    {
-      code: `
-              $t({
-                  defaultMessage: '{count, selectordinal, offset:1 one {#} other {# more}}'
-              })`,
-      options: [['selectordinal']],
-      settings: {
-        formatjs: {
-          additionalFunctionNames: ['$t'],
-        },
-      },
-      errors: [
-        {
-          message: 'selectordinal element is blocklisted',
-        },
-      ],
-    },
-  ],
-})
-
-vueRuleTester.run('vue/blocklist-elements', blocklistElements, {
-  valid: [
-    {
-      code: `<template>
-      <p>{{ $formatMessage({
-        defaultMessage: '{count, plural, offset:1 one {#} other {# more} }'
-      }) }} World!</p>
-    </template>`,
-      options: [['selectordinal']],
-    },
-    `<script>${dynamicMessage}</script>`,
-    `<script>${noMatch}</script>`,
-    `<script>${emptyFnCall}</script>`,
-  ],
-  invalid: [
-    {
-      code: `
-              <script>
-              intl.formatMessage({
-                  defaultMessage: '{count, selectordinal, offset:1 one {#} other {# more}}'
-              })</script>`,
-      options: [['selectordinal']],
-      errors: [
-        {
-          message: 'selectordinal element is blocklisted',
-        },
-      ],
-    },
-    {
-      code: `
-      <template>
-  <p>{{ $formatMessage({
-    defaultMessage: '{count, selectordinal, offset:1 one {#} other {# more} }'
-  }) }} World!</p>
-</template>`,
-      options: [['selectordinal']],
-      errors: [
-        {
-          message: 'selectordinal element is blocklisted',
-        },
-      ],
-    },
-  ],
-})