@nkzw/eslint-plugin-fbtee 0.1.3 → 0.2.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@nkzw/eslint-plugin-fbtee",
-  version: "0.1.3",
+  version: "0.2.0",
   description: "",
   keywords: [],
   repository: {
@@ -19,17 +19,17 @@ var package_default = {
     build: "tsup src/index.tsx -d lib --target=node22 --format=esm,cjs --clean --no-splitting --dts"
   },
   dependencies: {
-    "@typescript-eslint/utils": "^8.18.0"
+    "@typescript-eslint/utils": "^8.18.2"
   },
   devDependencies: {
-    "@typescript-eslint/rule-tester": "^8.18.0"
+    "@typescript-eslint/rule-tester": "^8.18.2"
   }
 };
 
 // src/utils.tsx
 import { ESLintUtils } from "@typescript-eslint/utils";
 var createRule = ESLintUtils.RuleCreator(
-  (name) => `https://github.com/nkzw-tech/fbtee/tree/main/packages/eslint-plugin-fbt/docs/rules/${name}`
+  (name) => `https://github.com/nkzw-tech/fbtee/blob/main/packages/eslint-plugin-fbtee/docs/rules/${name}.md`
 );
 function resolveMemberExpressions(object, property) {
   if (object.type === "JSXMemberExpression") {
@@ -93,15 +93,59 @@ function resolveNodeValue(node) {
   if (node.type === "JSXExpressionContainer") {
     return resolveNodeValue(node.expression);
   }
+  if (node.type === "ConditionalExpression") {
+    const consequent = resolveNodeValue(node.consequent);
+    const alternate = resolveNodeValue(node.alternate);
+    return consequent || alternate || null;
+  }
+  if (node.type === "LogicalExpression") {
+    const left = resolveNodeValue(node.left);
+    const right = resolveNodeValue(node.right);
+    return left || right || null;
+  }
   return null;
 }
+function getPropName(prop) {
+  if (prop.name.type === "JSXNamespacedName") {
+    return `${prop.name.namespace.name}:${prop.name.name.name}`;
+  }
+  return prop.name.name;
+}
+function hasFbtParent(node) {
+  let current = node.parent;
+  while (current) {
+    if (isFbtNode(current)) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isFbtNode(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === "JSXElement") {
+    const name = elementType(node);
+    return name === "fbt" || name === "fbs" || name?.startsWith("fbt:");
+  }
+  if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+    const name = node.callee.name;
+    return name === "fbt" || name === "fbs";
+  }
+  if (node.type === "MemberExpression" && node.object.type === "CallExpression" && node.object.callee.type === "Identifier") {
+    const name = node.object.callee.name;
+    return name === "fbt" || name === "fbs";
+  }
+  return false;
+}
 
 // src/rules/no-empty-strings.tsx
 var no_empty_strings_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "Identifier" || !(node.callee.name === "fbt" || node.callee.name === "fbs")) {
+        if (!isFbtNode(node)) {
           return;
         }
         const [text] = node.arguments;
@@ -113,18 +157,18 @@ var no_empty_strings_default = createRule({
         }
       },
       JSXElement(node) {
-        if (elementType(node) !== "fbt") {
+        if (!isFbtNode(node)) {
+          return;
+        }
+        if (node.openingElement.name.type === "JSXNamespacedName") {
           return;
         }
-        const nodesToReport = /* @__PURE__ */ new Set();
-        const hasTextContent = validateChildren(node, nodesToReport);
+        const hasTextContent = validateChildren(node);
         if (!hasTextContent) {
-          for (const node2 of nodesToReport) {
-            context.report({
-              messageId: "jsxEmptyString",
-              node: node2
-            });
-          }
+          context.report({
+            messageId: "jsxEmptyString",
+            node
+          });
         }
       }
     };
@@ -135,30 +179,30 @@ var no_empty_strings_default = createRule({
       description: "Disallow empty strings in fbt elements or function calls."
     },
     messages: {
-      emptyString: "Empty strings are not allowed in fbt() or fbs() function arguments.",
-      jsxEmptyString: "Empty strings are not allowed as children of <fbt> tags."
+      emptyString: "Empty strings are not allowed in fbt() and fbs() function arguments.",
+      jsxEmptyString: "Empty strings are not allowed as children of `<fbt>` and `<fbs>` tags."
     },
     schema: [],
     type: "problem"
   },
   name: "no-empty-strings"
 });
-function validateChildren(node, nodesToReport) {
+function validateChildren(node) {
   let hasTextContent = false;
   for (const child of node.children) {
-    if (child.type === "JSXText" && node.children.length === 1) {
-      if (child.value.trim() === "") {
-        nodesToReport.add(child);
-      } else {
+    if (child.type === "JSXText" && child.value.trim() !== "") {
+      hasTextContent = true;
+    }
+    if (child.type === "JSXExpressionContainer") {
+      if (child.expression.type === "JSXEmptyExpression") {
+        continue;
+      }
+      if (child.expression.type === "Identifier" && child.expression.name !== "undefined") {
         hasTextContent = true;
+        continue;
       }
-    }
-    if (child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression") {
-      if (isEmptyString(child.expression) && (node.children.length === 1 || node.children.every(
-        (otherChild) => child === otherChild || otherChild.type === "JSXText" && otherChild.value.trim() === ""
-      ))) {
-        nodesToReport.add(child.expression);
-      } else {
+      const value = resolveNodeValue(child.expression)?.trim();
+      if (value) {
         hasTextContent = true;
       }
     }
@@ -168,15 +212,12 @@ function validateChildren(node, nodesToReport) {
         hasTextContent = true;
         continue;
       }
-      hasTextContent ||= validateChildren(child, nodesToReport);
+      hasTextContent ||= validateChildren(child);
     }
     if (hasTextContent) {
       break;
     }
   }
-  if (!hasTextContent && nodesToReport.size === 0) {
-    nodesToReport.add(node);
-  }
   return hasTextContent;
 }
 function isEmptyString(node) {
@@ -188,7 +229,7 @@ var no_unhelpful_desc_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "Identifier" || !(node.callee.name === "fbt" || node.callee.name === "fbs")) {
+        if (!isFbtNode(node)) {
           return;
         }
         const [textArg, descArg] = node.arguments;
@@ -216,7 +257,7 @@ var no_unhelpful_desc_default = createRule({
         }
       },
       JSXAttribute(node) {
-        if (elementType(node.parent.parent) !== "fbt") {
+        if (!isFbtNode(node.parent.parent)) {
           return;
         }
         if (node.name.name !== "desc" || !node.value) {
@@ -267,6 +308,112 @@ var no_unhelpful_desc_default = createRule({
   name: "no-unhelpful-desc"
 });
 
+// src/rules/no-untranslated-strings.tsx
+var attributes = /* @__PURE__ */ new Set([
+  "title",
+  "placeholder",
+  "alt",
+  "label",
+  "aria-label",
+  "aria-errormessage"
+]);
+var no_untranslated_strings_default = createRule({
+  create(context, options) {
+    const ignoredWords = new Set(
+      options[0].ignoredWords.map((s) => s.trim().toLowerCase())
+    );
+    function isIgnoredWord(value) {
+      return ignoredWords.has(value.trim().toLowerCase());
+    }
+    return {
+      JSXAttribute(node) {
+        const propName = getPropName(node);
+        if (!attributes.has(propName)) {
+          return;
+        }
+        const value = node.value ? resolveNodeValue(node.value) : null;
+        if (!value) {
+          return;
+        }
+        if (isIgnoredWord(value)) {
+          return;
+        }
+        if (node.value?.type === "JSXExpressionContainer" && isFbtNode(node.value.expression)) {
+          return;
+        }
+        context.report({
+          messageId: "unwrappedString",
+          node
+        });
+      },
+      JSXExpressionContainer(node) {
+        if (node.parent.type === "JSXAttribute") {
+          return;
+        }
+        const value = resolveNodeValue(node.expression);
+        if (!value) {
+          return;
+        }
+        if (isIgnoredWord(value)) {
+          return;
+        }
+        if (!hasFbtParent(node)) {
+          context.report({
+            messageId: "unwrappedString",
+            node
+          });
+        }
+      },
+      JSXText(node) {
+        const value = node.value.trim();
+        if (!value) {
+          return;
+        }
+        if (isIgnoredWord(value)) {
+          return;
+        }
+        if (!hasFbtParent(node)) {
+          const startOffset = node.range[0] + node.value.indexOf(value);
+          const endOffset = startOffset + value.length;
+          context.report({
+            loc: {
+              end: context.sourceCode.getLocFromIndex(endOffset),
+              start: context.sourceCode.getLocFromIndex(startOffset)
+            },
+            messageId: "unwrappedString"
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [{ ignoredWords: [] }],
+  meta: {
+    docs: {
+      description: "Enforce text content to be wrapped with `<fbt>`, `fbt()` or `fbs()`"
+    },
+    messages: {
+      unwrappedString: "Text content must be wrapped in `<fbt>`, `fbt()` or `fbs()`"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoredWords: {
+            items: {
+              type: "string"
+            },
+            type: "array",
+            uniqueItems: true
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-untranslated-strings"
+});
+
 // src/index.tsx
 var meta = {
   name: package_default.name,
@@ -274,14 +421,22 @@ var meta = {
 };
 var rules = {
   "no-empty-strings": no_empty_strings_default,
-  "no-unhelpful-desc": no_unhelpful_desc_default
+  "no-unhelpful-desc": no_unhelpful_desc_default,
+  "no-untranslated-strings": no_untranslated_strings_default
 };
 var configs = {
-  strict: {
+  recommended: {
     rules: {
       "@nkzw/fbtee/no-empty-strings": 2,
       "@nkzw/fbtee/no-unhelpful-desc": 2
     }
+  },
+  strict: {
+    rules: {
+      "@nkzw/fbtee/no-empty-strings": 2,
+      "@nkzw/fbtee/no-unhelpful-desc": 2,
+      "@nkzw/fbtee/no-untranslated-strings": 2
+    }
   }
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/eslint-plugin-fbtee",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -15,10 +15,10 @@
     "require": "./lib/index.cjs"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.18.0"
+    "@typescript-eslint/utils": "^8.18.2"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "^8.18.0"
+    "@typescript-eslint/rule-tester": "^8.18.2"
   },
   "scripts": {
     "build": "tsup src/index.tsx -d lib --target=node22 --format=esm,cjs --clean --no-splitting --dts"

package/src/__tests__/no-empty-strings-test.tsx

@@ -66,7 +66,70 @@ ruleTester.run('no-empty-strings', rule, {
       `,
       errors: [
         {
-          line: 3,
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">{}</fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          {}
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          {null}
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          {undefined}
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          {/* This is a comment */}
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
           messageId: 'jsxEmptyString',
         },
       ],
@@ -79,7 +142,7 @@ ruleTester.run('no-empty-strings', rule, {
       `,
       errors: [
         {
-          line: 3,
+          line: 2,
           messageId: 'jsxEmptyString',
         },
       ],
@@ -92,7 +155,20 @@ ruleTester.run('no-empty-strings', rule, {
       `,
       errors: [
         {
-          line: 3,
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+
+    // <fbs>
+    {
+      code: `
+        <fbs desc="Greeting"></fbs>;
+      `,
+      errors: [
+        {
+          line: 2,
           messageId: 'jsxEmptyString',
         },
       ],
@@ -164,6 +240,13 @@ ruleTester.run('no-empty-strings', rule, {
         <fbt desc="Greeting">Hello world</fbt>;
       `,
     },
+    {
+      code: `
+        <fbt desc="Greeting">
+          Hello <span>world</span>
+        </fbt>;
+      `,
+    },
     {
       code: `
         <fbt desc="Greeting">{dynamicValue}</fbt>;
@@ -240,6 +323,13 @@ ruleTester.run('no-empty-strings', rule, {
       `,
     },
 
+    // <fbs>
+    {
+      code: `
+        <fbs desc="Greeting">Hello world</fbs>;
+      `,
+    },
+
     // fbt()
     {
       code: `

package/src/__tests__/no-unhelpful-desc-test.tsx

@@ -114,6 +114,19 @@ ruleTester.run('unhelpful-desc', rule, {
       ],
     },
 
+    // <fbs>
+    {
+      code: `
+        <fbt desc="">Hello world</fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyDesc',
+        },
+      ],
+    },
+
     // fbt()
     {
       code: `
@@ -274,6 +287,13 @@ ruleTester.run('unhelpful-desc', rule, {
       `,
     },
 
+    // <fbs>
+    {
+      code: `
+        <fbs desc="Greeting">Hello world</fbs>;
+      `,
+    },
+
     // fbt()
     {
       code: `