@nkzw/eslint-plugin-fbtee 0.0.1

package/lib/index.js

@@ -0,0 +1,284 @@
+// package.json
+var package_default = {
+  name: "@nkzw/eslint-plugin-fbtee",
+  version: "0.0.1",
+  description: "",
+  keywords: [],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/nkzw-tech/fbtee.git",
+    directory: "packages/eslint-plugin-fbtee"
+  },
+  license: "MIT",
+  type: "module",
+  exports: {
+    import: "./lib/index.js",
+    require: "./lib/index.cjs"
+  },
+  scripts: {
+    build: "tsup src/index.tsx -d lib --target=node22 --format=esm,cjs --clean --no-splitting --dts"
+  },
+  dependencies: {
+    "@typescript-eslint/utils": "^8.18.0"
+  },
+  devDependencies: {
+    "@typescript-eslint/rule-tester": "^8.18.0"
+  }
+};
+
+// 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}`
+);
+function resolveMemberExpressions(object, property) {
+  if (object.type === "JSXMemberExpression") {
+    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
+  }
+  return `${object.name}.${property.name}`;
+}
+function elementType(node) {
+  if (node.type === "JSXFragment") {
+    return "<>";
+  }
+  const { name } = node.openingElement;
+  switch (name.type) {
+    case "JSXIdentifier": {
+      return name.name;
+    }
+    case "JSXMemberExpression": {
+      const { object, property } = name;
+      return resolveMemberExpressions(object, property);
+    }
+    case "JSXNamespacedName": {
+      return `${name.namespace.name}:${name.name.name}`;
+    }
+    default: {
+      throw new Error("Unsupported JSX node type.");
+    }
+  }
+}
+function resolveJsxElementTextContent(node) {
+  return node.children.map((child) => {
+    if (child.type === "JSXText") {
+      return child.value.trim();
+    }
+    if (child.type === "JSXExpressionContainer") {
+      return resolveNodeValue(child.expression) || "";
+    }
+    return "";
+  }).join("").trim();
+}
+function resolveBinaryExpression(node) {
+  if (node.operator !== "+") {
+    return null;
+  }
+  const leftValue = resolveNodeValue(node.left);
+  const rightValue = resolveNodeValue(node.right);
+  if (leftValue !== null && rightValue !== null) {
+    return leftValue + rightValue;
+  }
+  return null;
+}
+function resolveNodeValue(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis.map((quasi) => quasi.value.raw).join("");
+  }
+  if (node.type === "BinaryExpression") {
+    return resolveBinaryExpression(node);
+  }
+  if (node.type === "JSXExpressionContainer") {
+    return resolveNodeValue(node.expression);
+  }
+  return null;
+}
+
+// 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")) {
+          return;
+        }
+        const [text] = node.arguments;
+        if (text && text.type !== "SpreadElement" && isEmptyString(text)) {
+          context.report({
+            messageId: "emptyString",
+            node: text
+          });
+        }
+      },
+      JSXElement(node) {
+        if (elementType(node) !== "fbt") {
+          return;
+        }
+        const nodesToReport = /* @__PURE__ */ new Set();
+        const hasTextContent = validateChildren(node, nodesToReport);
+        if (!hasTextContent) {
+          for (const node2 of nodesToReport) {
+            context.report({
+              messageId: "jsxEmptyString",
+              node: node2
+            });
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      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."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-empty-strings"
+});
+function validateChildren(node, nodesToReport) {
+  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 {
+        hasTextContent = true;
+      }
+    }
+    if (child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression") {
+      if (isEmptyString(child.expression)) {
+        nodesToReport.add(child.expression);
+      } else {
+        hasTextContent = true;
+      }
+    }
+    if (child.type === "JSXElement" || child.type === "JSXFragment") {
+      hasTextContent ||= validateChildren(child, nodesToReport);
+    }
+    if (hasTextContent) {
+      break;
+    }
+  }
+  if (!hasTextContent && nodesToReport.size === 0) {
+    nodesToReport.add(node);
+  }
+  return hasTextContent;
+}
+function isEmptyString(node) {
+  return resolveNodeValue(node)?.trim() === "";
+}
+
+// src/rules/no-unhelpful-desc.tsx
+var no_unhelpful_desc_default = createRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || !(node.callee.name === "fbt" || node.callee.name === "fbs")) {
+          return;
+        }
+        const [textArg, descArg] = node.arguments;
+        const desc = descArg && descArg.type !== "SpreadElement" ? resolveNodeValue(descArg)?.trim() : null;
+        if (!desc) {
+          context.report({
+            messageId: "emptyDesc",
+            node: descArg || node
+          });
+          return;
+        }
+        if (desc.length <= 4) {
+          context.report({
+            messageId: "shortDesc",
+            node: descArg || node
+          });
+          return;
+        }
+        const text = textArg && textArg.type !== "SpreadElement" ? resolveNodeValue(textArg)?.trim() : null;
+        if (desc.toLowerCase() === text?.toLowerCase()) {
+          context.report({
+            messageId: "duplicateDesc",
+            node: descArg || node
+          });
+        }
+      },
+      JSXAttribute(node) {
+        if (elementType(node.parent.parent) !== "fbt") {
+          return;
+        }
+        if (node.name.name !== "desc" || !node.value) {
+          return;
+        }
+        if (node.value.type === "JSXExpressionContainer" && (node.value.expression.type === "Identifier" || node.value.expression.type === "CallExpression")) {
+          return;
+        }
+        const desc = resolveNodeValue(node.value)?.trim();
+        if (!desc) {
+          context.report({
+            messageId: "jsxEmptyDesc",
+            node: node.value
+          });
+          return;
+        }
+        if (desc.length <= 4) {
+          context.report({
+            messageId: "shortDesc",
+            node: node.value
+          });
+          return;
+        }
+        const textContent = resolveJsxElementTextContent(node.parent.parent);
+        if (desc.toLowerCase() === textContent.toLowerCase()) {
+          context.report({
+            messageId: "duplicateDesc",
+            node: node.value
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce meaningful and non-empty descriptions in <fbt> elements and fbt()/fbs() function calls."
+    },
+    messages: {
+      duplicateDesc: 'The "desc" attribute or argument should not be a duplicate of the text content.',
+      emptyDesc: 'The "desc" argument in fbt() and fbs() must not be empty.',
+      jsxEmptyDesc: 'The "desc" attribute in <fbt> must not be empty.',
+      shortDesc: 'The "desc" attribute or argument is too short. Use a more descriptive and meaningful explanation.'
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-unhelpful-desc"
+});
+
+// src/index.tsx
+var meta = {
+  name: package_default.name,
+  version: package_default.version
+};
+var rules = {
+  "no-empty-strings": no_empty_strings_default,
+  "no-unhelpful-desc": no_unhelpful_desc_default
+};
+var configs = {
+  strict: {
+    rules: {
+      "@nkzw/fbtee/no-empty-strings": 2,
+      "@nkzw/fbtee/no-unhelpful-desc": 2
+    }
+  }
+};
+export {
+  configs,
+  meta,
+  rules
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@nkzw/eslint-plugin-fbtee",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nkzw-tech/fbtee.git",
+    "directory": "packages/eslint-plugin-fbtee"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "import": "./lib/index.js",
+    "require": "./lib/index.cjs"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.18.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/rule-tester": "^8.18.0"
+  },
+  "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

@@ -0,0 +1,210 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import rule from '../rules/no-empty-strings.tsx';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+});
+
+ruleTester.run('no-empty-strings', rule, {
+  invalid: [
+    {
+      code: `
+        <fbt desc="Greeting"></fbt>;
+      `,
+      errors: [
+        {
+          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">  </fbt>;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          {' '}
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          <span></span>
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          <></>
+        </fbt>;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'jsxEmptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        fbt('', 'Greeting');
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'emptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        fbt(' ', 'Greeting');
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'emptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        fbt(\`\`, 'Greeting');
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'emptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        fbt(\` \`, 'Greeting');
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'emptyString',
+        },
+      ],
+    },
+    {
+      code: `
+        fbs('', 'Greeting');
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'emptyString',
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      code: `
+        <fbt desc="Greeting">Hello world</fbt>;
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">{dynamicValue}</fbt>;
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">Hello {name}</fbt>;
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">{'Hello'}</fbt>;
+      `,
+    },
+    {
+      code: `
+        fbt('Hello world', 'Greeting');
+      `,
+    },
+    {
+      code: `
+        const text = 'Hello';
+        fbt(text, 'Greeting');
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          <span>Non-empty child</span>
+        </fbt>;
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          <span>Non-empty child with empty sibling</span>
+          <span></span>
+        </fbt>;
+      `,
+    },
+    {
+      code: `
+        <fbt desc="Greeting">
+          <>Hello</>
+        </fbt>;
+      `,
+    },
+  ],
+});