eslint-plugin-formatjs 4.2.0 → 4.2.2

package/index.ts

@@ -1,38 +0,0 @@
-import blocklistElements from './rules/blocklist-elements'
-import enforceDefaultMessage from './rules/enforce-default-message'
-import enforceDescription from './rules/enforce-description'
-import enforceId from './rules/enforce-id'
-import enforcePlaceholders from './rules/enforce-placeholders'
-import noInvalidICU from './rules/no-invalid-icu'
-import enforcePluralRules from './rules/enforce-plural-rules'
-import noCamelCase from './rules/no-camel-case'
-import noComplexSelectors from './rules/no-complex-selectors'
-import noEmoji from './rules/no-emoji'
-import noId from './rules/no-id'
-import noMultiplePlurals from './rules/no-multiple-plurals'
-import noMultipleWhitespaces from './rules/no-multiple-whitespaces'
-import noOffset from './rules/no-offset'
-import noLiteralStringInJsx from './rules/no-literal-string-in-jsx'
-const plugin = {
-  rules: {
-    'blocklist-elements': blocklistElements,
-    'enforce-default-message': enforceDefaultMessage,
-    'enforce-description': enforceDescription,
-    'enforce-id': enforceId,
-    'enforce-placeholders': enforcePlaceholders,
-    'enforce-plural-rules': enforcePluralRules,
-    'no-camel-case': noCamelCase,
-    'no-complex-selectors': noComplexSelectors,
-    'no-emoji': noEmoji,
-    'no-id': noId,
-    'no-literal-string-in-jsx': noLiteralStringInJsx,
-    'no-multiple-plurals': noMultiplePlurals,
-    'no-multiple-whitespaces': noMultipleWhitespaces,
-    'no-invalid-icu': noInvalidICU,
-    'no-offset': noOffset,
-  },
-}
-
-export type Plugin = typeof plugin
-
-module.exports = plugin

package/rules/blocklist-elements.ts

@@ -1,159 +0,0 @@
-import {Rule} from 'eslint'
-import {extractMessages, getSettings} from '../util'
-import {
-  parse,
-  isPluralElement,
-  MessageFormatElement,
-  isLiteralElement,
-  isArgumentElement,
-  isNumberElement,
-  isDateElement,
-  isTimeElement,
-  isSelectElement,
-  isTagElement,
-} from '@formatjs/icu-messageformat-parser'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-
-class BlacklistElement extends Error {
-  public message: string
-  constructor(type: Element) {
-    super()
-    this.message = `${type} element is blocklisted`
-  }
-}
-
-enum Element {
-  literal = 'literal',
-  argument = 'argument',
-  number = 'number',
-  date = 'date',
-  time = 'time',
-  select = 'select',
-  selectordinal = 'selectordinal',
-  plural = 'plural',
-  tag = 'tag',
-}
-
-function verifyAst(blocklist: Element[], ast: MessageFormatElement[]) {
-  for (const el of ast) {
-    if (isLiteralElement(el) && blocklist.includes(Element.literal)) {
-      throw new BlacklistElement(Element.literal)
-    }
-    if (isArgumentElement(el) && blocklist.includes(Element.argument)) {
-      throw new BlacklistElement(Element.argument)
-    }
-    if (isNumberElement(el) && blocklist.includes(Element.number)) {
-      throw new BlacklistElement(Element.number)
-    }
-    if (isDateElement(el) && blocklist.includes(Element.date)) {
-      throw new BlacklistElement(Element.date)
-    }
-    if (isTimeElement(el) && blocklist.includes(Element.time)) {
-      throw new BlacklistElement(Element.time)
-    }
-    if (isSelectElement(el) && blocklist.includes(Element.select)) {
-      throw new BlacklistElement(Element.select)
-    }
-    if (isTagElement(el) && blocklist.includes(Element.tag)) {
-      throw new BlacklistElement(Element.tag)
-    }
-    if (isPluralElement(el)) {
-      if (blocklist.includes(Element.plural)) {
-        throw new BlacklistElement(Element.argument)
-      }
-      if (
-        el.pluralType === 'ordinal' &&
-        blocklist.includes(Element.selectordinal)
-      ) {
-        throw new BlacklistElement(Element.selectordinal)
-      }
-    }
-    if (isSelectElement(el) || isPluralElement(el)) {
-      const {options} = el
-      for (const selector of Object.keys(options)) {
-        verifyAst(blocklist, options[selector].value)
-      }
-    }
-  }
-}
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const settings = getSettings(context)
-  const msgs = extractMessages(node, settings)
-  if (!msgs.length) {
-    return
-  }
-
-  const blocklist = context.options[0]
-  if (!Array.isArray(blocklist) || !blocklist.length) {
-    return
-  }
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-  ] of msgs) {
-    if (!defaultMessage || !messageNode) {
-      continue
-    }
-    try {
-      verifyAst(
-        context.options[0],
-        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 specific elements in ICU message format',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#blocklist-elements',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'array',
-        properties: {
-          items: {
-            type: 'string',
-            enum: Object.keys(Element),
-          },
-        },
-      },
-    ],
-  },
-  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/enforce-default-message.ts

@@ -1,71 +0,0 @@
-import {Rule} from 'eslint'
-import {extractMessages, getSettings} from '../util'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const msgs = extractMessages(node, getSettings(context))
-  const {
-    options: [type],
-  } = context
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-  ] of msgs) {
-    if (!defaultMessage) {
-      if (type === 'literal' && messageNode) {
-        context.report({
-          node: messageNode as any,
-          message: `"defaultMessage" must be:
-- a string literal or
-- template literal without variable`,
-        })
-      } else if (!messageNode) {
-        context.report({
-          node: node as any,
-          message: '`defaultMessage` has to be specified in message descriptor',
-        })
-      }
-    }
-  }
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Enforce defaultMessage in message descriptor',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#enforce-default-message',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        enum: ['literal', 'anything'],
-      },
-    ],
-  },
-  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/enforce-description.ts

@@ -1,68 +0,0 @@
-import {Rule} from 'eslint'
-import {extractMessages, getSettings} from '../util'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const msgs = extractMessages(node, getSettings(context))
-  const {
-    options: [type],
-  } = context
-  for (const [
-    {
-      message: {description},
-      descriptionNode,
-    },
-  ] of msgs) {
-    if (!description) {
-      if (type === 'literal' && descriptionNode) {
-        context.report({
-          node: descriptionNode as any,
-          message:
-            '`description` has to be a string literal (not function call or variable)',
-        })
-      } else if (!descriptionNode) {
-        context.report({
-          node: node as any,
-          message: '`description` has to be specified in message descriptor',
-        })
-      }
-    }
-  }
-}
-
-export default {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Enforce description in message descriptor',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#enforce-description',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        enum: ['literal', 'anything'],
-      },
-    ],
-  },
-  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,
-    }
-  },
-} as Rule.RuleModule

package/rules/enforce-id.ts

@@ -1,171 +0,0 @@
-import {Rule} from 'eslint'
-import {extractMessages, getSettings} from '../util'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-import {interpolateName} from '@formatjs/ts-transformer'
-
-interface Opts {
-  idInterpolationPattern: string
-  idWhitelistRegexps?: RegExp[]
-}
-
-function checkNode(
-  context: Rule.RuleContext,
-  node: TSESTree.Node,
-  {idInterpolationPattern, idWhitelistRegexps}: Opts
-) {
-  const msgs = extractMessages(node, getSettings(context))
-  for (const [
-    {
-      message: {defaultMessage, description, id},
-      idPropNode,
-      descriptionNode,
-      messagePropNode,
-    },
-  ] of msgs) {
-    if (!idInterpolationPattern && !idPropNode) {
-      context.report({
-        node: node as any,
-        message: `id must be specified`,
-      })
-    } else if (idInterpolationPattern) {
-      if (!defaultMessage) {
-        context.report({
-          node: node as any,
-          message: `defaultMessage must be a string literal to calculate generated IDs`,
-        })
-      } else if (!description && descriptionNode) {
-        context.report({
-          node: node as any,
-          message: `description must be a string literal to calculate generated IDs`,
-        })
-      } else {
-        if (
-          idWhitelistRegexps &&
-          id &&
-          idWhitelistRegexps.some((r: RegExp) => r.test(id))
-        ) {
-          // messageId is allowlisted so skip interpolation id check
-          return
-        }
-
-        const correctId = interpolateName(
-          {
-            resourcePath: context.getFilename(),
-          } as any,
-          idInterpolationPattern,
-          {
-            content: description
-              ? `${defaultMessage}#${description}`
-              : defaultMessage,
-          }
-        )
-        if (id !== correctId) {
-          let message = `"id" does not match with hash pattern ${idInterpolationPattern}`
-          if (idWhitelistRegexps) {
-            message += ` or allowlisted patterns ["${idWhitelistRegexps
-              .map(r => r.toString())
-              .join('", "')}"]`
-          }
-
-          context.report({
-            node: node as any,
-            message: `${message}.
-Expected: ${correctId}
-Actual: ${id}`,
-            fix(fixer) {
-              if (idPropNode) {
-                if (idPropNode.type === 'JSXAttribute') {
-                  return fixer.replaceText(
-                    idPropNode as any,
-                    `id="${correctId}"`
-                  )
-                }
-                return fixer.replaceText(
-                  idPropNode as any,
-                  `id: '${correctId}'`
-                )
-              }
-              // Insert after default message node
-              if (messagePropNode!.type === 'JSXAttribute') {
-                return fixer.insertTextAfter(
-                  messagePropNode as any,
-                  ` id="${correctId}"`
-                )
-              }
-              return fixer.replaceText(
-                messagePropNode as any,
-                `defaultMessage: '${defaultMessage}', id: '${correctId}'`
-              )
-            },
-          })
-        }
-      }
-    }
-  }
-}
-
-export default {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Enforce (generated) ID in message descriptor',
-      category: 'Errors',
-      recommended: false,
-      url: 'https://formatjs.io/docs/tooling/linter#enforce-id',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          idInterpolationPattern: {
-            type: 'string',
-            description:
-              'Pattern to verify ID against. Recommended value: [sha512:contenthash:base64:6]',
-          },
-          idWhitelist: {
-            type: 'array',
-            description:
-              "An array of strings with regular expressions. This array allows allowlist custom ids for messages. For example '`\\\\.`' allows any id which has dot; `'^payment_.*'` - allows any custom id which has prefix `payment_`. Be aware that any backslash \\ provided via string must be escaped with an additional backslash.",
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        required: ['idInterpolationPattern'],
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const tmp = context?.options?.[0]
-    const opts = {
-      idInterpolationPattern: tmp?.idInterpolationPattern,
-    } as Opts
-    if (Array.isArray(tmp?.idWhitelist)) {
-      const {idWhitelist} = tmp
-      opts.idWhitelistRegexps = idWhitelist.map(
-        (str: string) => new RegExp(str, 'i')
-      )
-    }
-
-    const callExpressionVisitor = (node: TSESTree.Node) =>
-      checkNode(context, node, opts)
-
-    if (context.parserServices.defineTemplateBodyVisitor) {
-      return context.parserServices.defineTemplateBodyVisitor(
-        {
-          CallExpression: callExpressionVisitor,
-        },
-        {
-          CallExpression: callExpressionVisitor,
-        }
-      )
-    }
-    return {
-      JSXOpeningElement: (node: TSESTree.Node) =>
-        checkNode(context, node, opts),
-      CallExpression: callExpressionVisitor,
-    }
-  },
-} as Rule.RuleModule

package/rules/enforce-placeholders.ts

@@ -1,161 +0,0 @@
-import {Rule} from 'eslint'
-import {TSESTree} from '@typescript-eslint/typescript-estree'
-import {extractMessages, getSettings} from '../util'
-import {
-  parse,
-  isPluralElement,
-  MessageFormatElement,
-  isLiteralElement,
-  isSelectElement,
-  isPoundElement,
-  isTagElement,
-} from '@formatjs/icu-messageformat-parser'
-
-class PlaceholderEnforcement extends Error {
-  public message: string
-  constructor(message: string) {
-    super()
-    this.message = message
-  }
-}
-
-function keyExistsInExpression(
-  key: string,
-  values: TSESTree.Expression | undefined
-) {
-  if (!values) {
-    return false
-  }
-  if (values.type !== 'ObjectExpression') {
-    return true // True bc we cannot evaluate this
-  }
-  if (values.properties.find(prop => prop.type === 'SpreadElement')) {
-    return true // True bc there's a spread element
-  }
-  return !!values.properties.find(prop => {
-    if (prop.type !== 'Property') {
-      return false
-    }
-    switch (prop.key.type) {
-      case 'Identifier':
-        return prop.key.name === key
-      case 'Literal':
-        return prop.key.value === key
-    }
-    return false
-  })
-}
-
-function verifyAst(
-  ast: MessageFormatElement[],
-  values: TSESTree.Expression | undefined,
-  ignoreList: Set<string>
-) {
-  for (const el of ast) {
-    if (isLiteralElement(el) || isPoundElement(el)) {
-      continue
-    }
-    const key = el.value
-    if (!ignoreList.has(key) && !keyExistsInExpression(key, values)) {
-      throw new PlaceholderEnforcement(
-        `Missing value for placeholder "${el.value}"`
-      )
-    }
-
-    if (isPluralElement(el) || isSelectElement(el)) {
-      for (const selector of Object.keys(el.options)) {
-        verifyAst(el.options[selector].value, values, ignoreList)
-      }
-    }
-
-    if (isTagElement(el)) {
-      verifyAst(el.children, values, ignoreList)
-    }
-  }
-}
-
-function checkNode(context: Rule.RuleContext, node: TSESTree.Node) {
-  const settings = getSettings(context)
-  const msgs = extractMessages(node, {
-    excludeMessageDeclCalls: true,
-    ...settings,
-  })
-  const {
-    options: [opt],
-  } = context
-  const ignoreList = new Set<string>(opt?.ignoreList || [])
-  for (const [
-    {
-      message: {defaultMessage},
-      messageNode,
-    },
-    values,
-  ] of msgs) {
-    if (!defaultMessage || !messageNode) {
-      continue
-    }
-    try {
-      verifyAst(
-        parse(defaultMessage, {
-          ignoreTag: settings.ignoreTag,
-        }),
-        values,
-        ignoreList
-      )
-    } 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:
-        'Enforce that all messages with placeholders have enough passed-in values',
-      category: 'Errors',
-      recommended: true,
-      url: 'https://formatjs.io/docs/tooling/linter#enforce-placeholders',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreList: {
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  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