pasika 0.10.29 → 0.10.31

package/dist/eslint/pasika/index.js

@@ -3984,6 +3984,58 @@ function looksLikeUserFacingString(value) {
 function looksLikeUserFacingJsxText(value) {
   return typeof value === "string" && /\p{L}/u.test(value);
 }
+var USER_FACING_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+  "alt",
+  "aria-label",
+  "cancelText",
+  "children",
+  "confirmText",
+  "description",
+  "emptyText",
+  "errorMessage",
+  "helperText",
+  "label",
+  "placeholder",
+  "submitText",
+  "successMessage",
+  "title"
+]);
+var USER_FACING_VARIABLE_SUFFIX_RE = /(?:Description|Label|Message|Text|Title)$/u;
+var TOAST_METHOD_NAMES = /* @__PURE__ */ new Set(["error", "info", "success", "warning"]);
+function getNodeName(node) {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function containsUserFacingString(node) {
+  if (!node) return false;
+  if (node.type === "Literal") return looksLikeUserFacingJsxText(node.value);
+  if (node.type === "TemplateLiteral") {
+    return node.quasis.some((quasi) => looksLikeUserFacingJsxText(quasi.value.cooked ?? quasi.value.raw));
+  }
+  if (node.type === "ConditionalExpression") {
+    return containsUserFacingString(node.consequent) || containsUserFacingString(node.alternate);
+  }
+  if (node.type === "LogicalExpression") {
+    return containsUserFacingString(node.left) || containsUserFacingString(node.right);
+  }
+  if (node.type === "BinaryExpression") {
+    return node.operator === "+" && (containsUserFacingString(node.left) || containsUserFacingString(node.right));
+  }
+  return false;
+}
+function isUserFacingVariable(node) {
+  const name = getNodeName(node);
+  return name !== null && USER_FACING_VARIABLE_SUFFIX_RE.test(name);
+}
+function objectContainsUserFacingProperties(node) {
+  return node.properties.some((property) => {
+    if (property.type !== "Property") return false;
+    const name = getNodeName(property.key);
+    return name !== null && USER_FACING_PROPERTY_NAMES.has(name) && containsUserFacingString(property.value);
+  });
+}
 var localesLocationRule = {
   meta: {
     schema: [],
@@ -4008,7 +4060,42 @@ var localesLocationRule = {
           message: "User-facing JSX text must come from src/locales/index.ts, not be written inline."
         });
       },
+      JSXAttribute(node) {
+        const name = node.name?.name;
+        if (typeof name !== "string" || !USER_FACING_PROPERTY_NAMES.has(name)) return;
+        const value = node.value;
+        if (!value) return;
+        const hasUserFacingString = value.type === "JSXExpressionContainer" ? containsUserFacingString(value.expression) : looksLikeUserFacingJsxText(value.value);
+        if (!hasUserFacingString) return;
+        context.report({
+          node,
+          message: "User-facing JSX attribute text must come from src/locales/index.ts, not be written inline."
+        });
+      },
+      "JSXElement > JSXExpressionContainer, JSXFragment > JSXExpressionContainer"(node) {
+        if (!containsUserFacingString(node.expression)) return;
+        context.report({
+          node,
+          message: "User-facing JSX expression text must come from src/locales/index.ts, not be written inline."
+        });
+      },
+      ObjectExpression(node) {
+        if (skipObjectLiteralCheck || node.parent.type === "VariableDeclarator" || !objectContainsUserFacingProperties(node)) {
+          return;
+        }
+        context.report({
+          node,
+          message: "User-facing object properties must come from src/locales/index.ts, not be written inline."
+        });
+      },
       VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && isUserFacingVariable(node.id) && containsUserFacingString(node.init)) {
+          context.report({
+            node,
+            message: "User-facing variable text must come from src/locales/index.ts, not be written inline."
+          });
+          return;
+        }
         if (skipObjectLiteralCheck) return;
         if (node.id.type === "Identifier" && node.init?.type === "ObjectExpression" && node.init.properties.length > 0 && looksLikeLocaleKey(node.id.name)) {
           const hasUserFacingStringValues = node.init.properties.some(
@@ -4021,6 +4108,24 @@ var localesLocationRule = {
             });
           }
         }
+      },
+      AssignmentExpression(node) {
+        if (!isUserFacingVariable(node.left) || !containsUserFacingString(node.right)) return;
+        context.report({
+          node,
+          message: "User-facing variable text must come from src/locales/index.ts, not be written inline."
+        });
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") return;
+        const objectName = getNodeName(node.callee.object);
+        const methodName = getNodeName(node.callee.property);
+        if (objectName !== "toast" || methodName === null || !TOAST_METHOD_NAMES.has(methodName)) return;
+        if (!containsUserFacingString(node.arguments[0])) return;
+        context.report({
+          node,
+          message: "User-facing toast text must come from src/locales/index.ts, not be written inline."
+        });
       }
     };
   }
@@ -4831,6 +4936,11 @@ function isSubstantial(node) {
 function blockChildren(node) {
   return (node.children ?? []).filter(isJsxNode);
 }
+function structuralChildren(node) {
+  return (node.children ?? []).filter(
+    (child) => isJsxNode(child) || isJsxExpressionContainer(child)
+  );
+}
 var repeatedStructureRule = {
   meta: {
     schema: [],
@@ -4850,6 +4960,10 @@ var repeatedStructureRule = {
       }
     };
     function checkChildren(node) {
+      checkSubstantialBlocks(node);
+      checkSmallElementExpressionPairs(node);
+    }
+    function checkSubstantialBlocks(node) {
       const children = blockChildren(node);
       const seen = /* @__PURE__ */ new Map();
       for (const child of children) {
@@ -4862,11 +4976,35 @@ var repeatedStructureRule = {
         if (group.length < 2) continue;
         const first = group[0];
         if (!first || !isSubstantial(first)) continue;
-        context.report({
-          node: first,
-          message: `The same arrangement of elements appears ${String(group.length)} times here; extract it as a named component. Different data or labels do not prevent extraction. See docs/next-codebase-guide/rules/repeated-structure-rule.md`
-        });
+        reportRepeatedStructure(first, group.length);
+      }
+    }
+    function checkSmallElementExpressionPairs(node) {
+      const children = structuralChildren(node);
+      const seen = /* @__PURE__ */ new Map();
+      for (let index = 0; index < children.length - 1; index += 1) {
+        const first = children[index];
+        const second = children[index + 1];
+        if (!first || !second || !isJsxNode(first) || !isJsxExpressionContainer(second) || isSubstantial(first)) {
+          continue;
+        }
+        const sig = `${signature(first)}/{}`;
+        const group = seen.get(sig) ?? [];
+        group.push(first);
+        seen.set(sig, group);
       }
+      for (const [, group] of seen) {
+        if (group.length < 2) continue;
+        const first = group[0];
+        if (!first) continue;
+        reportRepeatedStructure(first, group.length);
+      }
+    }
+    function reportRepeatedStructure(node, count) {
+      context.report({
+        node,
+        message: `The same arrangement of elements appears ${String(count)} times here; extract it as a named component. Different data or labels do not prevent extraction. See docs/next-codebase-guide/rules/repeated-structure-rule.md`
+      });
     }
   }
 };

package/package.json

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