pasika 0.10.74 → 0.10.76

package/dist/eslint/pasika/index.js

@@ -6092,6 +6092,86 @@ 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: [] };
+    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.push({ member, propertyName: propertyName5 });
+  }
+}
+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);
+    const propertyNames = /* @__PURE__ */ new Set();
+    for (const property of declarator.id.properties) {
+      if (property.type !== "Property" || property.computed || property.key.type !== "Identifier") continue;
+      propertyNames.add(property.key.name);
+      usage.propertyNames.add(property.key.name);
+    }
+    usage.destructuring ??= { pattern: declarator.id, propertyNames };
+  }
+}
+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 hasBinding(context, node, name) {
+  const initialScope = context.sourceCode.getScope(node);
+  if (initialScope.variables.some((variable) => variable.name === name)) return true;
+  for (let scope = initialScope.upper; scope !== null; scope = scope.upper) {
+    if (scope.variables.some((variable) => variable.name === name)) return true;
+  }
+  return false;
+}
+function containingStatement(context, scopeNode, node) {
+  if (scopeNode.type !== "Program" && scopeNode.type !== "BlockStatement") return void 0;
+  const [nodeStart, nodeEnd] = context.sourceCode.getRange(node);
+  return scopeNode.body.find((statement) => {
+    const [statementStart, statementEnd] = context.sourceCode.getRange(statement);
+    return statementStart <= nodeStart && statementEnd >= nodeEnd;
+  });
+}
+function statementIndentation(context, statement) {
+  const [start] = context.sourceCode.getRange(statement);
+  const lineStart = context.sourceCode.text.lastIndexOf("\n", start - 1) + 1;
+  return context.sourceCode.text.slice(lineStart, start);
+}
 function whitespaceKeepsStatementsAdjacent(text) {
   if (text.trim() !== "") return false;
   return (text.match(/\n/gu) ?? []).length <= 1;
@@ -6202,13 +6282,75 @@ 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 = (node) => {
+      usageScopes.push({ node, 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.length === 0) continue;
+        const firstDirectUsage = usage.directMembers[0];
+        if (!firstDirectUsage) continue;
+        const { member: firstDirectMember } = firstDirectUsage;
+        context.report({
+          node: firstDirectMember,
+          message: scopeUsageMessage(sourceText, usage.propertyNames),
+          fix(fixer) {
+            const propertyNames = [...usage.propertyNames];
+            const missingPropertyNames = propertyNames.filter(
+              (propertyName5) => !usage.destructuring?.propertyNames.has(propertyName5)
+            );
+            if (missingPropertyNames.some((propertyName5) => hasBinding(context, firstDirectMember, propertyName5))) {
+              return null;
+            }
+            const memberFixes = usage.directMembers.map(
+              ({ member, propertyName: propertyName5 }) => fixer.replaceText(member, propertyName5)
+            );
+            if (usage.destructuring) {
+              if (missingPropertyNames.length === 0) return memberFixes;
+              const patternText = context.sourceCode.getText(usage.destructuring.pattern);
+              const closeIndex = patternText.lastIndexOf("}");
+              const beforeClose = patternText.slice(0, closeIndex);
+              const contentEnd = beforeClose.trimEnd().length;
+              const trailingWhitespace = beforeClose.slice(contentEnd);
+              const separator = usage.destructuring.propertyNames.size > 0 ? ", " : "";
+              const replacement = `${beforeClose.slice(0, contentEnd)}${separator}${missingPropertyNames.join(", ")}${trailingWhitespace}${patternText.slice(closeIndex)}`;
+              return [fixer.replaceText(usage.destructuring.pattern, replacement), ...memberFixes];
+            }
+            const statement = containingStatement(context, scope.node, firstDirectMember);
+            if (!statement) return null;
+            const indentation = statementIndentation(context, statement);
+            const declaration = `const { ${propertyNames.join(", ")} } = ${sourceText};
+${indentation}`;
+            return [fixer.insertTextBefore(statement, declaration), ...memberFixes];
+          }
+        });
+      }
+    };
     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.76",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",