pasika 0.10.75 → 0.10.76

package/dist/eslint/pasika/index.js

@@ -6101,7 +6101,7 @@ function isStableObjectSource(source) {
 function objectUsage(scope, sourceText) {
   let usage = scope.objects.get(sourceText);
   if (!usage) {
-    usage = { propertyNames: /* @__PURE__ */ new Set(), directMembers: /* @__PURE__ */ new Map() };
+    usage = { propertyNames: /* @__PURE__ */ new Set(), directMembers: [] };
     scope.objects.set(sourceText, usage);
   }
   return usage;
@@ -6128,8 +6128,8 @@ function recordMemberUsage(context, scope, member) {
   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);
+  if (!memberIsDirectVariableInitializer(context, member)) {
+    usage.directMembers.push({ member, propertyName: propertyName5 });
   }
 }
 function recordDestructuringUsage(context, scope, declaration) {
@@ -6138,16 +6138,40 @@ function recordDestructuringUsage(context, scope, declaration) {
     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;
@@ -6265,19 +6289,49 @@ var preferObjectDestructuringRule = {
     const grouped = /* @__PURE__ */ new Set();
     const usageScopes = [];
     const currentUsageScope = () => usageScopes.at(-1);
-    const enterUsageScope = () => {
-      usageScopes.push({ objects: /* @__PURE__ */ new Map() });
+    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.size === 0) continue;
-        const firstDirectMember = usage.directMembers.values().next().value;
-        if (!firstDirectMember) continue;
+        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)
+          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];
+          }
         });
       }
     };

package/package.json

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