@discord/eslint-plugin-discord-intl 0.29.1 → 0.31.0

package/index.js

@@ -16,6 +16,7 @@ module.exports = {
 
     'use-static-access': require('./rules/use-static-access'),
     'no-opaque-messages-objects': require('./rules/no-opaque-messages-objects'),
+    'no-invalid-meta': require('./rules/no-invalid-meta'),
   },
   configs: {
     recommended: {
@@ -38,6 +39,7 @@ module.exports = {
         // JS rules
         '@discord/discord-intl/use-static-access': 'error',
         '@discord/discord-intl/no-opaque-messages-objects': 'error',
+        // '@discord/discord-intl/no-invalid-meta': 'error',
       },
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/eslint-plugin-discord-intl",
-  "version": "0.29.1",
+  "version": "0.31.0",
   "license": "MIT",
   "type": "commonjs",
   "description": "ESLint plugin for validating and linting messages and translations using @discord/intl",
@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@typescript-eslint/scope-manager": "^8.8.1",
-    "@discord/intl-message-database": "0.29.1"
+    "@discord/intl-message-database": "0.31.0"
   },
   "devDependencies": {
     "@types/eslint": "^8.56.12",

package/rules/no-invalid-meta.js

@@ -0,0 +1,65 @@
+const { isDefinitionsFile } = require('../lib/traverse');
+
+module.exports = /** @type {import('eslint').Rule.RuleModule} */ ({
+  meta: {
+    docs: {
+      description:
+        "Check that meta information is defined correctly and won't be silently ignored while processing.",
+      category: 'Correctness',
+    },
+    messages: {
+      metaMustBeInitialized: '`meta` must have an initializer',
+      metaMustBeObjectLiteral: '`meta` must be defined using an object literal',
+      disallowSpread: 'meta properties must be defined inline',
+      disallowComputedKey: 'meta properties cannot be defined using computed keys',
+      invalidTagsValue:
+        '`tags` must be initialized using an array literal containing only string literals',
+    },
+  },
+  create(context) {
+    if (!isDefinitionsFile(context.filename, context.sourceCode.text)) return {};
+
+    return {
+      /**
+       * @param {import('estree').VariableDeclarator} node
+       */
+      'VariableDeclarator[id.name="meta"]'(node) {
+        if (node.init == null) {
+          context.report({ node, messageId: 'metaMustBeInitialized' });
+          return;
+        }
+        if (node.init.type !== 'ObjectExpression') {
+          context.report({ node, messageId: 'metaMustBeObjectLiteral' });
+          return;
+        }
+
+        const initializer = node.init;
+
+        for (const property of initializer.properties) {
+          if (property.type === 'SpreadElement') {
+            context.report({ node: property, messageId: 'disallowSpread' });
+            continue;
+          }
+          if (property.computed || property.key.type !== 'Identifier') {
+            context.report({ node: property, messageId: 'disallowComputedKey' });
+            continue;
+          }
+          switch (property.key.name) {
+            // Tags are more than just a single literal. Every element of the array must also be a
+            // string literal for it to be valid.
+            case 'tags':
+              if (property.value.type !== 'ArrayExpression') {
+                context.report({ node: property.value, messageId: 'invalidTagsValue' });
+                continue;
+              }
+              for (const tag of property.value.elements) {
+                if (tag == null || tag.type !== 'Literal' || typeof tag.value !== 'string') {
+                  context.report({ node: tag ?? property.value, messageId: 'invalidTagsValue' });
+                }
+              }
+          }
+        }
+      },
+    };
+  },
+});

package/rules/no-invalid-meta.test.js

@@ -0,0 +1,126 @@
+const { RuleTester } = require('eslint');
+const noInvalidMeta = require('./no-invalid-meta');
+
+const ruleTester = new RuleTester({
+  // Must use at least ecmaVersion 2015 because
+  // that's when `const` variables were introduced.
+  // Using 2022 to make sure the spread operator is supported.
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+// @ts-ignore
+const errorMessages = noInvalidMeta.meta.messages ?? {};
+
+ruleTester.run('no-invalid-meta', noInvalidMeta, {
+  valid: [
+    {
+      name: 'no meta defined',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export default defineMessages({HELLO: "world"});
+      `,
+    },
+    {
+      name: 'not a messages file',
+      code: `
+      export const meta = {foobar: thisWouldBeInvalid};
+      `,
+    },
+    {
+      name: 'all literals',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = {
+        project: 'some-feature',
+        secret: false,
+        translate: true,
+        translationsPath: './translations',
+      };
+
+      export default defineMessages({HELLO: "world"});
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: 'no spread',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = {
+        ...something,
+      };
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.disallowSpread],
+    },
+    {
+      name: 'no computed key',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = {
+        [computed]: true,
+      };
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.disallowComputedKey],
+    },
+    {
+      name: 'no empty tags',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = {
+        tags: [,'foo']
+      };
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.invalidTagsValue],
+    },
+    {
+      name: 'no variable tags',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = {
+        tags: [aVariable]
+      };
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.invalidTagsValue],
+    },
+    {
+      name: 'no missing meta initializer',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export let meta;
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.metaMustBeInitialized],
+    },
+    {
+      name: 'require object literal initializer',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = false;
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.metaMustBeObjectLiteral],
+    },
+    {
+      name: 'require object literal initializer',
+      code: `
+      import {defineMessages} from '@discord/intl';
+      export const meta = someObject;
+
+      export default defineMessages({HELLO: "world"});
+      `,
+      errors: [errorMessages.metaMustBeObjectLiteral],
+    },
+  ],
+});
+
+console.log('All tests passed!');