@timmo001/oxlint-rules 0.4.0 → 0.5.0

package/dist/generic/index.js

@@ -1,8 +1,86 @@
 // src/generic/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/generic/rules/prefer-event-parameter-type.ts
+// src/generic/rules/no-explicit-inferable-type-predicate.ts
 import { defineRule } from "@oxlint/plugins";
+function isNamed(node, name) {
+  return node.type === "Identifier" && node.name === name;
+}
+function isNullish(node) {
+  return node.type === "Literal" && node.value === null || isNamed(node, "undefined");
+}
+function isNullishExclusion(node, name) {
+  return node.type === "BinaryExpression" && (node.operator === "!==" || node.operator === "!=") && (isNamed(node.left, name) && isNullish(node.right) || isNullish(node.left) && isNamed(node.right, name));
+}
+function isTypeofCheck(node, name) {
+  if (node.type !== "BinaryExpression" || node.operator !== "===" && node.operator !== "==") {
+    return false;
+  }
+  const isTypeof = (side) => side.type === "UnaryExpression" && side.operator === "typeof" && isNamed(side.argument, name);
+  const isLiteral = (side) => side.type === "Literal";
+  return isTypeof(node.left) && isLiteral(node.right) || isLiteral(node.left) && isTypeof(node.right);
+}
+function isInferableCheck(node, name) {
+  if (node.type === "LogicalExpression") {
+    return node.operator === "&&" && isNullishExclusion(node.left, name) && isNullishExclusion(node.right, name);
+  }
+  return isNullishExclusion(node, name) || isTypeofCheck(node, name) || node.type === "BinaryExpression" && node.operator === "instanceof" && isNamed(node.left, name);
+}
+function returnedExpression(owner) {
+  const body = owner.body;
+  if (!body)
+    return null;
+  if (body.type !== "BlockStatement")
+    return body;
+  const [statement] = body.body;
+  return body.body.length === 1 && statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+function isPublicSignature(owner) {
+  const parent = owner.parent;
+  if (parent.type === "MethodDefinition" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") {
+    return true;
+  }
+  return parent.type === "VariableDeclarator" && parent.parent.parent?.type === "ExportNamedDeclaration";
+}
+var noExplicitInferableTypePredicateRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit type predicates on simple null, typeof, or instanceof checks that TypeScript 5.5+ infers."
+    },
+    messages: {
+      removeTypePredicate: "TypeScript infers the type predicate for `{{parameter}}` from this check, while an explicit predicate is never checked against the body. Remove the annotation and rely on the inferred predicate."
+    }
+  },
+  create(context) {
+    const check = (owner) => {
+      const annotation = owner.returnType?.typeAnnotation;
+      if (annotation?.type !== "TSTypePredicate" || annotation.asserts || annotation.parameterName.type !== "Identifier" || isPublicSignature(owner)) {
+        return;
+      }
+      const parameter = annotation.parameterName.name;
+      const expression = returnedExpression(owner);
+      if (!owner.params.some((param) => isNamed(param, parameter)) || !expression || !isInferableCheck(expression, parameter)) {
+        return;
+      }
+      context.report({
+        node: annotation,
+        messageId: "removeTypePredicate",
+        data: { parameter }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+});
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+
+// src/shared/ast.ts
 function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
@@ -13,30 +91,204 @@ function nearestEnclosingFunction(node) {
   }
   return null;
 }
-function assertedEventParameter(node) {
-  const expression = node.expression;
-  if (expression.type !== "MemberExpression" || expression.computed || expression.object.type !== "Identifier" || expression.property.type !== "Identifier" || expression.property.name !== "currentTarget" && expression.property.name !== "target") {
+function staticMemberName(node) {
+  if (node.type !== "MemberExpression" || node.computed)
+    return null;
+  return node.property.type === "Identifier" ? node.property.name : null;
+}
+
+// src/shared/json.ts
+function jsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+
+// src/shared/lit.ts
+var renderRoots = new Set(["renderRoot", "shadowRoot"]);
+function litElementBaseClasses(settings) {
+  const configured = jsonObject(settings.lit)?.elementBaseClasses;
+  return new Set([
+    "LitElement",
+    ...Array.isArray(configured) ? configured.map(String) : []
+  ]);
+}
+function isWrapperExpression(node) {
+  return node?.type === "ChainExpression" || node?.type === "ParenthesizedExpression" || node?.type === "TSAsExpression" || node?.type === "TSNonNullExpression" || node?.type === "TSSatisfiesExpression" || node?.type === "TSTypeAssertion";
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (isWrapperExpression(current))
+    current = current.expression;
+  return current;
+}
+function extendsLitBase(node, bases) {
+  if (node.type === "Identifier")
+    return bases.has(node.name);
+  return node.type === "CallExpression" && node.arguments.some((argument) => extendsLitBase(argument, bases));
+}
+function isLitClass(node, bases) {
+  const hasCustomElementDecorator = node.decorators.some((decorator) => decorator.expression.type === "CallExpression" && decorator.expression.callee.type === "Identifier" && decorator.expression.callee.name === "customElement");
+  return hasCustomElementDecorator || node.superClass !== null && extendsLitBase(node.superClass, bases);
+}
+function classOfBody(body) {
+  const owner = body.parent;
+  return owner?.type === "ClassDeclaration" || owner?.type === "ClassExpression" ? owner : null;
+}
+function thisClass(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+      const owner = parent.parent;
+      return (owner?.type === "MethodDefinition" || owner?.type === "TSAbstractMethodDefinition") && !owner.static && owner.value === parent ? classOfBody(owner.parent) : null;
+    }
+    if ((parent.type === "PropertyDefinition" || parent.type === "AccessorProperty") && parent.value === current) {
+      return parent.static ? null : classOfBody(parent.parent);
+    }
+    if (parent.type === "StaticBlock" || parent.type === "ClassBody" || parent.type === "Program") {
+      return null;
+    }
+    current = parent;
+  }
+  return null;
+}
+function isStaticSelector(node) {
+  return node?.type === "Literal" || node?.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+function renderRootQuery(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (method !== "querySelector" && method !== "querySelectorAll" || node.callee.type !== "MemberExpression" || !isStaticSelector(node.arguments[0])) {
+    return null;
+  }
+  const receiver = unwrapExpression(node.callee.object);
+  const root = staticMemberName(receiver);
+  if (!root || !renderRoots.has(root) || receiver.type !== "MemberExpression" || receiver.object.type !== "ThisExpression") {
+    return null;
+  }
+  const owner = thisClass(receiver.object);
+  return owner && isLitClass(owner, bases) ? { method, root } : null;
+}
+function isAssignedMethod(name) {
+  return name === "assignedElements" || name === "assignedNodes";
+}
+function feedsAssignedCall(node) {
+  let current = node;
+  while (isWrapperExpression(current.parent))
+    current = current.parent;
+  const member = current.parent;
+  return member?.type === "MemberExpression" && member.object === current && isAssignedMethod(staticMemberName(member));
+}
+function litQueryDecoratorCall(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (!isAssignedMethod(method)) {
+    return feedsAssignedCall(node) ? null : renderRootQuery(node, bases);
+  }
+  if (node.callee.type !== "MemberExpression")
+    return null;
+  const inner = unwrapExpression(node.callee.object);
+  if (inner.type !== "CallExpression")
     return null;
+  const query = renderRootQuery(inner, bases);
+  return query?.method === "querySelector" ? { method, root: query.root } : null;
+}
+function isLitRenderRootQuery(node, bases) {
+  return renderRootQuery(node, bases) !== null;
+}
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+var queryMethods = new Set(["closest", "querySelector", "querySelectorAll"]);
+var noUncheckedQuerySelectorTypeRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type arguments on `querySelector`, `querySelectorAll`, and `closest`, which cast the result without checking it."
+    },
+    messages: {
+      checkQueryResult: "`{{method}}<T>` casts the result without checking it. Check it with `instanceof`, use a checked lookup helper, or query a tag name so TypeScript infers the element type."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    return {
+      CallExpression(node) {
+        const method = staticMemberName(node.callee);
+        if (!node.typeArguments || !method || !queryMethods.has(method) || isLitRenderRootQuery(node, bases)) {
+          return;
+        }
+        context.report({
+          node: node.typeArguments,
+          messageId: "checkQueryResult",
+          data: { method }
+        });
+      }
+    };
   }
-  const parameterName = expression.object.name;
-  const property = expression.property.name;
+});
+
+// src/generic/rules/no-untyped-custom-event.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var noUntypedCustomEventRule = defineRule3({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `CustomEvent` type references without a detail type, which leave `detail` as `any`."
+    },
+    messages: {
+      typeCustomEventDetail: "`CustomEvent` without a type argument leaves `detail` as `any`. Reuse the project's typed event helper if one fits, or add one, instead of a bare `CustomEvent`."
+    }
+  },
+  create(context) {
+    return {
+      TSTypeReference(node) {
+        if (node.typeName.type !== "Identifier" || node.typeName.name !== "CustomEvent" || node.typeArguments) {
+          return;
+        }
+        context.report({ node, messageId: "typeCustomEventDetail" });
+      }
+    };
+  }
+});
+
+// src/generic/rules/prefer-event-parameter-type.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+function staticMemberPath(node) {
+  const path = [];
+  let current = node.type === "ChainExpression" ? node.expression : node;
+  while (current.type === "MemberExpression") {
+    if (current.computed || current.property.type !== "Identifier") {
+      return null;
+    }
+    path.unshift(current.property.name);
+    current = current.object;
+  }
+  return current.type === "Identifier" && path.length > 0 ? { root: current.name, path } : null;
+}
+function isEventMemberPath(path) {
+  const [first] = path;
+  if (first === "detail")
+    return true;
+  return path.length === 1 && (first === "currentTarget" || first === "target");
+}
+function assertedEventParameter(node) {
+  const member = staticMemberPath(node.expression);
+  if (!member || !isEventMemberPath(member.path))
+    return null;
   const owner = nearestEnclosingFunction(node);
-  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
+  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === member.root)) {
     return null;
   }
   return {
-    parameter: parameterName,
-    property
+    parameter: member.root,
+    property: member.path.join(".")
   };
 }
-var preferEventParameterTypeRule = defineRule({
+var preferEventParameterTypeRule = defineRule4({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Prefer typing event target properties in the handler parameter instead of asserting them at use sites."
+      description: "Prefer typing event target and detail properties in the handler parameter instead of asserting them at use sites."
     },
     messages: {
-      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site."
+      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site. Reuse the project's typed event helper if one fits, or add one."
     }
   },
   create(context) {
@@ -57,9 +309,69 @@ var preferEventParameterTypeRule = defineRule({
   }
 });
 
+// src/generic/rules/prefer-lit-query-decorators.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var messageIds = {
+  assignedElements: "preferQueryAssignedElements",
+  assignedNodes: "preferQueryAssignedNodes",
+  querySelector: "preferQuery",
+  querySelectorAll: "preferQueryAll"
+};
+var preferLitQueryDecoratorsRule = defineRule5({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require Lit query decorators instead of static render-root queries in Lit elements."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          querySelector: { type: "boolean" },
+          querySelectorAll: { type: "boolean" },
+          assignedElements: { type: "boolean" },
+          assignedNodes: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    defaultOptions: [
+      {
+        querySelector: true,
+        querySelectorAll: true,
+        assignedElements: true,
+        assignedNodes: true
+      }
+    ],
+    messages: {
+      preferQuery: "Use the @query decorator instead of this.{{root}}.querySelector().",
+      preferQueryAll: "Use the @queryAll decorator instead of this.{{root}}.querySelectorAll().",
+      preferQueryAssignedElements: "Use the @queryAssignedElements decorator instead of this.{{root}}.querySelector().assignedElements().",
+      preferQueryAssignedNodes: "Use the @queryAssignedNodes decorator instead of this.{{root}}.querySelector().assignedNodes()."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    const options = jsonObject(context.options[0]);
+    const disabled = new Set(options ? Object.keys(options).filter((method) => options[method] === false) : []);
+    return {
+      CallExpression(node) {
+        const query = litQueryDecoratorCall(node, bases);
+        if (!query || disabled.has(query.method))
+          return;
+        context.report({
+          node,
+          messageId: messageIds[query.method],
+          data: { root: query.root }
+        });
+      }
+    };
+  }
+});
+
 // src/generic/rules/prefer-types-over-assertions.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
-var preferTypesOverAssertionsRule = defineRule2({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule6({
   meta: {
     type: "problem",
     docs: {
@@ -71,7 +383,7 @@ var preferTypesOverAssertionsRule = defineRule2({
   },
   create(context) {
     const checkAssertion = (node) => {
-      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const" || assertedEventParameter(node)) {
         return;
       }
       context.report({ node, messageId: "avoidAssertion" });
@@ -87,7 +399,11 @@ var preferTypesOverAssertionsRule = defineRule2({
 var timmoPlugin = eslintCompatPlugin({
   meta: { name: "timmo" },
   rules: {
+    "no-explicit-inferable-type-predicate": noExplicitInferableTypePredicateRule,
+    "no-unchecked-query-selector-type": noUncheckedQuerySelectorTypeRule,
+    "no-untyped-custom-event": noUntypedCustomEventRule,
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-lit-query-decorators": preferLitQueryDecoratorsRule,
     "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -25,6 +25,8 @@
     "src/generic",
     "!src/generic/**/*.test.ts",
     "!src/effect/**/*.test.ts",
+    "src/shared",
+    "!src/shared/**/*.test.ts",
     "vendor/anti-slop/src",
     "vendor/anti-slop/LICENSE",
     "!vendor/anti-slop/src/**/*.test.ts",

package/src/effect/index.ts

@@ -1,11 +1,13 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
 import { noTryCatchInEffectGeneratorsRule } from "./rules/no-try-catch-in-effect-generators.ts";
+import { preferPlatformServicesRule } from "./rules/prefer-platform-services.ts";
 
 const timmoEffectPlugin = eslintCompatPlugin({
   meta: { name: "timmo-effect" },
   rules: {
     "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule,
+    "prefer-platform-services": preferPlatformServicesRule,
   },
 });
 

package/src/effect/rules/no-try-catch-in-effect-generators.ts

@@ -1,104 +1,10 @@
 import { defineRule } from "@oxlint/plugins";
 
-import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+import { nearestEnclosingFunction } from "../../shared/ast.ts";
+import { isEffectMethod } from "../../shared/effect.ts";
 
-type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
-
-function resolveVariable(
-  sourceCode: SourceCode,
-  identifier: ESTree.IdentifierReference,
-): Variable | null {
-  let scope: Scope | null = sourceCode.getScope(identifier);
-
-  while (scope) {
-    const variable = scope.set.get(identifier.name);
-
-    if (variable) return variable;
-    scope = scope.upper;
-  }
-
-  return null;
-}
-
-function nearestEnclosingFunction(node: ESTree.Node): FunctionNode | null {
-  let current: ESTree.Node | null = node.parent;
-
-  while (current) {
-    if (
-      current.type === "FunctionDeclaration" ||
-      current.type === "FunctionExpression" ||
-      current.type === "ArrowFunctionExpression"
-    ) {
-      return current;
-    }
-
-    current = current.parent;
-  }
-
-  return null;
-}
-
-function staticMemberName(node: ESTree.Expression): string | null {
-  if (node.type !== "MemberExpression" || node.computed) return null;
-
-  return node.property.type === "Identifier" ? node.property.name : null;
-}
-
-function isEffectImport(
-  sourceCode: SourceCode,
-  identifier: ESTree.IdentifierReference,
-  namespace: boolean,
-): boolean {
-  const variable = resolveVariable(sourceCode, identifier);
-
-  return (
-    variable?.defs.some((definition) => {
-      if (
-        definition.type !== "ImportBinding" ||
-        definition.parent?.type !== "ImportDeclaration" ||
-        definition.parent.source.value !== "effect"
-      ) {
-        return false;
-      }
-
-      if (namespace) return definition.node.type === "ImportNamespaceSpecifier";
-
-      if (definition.node.type !== "ImportSpecifier") return false;
-      const imported = definition.node.imported;
-
-      return (
-        (imported.type === "Identifier" ? imported.name : imported.value) ===
-        "Effect"
-      );
-    }) ?? false
-  );
-}
-
-function isEffectMethod(
-  sourceCode: SourceCode,
-  node: ESTree.Expression,
-  method: "fn" | "gen",
-): boolean {
-  if (staticMemberName(node) !== method || node.type !== "MemberExpression") {
-    return false;
-  }
-
-  const object = node.object;
-
-  if (object.type === "Identifier") {
-    return isEffectImport(sourceCode, object, false);
-  }
-
-  if (
-    staticMemberName(object) !== "Effect" ||
-    object.type !== "MemberExpression" ||
-    object.object.type !== "Identifier"
-  ) {
-    return false;
-  }
-
-  return isEffectImport(sourceCode, object.object, true);
-}
+import type { FunctionNode } from "../../shared/ast.ts";
+import type { ESTree, SourceCode } from "@oxlint/plugins";
 
 function isDirectArgument(
   owner: FunctionNode,

package/src/effect/rules/prefer-platform-services.ts

@@ -0,0 +1,105 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { staticMemberName } from "../../shared/ast.ts";
+import { importsEffect } from "../../shared/effect.ts";
+import { resolveVariable } from "../../shared/scope.ts";
+
+type PlatformService = "childProcess" | "fileSystem";
+
+const moduleServices = new Map<string, PlatformService>([
+  ["child_process", "childProcess"],
+  ["fs", "fileSystem"],
+  ["fs/promises", "fileSystem"],
+]);
+
+const bunServices = new Map<string, PlatformService>([
+  ["$", "childProcess"],
+  ["file", "fileSystem"],
+  ["spawn", "childProcess"],
+  ["spawnSync", "childProcess"],
+  ["write", "fileSystem"],
+]);
+
+/** Prefer Effect's platform services over direct process and file system APIs in Effect modules. */
+export const preferPlatformServicesRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Prefer Effect's ChildProcessSpawner and FileSystem services over Node or Bun process and file system APIs in modules that use Effect.",
+    },
+    messages: {
+      childProcess:
+        "Use Effect's `ChildProcessSpawner` service (`effect/process`) instead of `{{api}}`, so scope cleanup, interruption, and test layers apply.",
+      fileSystem:
+        "Use Effect's `FileSystem` service instead of `{{api}}`, so failures stay typed and tests can provide a layer.",
+    },
+  },
+  create(context) {
+    let enabled = false;
+
+    return {
+      Program(node) {
+        enabled = importsEffect(node);
+      },
+      ImportDeclaration(node) {
+        if (!enabled || node.importKind === "type") return;
+        const source = node.source.value;
+        const service = moduleServices.get(source.replace(/^node:/u, ""));
+
+        if (service) {
+          context.report({ node, messageId: service, data: { api: source } });
+
+          return;
+        }
+
+        if (source !== "bun") return;
+
+        for (const specifier of node.specifiers) {
+          if (
+            specifier.type !== "ImportSpecifier" ||
+            specifier.importKind === "type"
+          ) {
+            continue;
+          }
+
+          const imported =
+            specifier.imported.type === "Identifier"
+              ? specifier.imported.name
+              : specifier.imported.value;
+
+          const bunService = bunServices.get(imported);
+
+          if (bunService) {
+            context.report({
+              node: specifier,
+              messageId: bunService,
+              data: { api: `Bun.${imported}` },
+            });
+          }
+        }
+      },
+      MemberExpression(node) {
+        const name = staticMemberName(node);
+        const service = name ? bunServices.get(name) : undefined;
+
+        if (
+          !enabled ||
+          !service ||
+          node.object.type !== "Identifier" ||
+          node.object.name !== "Bun" ||
+          (resolveVariable(context.sourceCode, node.object)?.defs.length ?? 0) >
+            0
+        ) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: service,
+          data: { api: `Bun.${name}` },
+        });
+      },
+    };
+  },
+});

package/src/generic/index.ts

@@ -1,12 +1,21 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
+import { noExplicitInferableTypePredicateRule } from "./rules/no-explicit-inferable-type-predicate.ts";
+import { noUncheckedQuerySelectorTypeRule } from "./rules/no-unchecked-query-selector-type.ts";
+import { noUntypedCustomEventRule } from "./rules/no-untyped-custom-event.ts";
 import { preferEventParameterTypeRule } from "./rules/prefer-event-parameter-type.ts";
+import { preferLitQueryDecoratorsRule } from "./rules/prefer-lit-query-decorators.ts";
 import { preferTypesOverAssertionsRule } from "./rules/prefer-types-over-assertions.ts";
 
 const timmoPlugin = eslintCompatPlugin({
   meta: { name: "timmo" },
   rules: {
+    "no-explicit-inferable-type-predicate":
+      noExplicitInferableTypePredicateRule,
+    "no-unchecked-query-selector-type": noUncheckedQuerySelectorTypeRule,
+    "no-untyped-custom-event": noUntypedCustomEventRule,
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-lit-query-decorators": preferLitQueryDecoratorsRule,
     "prefer-types-over-assertions": preferTypesOverAssertionsRule,
   },
 });