@discord/eslint-plugin-discord-intl 0.30.0 → 0.32.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/lib/native-validation.js

@@ -13,7 +13,8 @@ const {
   IntlMessagesDatabase,
   IntlDatabaseInsertStrategy,
 } = require('@discord/intl-message-database');
-/** @type {Map<SourceCode, Record<string, IntlDiagnostic[]>>} */
+/** @typedef {{ sourceFileKey: string, validations: Record<string, IntlDiagnostic[]> }} FileValidations */
+/** @type {Map<SourceCode, FileValidations>} */
 const FILE_VALIDATIONS = new Map();
 
 /** @type {Map<string, IntlMessagesDatabase>} */
@@ -50,7 +51,7 @@ function ensureInitialized(directory) {
  * @param {SourceCode} sourceCode
  * @param {string} fileName
  * @param {string} content
- * @return {Record<string, IntlDiagnostic[]>}
+ * @return {FileValidations}
  */
 function processAndValidateNative(database, sourceCode, fileName, content) {
   const fileKey = crypto.hash('sha1', content);
@@ -67,6 +68,10 @@ function processAndValidateNative(database, sourceCode, fileName, content) {
     'en-US',
     IntlDatabaseInsertStrategy.Update,
   );
+  // The database interns file paths and may store a different spelling than the one we passed in
+  // (on Windows it normalizes the drive letter and separators). Every diagnostic it hands back is
+  // tagged with _its_ spelling, so match on this rather than on `processingFileName`.
+  const sourceFileKey = processResult.fileKey;
 
   /** @type {Record<string, IntlDiagnostic[]>} */
   const validations = {};
@@ -77,7 +82,7 @@ function processAndValidateNative(database, sourceCode, fileName, content) {
       name: 'Processing::' + error.name,
       description: error.message,
       key: error.key ?? 'file',
-      file: error.file ?? processingFileName,
+      file: error.file ?? sourceFileKey,
       messageLine: error.line ?? 0,
       messageCol: error.col ?? 0,
       start: 0,
@@ -89,13 +94,14 @@ function processAndValidateNative(database, sourceCode, fileName, content) {
   }
 
   for (const diagnostic of database.validateMessages()) {
-    if (diagnostic.file === processingFileName) {
+    if (diagnostic.file === sourceFileKey) {
       (validations[diagnostic.key] ??= []).push(diagnostic);
     }
   }
 
-  FILE_VALIDATIONS.set(sourceCode, validations);
-  return validations;
+  const result = { sourceFileKey, validations };
+  FILE_VALIDATIONS.set(sourceCode, result);
+  return result;
 }
 
 /**
@@ -111,7 +117,7 @@ function traverseAndReportMatchingNativeValidations(context, predicate) {
 
   const projectDirectory = context.settings['intl']?.['projectDirectory'] ?? context.cwd;
   const database = ensureInitialized(projectDirectory);
-  const validations = processAndValidateNative(
+  const { sourceFileKey, validations } = processAndValidateNative(
     database,
     context.sourceCode,
     context.filename,
@@ -133,7 +139,7 @@ function traverseAndReportMatchingNativeValidations(context, predicate) {
     // log the diagnostic to be able to investigate further when it happens.
     const textLen = context.sourceCode.text.length;
     if (
-      diagnostic.file !== context.physicalFilename ||
+      diagnostic.file !== sourceFileKey ||
       messageOffset + diagnostic.start > textLen ||
       messageOffset + diagnostic.end > textLen
     ) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/eslint-plugin-discord-intl",
-  "version": "0.30.0",
+  "version": "0.32.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.30.0"
+    "@discord/intl-message-database": "0.32.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!');