@rpcbase/eslint-config 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/eslint-config",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -18,7 +18,8 @@
       "dependencies": [],
       "files": [
         "package.json",
-        "eslint.config.js"
+        "eslint.config.js",
+        "src/"
       ],
       "output": [],
       "env": {
@@ -33,6 +34,7 @@
   },
   "dependencies": {
     "@eslint/js": "9.26.0",
+    "@typescript-eslint/experimental-utils": "5.62.0",
     "eslint-config-flat-gitignore": "2.1.0",
     "eslint-import-resolver-typescript": "4.3.4",
     "eslint-plugin-import": "2.31.0",
@@ -43,7 +45,7 @@
   },
   "devDependencies": {
     "@types/eslint": "9.6.1",
-    "typescript": "^5.x",
-    "eslint": "^9.x"
+    "eslint": "^9.x",
+    "typescript": "^5.x"
   }
 }

package/src/rules/no-lone-text-node.ts

@@ -0,0 +1,160 @@
+import { TSESTree, ESLintUtils } from "@typescript-eslint/experimental-utils"
+
+type MessageIds = "loneText"
+
+/**
+ * Options accepted by the rule.
+ * Currently only `ignoredChars` is supported.
+ */
+type RuleOptions = {
+  /**
+   * Additional characters that should be treated as "ignorable"
+   * when they appear as the only non-whitespace content of a text node.
+   */
+  ignoredChars?: string[]
+}
+
+type Options = [RuleOptions]
+
+const createRule = ESLintUtils.RuleCreator(
+  name => `@rpcbase/eslint-config/rules/${name}`
+)
+
+const defaultIgnoredChars = ["*", ":", "·", "•", "—", "–", "…", "-", "+", "(", ")", "\"", "\'"]
+
+function isIgnoredText(text: string, ignored: string[]) {
+  // ignore if every non-whitespace char is in the list
+  return (
+    text.length > 0 &&
+    text.split("").every(ch => ch.trim().length === 0 || ignored.includes(ch))
+  )
+}
+
+function isMeaningful(child: TSESTree.JSXChild, ignored: string[]): boolean {
+  if (child.type === "JSXText") {
+    return !isIgnoredText(child.value.trim(), ignored) && child.value.trim().length > 0
+  }
+
+  if (
+    child.type === "JSXExpressionContainer" &&
+    child.expression.type === "Literal" &&
+    typeof child.expression.value === "string"
+  ) {
+    return child.expression.value.trim().length > 0
+  }
+
+  // Any non-text node counts as meaningful
+  return true
+}
+
+export const rules = {
+  "no-lone-text-node": createRule<Options, MessageIds>({
+    name: "no-lone-text-node",
+    meta: {
+      type: "problem",
+      docs: {
+        description: "disallow raw text nodes in JSX",
+        recommended: "error"
+      },
+      messages: {
+        loneText:
+          "Wrap text '{{text}}' in an element (e.g. <span>) to avoid Google Translate crashes."
+      },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            ignoredChars: {
+              type: "array",
+              items: { type: "string" }
+            }
+          },
+          additionalProperties: false
+        }
+      ]
+    },
+    defaultOptions: [{}],
+    create(context) {
+      //--------------------------------------------------------------------
+      // helpers
+      //--------------------------------------------------------------------
+      function report(node: TSESTree.Node, value: string) {
+        context.report({ node, messageId: "loneText", data: { text: value } })
+      }
+
+      //--------------------------------------------------------------------
+      // visitors
+      //--------------------------------------------------------------------
+      return {
+        JSXElement(node) {
+          const options = context.options[0] ?? {}
+          const ignored = options.ignoredChars ?? defaultIgnoredChars
+
+          // all meaningful children (ignoring whitespace & ignored chars)
+          const meaningfulChildren = node.children.filter(child =>
+            isMeaningful(child, ignored)
+          )
+
+          const singleMeaningfulTextChild =
+            meaningfulChildren.length === 1 &&
+            (meaningfulChildren[0].type === "JSXText" ||
+              (meaningfulChildren[0].type === "JSXExpressionContainer" &&
+                meaningfulChildren[0].expression.type === "Literal" &&
+                typeof meaningfulChildren[0].expression.value === "string"))
+
+          node.children.forEach(child => {
+            // --------------------------------------------------------------
+            // raw JSX text
+            // --------------------------------------------------------------
+            if (
+              child.type === "JSXText" &&
+              !isIgnoredText(child.value.trim(), ignored) &&
+              child.value.trim().length > 0
+            ) {
+              if (singleMeaningfulTextChild) return
+              report(child, child.value.trim())
+            }
+
+            // --------------------------------------------------------------
+            // {"string literal"} expression
+            // --------------------------------------------------------------
+            if (
+              child.type === "JSXExpressionContainer" &&
+              child.expression.type === "Literal" &&
+              typeof child.expression.value === "string" &&
+              child.expression.value.trim().length > 0
+            ) {
+              if (singleMeaningfulTextChild) return
+              report(child, child.expression.value.trim())
+            }
+          })
+        },
+
+        // Fragments: always report raw text, even if it's the only child
+        JSXFragment(node) {
+          const options = context.options[0] ?? {}
+          const ignored = options.ignoredChars ?? defaultIgnoredChars
+
+          node.children.forEach(child => {
+            if (
+              child.type === "JSXText" &&
+              !isIgnoredText(child.value.trim(), ignored) &&
+              child.value.trim().length > 0
+            ) {
+              report(child, child.value.trim())
+            }
+
+            if (
+              child.type === "JSXExpressionContainer" &&
+              child.expression.type === "Literal" &&
+              typeof child.expression.value === "string" &&
+              child.expression.value.trim().length > 0
+            ) {
+              report(child, child.expression.value.trim())
+            }
+          })
+        }
+      }
+    }
+  })
+}