pasika 0.10.92 → 0.10.94

package/dist/eslint/pasika/index.js

@@ -4508,6 +4508,18 @@ function keyName(key) {
 function reportFor(context, node, message) {
   context.report({ node, message });
 }
+function isLocaleWrapper(node) {
+  return ["TSAsExpression", "TSSatisfiesExpression"].includes(node.type) && "expression" in node && typeof node.expression === "object" && "type" in node.expression;
+}
+function localeObject(node) {
+  let current = node;
+  while (current) {
+    if (current.type === "ObjectExpression") return current;
+    if (!isLocaleWrapper(current)) return void 0;
+    current = current.expression;
+  }
+  return void 0;
+}
 function checkKey(context, node, name) {
   if (!ENGLISH.test(name)) {
     reportFor(
@@ -4544,13 +4556,22 @@ var localeKeyShapeRule = {
   },
   create(context) {
     if (!isLocalesFile(context.filename)) return {};
-    function visitObject(node) {
+    function visitObject(node, namespace) {
       for (const property of node.properties) {
         if (property.type !== "Property") continue;
         const name = keyName(property.key);
         if (name === void 0) continue;
-        if (property.value.type === "ObjectExpression") {
-          visitObject(property.value);
+        const nested = localeObject(property.value);
+        if (nested) {
+          if (namespace !== void 0) {
+            reportFor(
+              context,
+              property,
+              `Locale "${namespace}.${name}" must not be a nested object. Keep string keys directly inside the "${namespace}" feature namespace. See docs/next-codebase-guide/rules/locales-rule.md`
+            );
+          } else {
+            visitObject(nested, name);
+          }
         } else if (property.value.type === "Literal" && typeof property.value.value === "string") {
           checkKey(context, property, name);
         }
@@ -4559,8 +4580,9 @@ var localeKeyShapeRule = {
     return {
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier" || node.id.name !== "locales") return;
-        if (node.init?.type !== "ObjectExpression") return;
-        visitObject(node.init);
+        const root = localeObject(node.init);
+        if (!root) return;
+        visitObject(root);
       }
     };
   }
@@ -6489,6 +6511,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;
@@ -6507,14 +6550,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;
 }
@@ -6522,10 +6566,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;
@@ -6698,6 +6742,7 @@ var preferObjectDestructuringRule = {
   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);
@@ -6726,6 +6771,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)
             );
@@ -6787,7 +6838,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) {

package/package.json

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