pasika 0.10.91 → 0.10.93

package/dist/eslint/pasika/index.js

@@ -6418,13 +6418,17 @@ function canGroupSource(source) {
 function isGroupedUsageSource(source) {
   return source.type === "Identifier" || source.type === "ThisExpression";
 }
+function supportsSinglePropertySource(source) {
+  if (isGroupedUsageSource(source) || source.type === "CallExpression") return true;
+  return source.type === "MemberExpression" && !source.computed && !source.optional && source.property.type === "Identifier" && supportsSinglePropertySource(source.object);
+}
 function rootIdentifierName(node) {
   if (node.type === "Identifier") return node.name;
   if (node.type !== "MemberExpression" || node.object.type === "Super") return void 0;
   return rootIdentifierName(node.object);
 }
 function isCompliantLocalName(propertyName5) {
-  return !propertyName5.includes("_");
+  return !propertyName5.includes("_") || /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u.test(propertyName5);
 }
 function propertyNameOf(node) {
   if (node.type !== "Property" || node.computed) return void 0;
@@ -6485,6 +6489,27 @@ function enumValueResolver(context) {
     return typeSymbol ? isEnumSymbol(typeSymbol) : localEnumBinding(context, node);
   };
 }
+function detachableCallResolver(context) {
+  const services = typedParserServices(context.sourceCode.parserServices);
+  if (!services) return () => false;
+  const checker = services.program.getTypeChecker();
+  const { esTreeNodeToTSNodeMap: nodeMap } = services;
+  const isUnboundFunctionType = (type) => ts9.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts9.isIdentifier(parameter.name) && parameter.name.text === "this");
+  return (member) => {
+    const node = nodeMap.get(member);
+    if (!node || !ts9.isPropertyAccessExpression(node)) return false;
+    const symbol = checker.getSymbolAtLocation(node.name);
+    const declarations = symbol?.declarations;
+    if (!declarations?.length) return false;
+    return declarations.every((declaration) => {
+      if (ts9.isPropertySignature(declaration) || ts9.isPropertyDeclaration(declaration)) {
+        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts9.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts9.isArrowFunction(declaration.initializer);
+      }
+      if (ts9.isPropertyAssignment(declaration)) return ts9.isArrowFunction(declaration.initializer);
+      return false;
+    });
+  };
+}
 function directMappingRequiresQualifiedAccess(context, ownershipResolver, member) {
   const mapping = renamedDirectMapping(context, member);
   if (!mapping || !ownershipResolver) return false;
@@ -6503,14 +6528,15 @@ function objectUsage(scope, sourceText) {
   }
   return usage;
 }
-function memberIsRead(context, member) {
+function memberIsRead(context, member, detachableCall) {
   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 === "CallExpression" && parent.callee === member) return detachableCall(member);
+  if (parent.type === "NewExpression" && parent.callee === member) return false;
   if (parent.type === "TaggedTemplateExpression" && parent.tag === member) return false;
   return true;
 }
@@ -6518,10 +6544,10 @@ function memberIsDirectVariableInitializer(context, member) {
   const parent = context.sourceCode.getAncestors(member).at(-1);
   return parent?.type === "VariableDeclarator" && parent.init === member;
 }
-function recordMemberUsage(context, scope, ownershipResolver, member, isEnumValue) {
+function recordMemberUsage(context, scope, ownershipResolver, member, isEnumValue, detachableCall) {
   if (!scope || member.computed || member.optional || member.property.type !== "Identifier") return;
   if (!memberCanBeDestructured(context, ownershipResolver, member, isEnumValue)) return;
-  if (!isGroupedUsageSource(member.object) || !memberIsRead(context, member)) return;
+  if (!isGroupedUsageSource(member.object) || !memberIsRead(context, member, detachableCall)) return;
   const sourceText = context.sourceCode.getText(member.object);
   const usage = objectUsage(scope, sourceText);
   const propertyName5 = member.property.name;
@@ -6667,8 +6693,8 @@ function groupedDestructuringSelections(context, first, isEnumValue) {
 function declarationTerminator(context, declaration) {
   return context.sourceCode.getText(declaration).trimEnd().endsWith(";") ? ";" : "";
 }
-function singleMessage(binding) {
-  return `"${binding.localName}" is derived directly from "${binding.sourceText}.${binding.propertyName}". Use object destructuring. ${DOC5}`;
+function singlePropertyMessage(binding) {
+  return `"${binding.propertyName}" is the only property bound from "${binding.sourceText}". Read "${binding.sourceText}.${binding.propertyName}" directly instead of creating a local binding. ${DOC5}`;
 }
 function groupMessage(bindings) {
   const firstBinding = bindings[0];
@@ -6688,17 +6714,18 @@ var preferObjectDestructuringRule = {
     type: "problem",
     fixable: "code",
     docs: {
-      description: "Require related object-property reads to use one object destructuring declaration."
+      description: "Prefer direct access for one property and shared destructuring for related property reads."
     }
   },
   create(context) {
     const ownershipResolver = contractOwnershipResolver(context);
     const isEnumValue = enumValueResolver(context);
+    const detachableCall = detachableCallResolver(context);
     const grouped = /* @__PURE__ */ new Set();
     const usageScopes = [];
     const currentUsageScope = () => usageScopes.at(-1);
     const enterUsageScope = (node) => {
-      usageScopes.push({ node, objects: /* @__PURE__ */ new Map() });
+      usageScopes.push({ node, objects: /* @__PURE__ */ new Map(), singleProperties: [] });
     };
     const enterUsageBarrier = () => {
       usageScopes.push(void 0);
@@ -6722,6 +6749,12 @@ var preferObjectDestructuringRule = {
           node: firstDirectMember,
           message: scopeUsageMessage(sourceText, usage.propertyNames),
           fix(fixer) {
+            if (usage.directMembers.some(({ member }) => {
+              const parent = context.sourceCode.getAncestors(member).at(-1);
+              return parent?.type === "CallExpression" && parent.callee === member;
+            })) {
+              return null;
+            }
             const memberFixes = usage.directMembers.map(
               ({ member, propertyName: propertyName5 }) => fixer.replaceText(member, propertyName5)
             );
@@ -6745,6 +6778,31 @@ ${indentation}`;
           }
         });
       }
+      for (const binding of scope.singleProperties) {
+        const fromSameSource = scope.singleProperties.filter(({ sourceText }) => sourceText === binding.sourceText);
+        if (fromSameSource[0] !== binding) continue;
+        const usage = scope.objects.get(binding.sourceText);
+        const usedProperties = usage?.propertyNames;
+        if (usedProperties && usedProperties.size > 1 && usage.directMembers.length > 0) {
+          if (scope.singleProperties.some(
+            (item) => item.node.type === "ObjectPattern" && item.sourceText === binding.sourceText
+          )) {
+            continue;
+          }
+        }
+        if (usedProperties && usedProperties.size > 1) {
+          context.report({ node: binding.node, message: scopeUsageMessage(binding.sourceText, usedProperties) });
+          continue;
+        }
+        if (fromSameSource.length > 1) {
+          const names = new Set(fromSameSource.map(({ propertyName: propertyName5 }) => propertyName5));
+          if (names.size > 1) {
+            context.report({ node: binding.node, message: scopeUsageMessage(binding.sourceText, names) });
+            continue;
+          }
+        }
+        context.report({ node: binding.node, message: singlePropertyMessage(binding) });
+      }
     };
     return {
       Program: enterUsageScope,
@@ -6758,7 +6816,7 @@ ${indentation}`;
       ArrowFunctionExpression: enterUsageBarrier,
       "ArrowFunctionExpression:exit": exitUsageScope,
       MemberExpression(node) {
-        recordMemberUsage(context, currentUsageScope(), ownershipResolver, node, isEnumValue);
+        recordMemberUsage(context, currentUsageScope(), ownershipResolver, node, isEnumValue, detachableCall);
       },
       VariableDeclaration(node) {
         for (const declarator of node.declarations) {
@@ -6774,7 +6832,20 @@ ${indentation}`;
         const selection = destructuringSelection(context, node, isEnumValue);
         if (selection) {
           const group = groupedDestructuringSelections(context, selection, isEnumValue);
-          if (group.length <= 1) return;
+          if (group.length <= 1) {
+            if (node.kind === "const" && selection.propertyNames.length === 1 && supportsSinglePropertySource(selection.source)) {
+              const declarator = node.declarations[0];
+              const propertyName5 = selection.propertyNames[0];
+              if (declarator && propertyName5) {
+                currentUsageScope()?.singleProperties.push({
+                  node: declarator.id,
+                  sourceText: selection.sourceText,
+                  propertyName: propertyName5
+                });
+              }
+            }
+            return;
+          }
           for (const item of group.slice(1)) grouped.add(item.declaration);
           const lastDeclaration = group.at(-1)?.declaration;
           if (!lastDeclaration) return;
@@ -6841,13 +6912,11 @@ ${indentation}`;
           }
         }
         for (const binding of bindings) {
-          if (!canGroupSource(binding.source)) continue;
-          context.report({
+          if (node.kind !== "const" || !supportsSinglePropertySource(binding.source)) continue;
+          currentUsageScope()?.singleProperties.push({
             node: binding.declarator,
-            message: singleMessage(binding),
-            fix(fixer) {
-              return fixer.replaceText(binding.declarator, `{ ${binding.bindingText} } = ${binding.sourceText}`);
-            }
+            sourceText: binding.sourceText,
+            propertyName: binding.propertyName
           });
         }
       }

package/package.json

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