pasika 0.10.74 → 0.10.75

package/dist/eslint/pasika/index.js

@@ -6092,6 +6092,62 @@ function directPropertyBinding(context, declarator) {
 function canGroupSource(source) {
   return source.type === "Identifier" || source.type === "ThisExpression";
 }
+function isStableObjectSource(source) {
+  if (source.type === "Identifier" || source.type === "ThisExpression") return true;
+  if (source.type !== "MemberExpression") return false;
+  if (source.computed || source.optional || source.property.type !== "Identifier") return false;
+  return isStableObjectSource(source.object);
+}
+function objectUsage(scope, sourceText) {
+  let usage = scope.objects.get(sourceText);
+  if (!usage) {
+    usage = { propertyNames: /* @__PURE__ */ new Set(), directMembers: /* @__PURE__ */ new Map() };
+    scope.objects.set(sourceText, usage);
+  }
+  return usage;
+}
+function memberIsRead(context, member) {
+  const parent = context.sourceCode.getAncestors(member).at(-1);
+  if (!parent) return true;
+  if (parent.type === "AssignmentExpression" && parent.left === member) return false;
+  if (parent.type === "UpdateExpression" && parent.argument === member) return false;
+  if (parent.type === "UnaryExpression" && parent.operator === "delete" && parent.argument === member) return false;
+  if ((parent.type === "ForInStatement" || parent.type === "ForOfStatement") && parent.left === member) return false;
+  if ((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.callee === member) return false;
+  if (parent.type === "TaggedTemplateExpression" && parent.tag === member) return false;
+  return true;
+}
+function memberIsDirectVariableInitializer(context, member) {
+  const parent = context.sourceCode.getAncestors(member).at(-1);
+  return parent?.type === "VariableDeclarator" && parent.init === member;
+}
+function recordMemberUsage(context, scope, member) {
+  if (!scope || member.computed || member.optional || member.property.type !== "Identifier") return;
+  if (!isStableObjectSource(member.object) || !memberIsRead(context, member)) return;
+  const sourceText = context.sourceCode.getText(member.object);
+  const usage = objectUsage(scope, sourceText);
+  const propertyName5 = member.property.name;
+  usage.propertyNames.add(propertyName5);
+  if (!memberIsDirectVariableInitializer(context, member) && !usage.directMembers.has(propertyName5)) {
+    usage.directMembers.set(propertyName5, member);
+  }
+}
+function recordDestructuringUsage(context, scope, declaration) {
+  if (!scope) return;
+  for (const declarator of declaration.declarations) {
+    if (declarator.id.type !== "ObjectPattern" || !declarator.init || !isStableObjectSource(declarator.init)) continue;
+    const sourceText = context.sourceCode.getText(declarator.init);
+    const usage = objectUsage(scope, sourceText);
+    for (const property of declarator.id.properties) {
+      if (property.type !== "Property" || property.computed || property.key.type !== "Identifier") continue;
+      usage.propertyNames.add(property.key.name);
+    }
+  }
+}
+function scopeUsageMessage(sourceText, propertyNames) {
+  const names = [...propertyNames].map((name) => `"${name}"`).join(", ");
+  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC5}`;
+}
 function whitespaceKeepsStatementsAdjacent(text) {
   if (text.trim() !== "") return false;
   return (text.match(/\n/gu) ?? []).length <= 1;
@@ -6202,13 +6258,45 @@ var preferObjectDestructuringRule = {
     type: "problem",
     fixable: "code",
     docs: {
-      description: "Require locals derived directly from object properties to use object destructuring."
+      description: "Require related object-property reads to use one object destructuring declaration."
     }
   },
   create(context) {
     const grouped = /* @__PURE__ */ new Set();
+    const usageScopes = [];
+    const currentUsageScope = () => usageScopes.at(-1);
+    const enterUsageScope = () => {
+      usageScopes.push({ objects: /* @__PURE__ */ new Map() });
+    };
+    const exitUsageScope = () => {
+      const scope = usageScopes.pop();
+      if (!scope) return;
+      for (const [sourceText, usage] of scope.objects) {
+        if (usage.propertyNames.size < 2 || usage.directMembers.size === 0) continue;
+        const firstDirectMember = usage.directMembers.values().next().value;
+        if (!firstDirectMember) continue;
+        context.report({
+          node: firstDirectMember,
+          message: scopeUsageMessage(sourceText, usage.propertyNames)
+        });
+      }
+    };
     return {
+      Program: enterUsageScope,
+      "Program:exit": exitUsageScope,
+      BlockStatement: enterUsageScope,
+      "BlockStatement:exit": exitUsageScope,
+      FunctionDeclaration: enterUsageScope,
+      "FunctionDeclaration:exit": exitUsageScope,
+      FunctionExpression: enterUsageScope,
+      "FunctionExpression:exit": exitUsageScope,
+      ArrowFunctionExpression: enterUsageScope,
+      "ArrowFunctionExpression:exit": exitUsageScope,
+      MemberExpression(node) {
+        recordMemberUsage(context, currentUsageScope(), node);
+      },
       VariableDeclaration(node) {
+        recordDestructuringUsage(context, currentUsageScope(), node);
         if (grouped.has(node)) return;
         const selection = destructuringSelection(context, node);
         if (selection) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.74",
+  "version": "0.10.75",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",