eslint-plugin-harlanzw 0.5.21 → 0.6.0

package/README.md

@@ -60,6 +60,8 @@ The rules are organized into the following categories:
 | [`vue-no-reactive-destructuring`](./src/rules/vue-no-reactive-destructuring.md) | avoid destructuring reactive objects |
 | [`vue-no-ref-access-in-templates`](./src/rules/vue-no-ref-access-in-templates.md) | don't use `.value` in Vue templates |
 | [`vue-no-torefs-on-props`](./src/rules/vue-no-torefs-on-props.md) | don't use `toRefs()` on the props object |
+| [`vue-no-reactivity-after-await`](./src/rules/vue-no-reactivity-after-await.md) | disallow subscription APIs (`watch`, `computed`, etc.) after `await` in async functions |
+| [`vue-no-async-lifecycle-hook`](./src/rules/vue-no-async-lifecycle-hook.md) | disallow async callbacks in Vue lifecycle hooks |
 | [`vue-no-resolve-component-in-composables`](./src/rules/vue-no-resolve-component-in-composables.ts) | disallow `resolveComponent()`/`resolveDirective()` outside top-level `<script setup>` |
 | [`vue-require-composable-prefix`](./src/rules/vue-require-composable-prefix.ts) | enforce `use*` prefix for functions using Vue reactivity |
 | **AI Deslop** | |

package/dist/index.mjs

@@ -4,7 +4,7 @@ import process from 'node:process';
 import { TextSourceCodeBase, ConfigCommentParser, Directive, VisitNodeStep } from '@eslint/plugin-kit';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-const version = "0.5.21";
+const version = "0.6.0";
 
 const STRENGTH_PATTERNS = {
   strong: ["never", "must", "always", "under no circumstances", "absolutely", "required", "mandatory", "forbidden", "prohibited"],
@@ -1531,6 +1531,8 @@ const aiDeslopCodeLang = {
               continue;
             const code = match[1];
             const lastChar = code.at(-1);
+            if (!lastChar)
+              continue;
             const lang = LANG_MAP[lastChar];
             if (!lang)
               continue;
@@ -1628,7 +1630,8 @@ const aiDeslopFiller = {
 const REGEX_4$2 = /[.*+?^${}()|[\]\\]/g;
 const REGEX_3$4 = /(?:\bnot|n't|no longer|more than|rather than)\s+$/;
 const REGEX_2$b = /^[-*>\s#\d.]+$/;
-const REGEX_1$q = /\.\s+$/;
+const REGEX_1$q = /[.:]\s+$/;
+const NEGATION_AFTER = /^(?:never|no|nothing|none|nobody|nowhere)\b/;
 const COMPILED$2 = HEDGING_WORDS.map((word) => {
   const escaped = word.replace(REGEX_4$2, "\\$&");
   return { regex: new RegExp(`\\b${escaped}\\s+`, "gi"), word };
@@ -1668,6 +1671,8 @@ const aiDeslopHedging = {
                 continue;
               if (word === "just" && REGEX_3$4.test(line.slice(Math.max(0, match.index - 20), match.index)))
                 continue;
+              if (NEGATION_AFTER.test(line.slice(match.index + match[0].length)))
+                continue;
               const startOffset = lineNode.position.start.offset + match.index;
               const endOffset = startOffset + match[0].length;
               const textBefore = line.slice(0, match.index);
@@ -1800,6 +1805,8 @@ function report(context, lineIdx, col, messageId, fixStart, fixEnd, replacement)
 
 const REGEX_2$a = /!(?!\[)/g;
 const REGEX_1$o = /\w/;
+const REGEX_WORD_END = /(\w+)$/;
+const REGEX_UPPER_START = /^[A-Z]/;
 const aiDeslopNoExclamation = {
   meta: {
     type: "suggestion",
@@ -1830,6 +1837,10 @@ const aiDeslopNoExclamation = {
               continue;
             if (match.index === 0 || !REGEX_1$o.test(line[match.index - 1]))
               continue;
+            const beforeBang = line.slice(0, match.index);
+            const wordMatch = beforeBang.match(REGEX_WORD_END);
+            if (wordMatch && REGEX_UPPER_START.test(wordMatch[1]))
+              continue;
             const startOffset = lineNode.position.start.offset + match.index;
             const endOffset = startOffset + 1;
             context.report({
@@ -2841,11 +2852,12 @@ const promptUnclosedCodeFence = {
 
 const REGEX_2$5 = /<([a-z_][\w-]*)>/gi;
 const REGEX_1$b = /<\/([a-z_][\w-]*)>/gi;
+const REGEX_INLINE_CODE = /`[^`]+`/g;
 const promptUnclosedTag = {
   meta: {
     type: "problem",
     docs: { description: "Detect mismatched XML-style tags" },
-    fixable: "code",
+    fixable: void 0,
     schema: [],
     messages: {
       unclosed: "Mismatched XML tag: <{{tag}}> appears {{openCount}} time(s) but </{{tag}}> appears {{closeCount}} time(s)."
@@ -2858,7 +2870,7 @@ const promptUnclosedTag = {
         const lines = sourceCode.lines;
         const codeBlockLines = getCodeBlockLines(lines);
         const frontmatterEnd = getFrontmatterEnd(lines);
-        const filteredText = lines.filter((_, i) => !shouldSkipLine(i, codeBlockLines, frontmatterEnd)).join("\n");
+        const filteredText = lines.filter((_, i) => !shouldSkipLine(i, codeBlockLines, frontmatterEnd)).map((line) => line.replace(REGEX_INLINE_CODE, "")).join("\n");
         const openTags = /* @__PURE__ */ new Map();
         const closeTags = /* @__PURE__ */ new Map();
         let match;
@@ -2872,22 +2884,13 @@ const promptUnclosedTag = {
           const tag = match[1].toLowerCase();
           closeTags.set(tag, (closeTags.get(tag) ?? 0) + 1);
         }
-        const docEnd = node.position.end.offset;
         for (const [tag, count] of openTags) {
           const closeCount = closeTags.get(tag) ?? 0;
           if (count !== closeCount) {
-            const missing = count - closeCount;
             context.report({
               node,
               messageId: "unclosed",
-              data: { tag, openCount: String(count), closeCount: String(closeCount) },
-              ...missing > 0 && {
-                fix(fixer) {
-                  const closingTags = Array.from({ length: missing }).fill(`</${tag}>`).join("\n");
-                  return fixer.insertTextAfterRange([docEnd, docEnd], `
-${closingTags}`);
-                }
-              }
+              data: { tag, openCount: String(count), closeCount: String(closeCount) }
             });
           }
         }
@@ -3211,9 +3214,11 @@ const hasDocs = [
   "nuxt-prefer-navigate-to-over-router-push-replace",
   "nuxt-prefer-nuxt-link-over-router-link",
   "use-composables-must-use-reactivity",
+  "vue-no-async-lifecycle-hook",
   "vue-no-nested-reactivity",
   "vue-no-passing-refs-as-props",
   "vue-no-reactive-destructuring",
+  "vue-no-reactivity-after-await",
   "vue-no-ref-access-in-templates",
   "vue-no-torefs-on-props"
 ];
@@ -3636,9 +3641,9 @@ function createReactivityChecker(vueImports, nonVueImports) {
 
 const REGEX_2$4 = /[^\u0020-\u007F]/;
 const REGEX_1$6 = /[^\u0020-\u007F]/;
-const RULE_NAME$n = "link-ascii-only";
+const RULE_NAME$p = "link-ascii-only";
 const linkAsciiOnly = createEslintRule({
-  name: RULE_NAME$n,
+  name: RULE_NAME$p,
   meta: {
     type: "suggestion",
     docs: {
@@ -3714,9 +3719,9 @@ const REGEX_4$1 = /[A-Z]/;
 const REGEX_3$2 = /%[0-9A-F]{2}/i;
 const REGEX_2$3 = /[A-Z]/;
 const REGEX_1$5 = /%[0-9A-F]{2}/i;
-const RULE_NAME$m = "link-lowercase";
+const RULE_NAME$o = "link-lowercase";
 const linkLowercase = createEslintRule({
-  name: RULE_NAME$m,
+  name: RULE_NAME$o,
   meta: {
     type: "suggestion",
     docs: {
@@ -3795,7 +3800,7 @@ const linkLowercase = createEslintRule({
 const REGEX_3$1 = /\/+/g;
 const REGEX_2$2 = /\/{2,}/;
 const REGEX_1$4 = /\/{2,}/;
-const RULE_NAME$l = "link-no-double-slashes";
+const RULE_NAME$n = "link-no-double-slashes";
 function fixDoubleSlashesInUrl(url) {
   if (url.startsWith("//") || url.includes("://"))
     return url;
@@ -3815,7 +3820,7 @@ function fixDoubleSlashesInUrl(url) {
   return `${path.replace(REGEX_3$1, "/")}${search}${hash}`;
 }
 const linkNoDoubleSlashes = createEslintRule({
-  name: RULE_NAME$l,
+  name: RULE_NAME$n,
   meta: {
     type: "problem",
     docs: {
@@ -3891,9 +3896,9 @@ const linkNoDoubleSlashes = createEslintRule({
   }
 });
 
-const RULE_NAME$k = "link-no-underscores";
+const RULE_NAME$m = "link-no-underscores";
 const linkNoUnderscores = createEslintRule({
-  name: RULE_NAME$k,
+  name: RULE_NAME$m,
   meta: {
     type: "suggestion",
     docs: {
@@ -3971,9 +3976,9 @@ const REGEX_4 = /\s/;
 const REGEX_3 = /\s/g;
 const REGEX_2$1 = /\s/;
 const REGEX_1$3 = /\s/g;
-const RULE_NAME$j = "link-no-whitespace";
+const RULE_NAME$l = "link-no-whitespace";
 const linkNoWhitespace = createEslintRule({
-  name: RULE_NAME$j,
+  name: RULE_NAME$l,
   meta: {
     type: "suggestion",
     docs: {
@@ -4047,7 +4052,7 @@ const linkNoWhitespace = createEslintRule({
   }
 });
 
-const RULE_NAME$i = "link-require-descriptive-text";
+const RULE_NAME$k = "link-require-descriptive-text";
 const BAD_LINK_TEXTS = /* @__PURE__ */ new Set([
   "click here",
   "click this",
@@ -4093,7 +4098,7 @@ function getVueLinkUrl(node) {
   return null;
 }
 const linkRequireDescriptiveText = createEslintRule({
-  name: RULE_NAME$i,
+  name: RULE_NAME$k,
   meta: {
     type: "suggestion",
     docs: {
@@ -4169,9 +4174,9 @@ const linkRequireDescriptiveText = createEslintRule({
   }
 });
 
-const RULE_NAME$h = "link-require-href";
+const RULE_NAME$j = "link-require-href";
 const linkRequireHref = createEslintRule({
-  name: RULE_NAME$h,
+  name: RULE_NAME$j,
   meta: {
     type: "problem",
     docs: {
@@ -4239,12 +4244,12 @@ const linkRequireHref = createEslintRule({
   }
 });
 
-const RULE_NAME$g = "link-trailing-slash";
+const RULE_NAME$i = "link-trailing-slash";
 function shouldSkipUrl(url) {
   return url.startsWith("#") || url.includes(":") || url === "/" || url === "";
 }
 const linkTrailingSlash = createEslintRule({
-  name: RULE_NAME$g,
+  name: RULE_NAME$i,
   meta: {
     type: "suggestion",
     docs: {
@@ -4359,9 +4364,9 @@ const linkTrailingSlash = createEslintRule({
   }
 });
 
-const RULE_NAME$f = "nuxt-await-navigate-to";
+const RULE_NAME$h = "nuxt-await-navigate-to";
 const nuxtAwaitNavigateTo = createEslintRule({
-  name: RULE_NAME$f,
+  name: RULE_NAME$h,
   meta: {
     type: "problem",
     docs: {
@@ -4517,7 +4522,7 @@ function isInConsequentBranch(node, ternary) {
   return false;
 }
 
-const RULE_NAME$e = "nuxt-no-random";
+const RULE_NAME$g = "nuxt-no-random";
 function isMathRandomCall(node) {
   return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "Math" && node.callee.property.type === "Identifier" && node.callee.property.name === "random";
 }
@@ -4548,7 +4553,7 @@ function reportRandom(context, node, template) {
   }
 }
 const nuxtNoRandom = createEslintRule({
-  name: RULE_NAME$e,
+  name: RULE_NAME$g,
   meta: {
     type: "problem",
     docs: {
@@ -4587,9 +4592,9 @@ const nuxtNoRandom = createEslintRule({
   }
 });
 
-const RULE_NAME$d = "nuxt-no-redundant-import-meta";
+const RULE_NAME$f = "nuxt-no-redundant-import-meta";
 const nuxtNoRedundantImportMeta = createEslintRule({
-  name: RULE_NAME$d,
+  name: RULE_NAME$f,
   meta: {
     type: "problem",
     docs: {
@@ -4627,7 +4632,7 @@ const nuxtNoRedundantImportMeta = createEslintRule({
 });
 
 const REGEX_1$2 = /\n\s*\n\s*\n/g;
-const RULE_NAME$c = "nuxt-no-side-effects-in-async-data-handler";
+const RULE_NAME$e = "nuxt-no-side-effects-in-async-data-handler";
 const SIDE_EFFECT_PATTERNS = /* @__PURE__ */ new Set([
   // Store/State mutations ($ prefix makes these unambiguous)
   "$patch",
@@ -4737,7 +4742,7 @@ function findSideEffectsInFunction(functionNode) {
   return sideEffects;
 }
 const nuxtNoSideEffectsInAsyncDataHandler = createEslintRule({
-  name: RULE_NAME$c,
+  name: RULE_NAME$e,
   meta: {
     type: "problem",
     docs: {
@@ -4828,9 +4833,9 @@ ${indent}${callOnceBlock}`)
   }
 });
 
-const RULE_NAME$b = "nuxt-no-side-effects-in-setup";
+const RULE_NAME$d = "nuxt-no-side-effects-in-setup";
 const nuxtNoSideEffectsInSetup = createEslintRule({
-  name: RULE_NAME$b,
+  name: RULE_NAME$d,
   meta: {
     type: "problem",
     docs: {
@@ -4921,7 +4926,7 @@ ${indent}})`;
   }
 });
 
-const RULE_NAME$a = "nuxt-no-unsafe-date";
+const RULE_NAME$c = "nuxt-no-unsafe-date";
 function isDateNowCall(node) {
   return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "Date" && node.callee.property.type === "Identifier" && node.callee.property.name === "now";
 }
@@ -4952,7 +4957,7 @@ function isChainedWithStableMethod(node) {
   return grandparent?.type === "CallExpression" && grandparent.callee === parent;
 }
 const nuxtNoUnsafeDate = createEslintRule({
-  name: RULE_NAME$a,
+  name: RULE_NAME$c,
   meta: {
     type: "problem",
     docs: {
@@ -5016,9 +5021,9 @@ const nuxtNoUnsafeDate = createEslintRule({
   }
 });
 
-const RULE_NAME$9 = "nuxt-prefer-navigate-to-over-router-push-replace";
+const RULE_NAME$b = "nuxt-prefer-navigate-to-over-router-push-replace";
 const nuxtPreferNavigateToOverRouterPushReplace = createEslintRule({
-  name: RULE_NAME$9,
+  name: RULE_NAME$b,
   meta: {
     type: "suggestion",
     docs: {
@@ -5083,9 +5088,9 @@ const nuxtPreferNavigateToOverRouterPushReplace = createEslintRule({
 
 const REGEX_2 = /router-link|RouterLink/gi;
 const REGEX_1$1 = /router-link|RouterLink/gi;
-const RULE_NAME$8 = "nuxt-prefer-nuxt-link-over-router-link";
+const RULE_NAME$a = "nuxt-prefer-nuxt-link-over-router-link";
 const nuxtPreferNuxtLinkOverRouterLink = createEslintRule({
-  name: RULE_NAME$8,
+  name: RULE_NAME$a,
   meta: {
     type: "suggestion",
     docs: {
@@ -5156,7 +5161,7 @@ const nuxtPreferNuxtLinkOverRouterLink = createEslintRule({
   }
 });
 
-const RULE_NAME$7 = "nuxt-ui-prefer-shorthand-css";
+const RULE_NAME$9 = "nuxt-ui-prefer-shorthand-css";
 const REPLACEMENTS = {
   // text
   "text-[var(--ui-text)]": "text-default",
@@ -5213,7 +5218,7 @@ function findVerboseClasses(value) {
   return results;
 }
 const nuxtUiPreferShorthandCss = createEslintRule({
-  name: RULE_NAME$7,
+  name: RULE_NAME$9,
   meta: {
     type: "suggestion",
     docs: {
@@ -5362,9 +5367,60 @@ const nuxtUiPreferShorthandCss = createEslintRule({
   }
 });
 
-const RULE_NAME$6 = "vue-no-faux-composables";
+const RULE_NAME$8 = "vue-no-async-lifecycle-hook";
+const LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
+  "onBeforeMount",
+  "onMounted",
+  "onBeforeUnmount",
+  "onUnmounted",
+  "onBeforeUpdate",
+  "onUpdated",
+  "onActivated",
+  "onDeactivated",
+  "onErrorCaptured",
+  "onRenderTracked",
+  "onRenderTriggered"
+  // Note: onServerPrefetch is intentionally excluded — Vue awaits it
+]);
+const vueNoAsyncLifecycleHook = createEslintRule({
+  name: RULE_NAME$8,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow async callbacks in Vue lifecycle hooks \u2014 code after await runs as a detached microtask that Vue does not await"
+    },
+    schema: [],
+    messages: {
+      noAsyncLifecycleHook: "{{hook}}() with an async callback is unsafe \u2014 Vue does not await lifecycle callbacks, so code after await runs as a detached microtask that may not execute during the lifecycle phase."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier")
+          return;
+        const hook = node.callee.name;
+        if (!LIFECYCLE_HOOKS.has(hook))
+          return;
+        const callback = node.arguments[0];
+        if (!callback)
+          return;
+        if ((callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") && callback.async) {
+          context.report({
+            node,
+            messageId: "noAsyncLifecycleHook",
+            data: { hook }
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$7 = "vue-no-faux-composables";
 const vueNoFauxComposables = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$7,
   meta: {
     type: "problem",
     docs: {
@@ -5433,9 +5489,9 @@ const vueNoFauxComposables = createEslintRule({
   }
 });
 
-const RULE_NAME$5 = "vue-no-nested-reactivity";
+const RULE_NAME$6 = "vue-no-nested-reactivity";
 const vueNoNestedReactivity = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
     type: "problem",
     docs: {
@@ -5680,9 +5736,9 @@ const vueNoNestedReactivity = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "vue-no-passing-refs-as-props";
+const RULE_NAME$5 = "vue-no-passing-refs-as-props";
 const vueNoPassingRefsAsProps = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -5789,6 +5845,127 @@ const vueNoReactiveDestructuring = createEslintRule({
   }
 });
 
+const RULE_NAME$4 = "vue-no-reactivity-after-await";
+const SUBSCRIPTION_APIS = /* @__PURE__ */ new Set([
+  // Vue watchers
+  "watch",
+  "watchEffect",
+  "watchPostEffect",
+  "watchSyncEffect",
+  // Vue computed
+  "computed",
+  // VueUse watchers
+  "whenever",
+  "watchArray",
+  "watchAtMost",
+  "watchDebounced",
+  "watchDeep",
+  "watchIgnorable",
+  "watchImmediate",
+  "watchOnce",
+  "watchPausable",
+  "watchThrottled",
+  "watchTriggerable",
+  "watchWithFilter",
+  "debouncedWatch",
+  "throttledWatch",
+  // VueUse computed
+  "computedAsync",
+  "computedEager",
+  "computedInject",
+  "computedWithControl",
+  "reactiveComputed"
+]);
+function getEnclosingAsyncFunction(node) {
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") {
+      return parent.async ? parent : null;
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function hasAwaitBefore(callNode, asyncFn) {
+  const body = asyncFn.body;
+  if (body.type !== "BlockStatement")
+    return false;
+  const callStart = callNode.range[0];
+  let found = false;
+  function walkStatements(stmts) {
+    for (const stmt of stmts) {
+      if (found)
+        return;
+      walkNode(stmt);
+    }
+  }
+  function walkNode(node) {
+    if (found)
+      return;
+    if (node.range[0] >= callStart)
+      return;
+    if (node.type === "AwaitExpression") {
+      found = true;
+      return;
+    }
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      return;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent")
+        continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item.type === "string")
+              walkNode(item);
+          }
+        } else if (typeof child.type === "string") {
+          walkNode(child);
+        }
+      }
+    }
+  }
+  walkStatements(body.body);
+  return found;
+}
+const vueNoReactivityAfterAwait = createEslintRule({
+  name: RULE_NAME$4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow Vue subscription APIs (watch, computed, etc.) after await in async functions \u2014 they lose component instance context and become orphaned"
+    },
+    schema: [],
+    messages: {
+      noReactivityAfterAwait: "{{name}}() called after await loses Vue component instance context and will never be auto-stopped on unmount. Move it before any await or wrap in effectScope()."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier")
+          return;
+        const name = node.callee.name;
+        if (!SUBSCRIPTION_APIS.has(name))
+          return;
+        const asyncFn = getEnclosingAsyncFunction(node);
+        if (!asyncFn)
+          return;
+        if (hasAwaitBefore(node, asyncFn)) {
+          context.report({
+            node,
+            messageId: "noReactivityAfterAwait",
+            data: { name }
+          });
+        }
+      }
+    };
+  }
+});
+
 const RULE_NAME$3 = "vue-no-ref-access-in-templates";
 const vueNoRefAccessInTemplates = createEslintRule({
   name: RULE_NAME$3,
@@ -6162,10 +6339,12 @@ const plugin = {
     "prompt-unresolved-reference": promptUnresolvedReference,
     "prompt-vague-term": promptVagueTerm,
     "prompt-weak-instruction": promptWeakInstruction,
+    "vue-no-async-lifecycle-hook": vueNoAsyncLifecycleHook,
     "vue-no-faux-composables": vueNoFauxComposables,
     "vue-no-nested-reactivity": vueNoNestedReactivity,
     "vue-no-passing-refs-as-props": vueNoPassingRefsAsProps,
     "vue-no-reactive-destructuring": vueNoReactiveDestructuring,
+    "vue-no-reactivity-after-await": vueNoReactivityAfterAwait,
     "vue-no-ref-access-in-templates": vueNoRefAccessInTemplates,
     "vue-no-resolve-component-in-composables": vueNoResolveComponentInComposables,
     "vue-no-torefs-on-props": vueNoTorefsOnProps,
@@ -6310,10 +6489,12 @@ plugin.configs.vue = [
     ignores: CODE_IGNORES,
     plugins: { harlanzw: plugin },
     rules: {
+      "harlanzw/vue-no-async-lifecycle-hook": "error",
       "harlanzw/vue-no-faux-composables": "error",
       "harlanzw/vue-no-nested-reactivity": "error",
       "harlanzw/vue-no-passing-refs-as-props": "error",
       "harlanzw/vue-no-reactive-destructuring": "error",
+      "harlanzw/vue-no-reactivity-after-await": "error",
       "harlanzw/vue-no-ref-access-in-templates": "warn",
       "harlanzw/vue-no-resolve-component-in-composables": "error",
       "harlanzw/vue-no-torefs-on-props": "warn",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-harlanzw",
   "type": "module",
-  "version": "0.5.21",
+  "version": "0.6.0",
   "description": "Harlan's opinionated ESLint rules",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
@@ -32,14 +32,14 @@
     "@eslint/plugin-kit": "^0.6.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^7.7.2",
+    "@antfu/eslint-config": "^7.7.3",
     "@antfu/ni": "^29.0.0",
     "@antfu/utils": "^9.3.0",
     "@types/eslint": "^9.6.1",
     "@types/node": "^25.5.0",
-    "@typescript-eslint/typescript-estree": "^8.57.0",
-    "@typescript-eslint/utils": "^8.57.0",
-    "bumpp": "^11.0.0",
+    "@typescript-eslint/typescript-estree": "^8.57.1",
+    "@typescript-eslint/utils": "^8.57.1",
+    "bumpp": "^11.0.1",
     "eslint": "^10.0.3",
     "eslint-vitest-rule-tester": "^3.1.0",
     "jsonc-eslint-parser": "^3.1.0",