@bigbinary/eslint-plugin-neeto 1.1.16 → 1.1.18

package/README.md

@@ -46,6 +46,7 @@ module.exports = {
 
 ## Exported rules
 
+- [no-withT-for-smart-components](./docs/src/rules/no-withT-for-smart-components.md)
 - [no-large-functions-inside-jsx](./docs/src/rules/no-large-functions-inside-jsx.md)
 - [use-standard-date-time-formats](./docs/src/rules/use-standard-date-time-formats.md)
 - [no-dumb-components-with-use-translation](./docs/src/rules/no-dumb-components-with-use-translation.md)

package/dist/index.js

@@ -42,6 +42,7 @@
   var commonResolve$2 = loadJS$2("node_modules/@bigbinary/neeto-commons-frontend/configs/webpack/resolve.js");
   var resolve$2 = ramda.mergeDeepLeft(projectResolve$2, commonResolve$2);
   var rules = {
+    "@bigbinary/neeto/no-withT-for-smart-components": "error",
     "@bigbinary/neeto/no-large-functions-inside-jsx": "error",
     "@bigbinary/neeto/use-standard-date-time-formats": "error",
     "@bigbinary/neeto/no-dumb-components-with-use-translation": "error",
@@ -544,6 +545,7 @@
   var PROP_KEY_VALUE_DUPLICATE = "Prop key and value names should not be repeated";
   var USE_WITH_IMMUTABLE_ACTIONS_WRAPPER = 'Use "withImmutableActions" wrapper from "neeto-commons-frontend" inside zustand create. Refer: https://bit.ly/withimmutableactions';
   var USE_WITH_T_HOC_IN_DUMB_COMPONENTS = 'Use "withT" HOC from "neeto-commons-frontend" instead of useTranslation hook in Dumb components';
+  var NO_WITH_T_IN_SMART_COMPONENTS = '"withT" HOC should only be used in dumb components. "useTranslation" hook should be used here.';
   var USE_STANDARD_DATE_TIME_FORMATS = 'Use "dateFormat/timeFormat" from "@bigbinary/neeto-commons-frontend/utils" instead. Refer: https://github.com/bigbinary/neeto-commons-frontend/blob/main/docs/utils/README.md#dateformattimeformat';
 
   var PACKAGES_TO_CHECK = ["@bigbinary/neeto-molecules", "@bigbinary/neetoui", "@bigbinary/neeto-commons-frontend"];
@@ -3862,6 +3864,41 @@
       }
     }]
   };
+  var WRAPPED_WITH_T_PATTERN = {
+    type: TYPES.VARIABLE_DECLARATOR,
+    init: {
+      type: TYPES.CALL_EXPRESSION,
+      callee: {
+        name: "withT"
+      },
+      arguments: [{
+        body: {
+          type: TYPES.BLOCK_STATEMENT,
+          body: function body(_body) {
+            return _body.length >= 2;
+          }
+        }
+      }]
+    },
+    id: {
+      type: TYPES.IDENTIFIER,
+      name: ramda.test(PASCAL_CASE_REGEX)
+    }
+  };
+  var EXPORTED_WITH_T_PATTERN = {
+    type: TYPES.EXPORT_DEFAULT_DECLARATION,
+    declaration: {
+      type: TYPES.CALL_EXPRESSION,
+      callee: {
+        type: TYPES.IDENTIFIER,
+        name: "withT"
+      },
+      arguments: ramda.any(pure.matches({
+        type: TYPES.IDENTIFIER,
+        name: ramda.test(PASCAL_CASE_REGEX)
+      }))
+    }
+  };
 
   // components={{}}
   var COMPONENTS_PROP_PATTERN = {
@@ -4447,6 +4484,7 @@
           if (!isInsideComponentsDirectory(context)) return;
           var componentNodes = findMatchingNodesDeep(node.body, COMPONENT_PATTERN);
           if (ramda.isEmpty(componentNodes)) return;
+          var isExportedWithT = patternExistsDeep(EXPORTED_WITH_T_PATTERN, node);
           componentNodes.forEach(function (node) {
             var tFunctionMemeberExpressionNodes = findMatchingNodesDeep(node, T_FUNCTION_MEMBER_EXPRESSION_PATTERN);
             tFunctionMemeberExpressionNodes.forEach(function (node) {
@@ -4458,7 +4496,9 @@
             var tFunctionNodes = findMatchingNodesDeep(node, T_FUNCTION_PATTERN);
             if (ramda.isEmpty(tFunctionNodes)) return;
             var isUseTranslationHookPresent = patternExistsDeep(USE_TRANSLATION_HOOK_PATTERN, node);
+            var isWrappedWithT = patternExistsDeep(WRAPPED_WITH_T_PATTERN, node) || isExportedWithT;
             if (isUseTranslationHookPresent) return;
+            if (isWrappedWithT) return;
             tFunctionNodes.forEach(function (node) {
               context.report({
                 node: node,
@@ -6487,6 +6527,110 @@
     }
   };
 
+  var REACT_I18_IMPORT_PATTERN = {
+    type: TYPES.IMPORT_DECLARATION,
+    source: {
+      type: TYPES.LITERAL,
+      value: "react-i18next"
+    },
+    specifiers: [{
+      type: TYPES.IMPORT_SPECIFIER
+    }]
+  };
+  var WITH_T_HOC_PATTERN = {
+    type: TYPES.VARIABLE_DECLARATION,
+    kind: "const",
+    declarations: [{
+      type: TYPES.VARIABLE_DECLARATOR,
+      init: {
+        type: TYPES.CALL_EXPRESSION,
+        callee: {
+          name: "withT"
+        },
+        arguments: [{
+          body: {
+            type: TYPES.BLOCK_STATEMENT,
+            body: function body(_body) {
+              return _body.length >= 2;
+            }
+          }
+        }]
+      },
+      id: {
+        type: TYPES.IDENTIFIER,
+        name: ramda.test(PASCAL_CASE_REGEX)
+      }
+    }]
+  };
+
+  var insertTextAfterPosition = function insertTextAfterPosition(position, inputString, textToInsert) {
+    var firstCharacter = inputString.charAt(position);
+    var restOfString = inputString.slice(position + 1);
+    return firstCharacter + textToInsert + restOfString;
+  };
+
+  var noWithTForSmartComponents = {
+    meta: {
+      type: "problem",
+      docs: {
+        url: "https://github.com/bigbinary/eslint-plugin-neeto/blob/main/docs/src/rules/no-withT-for-smart-components.md",
+        description: "Disallows usage of 'withT' HOC in smart components."
+      },
+      fixable: "code"
+    },
+    create: function create(context) {
+      return {
+        VariableDeclaration: function VariableDeclaration(node) {
+          if (!pure.matches(WITH_T_HOC_PATTERN, node)) return;
+          var arrowFunctionExpression = node.declarations[0].init.arguments[0];
+          var body = arrowFunctionExpression.body;
+          context.report({
+            node: node,
+            message: NO_WITH_T_IN_SMART_COMPONENTS,
+            fix: function fix(fixer) {
+              var fixers = [];
+              var _arrowFunctionExpress = _toArray(arrowFunctionExpression.params),
+                props = _arrowFunctionExpress[0],
+                restParams = _arrowFunctionExpress.slice(1);
+              var getPropsCode = function getPropsCode() {
+                if (ramda.isEmpty(arrowFunctionExpression.params)) return "";
+                if (props.type === TYPES.IDENTIFIER) {
+                  return "{...".concat(getCode$1(context, props), " }");
+                }
+                if (props.type === TYPES.OBJECT_PATTERN) {
+                  var _props$properties, _props$properties2, _props$properties2$0$;
+                  if (((_props$properties = props.properties) === null || _props$properties === void 0 ? void 0 : _props$properties.length) === 1 && ((_props$properties2 = props.properties) === null || _props$properties2 === void 0 ? void 0 : (_props$properties2$0$ = _props$properties2[0].value) === null || _props$properties2$0$ === void 0 ? void 0 : _props$properties2$0$.name) === "t") {
+                    return "";
+                  }
+                  return "{".concat(props.properties.map(function (property) {
+                    return getCode$1(context, property);
+                  }).filter(pure.isNot("t")).join(", "), " }");
+                }
+                return "";
+              };
+              var codeInsideBody = getCode$1(context, body);
+              var codeWithUseTranslation = insertTextAfterPosition(0, codeInsideBody, "const { t } = useTranslation();\n");
+              var updatedProps = getPropsCode();
+              var replacedCodeWithUseTranslation = "(".concat(updatedProps).concat(ramda.isEmpty(restParams) ? "" : "".concat(pure.isNotEmpty(updatedProps) ? ", " : "").concat(restParams.map(function (param) {
+                return getCode$1(context, param);
+              }).join(", ")), ") => ").concat(codeWithUseTranslation);
+              var replaceIncorrectWithTCode = fixer.replaceText(node.declarations[0].init, replacedCodeWithUseTranslation);
+              fixers.push(replaceIncorrectWithTCode);
+              var importUseTranslation = addFunctionImport({
+                context: context,
+                fixer: fixer,
+                functions: ["useTranslation"],
+                importPattern: REACT_I18_IMPORT_PATTERN
+              });
+              importUseTranslation && fixers.push(importUseTranslation);
+              return fixers;
+            }
+          });
+        }
+      };
+    }
+  };
+
   var NEETO_PACKAGES = ["@bigbinary/neetoui", "@bigbinary/neeto-icons"];
 
   var importedFromNeeto = function importedFromNeeto(context, node) {
@@ -26614,6 +26758,7 @@
 
   var index = {
     rules: {
+      "no-withT-for-smart-components": noWithTForSmartComponents,
       "no-large-functions-inside-jsx": noLargeFunctionsInsideJsx,
       "use-standard-date-time-formats": useStandardDateTimeFormats,
       "no-dumb-components-with-use-translation": noDumbComponentsWithUseTranslation,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigbinary/eslint-plugin-neeto",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "main": "dist/index.js",
   "license": "UNLICENSED",
   "scripts": {