eslint-plugin-harlanzw 0.0.1

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# eslint-plugin-harlanzw
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+
+Harlan's ESLint rules for Vue projects.
+
+<p align="center">
+<table>
+<tbody>
+<td align="center">
+<sub>Made possible by my <a href="https://github.com/sponsors/harlan-zw">Sponsor Program 💖</a><br> Follow me <a href="https://twitter.com/harlan_zw">@harlan_zw</a> 🐦</sub><br>
+</td>
+</tbody>
+</table>
+</p>
+
+## Rules
+
+> **Note:** These rules are experimental and may change. They will be submitted to the official Vue ESLint plugin for consideration.
+
+<!-- rules:start -->
+- [`vue-no-faux-composables`](./src/rules/vue-no-faux-composables.md) - stop fake composables that don't use Vue reactivity
+- [`vue-no-nested-reactivity`](./src/rules/vue-no-nested-reactivity.md) - don't mix `ref()` and `reactive()` together
+- [`vue-no-passing-refs-as-props`](./src/rules/vue-no-passing-refs-as-props.md) - don't pass refs as props - unwrap them first
+- [`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
+<!-- rules:end -->
+
+## Installation
+
+Install the plugin:
+
+```bash
+pnpm add -D eslint-plugin-harlanzw
+```
+
+## Usage
+
+### With @antfu/eslint-config
+
+```js
+// eslint.config.js
+import antfu from '@antfu/eslint-config'
+import harlanzw from 'eslint-plugin-harlanzw'
+
+export default antfu(
+  {
+    vue: true,
+  },
+  {
+    plugins: {
+      harlanzw
+    },
+    rules: {
+      'harlanzw/vue-no-faux-composables': 'error',
+      'harlanzw/vue-no-nested-reactivity': 'error',
+      'harlanzw/vue-no-passing-refs-as-props': 'error',
+      'harlanzw/vue-no-ref-access-in-templates': 'error',
+      'harlanzw/vue-no-torefs-on-props': 'error'
+    }
+  }
+)
+```
+
+### Standalone Usage
+
+Add the plugin to your ESLint configuration:
+
+```js
+// eslint.config.js
+import harlanzw from 'eslint-plugin-harlanzw'
+
+export default [
+  {
+    plugins: {
+      harlanzw
+    },
+    rules: {
+      'harlanzw/vue-no-faux-composables': 'error',
+      'harlanzw/vue-no-nested-reactivity': 'error',
+      'harlanzw/vue-no-passing-refs-as-props': 'error',
+      'harlanzw/vue-no-ref-access-in-templates': 'error',
+      'harlanzw/vue-no-torefs-on-props': 'error'
+    }
+  }
+]
+```
+
+
+## Sponsors
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg">
+    <img src='https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg'/>
+  </a>
+</p>
+
+## Credits
+
+This plugin is based on [eslint-plugin-antfu](https://github.com/antfu/eslint-plugin-antfu) by Anthony Fu.
+
+## License
+
+Licensed under the [MIT license](https://github.com/harlan-zw/eslint-plugin-harlanzw/blob/main/LICENSE).
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-harlanzw?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/eslint-plugin-harlanzw
+[npm-downloads-src]: https://img.shields.io/npm/dm/eslint-plugin-harlanzw?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/eslint-plugin-harlanzw
+
+[license-src]: https://img.shields.io/github/license/harlan-zw/eslint-plugin-harlanzw.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/harlan-zw/eslint-plugin-harlanzw/blob/main/LICENSE

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { Rule, Linter } from 'eslint';
+
+type RuleModule<T extends readonly unknown[]> = Rule.RuleModule & {
+    defaultOptions: T;
+};
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'vue-no-faux-composables': RuleModule<[]>;
+        'vue-no-nested-reactivity': RuleModule<[]>;
+        'vue-no-passing-refs-as-props': RuleModule<[]>;
+        'vue-no-ref-access-in-templates': RuleModule<[]>;
+        'vue-no-torefs-on-props': RuleModule<[]>;
+    };
+};
+
+type RuleDefinitions = typeof plugin['rules'];
+type RuleOptions = {
+    [K in keyof RuleDefinitions]: RuleDefinitions[K]['defaultOptions'];
+};
+type Rules = {
+    [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>;
+};
+
+export { plugin as default };
+export type { RuleOptions, Rules };

package/dist/index.mjs

@@ -0,0 +1,686 @@
+const version = "0.0.0";
+
+const hasDocs = [
+  "use-composables-must-use-reactivity",
+  "vue-no-nested-reactivity",
+  "vue-no-passing-refs-as-props",
+  "vue-no-ref-access-in-templates",
+  "vue-no-torefs-on-props"
+];
+const blobUrl = "https://github.com/harlan-zw/eslint-plugin-harlanzw/blob/main/src/rules/";
+function RuleCreator(urlCreator) {
+  return function createNamedRule({
+    name,
+    meta,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name)
+        }
+      },
+      ...rule
+    });
+  };
+}
+function createRule({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: ((context) => {
+      const optionsWithDefault = context.options.map((options, index) => {
+        return {
+          ...defaultOptions[index] || {},
+          ...options || {}
+        };
+      });
+      return create(context, optionsWithDefault);
+    }),
+    defaultOptions,
+    meta
+  };
+}
+const createEslintRule = RuleCreator(
+  (ruleName) => hasDocs.includes(ruleName) ? `${blobUrl}${ruleName}.md` : `${blobUrl}${ruleName}.test.ts`
+);
+
+const VUE_REACTIVITY_APIS = /* @__PURE__ */ new Set([
+  // Core reactivity
+  "ref",
+  "reactive",
+  "computed",
+  "watch",
+  "watchEffect",
+  "readonly",
+  "watchPostEffect",
+  "watchSyncEffect",
+  "onWatcherCleanup",
+  // Shallow variants
+  "shallowRef",
+  "shallowReactive",
+  "shallowReadonly",
+  // Utilities
+  "toRef",
+  "toRefs",
+  "unref",
+  "toRaw",
+  "markRaw",
+  // Type checking
+  "isRef",
+  "isReactive",
+  "isReadonly",
+  // Advanced
+  "customRef",
+  "triggerRef",
+  "effectScope",
+  "getCurrentScope",
+  "onScopeDispose"
+]);
+function isRefCall(node) {
+  return node.callee.type === "Identifier" && node.callee.name === "ref";
+}
+function isInVueTemplateString(node) {
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "TemplateLiteral") {
+      const grandparent = parent.parent;
+      if (grandparent?.type === "TaggedTemplateExpression") {
+        const tag = grandparent.tag;
+        if (tag.type === "Identifier" && tag.name === "html") {
+          return true;
+        }
+      }
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function getParserServices(context) {
+  const legacy = context.sourceCode;
+  return legacy?.parserServices || context.parserServices;
+}
+function isVueParser(context) {
+  const parserServices = getParserServices(context);
+  return !!parserServices?.defineTemplateBodyVisitor;
+}
+function defineTemplateBodyVisitor(context, templateVisitor, scriptVisitor) {
+  const parserServices = getParserServices(context);
+  if (!parserServices?.defineTemplateBodyVisitor) {
+    return {};
+  }
+  return parserServices.defineTemplateBodyVisitor(
+    templateVisitor,
+    scriptVisitor
+  );
+}
+function isReactivityCall(node, vueImports) {
+  if (node.callee.type === "Identifier") {
+    return VUE_REACTIVITY_APIS.has(node.callee.name) && vueImports.has(node.callee.name);
+  }
+  return false;
+}
+function isComposableCall(node) {
+  if (node.callee.type === "Identifier") {
+    return /^use[A-Z_]/.test(node.callee.name);
+  }
+  return false;
+}
+function isComposableName(name) {
+  return /^use[A-Z_]/.test(name);
+}
+
+const RULE_NAME$4 = "vue-no-faux-composables";
+const vueNoFauxComposables = createEslintRule({
+  name: RULE_NAME$4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce that composables must use Vue reactivity APIs"
+    },
+    schema: [],
+    messages: {
+      mustUseReactivity: "Functions starting with use must implement reactivity APIs (use*, ref, reactive, computed, watch, etc.)"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const vueImports = /* @__PURE__ */ new Set();
+    const composableFunctions = /* @__PURE__ */ new Map();
+    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) || 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));
+        default:
+          return false;
+      }
+    }
+    function checkFunctionForReactivity(functionNode, functionName) {
+      if (!functionNode.body || functionNode.body.type !== "BlockStatement")
+        return;
+      const hasReactivity = functionNode.body.body.some((stmt) => hasReactivityInStatement(stmt));
+      if (!hasReactivity) {
+        context.report({
+          node: functionNode,
+          messageId: "mustUseReactivity",
+          data: { name: functionName }
+        });
+      }
+    }
+    return {
+      Program() {
+        vueImports.clear();
+        composableFunctions.clear();
+      },
+      ImportDeclaration(node) {
+        if (node.source.value === "vue") {
+          node.specifiers.forEach((spec) => {
+            if (spec.type === "ImportSpecifier") {
+              const imported = spec.imported;
+              if (imported.type === "Identifier") {
+                vueImports.add(imported.name);
+              }
+            }
+          });
+        }
+      },
+      "Program:exit": function() {
+        for (const [name, functionNode] of composableFunctions)
+          checkFunctionForReactivity(functionNode, name);
+      },
+      FunctionDeclaration(node) {
+        if (node.id && isComposableName(node.id.name))
+          composableFunctions.set(node.id.name, node);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && isComposableName(node.id.name) && (node.init?.type === "FunctionExpression" || node.init?.type === "ArrowFunctionExpression")) {
+          composableFunctions.set(node.id.name, node.init);
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === "FunctionDeclaration" && node.declaration.id && isComposableName(node.declaration.id.name)) {
+          composableFunctions.set(node.declaration.id.name, node.declaration);
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$3 = "vue-no-nested-reactivity";
+const vueNoNestedReactivity = createEslintRule({
+  name: RULE_NAME$3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow nested reactivity patterns like reactive({ foo: ref() }) or ref({ foo: reactive() })"
+    },
+    fixable: void 0,
+    schema: [],
+    messages: {
+      noNestedInRef: "Avoid nesting reactivity primitives inside ref().",
+      noNestedInReactive: "Avoid nesting reactivity primitives inside reactive().",
+      noNestedInShallowRef: "Avoid nesting reactivity primitives inside shallowRef().",
+      noNestedInShallowReactive: "Avoid nesting reactivity primitives inside shallowReactive().",
+      noNestedInComputed: "Avoid nesting reactivity primitives inside computed().",
+      noNestedInWatch: "Avoid nesting reactivity primitives inside watch().",
+      noNestedInWatchEffect: "Avoid nesting reactivity primitives inside watchEffect()."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const reactiveAPIs = /* @__PURE__ */ new Set(["ref", "reactive", "shallowRef", "shallowReactive", "computed", "watch", "watchEffect"]);
+    const vueImports = /* @__PURE__ */ new Set();
+    const reactiveVariables = /* @__PURE__ */ new Map();
+    function getMessageId(outerType) {
+      switch (outerType) {
+        case "ref":
+          return "noNestedInRef";
+        case "reactive":
+          return "noNestedInReactive";
+        case "shallowRef":
+          return "noNestedInShallowRef";
+        case "shallowReactive":
+          return "noNestedInShallowReactive";
+        case "computed":
+          return "noNestedInComputed";
+        case "watch":
+          return "noNestedInWatch";
+        case "watchEffect":
+          return "noNestedInWatchEffect";
+        default:
+          return "noNestedInReactive";
+      }
+    }
+    function isReactiveCall(node) {
+      if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+        const name = node.callee.name;
+        if (reactiveAPIs.has(name) && vueImports.has(name)) {
+          return name;
+        }
+      }
+      return null;
+    }
+    function checkObjectExpressionForReactivity(obj, outerType) {
+      for (const prop of obj.properties) {
+        if (prop.type === "Property") {
+          if (prop.value.type === "CallExpression") {
+            const innerType = isReactiveCall(prop.value);
+            if (innerType && innerType !== outerType) {
+              context.report({
+                node: prop.value,
+                messageId: getMessageId(outerType)
+              });
+            }
+          } else if (prop.value.type === "ObjectExpression") {
+            checkObjectExpressionForReactivity(prop.value, outerType);
+          } else if (prop.value.type === "Identifier") {
+            const varType = reactiveVariables.get(prop.value.name);
+            if (varType && varType !== outerType) {
+              context.report({
+                node: prop.value,
+                messageId: getMessageId(outerType)
+              });
+            }
+          } else if (prop.shorthand && prop.key.type === "Identifier") {
+            const varType = reactiveVariables.get(prop.key.name);
+            if (varType && varType !== outerType) {
+              context.report({
+                node: prop.key,
+                messageId: getMessageId(outerType)
+              });
+            }
+          }
+        }
+      }
+    }
+    function checkComputedCallback(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "computed" && vueImports.has("computed")) {
+        if (node.arguments.length > 0) {
+          const callback = node.arguments[0];
+          if (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") {
+            if (callback.body.type === "BlockStatement") {
+              for (const stmt of callback.body.body) {
+                if (stmt.type === "ReturnStatement" && stmt.argument) {
+                  checkReturnForReactivity(stmt.argument);
+                }
+              }
+            } else {
+              checkReturnForReactivity(callback.body);
+            }
+          }
+        }
+      }
+    }
+    function checkReturnForReactivity(node) {
+      if (node.type === "CallExpression") {
+        const reactiveType = isReactiveCall(node);
+        if (reactiveType) {
+          context.report({
+            node,
+            messageId: "noNestedInComputed"
+          });
+        }
+      } else if (node.type === "Identifier") {
+        const varType = reactiveVariables.get(node.name);
+        if (varType) {
+          context.report({
+            node,
+            messageId: "noNestedInComputed"
+          });
+        }
+      } else if (node.type === "ObjectExpression") {
+        for (const prop of node.properties) {
+          if (prop.type === "Property") {
+            if (prop.value.type === "CallExpression") {
+              const reactiveType = isReactiveCall(prop.value);
+              if (reactiveType) {
+                context.report({
+                  node: prop.value,
+                  messageId: "noNestedInComputed"
+                });
+              }
+            } else if (prop.value.type === "Identifier") {
+              const varType = reactiveVariables.get(prop.value.name);
+              if (varType) {
+                context.report({
+                  node: prop.value,
+                  messageId: "noNestedInComputed"
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    function checkForNestedReactivity(node, outerType) {
+      if (!node.arguments.length)
+        return;
+      const arg = node.arguments[0];
+      if (arg.type === "ObjectExpression") {
+        checkObjectExpressionForReactivity(arg, outerType);
+      } else if (arg.type === "Identifier") {
+        const varType = reactiveVariables.get(arg.name);
+        if (varType && varType !== outerType) {
+          context.report({
+            node: arg,
+            messageId: getMessageId(outerType)
+          });
+        }
+      }
+    }
+    return {
+      Program() {
+        vueImports.clear();
+        reactiveVariables.clear();
+      },
+      ImportDeclaration(node) {
+        if (node.source.value === "vue") {
+          node.specifiers.forEach((spec) => {
+            if (spec.type === "ImportSpecifier") {
+              const imported = spec.imported;
+              if (imported.type === "Identifier") {
+                vueImports.add(imported.name);
+              }
+            }
+          });
+        }
+      },
+      CallExpression(node) {
+        const reactiveType = isReactiveCall(node);
+        if (reactiveType) {
+          checkForNestedReactivity(node, reactiveType);
+        }
+        checkComputedCallback(node);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && node.init?.type === "CallExpression") {
+          const reactiveType = isReactiveCall(node.init);
+          if (reactiveType) {
+            reactiveVariables.set(node.id.name, reactiveType);
+          }
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$2 = "vue-no-passing-refs-as-props";
+const vueNoPassingRefsAsProps = createEslintRule({
+  name: RULE_NAME$2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow passing refs as props to Vue components"
+    },
+    schema: [],
+    messages: {
+      noPassingRefsAsProps: "Avoid passing refs as props. Pass the unwrapped value using ref.value or use reactive() instead."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const refProperties = /* @__PURE__ */ new Map();
+    function isRefProperty(objectName, propertyName) {
+      const properties = refProperties.get(objectName);
+      return properties?.has(propertyName) ?? false;
+    }
+    return {
+      Program() {
+        refProperties.clear();
+      },
+      // Track object properties assigned from ref() calls
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && node.init?.type === "ObjectExpression") {
+          const objectName = node.id.name;
+          const objectProperties = /* @__PURE__ */ new Set();
+          for (const property of node.init.properties) {
+            if (property.type === "Property" && property.key.type === "Identifier" && property.value.type === "CallExpression" && isRefCall(property.value)) {
+              objectProperties.add(property.key.name);
+            }
+          }
+          if (objectProperties.size > 0) {
+            refProperties.set(objectName, objectProperties);
+          }
+        }
+      },
+      // Check for ref property access in template expressions
+      MemberExpression(node) {
+        if (isInVueTemplateString(node) && node.object.type === "Identifier" && node.property.type === "Identifier" && isRefProperty(node.object.name, node.property.name)) {
+          const parent = node.parent;
+          if (parent?.type === "MemberExpression" && parent.property.type === "Identifier" && parent.property.name === "value") {
+            return;
+          }
+          context.report({
+            node,
+            messageId: "noPassingRefsAsProps"
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$1 = "vue-no-ref-access-in-templates";
+const vueNoRefAccessInTemplates = createEslintRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow accessing ref.value in Vue templates"
+    },
+    fixable: void 0,
+    schema: [],
+    messages: {
+      noRefAccessInTemplate: "Avoid unpacking refs in templates for cleaner separation of reactivity."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const refVariables = /* @__PURE__ */ new Set();
+    const objectRefs = /* @__PURE__ */ new Map();
+    function isRefAccess(node) {
+      if (node.object.type === "Identifier" && refVariables.has(node.object.name) && node.property.type === "Identifier" && node.property.name === "value") {
+        return true;
+      }
+      if (node.object.type === "MemberExpression" && node.object.object.type === "Identifier" && node.object.property.type === "Identifier" && node.property.type === "Identifier" && node.property.name === "value") {
+        const objectName = node.object.object.name;
+        const propertyName = node.object.property.name;
+        const objectRefProperties = objectRefs.get(objectName);
+        return objectRefProperties?.has(propertyName) || false;
+      }
+      return false;
+    }
+    if (isVueParser(context)) {
+      const scriptVisitor = {
+        Program() {
+          refVariables.clear();
+          objectRefs.clear();
+        },
+        VariableDeclarator(node) {
+          if (node.init?.type === "CallExpression" && isRefCall(node.init)) {
+            if (node.id.type === "Identifier") {
+              refVariables.add(node.id.name);
+            }
+          }
+          if (node.init?.type === "ObjectExpression" && node.id.type === "Identifier") {
+            const objectName = node.id.name;
+            const refProperties = /* @__PURE__ */ new Set();
+            for (const property of node.init.properties) {
+              if (property.type === "Property" && property.key.type === "Identifier" && property.value.type === "CallExpression" && isRefCall(property.value)) {
+                refProperties.add(property.key.name);
+              }
+            }
+            if (refProperties.size > 0) {
+              objectRefs.set(objectName, refProperties);
+            }
+          }
+        },
+        MemberExpression(node) {
+          if (isInVueTemplateString(node) && isRefAccess(node)) {
+            context.report({
+              node,
+              messageId: "noRefAccessInTemplate"
+            });
+          }
+        }
+      };
+      const templateVisitor = {
+        MemberExpression(node) {
+          if (isRefAccess(node)) {
+            context.report({
+              node,
+              messageId: "noRefAccessInTemplate"
+            });
+          }
+        }
+      };
+      return defineTemplateBodyVisitor(context, templateVisitor, scriptVisitor);
+    }
+    return {
+      Program() {
+        refVariables.clear();
+        objectRefs.clear();
+      },
+      VariableDeclarator(node) {
+        if (node.init?.type === "CallExpression" && isRefCall(node.init)) {
+          if (node.id.type === "Identifier") {
+            refVariables.add(node.id.name);
+          }
+        }
+        if (node.init?.type === "ObjectExpression" && node.id.type === "Identifier") {
+          const objectName = node.id.name;
+          const refProperties = /* @__PURE__ */ new Set();
+          for (const property of node.init.properties) {
+            if (property.type === "Property" && property.key.type === "Identifier" && property.value.type === "CallExpression" && isRefCall(property.value)) {
+              refProperties.add(property.key.name);
+            }
+          }
+          if (refProperties.size > 0) {
+            objectRefs.set(objectName, refProperties);
+          }
+        }
+      },
+      MemberExpression(node) {
+        if (isInVueTemplateString(node) && isRefAccess(node)) {
+          context.report({
+            node,
+            messageId: "noRefAccessInTemplate"
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME = "vue-no-torefs-on-props";
+const vueNoTorefsOnProps = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow using toRefs on props object in Vue"
+    },
+    schema: [],
+    messages: {
+      noToRefsOnProps: "Using toRefs() on all props can be an antipattern as props are already reactive. Destruct props directory and wrap as refs individually if needed."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const propsVariables = /* @__PURE__ */ new Set();
+    function isPropsRelated(node) {
+      return propsVariables.has(node.name);
+    }
+    function checkToRefsCall(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "toRefs") {
+        if (node.arguments.length > 0) {
+          const firstArg = node.arguments[0];
+          if (firstArg.type === "Identifier" && isPropsRelated(firstArg)) {
+            context.report({
+              node,
+              messageId: "noToRefsOnProps"
+            });
+          }
+        }
+      }
+    }
+    return {
+      Program() {
+        propsVariables.clear();
+      },
+      // Track variables assigned from defineProps()
+      VariableDeclarator(node) {
+        if (node.init?.type === "CallExpression") {
+          const callExpr = node.init;
+          if (callExpr.callee.type === "Identifier" && callExpr.callee.name === "defineProps") {
+            if (node.id.type === "Identifier") {
+              propsVariables.add(node.id.name);
+            }
+          }
+        }
+      },
+      // Check for toRefs calls
+      CallExpression(node) {
+        checkToRefsCall(node);
+      }
+    };
+  }
+});
+
+const plugin = {
+  meta: {
+    name: "harlanzw",
+    version
+  },
+  // @keep-sorted
+  rules: {
+    "vue-no-faux-composables": vueNoFauxComposables,
+    "vue-no-nested-reactivity": vueNoNestedReactivity,
+    "vue-no-passing-refs-as-props": vueNoPassingRefsAsProps,
+    "vue-no-ref-access-in-templates": vueNoRefAccessInTemplates,
+    "vue-no-torefs-on-props": vueNoTorefsOnProps
+  }
+};
+
+export { plugin as default };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "eslint-plugin-harlanzw",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Harlan's opinionated ESLint rules",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://github.com/harlan-zw/eslint-plugin-harlanzw#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harlan-zw/eslint-plugin-harlanzw.git"
+  },
+  "bugs": "https://github.com/harlan-zw/eslint-plugin-harlanzw/issues",
+  "keywords": [
+    "eslint-plugin"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "eslint": "*"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^5.2.1",
+    "@antfu/ni": "^25.0.0",
+    "@antfu/utils": "^9.2.0",
+    "@types/eslint": "^9.6.1",
+    "@types/node": "^24.3.0",
+    "@typescript-eslint/typescript-estree": "^8.39.1",
+    "@typescript-eslint/utils": "^8.39.1",
+    "bumpp": "^10.2.3",
+    "eslint": "^9.33.0",
+    "eslint-vitest-rule-tester": "^2.2.1",
+    "jsonc-eslint-parser": "^2.4.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.4",
+    "typescript": "^5.9.2",
+    "unbuild": "^3.6.1",
+    "vite": "^7.1.2",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.18"
+  },
+  "resolutions": {
+    "eslint-plugin-harlanzw": "workspace:*"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "lint": "pnpm run dev && eslint . --fix",
+    "release": "pnpm build && bumpp && pnpm -r publish",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}