@dxos/eslint-plugin-rules 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # @dxos/eslint-plugin-rules
 
+## 0.15.0
+
 ## 0.14.0
 
 ## 0.13.0

package/index.js

@@ -17,6 +17,7 @@ import noBareDotImports from './rules/no-bare-dot-imports.js';
 import noDeadTailwindLogical from './rules/no-dead-tailwind-logical.js';
 import noEffectRunPromise from './rules/no-effect-run-promise.js';
 import noEmptyPromiseCatch from './rules/no-empty-promise-catch.js';
+import noErrorClassName from './rules/no-error-class-name.js';
 import noSimilarSiblingFiles from './rules/no-similar-sibling-files.js';
 import operationKeyShape from './rules/operation-key-shape.js';
 import preferSizingUtilities from './rules/prefer-sizing-utilities.js';
@@ -46,6 +47,7 @@ const plugin = {
     'operation-key-shape': operationKeyShape,
     'prefer-sizing-utilities': preferSizingUtilities,
     'no-empty-promise-catch': noEmptyPromiseCatch,
+    'no-error-class-name': noErrorClassName,
     'no-similar-sibling-files': noSimilarSiblingFiles,
     'translation-key-format': translationKeyFormat,
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/eslint-plugin-rules",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "repository": {
@@ -16,7 +16,7 @@
   },
   "devDependencies": {
     "@typescript-eslint/parser": "^8.71.0",
-    "@dxos/plugin-chess": "0.14.0"
+    "@dxos/plugin-chess": "0.15.0"
   },
   "publishConfig": {
     "access": "public"

package/rules/no-error-class-name.js

@@ -0,0 +1,89 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+'use strict';
+
+const ERROR_CLASS_RE = /^[A-Z]\w*Error$/;
+
+const EQUALITY_OPERATORS = new Set(['===', '!==', '==', '!=']);
+
+/** The trailing identifier of `Foo` or `Ns.Foo`. */
+const className = (node) => {
+  if (node.type === 'Identifier') {
+    return node.name;
+  }
+  if (node.type === 'MemberExpression' && !node.computed && node.property.type === 'Identifier') {
+    return node.property.name;
+  }
+  return undefined;
+};
+
+const isPropertyAccess = (node, property) =>
+  node?.type === 'MemberExpression' &&
+  !node.computed &&
+  node.property.type === 'Identifier' &&
+  node.property.name === property;
+
+const unwrapChain = (node) => (node?.type === 'ChainExpression' ? node.expression : node);
+
+/**
+ * Disallow matching errors by their class's runtime `name`, which minification renames.
+ * @example
+ * // bad
+ * registerError(UnknownProtocolError.name, decode);
+ * if (err.constructor.name === 'TimeoutError') {}
+ *
+ * // good
+ * registerError('UnknownProtocolError', decode);
+ * if (TimeoutError.is(err)) {}
+ */
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow identifying errors by the class name, which minified builds rename.',
+      recommended: true,
+    },
+    messages: {
+      errorClassName:
+        '`{{name}}.name` is renamed by minification. Use the declared name string, or `{{name}}.is(error)` for a `BaseError.extend` class.',
+      constructorName:
+        '`constructor.name` is renamed by minification. Compare `error.name`, or use `.is(error)` for a `BaseError.extend` class.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (!isPropertyAccess(node, 'name')) {
+          return;
+        }
+        const name = className(node.object);
+        if (name && ERROR_CLASS_RE.test(name)) {
+          context.report({ node, messageId: 'errorClassName', data: { name } });
+        }
+      },
+      BinaryExpression(node) {
+        if (!EQUALITY_OPERATORS.has(node.operator)) {
+          return;
+        }
+        for (const [access, other] of [
+          [node.left, node.right],
+          [node.right, node.left],
+        ]) {
+          const member = unwrapChain(access);
+          if (
+            isPropertyAccess(member, 'name') &&
+            isPropertyAccess(member.object, 'constructor') &&
+            other.type === 'Literal' &&
+            typeof other.value === 'string' &&
+            ERROR_CLASS_RE.test(other.value)
+          ) {
+            context.report({ node, messageId: 'constructorName' });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/operation-key-shape.js

@@ -44,6 +44,7 @@ const VERBS = new Set([
   'close',
   'collect',
   'complete',
+  'configure',
   'connect',
   'convert',
   'copy',
@@ -84,6 +85,7 @@ const VERBS = new Set([
   'insert',
   'inspect',
   'install',
+  'invite',
   'invoke',
   'join',
   'label',

package/src/no-error-class-name.test.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { RuleTester } from 'eslint';
+import { describe, it } from 'vitest';
+
+import rule from '../rules/no-error-class-name.js';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    parser: await import('@typescript-eslint/parser'),
+  },
+});
+
+describe('no-error-class-name', () => {
+  it('reports identity checks on the minified class name', () => {
+    ruleTester.run('no-error-class-name', rule, {
+      valid: [
+        "registerError('UnknownProtocolError', decode);",
+        'if (TimeoutError.is(err)) {}',
+        "if (err.name === 'TimeoutError') {}",
+        // Non-error classes and built-ins are out of scope.
+        'log(Foo.name);',
+        "if (value.constructor.name === 'ArrayBuffer') {}",
+      ],
+      invalid: [
+        {
+          code: 'registerError(UnknownProtocolError.name, decode);',
+          errors: [{ messageId: 'errorClassName' }],
+        },
+        {
+          code: 'new Set([EchoError.EntityNotFoundError.name]);',
+          errors: [{ messageId: 'errorClassName' }],
+        },
+        {
+          code: "if (err.constructor.name === 'TimeoutError') {}",
+          errors: [{ messageId: 'constructorName' }],
+        },
+        {
+          code: "if ('TimeoutError' !== err?.constructor.name) {}",
+          errors: [{ messageId: 'constructorName' }],
+        },
+      ],
+    });
+  });
+});