eslint-plugin-harlanzw 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+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.3.0";
+const version = "0.4.0";
 
 const STRENGTH_PATTERNS = {
   strong: ["never", "must", "always", "under no circumstances", "absolutely", "required", "mandatory", "forbidden", "prohibited"],
@@ -1465,8 +1466,10 @@ const hasDocs = [
   "link-require-descriptive-text",
   "link-require-href",
   "link-trailing-slash",
+  "nuxt-no-random",
   "nuxt-no-redundant-import-meta",
   "nuxt-no-side-effects-in-setup",
+  "nuxt-no-unsafe-date",
   "nuxt-prefer-navigate-to-over-router-push-replace",
   "nuxt-prefer-nuxt-link-over-router-link",
   "use-composables-must-use-reactivity",
@@ -1633,6 +1636,57 @@ const VUE_REACTIVITY_APIS = /* @__PURE__ */ new Set([
   "getCurrentScope",
   "onScopeDispose"
 ]);
+const VUEUSE_REACTIVITY_APIS = /* @__PURE__ */ new Set([
+  // Watch variants
+  "whenever",
+  "watchArray",
+  "watchAtMost",
+  "watchDebounced",
+  "watchDeep",
+  "watchIgnorable",
+  "watchImmediate",
+  "watchOnce",
+  "watchPausable",
+  "watchThrottled",
+  "watchTriggerable",
+  "watchWithFilter",
+  "debouncedWatch",
+  "throttledWatch",
+  "until",
+  // Computed variants
+  "computedAsync",
+  "computedEager",
+  "computedInject",
+  "computedWithControl",
+  // Reactive utilities
+  "reactiveComputed",
+  "reactiveOmit",
+  "reactivePick",
+  "toReactive",
+  // Ref utilities
+  "controlledRef",
+  "debouncedRef",
+  "throttledRef",
+  "refAutoReset",
+  "refDebounced",
+  "refDefault",
+  "refThrottled",
+  "refWithControl",
+  "extendRef",
+  "syncRef",
+  "syncRefs",
+  "templateRef",
+  // State management
+  "createGlobalState",
+  "createInjectionState",
+  "createSharedComposable",
+  // Event/lifecycle hooks
+  "onClickOutside",
+  "onKeyStroke",
+  "onLongPress",
+  "onStartTyping",
+  "createEventHook"
+]);
 const SIDE_EFFECT_FUNCTIONS = /* @__PURE__ */ new Set([
   // Timer functions
   "setTimeout",
@@ -1744,10 +1798,99 @@ function trackVueImports(node, vueImports) {
     });
   }
 }
+function trackNonVueImports(node, nonVueImports) {
+  if (node.source.value !== "vue") {
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
+        nonVueImports.add(spec.imported.name);
+      }
+    }
+  }
+}
+function createReactivityChecker(vueImports, nonVueImports) {
+  function isAutoImportedReactivityCall(node) {
+    if (node.callee.type === "Identifier") {
+      const name = node.callee.name;
+      return (VUE_REACTIVITY_APIS.has(name) || VUEUSE_REACTIVITY_APIS.has(name)) && !nonVueImports.has(name);
+    }
+    return false;
+  }
+  function isReactiveLifecycleCall(node) {
+    return node.callee.type === "Identifier" && /^tryOn[A-Z]/.test(node.callee.name);
+  }
+  function hasReactivityInExpression(expr) {
+    if (!expr)
+      return false;
+    switch (expr.type) {
+      case "CallExpression":
+        if (isReactivityCall(expr, vueImports) || isAutoImportedReactivityCall(expr) || isComposableCall(expr) || isReactiveLifecycleCall(expr))
+          return true;
+        return expr.arguments.some((arg) => hasReactivityInArg(arg));
+      case "NewExpression":
+        return expr.arguments.some((arg) => hasReactivityInArg(arg));
+      case "MemberExpression":
+        return hasReactivityInExpression(expr.object);
+      case "AssignmentExpression":
+        return hasReactivityInExpression(expr.right);
+      case "ObjectExpression":
+        return expr.properties.some((prop) => prop.type === "Property" && hasReactivityInExpression(prop.value));
+      case "ArrayExpression":
+        return expr.elements.some((elem) => hasReactivityInExpression(elem));
+      case "AwaitExpression":
+        return hasReactivityInExpression(expr.argument);
+      case "ConditionalExpression":
+        return hasReactivityInExpression(expr.consequent) || hasReactivityInExpression(expr.alternate);
+      case "LogicalExpression":
+        return hasReactivityInExpression(expr.left) || hasReactivityInExpression(expr.right);
+      default:
+        return false;
+    }
+  }
+  function hasReactivityInArg(arg) {
+    if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") {
+      if (arg.body.type === "BlockStatement")
+        return arg.body.body.some((stmt) => hasReactivityInStatement(stmt));
+      return hasReactivityInExpression(arg.body);
+    }
+    if (arg.type === "SpreadElement")
+      return hasReactivityInExpression(arg.argument);
+    return hasReactivityInExpression(arg);
+  }
+  function hasReactivityInStatement(stmt) {
+    if (!stmt)
+      return false;
+    switch (stmt.type) {
+      case "ExpressionStatement":
+        return hasReactivityInExpression(stmt.expression);
+      case "VariableDeclaration":
+        return stmt.declarations.some((decl) => hasReactivityInExpression(decl.init));
+      case "ReturnStatement":
+        return hasReactivityInExpression(stmt.argument);
+      case "BlockStatement":
+        return stmt.body.some((s) => hasReactivityInStatement(s));
+      case "IfStatement":
+        return hasReactivityInStatement(stmt.consequent) || (stmt.alternate ? hasReactivityInStatement(stmt.alternate) : false);
+      case "WhileStatement":
+      case "DoWhileStatement":
+        return hasReactivityInStatement(stmt.body);
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement":
+        return hasReactivityInStatement(stmt.body);
+      case "TryStatement":
+        return hasReactivityInStatement(stmt.block) || (stmt.handler ? hasReactivityInStatement(stmt.handler.body) : false) || (stmt.finalizer ? hasReactivityInStatement(stmt.finalizer) : false);
+      case "SwitchStatement":
+        return stmt.cases.some((switchCase) => switchCase.consequent.some((s) => hasReactivityInStatement(s)));
+      default:
+        return false;
+    }
+  }
+  return { hasReactivityInStatement, hasReactivityInExpression };
+}
 
-const RULE_NAME$i = "link-ascii-only";
+const RULE_NAME$l = "link-ascii-only";
 const linkAsciiOnly = createEslintRule({
-  name: RULE_NAME$i,
+  name: RULE_NAME$l,
   meta: {
     type: "suggestion",
     docs: {
@@ -1819,9 +1962,9 @@ const linkAsciiOnly = createEslintRule({
   }
 });
 
-const RULE_NAME$h = "link-lowercase";
+const RULE_NAME$k = "link-lowercase";
 const linkLowercase = createEslintRule({
-  name: RULE_NAME$h,
+  name: RULE_NAME$k,
   meta: {
     type: "suggestion",
     docs: {
@@ -1897,7 +2040,7 @@ const linkLowercase = createEslintRule({
   }
 });
 
-const RULE_NAME$g = "link-no-double-slashes";
+const RULE_NAME$j = "link-no-double-slashes";
 function fixDoubleSlashesInUrl(url) {
   if (url.startsWith("//") || url.includes("://"))
     return url;
@@ -1917,7 +2060,7 @@ function fixDoubleSlashesInUrl(url) {
   return `${path.replace(/\/+/g, "/")}${search}${hash}`;
 }
 const linkNoDoubleSlashes = createEslintRule({
-  name: RULE_NAME$g,
+  name: RULE_NAME$j,
   meta: {
     type: "problem",
     docs: {
@@ -1993,9 +2136,9 @@ const linkNoDoubleSlashes = createEslintRule({
   }
 });
 
-const RULE_NAME$f = "link-no-underscores";
+const RULE_NAME$i = "link-no-underscores";
 const linkNoUnderscores = createEslintRule({
-  name: RULE_NAME$f,
+  name: RULE_NAME$i,
   meta: {
     type: "suggestion",
     docs: {
@@ -2069,9 +2212,9 @@ const linkNoUnderscores = createEslintRule({
   }
 });
 
-const RULE_NAME$e = "link-no-whitespace";
+const RULE_NAME$h = "link-no-whitespace";
 const linkNoWhitespace = createEslintRule({
-  name: RULE_NAME$e,
+  name: RULE_NAME$h,
   meta: {
     type: "suggestion",
     docs: {
@@ -2145,7 +2288,7 @@ const linkNoWhitespace = createEslintRule({
   }
 });
 
-const RULE_NAME$d = "link-require-descriptive-text";
+const RULE_NAME$g = "link-require-descriptive-text";
 const BAD_LINK_TEXTS = /* @__PURE__ */ new Set([
   "click here",
   "click this",
@@ -2191,7 +2334,7 @@ function getVueLinkUrl(node) {
   return null;
 }
 const linkRequireDescriptiveText = createEslintRule({
-  name: RULE_NAME$d,
+  name: RULE_NAME$g,
   meta: {
     type: "suggestion",
     docs: {
@@ -2267,9 +2410,9 @@ const linkRequireDescriptiveText = createEslintRule({
   }
 });
 
-const RULE_NAME$c = "link-require-href";
+const RULE_NAME$f = "link-require-href";
 const linkRequireHref = createEslintRule({
-  name: RULE_NAME$c,
+  name: RULE_NAME$f,
   meta: {
     type: "problem",
     docs: {
@@ -2334,12 +2477,12 @@ const linkRequireHref = createEslintRule({
   }
 });
 
-const RULE_NAME$b = "link-trailing-slash";
+const RULE_NAME$e = "link-trailing-slash";
 function shouldSkipUrl(url) {
   return url.startsWith("#") || url.includes(":") || url === "/" || url === "";
 }
 const linkTrailingSlash = createEslintRule({
-  name: RULE_NAME$b,
+  name: RULE_NAME$e,
   meta: {
     type: "suggestion",
     docs: {
@@ -2454,9 +2597,9 @@ const linkTrailingSlash = createEslintRule({
   }
 });
 
-const RULE_NAME$a = "nuxt-await-navigate-to";
+const RULE_NAME$d = "nuxt-await-navigate-to";
 const nuxtAwaitNavigateTo = createEslintRule({
-  name: RULE_NAME$a,
+  name: RULE_NAME$d,
   meta: {
     type: "problem",
     docs: {
@@ -2505,9 +2648,188 @@ const nuxtAwaitNavigateTo = createEslintRule({
   }
 });
 
-const RULE_NAME$9 = "nuxt-no-redundant-import-meta";
+const CLIENT_LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
+  "onMounted",
+  "onBeforeMount",
+  "onUpdated",
+  "onBeforeUpdate",
+  "onActivated",
+  "onDeactivated"
+]);
+const DEFERRED_CALLBACK_FUNCTIONS = /* @__PURE__ */ new Set([
+  "watch"
+]);
+const SERVER_HANDLER_FUNCTIONS = /* @__PURE__ */ new Set([
+  "defineEventHandler",
+  "defineCachedEventHandler",
+  "defineNitroPlugin",
+  "defineTask"
+]);
+function isNamedFunction(funcNode) {
+  if (funcNode.type === "FunctionDeclaration")
+    return true;
+  const parent = funcNode.parent;
+  if (!parent)
+    return false;
+  if (parent.type === "VariableDeclarator")
+    return true;
+  if (parent.type === "Property") {
+    if (parent.key.type === "Identifier" && parent.key.name === "setup" && parent.parent?.type === "ObjectExpression" && parent.parent.parent?.type === "CallExpression" && parent.parent.parent.callee.type === "Identifier" && parent.parent.parent.callee.name === "defineComponent") {
+      return false;
+    }
+    return true;
+  }
+  if (parent.type === "MethodDefinition")
+    return true;
+  if (parent.type === "AssignmentExpression" && parent.left.type === "Identifier")
+    return true;
+  return false;
+}
+function executedDuringSetup(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression" || current.type === "FunctionDeclaration") {
+      if ((current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") && current.parent?.type === "CallExpression" && current.parent.callee.type === "Identifier") {
+        const calleeName = current.parent.callee.name;
+        if (CLIENT_LIFECYCLE_HOOKS.has(calleeName))
+          return false;
+        if (SERVER_HANDLER_FUNCTIONS.has(calleeName))
+          return false;
+        if (DEFERRED_CALLBACK_FUNCTIONS.has(calleeName)) {
+          const args = current.parent.arguments;
+          const argIndex = args.indexOf(current);
+          if (argIndex > 0)
+            return false;
+        }
+      }
+      if (isNamedFunction(current))
+        return false;
+    }
+    if (current.type === "Program")
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isClientGuardTest(test) {
+  if (test.type === "MemberExpression" && test.object.type === "MetaProperty" && test.property.type === "Identifier" && test.property.name === "client") {
+    return true;
+  }
+  if (test.type === "MemberExpression" && test.object.type === "Identifier" && test.object.name === "process" && test.property.type === "Identifier" && test.property.name === "client") {
+    return true;
+  }
+  if (test.type === "BinaryExpression" && test.left.type === "UnaryExpression" && test.left.operator === "typeof" && test.left.argument.type === "Identifier" && test.left.argument.name === "window") {
+    return true;
+  }
+  return false;
+}
+function isInsideClientGuard(node) {
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "IfStatement" && isClientGuardTest(parent.test))
+      return isDescendantOfConsequent(node, parent);
+    if (parent.type === "ConditionalExpression" && isClientGuardTest(parent.test)) {
+      return isInConsequentBranch(node, parent);
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function isDescendantOfConsequent(node, ifStmt) {
+  let current = node;
+  while (current && current !== ifStmt) {
+    if (current === ifStmt.consequent)
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isInConsequentBranch(node, ternary) {
+  let current = node;
+  while (current && current !== ternary) {
+    if (current === ternary.consequent)
+      return true;
+    if (current === ternary.alternate)
+      return false;
+    current = current.parent;
+  }
+  return false;
+}
+
+const RULE_NAME$c = "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";
+}
+function isCryptoRandomCall(node) {
+  if (node.callee.type !== "MemberExpression" || node.callee.property.type !== "Identifier")
+    return false;
+  const method = node.callee.property.name;
+  if (method !== "randomUUID" && method !== "getRandomValues")
+    return false;
+  const obj = node.callee.object;
+  if (obj.type === "Identifier" && obj.name === "crypto")
+    return true;
+  if (obj.type === "MemberExpression" && obj.object.type === "Identifier" && (obj.object.name === "globalThis" || obj.object.name === "window") && obj.property.type === "Identifier" && obj.property.name === "crypto") {
+    return true;
+  }
+  return false;
+}
+function reportRandom(context, node, template) {
+  if (isMathRandomCall(node)) {
+    context.report({ node, messageId: template ? "noMathRandomTemplate" : "noMathRandom" });
+  } else if (isCryptoRandomCall(node)) {
+    const method = node.callee.property;
+    context.report({
+      node,
+      messageId: template ? "noCryptoRandomTemplate" : "noCryptoRandom",
+      data: { method: `crypto.${method.name}` }
+    });
+  }
+}
+const nuxtNoRandom = createEslintRule({
+  name: RULE_NAME$c,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow Math.random() and crypto random APIs in SSR-rendered code to prevent hydration mismatches"
+    },
+    schema: [],
+    messages: {
+      noMathRandom: "Math.random() produces different values on server and client, causing hydration mismatches. Move to onMounted() or guard with `if (import.meta.client)`.",
+      noCryptoRandom: "{{method}}() produces different values on server and client, causing hydration mismatches. Move to onMounted() or guard with `if (import.meta.client)`.",
+      noMathRandomTemplate: "Math.random() in templates produces different values on server and client, causing hydration mismatches. Move to a computed property backed by onMounted().",
+      noCryptoRandomTemplate: "{{method}}() in templates produces different values on server and client, causing hydration mismatches. Move to a computed property backed by onMounted()."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    function checkScript(node) {
+      if (!isMathRandomCall(node) && !isCryptoRandomCall(node))
+        return;
+      if (!executedDuringSetup(node))
+        return;
+      if (isInsideClientGuard(node))
+        return;
+      reportRandom(context, node, false);
+    }
+    if (isVueParser(context)) {
+      return defineTemplateBodyVisitor(context, {
+        // Template expressions — always execute during render
+        CallExpression(node) {
+          if (isMathRandomCall(node) || isCryptoRandomCall(node))
+            reportRandom(context, node, true);
+        }
+      }, {
+        CallExpression: checkScript
+      });
+    }
+    return { CallExpression: checkScript };
+  }
+});
+
+const RULE_NAME$b = "nuxt-no-redundant-import-meta";
 const nuxtNoRedundantImportMeta = createEslintRule({
-  name: RULE_NAME$9,
+  name: RULE_NAME$b,
   meta: {
     type: "problem",
     docs: {
@@ -2544,7 +2866,7 @@ const nuxtNoRedundantImportMeta = createEslintRule({
   }
 });
 
-const RULE_NAME$8 = "nuxt-no-side-effects-in-async-data-handler";
+const RULE_NAME$a = "nuxt-no-side-effects-in-async-data-handler";
 const SIDE_EFFECT_PATTERNS = /* @__PURE__ */ new Set([
   // Store/State mutations
   "$patch",
@@ -2652,7 +2974,7 @@ function findSideEffectsInFunction(functionNode) {
   return sideEffects;
 }
 const nuxtNoSideEffectsInAsyncDataHandler = createEslintRule({
-  name: RULE_NAME$8,
+  name: RULE_NAME$a,
   meta: {
     type: "problem",
     docs: {
@@ -2743,9 +3065,9 @@ ${indent}${callOnceBlock}`)
   }
 });
 
-const RULE_NAME$7 = "nuxt-no-side-effects-in-setup";
+const RULE_NAME$9 = "nuxt-no-side-effects-in-setup";
 const nuxtNoSideEffectsInSetup = createEslintRule({
-  name: RULE_NAME$7,
+  name: RULE_NAME$9,
   meta: {
     type: "problem",
     docs: {
@@ -2838,9 +3160,82 @@ ${indent}})`;
   }
 });
 
-const RULE_NAME$6 = "nuxt-prefer-navigate-to-over-router-push-replace";
+const RULE_NAME$8 = "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";
+}
+function isDateFunctionCall(node) {
+  return node.callee.type === "Identifier" && node.callee.name === "Date" && node.parent?.type !== "NewExpression";
+}
+function isNewDateCall(node) {
+  return node.callee.type === "Identifier" && node.callee.name === "Date" && node.arguments.length === 0;
+}
+const nuxtNoUnsafeDate = createEslintRule({
+  name: RULE_NAME$8,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow Date.now() and new Date() in SSR-rendered code to prevent hydration mismatches"
+    },
+    schema: [],
+    messages: {
+      noDateNow: "Date.now() returns different timestamps on server and client, causing hydration mismatches. Use the <NuxtTime> component or move to onMounted().",
+      noNewDate: "new Date() returns different timestamps on server and client, causing hydration mismatches. Use the <NuxtTime> component or move to onMounted().",
+      noDateCall: "Date() returns the current time as a string, which differs on server and client. Use the <NuxtTime> component or move to onMounted().",
+      noDateNowTemplate: "Date.now() in templates returns different timestamps on server and client. Use the <NuxtTime> component instead.",
+      noNewDateTemplate: "new Date() in templates returns different timestamps on server and client. Use the <NuxtTime> component instead.",
+      noDateCallTemplate: "Date() in templates returns the current time, which differs on server and client. Use the <NuxtTime> component instead."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    function checkCallScript(node) {
+      const isNow = isDateNowCall(node);
+      const isCall = !isNow && isDateFunctionCall(node);
+      if (!isNow && !isCall)
+        return;
+      if (!executedDuringSetup(node))
+        return;
+      if (isInsideClientGuard(node))
+        return;
+      context.report({ node, messageId: isNow ? "noDateNow" : "noDateCall" });
+    }
+    function checkNewScript(node) {
+      if (!isNewDateCall(node))
+        return;
+      if (!executedDuringSetup(node))
+        return;
+      if (isInsideClientGuard(node))
+        return;
+      context.report({ node, messageId: "noNewDate" });
+    }
+    if (isVueParser(context)) {
+      return defineTemplateBodyVisitor(context, {
+        CallExpression(node) {
+          if (isDateNowCall(node))
+            context.report({ node, messageId: "noDateNowTemplate" });
+          else if (isDateFunctionCall(node))
+            context.report({ node, messageId: "noDateCallTemplate" });
+        },
+        NewExpression(node) {
+          if (isNewDateCall(node))
+            context.report({ node, messageId: "noNewDateTemplate" });
+        }
+      }, {
+        CallExpression: checkCallScript,
+        NewExpression: checkNewScript
+      });
+    }
+    return {
+      CallExpression: checkCallScript,
+      NewExpression: checkNewScript
+    };
+  }
+});
+
+const RULE_NAME$7 = "nuxt-prefer-navigate-to-over-router-push-replace";
 const nuxtPreferNavigateToOverRouterPushReplace = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$7,
   meta: {
     type: "suggestion",
     docs: {
@@ -2903,9 +3298,9 @@ const nuxtPreferNavigateToOverRouterPushReplace = createEslintRule({
   }
 });
 
-const RULE_NAME$5 = "nuxt-prefer-nuxt-link-over-router-link";
+const RULE_NAME$6 = "nuxt-prefer-nuxt-link-over-router-link";
 const nuxtPreferNuxtLinkOverRouterLink = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
     type: "suggestion",
     docs: {
@@ -2976,9 +3371,9 @@ const nuxtPreferNuxtLinkOverRouterLink = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "vue-no-faux-composables";
+const RULE_NAME$5 = "vue-no-faux-composables";
 const vueNoFauxComposables = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -2994,64 +3389,16 @@ const vueNoFauxComposables = createEslintRule({
     const vueImports = /* @__PURE__ */ new Set();
     const nonVueImports = /* @__PURE__ */ new Set();
     const composableFunctions = /* @__PURE__ */ new Map();
-    function isAutoImportedReactivityCall(node) {
-      if (node.callee.type === "Identifier") {
-        const name = node.callee.name;
-        return VUE_REACTIVITY_APIS.has(name) && !nonVueImports.has(name);
-      }
-      return false;
-    }
-    function hasReactivityInStatement(stmt) {
-      if (!stmt)
-        return false;
-      switch (stmt.type) {
-        case "ExpressionStatement":
-          return hasReactivityInExpression(stmt.expression);
-        case "VariableDeclaration":
-          return stmt.declarations.some((decl) => hasReactivityInExpression(decl.init));
-        case "ReturnStatement":
-          return hasReactivityInExpression(stmt.argument);
-        case "BlockStatement":
-          return stmt.body.some((s) => hasReactivityInStatement(s));
-        case "IfStatement":
-          return hasReactivityInStatement(stmt.consequent) || (stmt.alternate ? hasReactivityInStatement(stmt.alternate) : false);
-        case "WhileStatement":
-        case "DoWhileStatement":
-          return hasReactivityInStatement(stmt.body);
-        case "ForStatement":
-        case "ForInStatement":
-        case "ForOfStatement":
-          return hasReactivityInStatement(stmt.body);
-        case "TryStatement":
-          return hasReactivityInStatement(stmt.block) || (stmt.handler ? hasReactivityInStatement(stmt.handler.body) : false) || (stmt.finalizer ? hasReactivityInStatement(stmt.finalizer) : false);
-        case "SwitchStatement":
-          return stmt.cases.some((switchCase) => switchCase.consequent.some((s) => hasReactivityInStatement(s)));
-        default:
-          return false;
-      }
-    }
-    function hasReactivityInExpression(expr) {
-      if (!expr)
-        return false;
-      switch (expr.type) {
-        case "CallExpression":
-          if (isReactivityCall(expr, vueImports) || isAutoImportedReactivityCall(expr) || isComposableCall(expr))
-            return true;
-          return false;
-        case "ObjectExpression":
-          return expr.properties.some((prop) => prop.type === "Property" && hasReactivityInExpression(prop.value));
-        case "ArrayExpression":
-          return expr.elements.some((elem) => hasReactivityInExpression(elem));
-        case "AwaitExpression":
-          return hasReactivityInExpression(expr.argument);
-        default:
-          return false;
-      }
-    }
+    const { hasReactivityInStatement, hasReactivityInExpression } = createReactivityChecker(vueImports, nonVueImports);
     function checkFunctionForReactivity(functionNode, functionName) {
-      if (!functionNode.body || functionNode.body.type !== "BlockStatement")
+      if (!functionNode.body)
         return;
-      const hasReactivity = functionNode.body.body.some((stmt) => hasReactivityInStatement(stmt));
+      let hasReactivity;
+      if (functionNode.body.type === "BlockStatement") {
+        hasReactivity = functionNode.body.body.some((stmt) => hasReactivityInStatement(stmt));
+      } else {
+        hasReactivity = hasReactivityInExpression(functionNode.body);
+      }
       if (!hasReactivity) {
         context.report({
           node: functionNode,
@@ -3068,13 +3415,7 @@ const vueNoFauxComposables = createEslintRule({
       },
       ImportDeclaration(node) {
         trackVueImports(node, vueImports);
-        if (node.source.value !== "vue") {
-          for (const spec of node.specifiers) {
-            if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
-              nonVueImports.add(spec.imported.name);
-            }
-          }
-        }
+        trackNonVueImports(node, nonVueImports);
       },
       "Program:exit": function() {
         for (const [name, functionNode] of composableFunctions)
@@ -3098,9 +3439,9 @@ const vueNoFauxComposables = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "vue-no-nested-reactivity";
+const RULE_NAME$4 = "vue-no-nested-reactivity";
 const vueNoNestedReactivity = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$4,
   meta: {
     type: "problem",
     docs: {
@@ -3345,9 +3686,9 @@ const vueNoNestedReactivity = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "vue-no-passing-refs-as-props";
+const RULE_NAME$3 = "vue-no-passing-refs-as-props";
 const vueNoPassingRefsAsProps = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$3,
   meta: {
     type: "problem",
     docs: {
@@ -3454,9 +3795,9 @@ const vueNoReactiveDestructuring = createEslintRule({
   }
 });
 
-const RULE_NAME$1 = "vue-no-ref-access-in-templates";
+const RULE_NAME$2 = "vue-no-ref-access-in-templates";
 const vueNoRefAccessInTemplates = createEslintRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME$2,
   meta: {
     type: "suggestion",
     docs: {
@@ -3566,9 +3907,9 @@ const vueNoRefAccessInTemplates = createEslintRule({
   }
 });
 
-const RULE_NAME = "vue-no-torefs-on-props";
+const RULE_NAME$1 = "vue-no-torefs-on-props";
 const vueNoTorefsOnProps = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$1,
   meta: {
     type: "suggestion",
     docs: {
@@ -3629,6 +3970,94 @@ const vueNoTorefsOnProps = createEslintRule({
   }
 });
 
+const RULE_NAME = "vue-require-composable-prefix";
+const vueRequireComposablePrefix = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce use* prefix for functions that use Vue reactivity"
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      requirePrefix: 'Function "{{name}}" uses Vue reactivity \u2014 consider renaming to "use{{Name}}"'
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const vueImports = /* @__PURE__ */ new Set();
+    const nonVueImports = /* @__PURE__ */ new Set();
+    const candidateFunctions = /* @__PURE__ */ new Map();
+    const { hasReactivityInStatement, hasReactivityInExpression } = createReactivityChecker(vueImports, nonVueImports);
+    function isExcludedName(name) {
+      return /^define[A-Z]/.test(name) || name === "setup";
+    }
+    function checkFunctionForReactivity(functionNode, idNode, functionName) {
+      if (!functionNode.body)
+        return;
+      let hasReactivity;
+      if (functionNode.body.type === "BlockStatement") {
+        hasReactivity = functionNode.body.body.some((stmt) => hasReactivityInStatement(stmt));
+      } else {
+        hasReactivity = hasReactivityInExpression(functionNode.body);
+      }
+      if (hasReactivity) {
+        const capitalizedName = `${functionName.charAt(0).toUpperCase()}${functionName.slice(1)}`;
+        const suggestedName = `use${capitalizedName}`;
+        context.report({
+          node: idNode,
+          messageId: "requirePrefix",
+          data: { name: functionName, Name: capitalizedName },
+          suggest: [
+            {
+              messageId: "requirePrefix",
+              data: { name: functionName, Name: capitalizedName },
+              fix(fixer) {
+                return fixer.replaceText(idNode, suggestedName);
+              }
+            }
+          ]
+        });
+      }
+    }
+    return {
+      Program() {
+        vueImports.clear();
+        nonVueImports.clear();
+        candidateFunctions.clear();
+      },
+      ImportDeclaration(node) {
+        trackVueImports(node, vueImports);
+        trackNonVueImports(node, nonVueImports);
+      },
+      "Program:exit": function() {
+        for (const [name, { node, idNode }] of candidateFunctions)
+          checkFunctionForReactivity(node, idNode, name);
+      },
+      FunctionDeclaration(node) {
+        if (!node.id || isComposableName(node.id.name) || isExcludedName(node.id.name))
+          return;
+        if (node.parent.type === "Program" || node.parent.type === "ExportNamedDeclaration")
+          candidateFunctions.set(node.id.name, { node, idNode: node.id });
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier" || isComposableName(node.id.name) || isExcludedName(node.id.name)) {
+          return;
+        }
+        if (node.init?.type !== "FunctionExpression" && node.init?.type !== "ArrowFunctionExpression")
+          return;
+        const varDecl = node.parent;
+        if (varDecl?.type !== "VariableDeclaration")
+          return;
+        if (varDecl.parent?.type !== "Program" && varDecl.parent?.type !== "ExportNamedDeclaration")
+          return;
+        candidateFunctions.set(node.id.name, { node: node.init, idNode: node.id });
+      }
+    };
+  }
+});
+
 const plugin = {
   meta: {
     name: "harlanzw",
@@ -3648,9 +4077,11 @@ const plugin = {
     "link-require-href": linkRequireHref,
     "link-trailing-slash": linkTrailingSlash,
     "nuxt-await-navigate-to": nuxtAwaitNavigateTo,
+    "nuxt-no-random": nuxtNoRandom,
     "nuxt-no-redundant-import-meta": nuxtNoRedundantImportMeta,
     "nuxt-no-side-effects-in-async-data-handler": nuxtNoSideEffectsInAsyncDataHandler,
     "nuxt-no-side-effects-in-setup": nuxtNoSideEffectsInSetup,
+    "nuxt-no-unsafe-date": nuxtNoUnsafeDate,
     "nuxt-prefer-navigate-to-over-router-push-replace": nuxtPreferNavigateToOverRouterPushReplace,
     "nuxt-prefer-nuxt-link-over-router-link": nuxtPreferNuxtLinkOverRouterLink,
     "prompt-ambiguous-quantifier": promptAmbiguousQuantifier,
@@ -3679,7 +4110,8 @@ const plugin = {
     "vue-no-passing-refs-as-props": vueNoPassingRefsAsProps,
     "vue-no-reactive-destructuring": vueNoReactiveDestructuring,
     "vue-no-ref-access-in-templates": vueNoRefAccessInTemplates,
-    "vue-no-torefs-on-props": vueNoTorefsOnProps
+    "vue-no-torefs-on-props": vueNoTorefsOnProps,
+    "vue-require-composable-prefix": vueRequireComposablePrefix
   },
   configs: {}
 };
@@ -3776,9 +4208,11 @@ plugin.configs.nuxt = [
     plugins: { harlanzw: plugin },
     rules: {
       "harlanzw/nuxt-await-navigate-to": "error",
+      "harlanzw/nuxt-no-random": "error",
       "harlanzw/nuxt-no-redundant-import-meta": "error",
       "harlanzw/nuxt-no-side-effects-in-async-data-handler": "error",
       "harlanzw/nuxt-no-side-effects-in-setup": "error",
+      "harlanzw/nuxt-no-unsafe-date": "warn",
       "harlanzw/nuxt-prefer-navigate-to-over-router-push-replace": "warn",
       "harlanzw/nuxt-prefer-nuxt-link-over-router-link": "warn"
     }
@@ -3795,7 +4229,8 @@ plugin.configs.vue = [
       "harlanzw/vue-no-passing-refs-as-props": "error",
       "harlanzw/vue-no-reactive-destructuring": "error",
       "harlanzw/vue-no-ref-access-in-templates": "warn",
-      "harlanzw/vue-no-torefs-on-props": "warn"
+      "harlanzw/vue-no-torefs-on-props": "warn",
+      "harlanzw/vue-require-composable-prefix": "warn"
     }
   }
 ];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-harlanzw",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Harlan's opinionated ESLint rules",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",