Fix tests

Author: Pearce-Ropion

lib/rules/jsx-no-literals.js

@@ -85,7 +85,7 @@ const commonPropertiesSchema = {
  * ----------------------------------------------------------------------
  *
  * @typedef ElementConfig
- * @property {boolean} isOverride
+ * @property {'element' | 'override'} type
  * @property {boolean} noStrings
  * @property {Set<string>} allowedStrings
  * @property {boolean} ignoreProps
@@ -102,6 +102,8 @@ const commonPropertiesSchema = {
  * @property {Record<string, OverrideConfig>} elementOverrides
  *
  * @typedef {ElementConfig & OverrideProperty} Config
+ *
+ * @typedef {Config | OverrideConfig} ResolvedConfig
  */
 
 /**
@@ -113,7 +115,7 @@ const commonPropertiesSchema = {
 function normalizeConfig(config, handleElementOverrides = true) {
   /** @type {Config} */
   const normalizedConfig = {
-    isOverride: false,
+    type: 'element',
     noStrings: config.noStrings || false,
     allowedStrings: config.allowedStrings
       ? new Set(map(iterFrom(config.allowedStrings), trimIfString))
@@ -133,8 +135,8 @@ function normalizeConfig(config, handleElementOverrides = true) {
             acc.push([
               key,
               Object.assign(normalizeConfig(value, false), {
+                type: 'override',
                 name: key,
-                isOverride: true,
                 allowElement: value.allowElement || false,
                 applyToNestedElements: value.applyToNestedElements !== undefined ? value.applyToNestedElements : true,
               }),
@@ -335,7 +337,7 @@ module.exports = {
      * Determines whether a given node's value and its immediate parent are
      * viable text nodes that can/should be reported on
      * @param {ASTNode} node
-     * @param {Config | OverrideConfig} resolvedConfig
+     * @param {ResolvedConfig} resolvedConfig
      * @returns {boolean}
      */
     function isViableTextNode(node, resolvedConfig) {
@@ -395,41 +397,41 @@ module.exports = {
     }
 
     /**
-     * @param {Config | ElementConfig} resolvedConfig
+     * @param {ResolvedConfig} resolvedConfig
      * @returns {boolean}
      */
     function shouldAllowElement(resolvedConfig) {
-      return resolvedConfig.isOverride && !!resolvedConfig.allowElement;
+      return resolvedConfig.type === 'override' && 'allowElement' in resolvedConfig && !!resolvedConfig.allowElement;
     }
 
     /**
      * @param {boolean} ancestorIsJSXElement
-     * @param {Config | ElementConfig} resolvedConfig
+     * @param {ResolvedConfig} resolvedConfig
      * @returns {string}
      */
     function defaultMessageId(ancestorIsJSXElement, resolvedConfig) {
       if (resolvedConfig.noAttributeStrings && !ancestorIsJSXElement) {
-        return resolvedConfig.isOverride ? 'noStringsInAttributesInElement' : 'noStringsInAttributes';
+        return resolvedConfig.type === 'override' ? 'noStringsInAttributesInElement' : 'noStringsInAttributes';
       }
 
       if (resolvedConfig.noStrings) {
-        return resolvedConfig.isOverride ? 'noStringsInJSXInElement' : 'noStringsInJSX';
+        return resolvedConfig.type === 'override' ? 'noStringsInJSXInElement' : 'noStringsInJSX';
       }
 
-      return resolvedConfig.isOverride ? 'literalNotInJSXExpressionInElement' : 'literalNotInJSXExpression';
+      return resolvedConfig.type === 'override' ? 'literalNotInJSXExpressionInElement' : 'literalNotInJSXExpression';
     }
 
     /**
      * @param {ASTNode} node
      * @param {string} messageId
-     * @param {Config | ElementConfig} resolvedConfig
+     * @param {ResolvedConfig} resolvedConfig
      */
     function reportLiteralNode(node, messageId, resolvedConfig) {
       report(context, messages[messageId], messageId, {
         node,
         data: {
           text: getText(context, node).trim(),
-          element: resolvedConfig.isOverride ? resolvedConfig.name : undefined,
+          element: resolvedConfig.type === 'override' && 'name' in resolvedConfig ? resolvedConfig.name : undefined,
         },
       });
     }
@@ -499,7 +501,7 @@ module.exports = {
             && !resolvedConfig.ignoreProps
             && !resolvedConfig.allowedStrings.has(node.value.value)
           ) {
-            const messageId = resolvedConfig.isOverride ? 'invalidPropValueInElement' : 'invalidPropValue';
+            const messageId = resolvedConfig.type === 'override' ? 'invalidPropValueInElement' : 'invalidPropValue';
             reportLiteralNode(node, messageId, resolvedConfig);
           }
         }

tests/lib/rules/jsx-no-literals.js

@@ -457,6 +457,12 @@ ruleTester.run('jsx-no-literals', rule, {
       `,
       options: [{ elementOverrides: { 'React.Fragment': { allowElement: true } } }],
     },
+    {
+      code: `
+        <div>{'foo'}</div>
+      `,
+      options: [{ elementOverrides: { div: { allowElement: true } } }],
+    },
   ]),
 
   invalid: parsers.all([
@@ -1143,5 +1149,12 @@ ruleTester.run('jsx-no-literals', rule, {
       options: [{ elementOverrides: { 'React.Fragment': { allowElement: true } } }],
       errors: [{ messageId: 'literalNotInJSXExpression' }],
     },
+    {
+      code: `
+        <div>foo</div>
+      `,
+      options: [{ elementOverrides: { div: { allowElement: true } } }],
+      errors: [{ messageId: 'literalNotInJSXExpression' }],
+    },
   ]),
 });