@nkzw/eslint-plugin-fbtee 0.2.2 → 1.0.0

package/lib/index.cjs

@@ -1,470 +1,378 @@
-"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/index.tsx
-var index_exports = {};
-__export(index_exports, {
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
+//#endregion
+const __typescript_eslint_utils = __toESM(require("@typescript-eslint/utils"));
 
-// package.json
+//#region package.json
+var name = "@nkzw/eslint-plugin-fbtee";
+var version = "1.0.0";
+var description = "";
+var keywords = [];
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/nkzw-tech/fbtee.git",
+	"directory": "packages/eslint-plugin-fbtee"
+};
+var license = "MIT";
+var type = "module";
+var exports$1 = {
+	"import": "./lib/index.js",
+	"require": "./lib/index.cjs"
+};
+var main = "lib/index.cjs";
+var scripts = { "build": "tsdown src/index.tsx -d lib --target=node22 --format=esm,cjs --clean --dts" };
+var dependencies = { "@typescript-eslint/utils": "^8.35.1" };
+var devDependencies = { "@typescript-eslint/rule-tester": "^8.35.1" };
 var package_default = {
-  name: "@nkzw/eslint-plugin-fbtee",
-  version: "0.2.2",
-  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"
-  },
-  main: "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.29.0"
-  },
-  devDependencies: {
-    "@typescript-eslint/rule-tester": "^8.29.0"
-  }
+	name,
+	version,
+	description,
+	keywords,
+	repository,
+	license,
+	type,
+	exports: exports$1,
+	main,
+	scripts,
+	dependencies,
+	devDependencies
 };
 
-// src/utils.tsx
-var import_utils = require("@typescript-eslint/utils");
-var createRule = import_utils.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/nkzw-tech/fbtee/blob/main/packages/eslint-plugin-fbtee/docs/rules/${name}.md`
-);
+//#endregion
+//#region src/utils.tsx
+const createRule = __typescript_eslint_utils.ESLintUtils.RuleCreator((name$1) => `https://github.com/nkzw-tech/fbtee/blob/main/packages/eslint-plugin-fbtee/docs/rules/${name$1}.md`);
 function resolveMemberExpressions(object, property) {
-  if (object.type === "JSXMemberExpression") {
-    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
-  }
-  return `${object.name}.${property.name}`;
+	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.");
-    }
-  }
+	if (node.type === "JSXFragment") return "<>";
+	const { name: name$1 } = node.openingElement;
+	switch (name$1.type) {
+		case "JSXIdentifier": return name$1.name;
+		case "JSXMemberExpression": {
+			const { object, property } = name$1;
+			return resolveMemberExpressions(object, property);
+		}
+		case "JSXNamespacedName": return `${name$1.namespace.name}:${name$1.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();
+	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;
+	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);
-  }
-  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;
+	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);
+	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;
+	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;
+	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;
+	if (!node) return null;
+	if (node.type === "JSXElement") {
+		const name$1 = elementType(node);
+		return name$1 === "fbt" || name$1 === "fbs" || name$1?.startsWith("fbt:");
+	}
+	if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+		const name$1 = node.callee.name;
+		return name$1 === "fbt" || name$1 === "fbs";
+	}
+	if (node.type === "MemberExpression" && node.object.type === "CallExpression" && node.object.callee.type === "Identifier") {
+		const name$1 = node.object.callee.name;
+		return name$1 === "fbt" || name$1 === "fbs";
+	}
+	return false;
 }
 
-// src/rules/no-empty-strings.tsx
+//#endregion
+//#region src/rules/no-empty-strings.tsx
 var no_empty_strings_default = createRule({
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (!isFbtNode(node)) {
-          return;
-        }
-        const [text] = node.arguments;
-        if (text && text.type !== "SpreadElement" && isEmptyString(text)) {
-          context.report({
-            messageId: "emptyString",
-            node: text
-          });
-        }
-      },
-      JSXElement(node) {
-        if (!isFbtNode(node)) {
-          return;
-        }
-        if (node.openingElement.name.type === "JSXNamespacedName") {
-          return;
-        }
-        const hasTextContent = validateChildren(node);
-        if (!hasTextContent) {
-          context.report({
-            messageId: "jsxEmptyString",
-            node
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow empty strings in fbt elements or function calls."
-    },
-    messages: {
-      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"
+	create(context) {
+		return {
+			CallExpression(node) {
+				if (!isFbtNode(node)) return;
+				const [text] = node.arguments;
+				if (text && text.type !== "SpreadElement" && isEmptyString(text)) context.report({
+					messageId: "emptyString",
+					node: text
+				});
+			},
+			JSXElement(node) {
+				if (!isFbtNode(node)) return;
+				if (node.openingElement.name.type === "JSXNamespacedName") return;
+				const hasTextContent = validateChildren(node);
+				if (!hasTextContent) context.report({
+					messageId: "jsxEmptyString",
+					node
+				});
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow empty strings in fbt elements or function calls." },
+		messages: {
+			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) {
-  let hasTextContent = false;
-  for (const child of node.children) {
-    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;
-      }
-      const value = resolveNodeValue(child.expression)?.trim();
-      if (value) {
-        hasTextContent = true;
-      }
-    }
-    if (child.type === "JSXElement" || child.type === "JSXFragment") {
-      const childName = elementType(child);
-      if (/^[A-Z]/.test(childName) || childName.startsWith("fbt:")) {
-        hasTextContent = true;
-        continue;
-      }
-      hasTextContent ||= validateChildren(child);
-    }
-    if (hasTextContent) {
-      break;
-    }
-  }
-  return hasTextContent;
+	let hasTextContent = false;
+	for (const child of node.children) {
+		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;
+			}
+			const value = resolveNodeValue(child.expression)?.trim();
+			if (value) hasTextContent = true;
+		}
+		if (child.type === "JSXElement" || child.type === "JSXFragment") {
+			const childName = elementType(child);
+			if (/^[A-Z]/.test(childName) || childName.startsWith("fbt:")) {
+				hasTextContent = true;
+				continue;
+			}
+			hasTextContent ||= validateChildren(child);
+		}
+		if (hasTextContent) break;
+	}
+	return hasTextContent;
 }
 function isEmptyString(node) {
-  return resolveNodeValue(node)?.trim() === "";
+	return resolveNodeValue(node)?.trim() === "";
 }
 
-// src/rules/no-unhelpful-desc.tsx
+//#endregion
+//#region src/rules/no-unhelpful-desc.tsx
 var no_unhelpful_desc_default = createRule({
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (!isFbtNode(node)) {
-          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 (!isFbtNode(node.parent.parent)) {
-          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"
+	create(context) {
+		return {
+			CallExpression(node) {
+				if (!isFbtNode(node)) 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 (!isFbtNode(node.parent.parent)) 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/rules/no-untranslated-strings.tsx
-var attributes = /* @__PURE__ */ new Set([
-  "title",
-  "placeholder",
-  "alt",
-  "label",
-  "aria-label",
-  "aria-errormessage"
+//#endregion
+//#region src/rules/no-untranslated-strings.tsx
+const attributes = 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"
+	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 index_default = {
-  configs: {
-    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
-      }
-    }
-  },
-  meta: {
-    name: package_default.name,
-    version: package_default.version
-  },
-  rules: {
-    "no-empty-strings": no_empty_strings_default,
-    "no-unhelpful-desc": no_unhelpful_desc_default,
-    "no-untranslated-strings": no_untranslated_strings_default
-  }
+//#endregion
+//#region src/index.tsx
+var src_default = {
+	configs: {
+		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
+		} }
+	},
+	meta: {
+		name: package_default.name,
+		version: package_default.version
+	},
+	rules: {
+		"no-empty-strings": no_empty_strings_default,
+		"no-unhelpful-desc": no_unhelpful_desc_default,
+		"no-untranslated-strings": no_untranslated_strings_default
+	}
 };
+
+//#endregion
+module.exports = src_default;