uilint-eslint 0.2.103 → 0.2.104

package/dist/index.d.ts

@@ -815,6 +815,11 @@ declare const rules: {
     }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
+    "prefer-store-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"useMemoWithStoreData" | "chainedDerivedState", [{
+        storeHookPattern?: string;
+    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
 };
 /**
  * Plugin metadata
@@ -968,6 +973,11 @@ declare const plugin: {
         }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
+        "prefer-store-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"useMemoWithStoreData" | "chainedDerivedState", [{
+            storeHookPattern?: string;
+        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
     };
 };
 /**

package/dist/index.js

@@ -3,8 +3,8 @@ import { ESLintUtils } from "@typescript-eslint/utils";
 var createRule = ESLintUtils.RuleCreator(
   (name) => `https://github.com/peter-suggate/uilint/blob/main/packages/uilint-eslint/docs/rules/${name}.md`
 );
-function defineRuleMeta(meta18) {
-  return meta18;
+function defineRuleMeta(meta19) {
+  return meta19;
 }
 
 // src/rules/consistent-dark-mode.ts
@@ -3658,7 +3658,7 @@ var no_secrets_in_code_default = createRule({
         }
       }
     }
-    function getVariableName(node) {
+    function getVariableName2(node) {
       if (node.parent?.type === "VariableDeclarator") {
         const declarator = node.parent;
         if (declarator.id.type === "Identifier") {
@@ -3677,7 +3677,7 @@ var no_secrets_in_code_default = createRule({
       // Check string literals
       Literal(node) {
         if (typeof node.value === "string") {
-          const variableName = getVariableName(node);
+          const variableName = getVariableName2(node);
           checkStringForSecrets(node.value, node, variableName);
         }
       },
@@ -3685,7 +3685,7 @@ var no_secrets_in_code_default = createRule({
       TemplateLiteral(node) {
         if (node.expressions.length === 0 && node.quasis.length === 1) {
           const value = node.quasis[0].value.raw;
-          const variableName = getVariableName(node);
+          const variableName = getVariableName2(node);
           checkStringForSecrets(value, node, variableName);
         }
       }
@@ -4197,8 +4197,8 @@ function loadIndex(projectRoot, indexPath) {
     log(`Loaded metadata.json: ${Object.keys(entries).length} entries`);
     const metadataStore = /* @__PURE__ */ new Map();
     const fileToChunks = /* @__PURE__ */ new Map();
-    for (const [id, meta18] of Object.entries(entries)) {
-      const m = meta18;
+    for (const [id, meta19] of Object.entries(entries)) {
+      const m = meta19;
       metadataStore.set(id, {
         filePath: m.filePath,
         startLine: m.startLine,
@@ -4302,9 +4302,9 @@ function findSimilarChunks(index, chunkId, threshold) {
   const sortedAll = allScores.sort((a, b) => b.score - a.score).slice(0, 10);
   log(`  Top 10 similarity scores (threshold=${threshold}):`);
   for (const { id, score } of sortedAll) {
-    const meta18 = index.metadataStore.get(id);
+    const meta19 = index.metadataStore.get(id);
     const meetsThreshold = score >= threshold ? "\u2713" : "\u2717";
-    log(`    ${meetsThreshold} ${(score * 100).toFixed(1)}% - ${id} (${meta18?.name || "anonymous"} in ${meta18?.filePath})`);
+    log(`    ${meetsThreshold} ${(score * 100).toFixed(1)}% - ${id} (${meta19?.name || "anonymous"} in ${meta19?.filePath})`);
   }
   log(`  Found ${results.length} chunks above threshold`);
   return results.sort((a, b) => b.score - a.score);
@@ -4395,20 +4395,20 @@ var no_semantic_duplicates_default = createRule({
           log(`  Chunk ${chunkId} already reported, skipping`);
           continue;
         }
-        const meta18 = index.metadataStore.get(chunkId);
-        if (!meta18) {
+        const meta19 = index.metadataStore.get(chunkId);
+        if (!meta19) {
           log(`  No metadata for chunk ${chunkId}`);
           continue;
         }
-        log(`  Checking chunk ${chunkId}: lines ${meta18.startLine}-${meta18.endLine} (node at line ${nodeLine})`);
-        if (nodeLine >= meta18.startLine && nodeLine <= meta18.endLine) {
+        log(`  Checking chunk ${chunkId}: lines ${meta19.startLine}-${meta19.endLine} (node at line ${nodeLine})`);
+        if (nodeLine >= meta19.startLine && nodeLine <= meta19.endLine) {
           log(`  Node is within chunk range, searching for similar chunks...`);
           const similar = findSimilarChunks(index, chunkId, threshold);
           if (similar.length > 0) {
             const best = similar[0];
             const bestMeta = index.metadataStore.get(best.id);
             if (bestMeta) {
-              const chunkLines = meta18.endLine - meta18.startLine + 1;
+              const chunkLines = meta19.endLine - meta19.startLine + 1;
               if (chunkLines < minLines) {
                 log(`  Skipping: chunk has ${chunkLines} lines, below minLines=${minLines}`);
                 continue;
@@ -4418,8 +4418,8 @@ var no_semantic_duplicates_default = createRule({
               const similarity = Math.round(best.score * 100);
               const sourceCode = extractCodeFromFile(
                 filename,
-                meta18.startLine,
-                meta18.endLine
+                meta19.startLine,
+                meta19.endLine
               );
               const targetAbsolutePath = join6(projectRoot, bestMeta.filePath);
               const targetCode = extractCodeFromFile(
@@ -4427,17 +4427,17 @@ var no_semantic_duplicates_default = createRule({
                 bestMeta.startLine,
                 bestMeta.endLine
               );
-              log(`  REPORTING: ${meta18.kind} '${name || meta18.name}' is ${similarity}% similar to '${bestMeta.name}' at ${relPath}:${bestMeta.startLine}`);
+              log(`  REPORTING: ${meta19.kind} '${name || meta19.name}' is ${similarity}% similar to '${bestMeta.name}' at ${relPath}:${bestMeta.startLine}`);
               context.report({
                 node,
                 loc: {
-                  start: { line: meta18.startLine, column: meta18.startColumn },
-                  end: { line: meta18.endLine, column: meta18.endColumn }
+                  start: { line: meta19.startLine, column: meta19.startColumn },
+                  end: { line: meta19.endLine, column: meta19.endColumn }
                 },
                 messageId: "semanticDuplicate",
                 data: {
-                  kind: meta18.kind,
-                  name: name || meta18.name || "(anonymous)",
+                  kind: meta19.kind,
+                  name: name || meta19.name || "(anonymous)",
                   similarity: String(similarity),
                   otherName: bestMeta.name || "(anonymous)",
                   otherLocation: `${relPath}:${bestMeta.startLine}`,
@@ -4446,10 +4446,10 @@ var no_semantic_duplicates_default = createRule({
                   targetCode: targetCode || "",
                   sourceLocation: JSON.stringify({
                     filePath: relativeFilename,
-                    startLine: meta18.startLine,
-                    endLine: meta18.endLine,
-                    startColumn: meta18.startColumn,
-                    endColumn: meta18.endColumn
+                    startLine: meta19.startLine,
+                    endLine: meta19.endLine,
+                    startColumn: meta19.startColumn,
+                    endColumn: meta19.endColumn
                   }),
                   targetLocation: JSON.stringify({
                     filePath: bestMeta.filePath,
@@ -4459,7 +4459,7 @@ var no_semantic_duplicates_default = createRule({
                     startColumn: bestMeta.startColumn,
                     endColumn: bestMeta.endColumn
                   }),
-                  sourceName: name || meta18.name || "(anonymous)",
+                  sourceName: name || meta19.name || "(anonymous)",
                   targetName: bestMeta.name || "(anonymous)",
                   similarityScore: String(best.score)
                 }
@@ -4469,7 +4469,7 @@ var no_semantic_duplicates_default = createRule({
             log(`  No similar chunks found above threshold`);
           }
         } else {
-          log(`  Node line ${nodeLine} not in chunk range ${meta18.startLine}-${meta18.endLine}`);
+          log(`  Node line ${nodeLine} not in chunk range ${meta19.startLine}-${meta19.endLine}`);
         }
       }
     }
@@ -7038,7 +7038,14 @@ function getTypeName(typeAnnotation) {
   }
 }
 function getQualifiedName(node) {
-  const left = node.left.type === "Identifier" ? node.left.name : getQualifiedName(node.left);
+  let left;
+  if (node.left.type === "Identifier") {
+    left = node.left.name;
+  } else if (node.left.type === "TSQualifiedName") {
+    left = getQualifiedName(node.left);
+  } else {
+    left = "this";
+  }
   return `${left}.${node.right.name}`;
 }
 function isAllowedType(typeAnnotation, allowedTypes) {
@@ -7203,6 +7210,430 @@ var no_unsafe_type_casts_default = createRule({
   }
 });
 
+// src/rules/prefer-store-selectors.ts
+var meta17 = defineRuleMeta({
+  id: "prefer-store-selectors",
+  version: "1.0.0",
+  name: "Prefer Store Selectors",
+  description: "Derived state from store should use selectors, not useMemo",
+  defaultSeverity: "warn",
+  category: "static",
+  icon: "\u{1F3EA}",
+  hint: "Move derived state to store selectors",
+  defaultEnabled: true,
+  defaultOptions: [{ storeHookPattern: "^use.*Store$" }],
+  optionSchema: {
+    fields: [
+      {
+        key: "storeHookPattern",
+        label: "Store hook pattern",
+        type: "text",
+        defaultValue: "^use.*Store$",
+        description: "Regex pattern for identifying Zustand store hooks"
+      }
+    ]
+  },
+  docs: `
+## What it does
+
+Detects when derived state computed from Zustand store data using \`useMemo\`
+should instead be moved to a store selector for better performance and cleaner code.
+
+## Why it's useful
+
+- **Performance**: Selectors are memoized at the store level, avoiding recomputation
+- **Reusability**: Selectors can be shared across components
+- **Testability**: Selectors are pure functions that are easy to unit test
+- **Separation of concerns**: Keeps data transformation logic out of components
+
+## Examples
+
+### \u274C Incorrect
+
+\`\`\`tsx
+function ProductList() {
+  const products = useStore((s) => s.products);
+
+  // Derived state computed in component - should be a selector
+  const activeProducts = useMemo(
+    () => products.filter((p) => p.isActive),
+    [products]
+  );
+
+  return <List items={activeProducts} />;
+}
+
+// Multiple chained useMemo calls
+function Dashboard() {
+  const data = useDataStore((s) => s.data);
+
+  const filtered = useMemo(() => data.filter(isValid), [data]);
+  const sorted = useMemo(() => filtered.sort(byDate), [filtered]);
+  const mapped = useMemo(() => sorted.map(format), [sorted]);
+
+  return <Table rows={mapped} />;
+}
+\`\`\`
+
+### \u2705 Correct
+
+\`\`\`tsx
+// Define selectors in the store file
+const selectActiveProducts = (state) =>
+  state.products.filter((p) => p.isActive);
+
+function ProductList() {
+  // Use selector for derived state
+  const activeProducts = useStore(selectActiveProducts);
+
+  return <List items={activeProducts} />;
+}
+
+// Combined selector for dashboard
+const selectFormattedData = (state) =>
+  state.data
+    .filter(isValid)
+    .sort(byDate)
+    .map(format);
+
+function Dashboard() {
+  const formattedData = useDataStore(selectFormattedData);
+  return <Table rows={formattedData} />;
+}
+\`\`\`
+
+## Configuration
+
+\`\`\`js
+// eslint.config.js
+"uilint/prefer-store-selectors": ["warn", {
+  storeHookPattern: "^use.*Store$"  // Match useXxxStore pattern
+}]
+\`\`\`
+`
+});
+var TRANSFORMATION_METHODS = /* @__PURE__ */ new Set([
+  "filter",
+  "map",
+  "reduce",
+  "sort",
+  "flat",
+  "flatMap",
+  "slice",
+  "concat",
+  "find",
+  "findIndex",
+  "some",
+  "every",
+  "includes",
+  "reverse",
+  "join"
+]);
+var ARRAY_TRANSFORMATION_FUNCTIONS = /* @__PURE__ */ new Set([
+  "Array.from",
+  "Object.keys",
+  "Object.values",
+  "Object.entries"
+]);
+function isZustandStoreCall2(node, storePattern) {
+  if (node.callee.type === "Identifier") {
+    return storePattern.test(node.callee.name);
+  }
+  return false;
+}
+function isUseMemoCall(node) {
+  return node.callee.type === "Identifier" && node.callee.name === "useMemo";
+}
+function getVariableName(node) {
+  if (node.id.type === "Identifier") {
+    return node.id.name;
+  }
+  return null;
+}
+function isTransformationCall(node, trackedVars) {
+  if (node.callee.type === "MemberExpression") {
+    const { object, property } = node.callee;
+    if (object.type === "Identifier" && property.type === "Identifier" && trackedVars.has(object.name) && TRANSFORMATION_METHODS.has(property.name)) {
+      return { isTransform: true, varName: object.name };
+    }
+    if (object.type === "CallExpression") {
+      const nested = isTransformationCall(object, trackedVars);
+      if (nested.isTransform) {
+        return nested;
+      }
+    }
+  }
+  if (node.callee.type === "MemberExpression") {
+    const { object, property } = node.callee;
+    if (object.type === "Identifier" && property.type === "Identifier") {
+      const funcName = `${object.name}.${property.name}`;
+      if (ARRAY_TRANSFORMATION_FUNCTIONS.has(funcName)) {
+        if (node.arguments.length > 0 && node.arguments[0].type === "Identifier" && trackedVars.has(node.arguments[0].name)) {
+          return { isTransform: true, varName: node.arguments[0].name };
+        }
+      }
+    }
+  }
+  return { isTransform: false, varName: null };
+}
+function referencesTrackedVar(node, trackedVars) {
+  if (node.type === "Identifier" && trackedVars.has(node.name)) {
+    return node.name;
+  }
+  if (node.type === "MemberExpression") {
+    return referencesTrackedVar(node.object, trackedVars);
+  }
+  if (node.type === "CallExpression") {
+    const calleeRef = referencesTrackedVar(node.callee, trackedVars);
+    if (calleeRef) return calleeRef;
+    for (const arg of node.arguments) {
+      const argRef = referencesTrackedVar(arg, trackedVars);
+      if (argRef) return argRef;
+    }
+  }
+  if (node.type === "BinaryExpression" || node.type === "LogicalExpression") {
+    const leftRef = referencesTrackedVar(node.left, trackedVars);
+    if (leftRef) return leftRef;
+    return referencesTrackedVar(node.right, trackedVars);
+  }
+  if (node.type === "ConditionalExpression") {
+    const testRef = referencesTrackedVar(node.test, trackedVars);
+    if (testRef) return testRef;
+    const consequentRef = referencesTrackedVar(node.consequent, trackedVars);
+    if (consequentRef) return consequentRef;
+    return referencesTrackedVar(node.alternate, trackedVars);
+  }
+  if (node.type === "ArrayExpression") {
+    for (const element of node.elements) {
+      if (element) {
+        const elemRef = referencesTrackedVar(element, trackedVars);
+        if (elemRef) return elemRef;
+      }
+    }
+  }
+  if (node.type === "SpreadElement") {
+    return referencesTrackedVar(node.argument, trackedVars);
+  }
+  return null;
+}
+function analyzeUseMemoBody(body, trackedVars) {
+  if (body.type === "CallExpression") {
+    const result = isTransformationCall(body, trackedVars);
+    if (result.isTransform) {
+      return { hasTransformation: true, varName: result.varName };
+    }
+  }
+  if (body.type === "BlockStatement") {
+    for (const statement of body.body) {
+      if (statement.type === "ReturnStatement" && statement.argument) {
+        if (statement.argument.type === "CallExpression") {
+          const result = isTransformationCall(statement.argument, trackedVars);
+          if (result.isTransform) {
+            return { hasTransformation: true, varName: result.varName };
+          }
+        }
+        const varRef = referencesTrackedVar(statement.argument, trackedVars);
+        if (varRef && statement.argument.type === "CallExpression") {
+          return { hasTransformation: true, varName: varRef };
+        }
+      }
+      if (statement.type === "VariableDeclaration") {
+        for (const decl of statement.declarations) {
+          if (decl.init && decl.init.type === "CallExpression") {
+            const result = isTransformationCall(decl.init, trackedVars);
+            if (result.isTransform) {
+              return { hasTransformation: true, varName: result.varName };
+            }
+          }
+        }
+      }
+    }
+  }
+  return { hasTransformation: false, varName: null };
+}
+function getUseMemoCallback(node) {
+  if (node.arguments.length === 0) return null;
+  const callback = node.arguments[0];
+  if (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") {
+    return callback;
+  }
+  return null;
+}
+var prefer_store_selectors_default = createRule({
+  name: "prefer-store-selectors",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Derived state from store should use selectors, not useMemo"
+    },
+    messages: {
+      useMemoWithStoreData: "useMemo derives state from '{{varName}}' which comes from store. Move this computation to a Zustand selector.",
+      chainedDerivedState: "Multiple chained useMemo calls derive from store data. Consolidate into store selectors."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          storeHookPattern: {
+            type: "string",
+            description: "Regex pattern for store hook names"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      storeHookPattern: "^use.*Store$"
+    }
+  ],
+  create(context) {
+    const options = context.options[0] || {};
+    const storeHookPatternStr = options.storeHookPattern ?? "^use.*Store$";
+    let storePattern;
+    try {
+      storePattern = new RegExp(storeHookPatternStr);
+    } catch {
+      storePattern = /^use.*Store$/;
+    }
+    const scopeStack = [];
+    function currentScope() {
+      return scopeStack[scopeStack.length - 1];
+    }
+    function pushScope() {
+      scopeStack.push({
+        storeVars: /* @__PURE__ */ new Set(),
+        derivedMemoVars: /* @__PURE__ */ new Set(),
+        useMemoNodes: []
+      });
+    }
+    function popScope() {
+      return scopeStack.pop();
+    }
+    function reportScope(scope) {
+      const { useMemoNodes, derivedMemoVars } = scope;
+      if (useMemoNodes.length === 1) {
+        const { node, sourceVar } = useMemoNodes[0];
+        context.report({
+          node,
+          messageId: "useMemoWithStoreData",
+          data: { varName: sourceVar }
+        });
+      } else if (useMemoNodes.length > 1) {
+        const hasChain = useMemoNodes.some(
+          ({ sourceVar }) => derivedMemoVars.has(sourceVar)
+        );
+        if (hasChain) {
+          context.report({
+            node: useMemoNodes[0].node,
+            messageId: "chainedDerivedState"
+          });
+        } else {
+          for (const { node, sourceVar } of useMemoNodes) {
+            context.report({
+              node,
+              messageId: "useMemoWithStoreData",
+              data: { varName: sourceVar }
+            });
+          }
+        }
+      }
+    }
+    function isComponentOrHook(node) {
+      if (node.type === "FunctionDeclaration") {
+        return true;
+      }
+      if (node.parent?.type === "VariableDeclarator") {
+        const declarator = node.parent;
+        if (declarator.id.type === "Identifier") {
+          const name = declarator.id.name;
+          return /^[A-Z]/.test(name) || /^use[A-Z]/.test(name);
+        }
+      }
+      if (node.type === "FunctionExpression" && node.id) {
+        const name = node.id.name;
+        return /^[A-Z]/.test(name) || /^use[A-Z]/.test(name);
+      }
+      return false;
+    }
+    return {
+      // Push scope for component/hook functions
+      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
+        if (isComponentOrHook(node)) {
+          pushScope();
+        }
+      },
+      // Pop scope and report when exiting component/hook functions
+      "FunctionDeclaration:exit"(node) {
+        if (isComponentOrHook(node)) {
+          const scope = popScope();
+          if (scope) {
+            reportScope(scope);
+          }
+        }
+      },
+      "FunctionExpression:exit"(node) {
+        if (isComponentOrHook(node)) {
+          const scope = popScope();
+          if (scope) {
+            reportScope(scope);
+          }
+        }
+      },
+      "ArrowFunctionExpression:exit"(node) {
+        if (isComponentOrHook(node)) {
+          const scope = popScope();
+          if (scope) {
+            reportScope(scope);
+          }
+        }
+      },
+      // Also handle program-level code
+      Program() {
+        pushScope();
+      },
+      "Program:exit"() {
+        const scope = popScope();
+        if (scope) {
+          reportScope(scope);
+        }
+      },
+      // Track variable declarations from store hooks
+      VariableDeclarator(node) {
+        const scope = currentScope();
+        if (!scope) return;
+        if (!node.init || node.init.type !== "CallExpression") {
+          return;
+        }
+        const varName = getVariableName(node);
+        if (!varName) return;
+        if (isZustandStoreCall2(node.init, storePattern)) {
+          scope.storeVars.add(varName);
+          return;
+        }
+        if (isUseMemoCall(node.init)) {
+          const callback = getUseMemoCallback(node.init);
+          if (!callback) return;
+          const body = callback.body;
+          const allTracked = /* @__PURE__ */ new Set();
+          scope.storeVars.forEach((v) => allTracked.add(v));
+          scope.derivedMemoVars.forEach((v) => allTracked.add(v));
+          const analysis = analyzeUseMemoBody(body, allTracked);
+          if (analysis.hasTransformation && analysis.varName) {
+            scope.derivedMemoVars.add(varName);
+            scope.useMemoNodes.push({
+              node: node.init,
+              varName,
+              sourceVar: analysis.varName
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/category-registry.ts
 var categoryRegistry = [
   {
@@ -7248,7 +7679,9 @@ var ruleRegistry = [
   // Style preferences
   meta15,
   // Type safety
-  meta16
+  meta16,
+  // Zustand best practices
+  meta17
 ];
 function getRuleMetadata(id) {
   return ruleRegistry.find((rule) => rule.id === id);
@@ -7282,15 +7715,16 @@ var rules = {
   "no-semantic-duplicates": no_semantic_duplicates_default,
   "require-test-coverage": require_test_coverage_default,
   "prefer-tailwind": prefer_tailwind_default,
-  "no-unsafe-type-casts": no_unsafe_type_casts_default
+  "no-unsafe-type-casts": no_unsafe_type_casts_default,
+  "prefer-store-selectors": prefer_store_selectors_default
 };
 var version = "0.1.0";
-var meta17 = {
+var meta18 = {
   name: "uilint",
   version
 };
 var plugin = {
-  meta: meta17,
+  meta: meta18,
   rules
 };
 var jsxLanguageOptions = {
@@ -7435,6 +7869,11 @@ var recommendedConfig = {
         "allowInCatchBlocks": true,
         "allowedTypes": []
       }
+    ]],
+    "uilint/prefer-store-selectors": ["warn", ...[
+      {
+        "storeHookPattern": "^use.*Store$"
+      }
     ]]
   }
 };
@@ -7592,6 +8031,11 @@ var strictConfig = {
         "allowInCatchBlocks": true,
         "allowedTypes": []
       }
+    ]],
+    "uilint/prefer-store-selectors": ["warn", ...[
+      {
+        "storeHookPattern": "^use.*Store$"
+      }
     ]]
   }
 };
@@ -7600,7 +8044,7 @@ var configs = {
   strict: strictConfig
 };
 var uilintEslint = {
-  meta: meta17,
+  meta: meta18,
   plugin,
   rules,
   configs
@@ -7638,7 +8082,7 @@ export {
   isEventHandlerAttribute,
   loadCache,
   loadStyleguide,
-  meta17 as meta,
+  meta18 as meta,
   plugin,
   ruleRegistry,
   rules,