@dfinity/eslint-config-oisy-wallet 0.0.1 → 0.0.2

package/README.md

@@ -46,6 +46,15 @@ module.exports = {
 };
 ```
 
+Finally, create an `eslint-local-rules.cjs` file at the root of your project containing the following:
+
+```javascript
+module.exports = require("@dfinity/eslint-config-oisy-wallet/eslint-local-rules");
+```
+
+> [!NOTE]
+> This is necessary because the `eslint-plugin-local-rules` plugin we use for custom rules requires a file located at the root and does not offer any customizable location option.
+
 ## 🛠️ TypeScript Support
 
 If your project uses TypeScript, make sure you have a `tsconfig.json` file in your project root.

package/eslint-local-rules.cjs

@@ -92,55 +92,94 @@ module.exports = {
       };
     },
   },
-  "use-nullish-checks": {
+  "prefer-object-params": {
     meta: {
       type: "suggestion",
       docs: {
         description:
-          "Enforce the use of isNullish functions for nullish checks",
+          "Enforce passing parameters as an object when a function has more than one parameter",
         category: "Best Practices",
         recommended: true,
       },
-      fixable: "code",
       schema: [],
     },
     create(context) {
-      const isNullishMessage =
-        "Use isNullish() instead of direct variable check for nullish checks.";
-      const nonNullishMessage =
-        "Use nonNullish() instead of direct variable check for nullish checks.";
+      const checkForMoreThanOneParameter = (node) => {
+        const parent = node.parent;
 
-      const binaryCheck = (node) => {
-        if (node.type === "BinaryExpression") {
-          return (
-            (node.operator === "===" || node.operator === "!==") &&
-            ((node.right.type === "Identifier" &&
-              node.right.name === "undefined") ||
-              // eslint-disable-next-line local-rules/use-nullish-checks -- This is the rule that is being implemented
-              (node.right.type === "Literal" && node.right.value === null))
-          );
+        const nonNullish = (element) =>
+          element !== undefined && element !== null;
+
+        // Check if it is a callback for looping methods
+        if (
+          nonNullish(parent) &&
+          parent.type === "CallExpression" &&
+          parent.callee.type === "MemberExpression" &&
+          ["map", "reduce", "forEach", "filter", "sort", "replace"].includes(
+            parent.callee.property.name,
+          )
+        ) {
+          return;
         }
-      };
 
-      const binaryReportCheck = (node) => {
-        context.report({
-          node,
-          message:
-            node.operator === "===" ? isNullishMessage : nonNullishMessage,
-          fix(fixer) {
-            return fixer.replaceText(
-              node,
-              `${node.operator === "===" ? "isNullish" : "nonNullish"}(${context.getSourceCode().getText(node.left)})`,
-            );
-          },
-        });
+        // Check if it is a callback for Array.from
+        if (
+          nonNullish(parent) &&
+          parent.type === "CallExpression" &&
+          parent.callee.type === "MemberExpression" &&
+          parent.callee.object.name === "Array" &&
+          parent.callee.property.name === "from"
+        ) {
+          return;
+        }
+
+        // Check if it is a callback in a Promise constructor
+        if (
+          nonNullish(parent) &&
+          parent.type === "NewExpression" &&
+          parent.callee.name === "Promise"
+        ) {
+          return;
+        }
+
+        // Check if it is a callback in JSON.stringify
+        if (
+          nonNullish(parent) &&
+          parent.type === "CallExpression" &&
+          parent.callee.type === "MemberExpression" &&
+          parent.callee.object.name === "JSON" &&
+          parent.callee.property.name === "stringify"
+        ) {
+          return;
+        }
+
+        // Check if it is inside a class constructor
+        if (
+          nonNullish(parent) &&
+          parent.type === "MethodDefinition" &&
+          parent.kind === "constructor"
+        ) {
+          return;
+        }
+
+        if (node.params.length > 1) {
+          context.report({
+            node,
+            message:
+              "Functions with more than one parameter should accept an object and use destructuring.",
+          });
+        }
       };
 
       return {
-        BinaryExpression(node) {
-          if (binaryCheck(node)) {
-            binaryReportCheck(node);
-          }
+        FunctionDeclaration(node) {
+          checkForMoreThanOneParameter(node);
+        },
+        FunctionExpression(node) {
+          checkForMoreThanOneParameter(node);
+        },
+        ArrowFunctionExpression(node) {
+          checkForMoreThanOneParameter(node);
         },
       };
     },

package/index.cjs

@@ -33,8 +33,8 @@ module.exports = {
     "@typescript-eslint/prefer-reduce-type-parameter": "error",
     "arrow-body-style": ["warn", "as-needed"],
     curly: "error",
+    "local-rules/prefer-object-params": "warn",
     "local-rules/use-option-type-wrapper": "warn",
-    "local-rules/use-nullish-checks": "warn",
     "import/no-duplicates": ["error", { "prefer-inline": true }],
     "no-console": ["error", { allow: ["error", "warn"] }],
     "no-continue": "warn",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfinity/eslint-config-oisy-wallet",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "Apache-2.0",
   "description": "Shared ESLint configurations from the Oisy Wallet team",
   "repository": {
@@ -26,6 +26,10 @@
     "./svelte": {
       "import": "./svelte.cjs",
       "require": "./svelte.cjs"
+    },
+    "./eslint-local-rules": {
+      "import": "./eslint-local-rules.cjs",
+      "require": "./eslint-local-rules.cjs"
     }
   },
   "scripts": {