@dfinity/eslint-config-oisy-wallet 0.0.4 → 0.0.6

package/eslint-local-rules.cjs

@@ -1,249 +1,7 @@
 module.exports = {
-  "no-svelte-store-in-api": {
-    meta: {
-      docs: {
-        description:
-          "Svelte stores should not be used in APIs since they are also utilized by workers.",
-        category: "Possible Errors",
-        recommended: false,
-      },
-      schema: [],
-    },
-    create(context) {
-      return {
-        ImportDeclaration(node) {
-          const filePath = context.getFilename();
-
-          const {
-            source: { value },
-          } = node;
-
-          if (filePath.includes("/api/") && value === "svelte/store") {
-            context.report({
-              node,
-              message:
-                "Importing 'svelte/store' is not allowed in API modules.",
-            });
-          }
-        },
-      };
-    },
-  },
-  "use-option-type-wrapper": {
-    meta: {
-      type: "suggestion",
-      docs: {
-        description: "Enforce use of Option<T> instead of T | null | undefined",
-        category: "Best Practices",
-        recommended: true,
-      },
-      messages: {
-        useOption:
-          "Use Option<{{ type }}> instead of {{ type }} | null | undefined.",
-      },
-      fixable: "code",
-      schema: [],
-    },
-    create: function (context) {
-      const checkForOptionType = (node) => {
-        if (
-          node.typeAnnotation.type === "TSUnionType" &&
-          node.typeAnnotation.types.length === 3 &&
-          node.typeAnnotation.types.some((t) => t.type === "TSNullKeyword") &&
-          node.typeAnnotation.types.some((t) => t.type === "TSUndefinedKeyword")
-        ) {
-          const type = node.typeAnnotation.types.find(
-            (t) =>
-              t.type !== "TSNullKeyword" && t.type !== "TSUndefinedKeyword",
-          );
-
-          const typeText =
-            type.type === "TSTypeReference" &&
-            type.typeName &&
-            type.typeName.name
-              ? type.typeName.name
-              : context.getSourceCode().getText(type);
-
-          if (type) {
-            try {
-              context.report({
-                node,
-                messageId: "useOption",
-                data: {
-                  type: typeText,
-                },
-                fix(fixer) {
-                  return fixer.replaceText(
-                    node.typeAnnotation,
-                    `Option<${typeText}>`,
-                  );
-                },
-              });
-            } catch (e) {
-              // eslint-disable-next-line no-console
-              console.error(e);
-              // eslint-disable-next-line no-console
-              console.log(type);
-            }
-          }
-        }
-      };
-
-      return {
-        TSTypeAnnotation(node) {
-          checkForOptionType(node);
-        },
-        TSTypeAliasDeclaration(node) {
-          checkForOptionType(node);
-        },
-      };
-    },
-  },
-  "prefer-object-params": {
-    meta: {
-      type: "suggestion",
-      docs: {
-        description:
-          "Enforce passing parameters as an object when a function has more than one parameter",
-        category: "Best Practices",
-        recommended: true,
-      },
-      schema: [],
-    },
-    create(context) {
-      const checkForMoreThanOneParameter = (node) => {
-        const parent = node.parent;
-
-        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",
-            "concat",
-            "copyWithin",
-            "every",
-            "fill",
-            "find",
-            "findIndex",
-            "findLast",
-            "findLastIndex",
-            "flatMap",
-            "includes",
-            "indexOf",
-            "lastIndexOf",
-            "push",
-            "reduce",
-            "reduceRight",
-            "slice",
-            "splice",
-            "toLocaleString",
-            "toSpliced",
-            "unshift",
-            "with",
-          ].includes(parent.callee.property.name)
-        ) {
-          return;
-        }
-
-        // 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 {
-        FunctionDeclaration(node) {
-          checkForMoreThanOneParameter(node);
-        },
-        FunctionExpression(node) {
-          checkForMoreThanOneParameter(node);
-        },
-        ArrowFunctionExpression(node) {
-          checkForMoreThanOneParameter(node);
-        },
-      };
-    },
-  },
-  "no-relative-imports": {
-    meta: {
-      type: "suggestion",
-      docs: {
-        description: "Disallow all relative imports",
-        category: "Best Practices",
-        recommended: false,
-      },
-      messages: {
-        noRelativeImports:
-          "Relative imports are not allowed. Use an alias or absolute imports.",
-      },
-      schema: [],
-    },
-    create(context) {
-      return {
-        ImportDeclaration(node) {
-          const path = node.source.value;
-
-          if (path.startsWith("./")) {
-            context.report({
-              node,
-              messageId: "noRelativeImports",
-            });
-          }
-        },
-      };
-    },
-  },
+  "no-svelte-store-in-api": require("./rules/no-svelte-store-in-api.cjs"),
+  "use-option-type-wrapper": require("./rules/use-option-type-wrapper.cjs"),
+  "prefer-object-params": require("./rules/prefer-object-params.cjs"),
+  "no-relative-imports": require("./rules/no-relative-imports.cjs"),
+  "explicit-non-void-return-type": require("./rules/explicit-non-void-return-type.cjs"),
 };

package/index.cjs

@@ -34,11 +34,11 @@ module.exports = {
   },
   overrides: [
     {
-      files: ['*.ts'],
+      files: ["*.ts"],
       rules: {
-        'prefer-const': 'error'
-      }
-    }
+        "prefer-const": "error",
+      },
+    },
   ],
   rules: {
     "@typescript-eslint/consistent-type-definitions": "error",
@@ -66,6 +66,7 @@ module.exports = {
     "no-else-return": ["warn", { allowElseIf: false }],
     "no-unused-vars": "off",
     "prefer-template": "error",
+    "require-await": "error",
   },
   globals: {
     NodeJS: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfinity/eslint-config-oisy-wallet",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "Apache-2.0",
   "description": "Shared ESLint configurations from the Oisy Wallet team",
   "repository": {
@@ -12,10 +12,12 @@
   },
   "main": "index.cjs",
   "files": [
+    "README.md",
     "LICENSE",
     "index.cjs",
     "svelte.cjs",
-    "eslint-local-rules.cjs"
+    "eslint-local-rules.cjs",
+    "rules/**/*.cjs"
   ],
   "exports": {
     ".": {
@@ -56,8 +58,8 @@
   "peerDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.20.0",
     "eslint": "^8.57.0",
+    "eslint-config-love": "^84.1.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-local-rules": "^3.0.2",
     "eslint-plugin-n": "^16.6.2",

package/rules/explicit-non-void-return-type.cjs

@@ -0,0 +1,84 @@
+const inferReturnType = (node) => {
+  if (node.async) {
+    if (
+      node.body.type === "BlockStatement" &&
+      !node.body.body.some((statement) => statement.type === "ReturnStatement")
+    ) {
+      return "Promise<void>";
+    }
+    return "Promise<unknown>";
+  }
+
+  if (
+    node.body.type === "BlockStatement" &&
+    !node.body.body.some((statement) => statement.type === "ReturnStatement")
+  ) {
+    return "void";
+  }
+
+  const returnStatements = node.body.body.filter(
+    (statement) => statement.type === "ReturnStatement",
+  );
+
+  if (returnStatements.length > 0) {
+    const returnArgument = returnStatements[0].argument;
+
+    if (returnArgument) {
+      if (returnArgument.type === "Literal") {
+        return typeof returnArgument.value;
+      }
+
+      if (returnArgument.type === "ObjectExpression") {
+        return "{}";
+      }
+    }
+  }
+
+  return "unknown";
+};
+
+const checkReturnType = ({ node, context }) => {
+  const returnType = node.returnType;
+
+  if (!returnType) {
+    const inferredType = inferReturnType(node);
+
+    if (inferredType !== "void" && inferredType !== "Promise<void>") {
+      context.report({
+        node,
+        messageId: "missingReturnType",
+      });
+    }
+  }
+};
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Require explicit return types for functions, except when returning void",
+      category: "Best Practices",
+      recommended: false,
+    },
+    messages: {
+      missingReturnType:
+        "Function return type must be explicitly defined unless it returns void.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        checkReturnType({ node, context });
+      },
+      FunctionExpression(node) {
+        checkReturnType({ node, context });
+      },
+      ArrowFunctionExpression(node) {
+        checkReturnType({ node, context });
+      },
+    };
+  },
+};

package/rules/no-relative-imports.cjs

@@ -0,0 +1,29 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow all relative imports",
+      category: "Best Practices",
+      recommended: false,
+    },
+    messages: {
+      noRelativeImports:
+        "Relative imports are not allowed. Use an alias or absolute imports.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const path = node.source.value;
+
+        if (path.startsWith("./")) {
+          context.report({
+            node,
+            messageId: "noRelativeImports",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-svelte-store-in-api.cjs

@@ -0,0 +1,29 @@
+module.exports = {
+  meta: {
+    docs: {
+      description:
+        "Svelte stores should not be used in APIs since they are also utilized by workers.",
+      category: "Possible Errors",
+      recommended: false,
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const filePath = context.getFilename();
+
+        const {
+          source: { value },
+        } = node;
+
+        if (filePath.includes("/api/") && value === "svelte/store") {
+          context.report({
+            node,
+            message: "Importing 'svelte/store' is not allowed in API modules.",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/prefer-object-params.cjs

@@ -0,0 +1,117 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Enforce passing parameters as an object when a function has more than one parameter",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+  },
+  create(context) {
+    const checkForMoreThanOneParameter = (node) => {
+      const parent = node.parent;
+
+      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",
+          "concat",
+          "copyWithin",
+          "every",
+          "fill",
+          "find",
+          "findIndex",
+          "findLast",
+          "findLastIndex",
+          "flatMap",
+          "includes",
+          "indexOf",
+          "lastIndexOf",
+          "push",
+          "reduce",
+          "reduceRight",
+          "slice",
+          "splice",
+          "toLocaleString",
+          "toSpliced",
+          "unshift",
+          "with",
+        ].includes(parent.callee.property.name)
+      ) {
+        return;
+      }
+
+      // 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 {
+      FunctionDeclaration(node) {
+        checkForMoreThanOneParameter(node);
+      },
+      FunctionExpression(node) {
+        checkForMoreThanOneParameter(node);
+      },
+      ArrowFunctionExpression(node) {
+        checkForMoreThanOneParameter(node);
+      },
+    };
+  },
+};

package/rules/use-option-type-wrapper.cjs

@@ -0,0 +1,67 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce use of Option<T> instead of T | null | undefined",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      useOption:
+        "Use Option<{{ type }}> instead of {{ type }} | null | undefined.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create: function (context) {
+    const checkForOptionType = (node) => {
+      if (
+        node.typeAnnotation.type === "TSUnionType" &&
+        node.typeAnnotation.types.length === 3 &&
+        node.typeAnnotation.types.some((t) => t.type === "TSNullKeyword") &&
+        node.typeAnnotation.types.some((t) => t.type === "TSUndefinedKeyword")
+      ) {
+        const type = node.typeAnnotation.types.find(
+          (t) => t.type !== "TSNullKeyword" && t.type !== "TSUndefinedKeyword",
+        );
+
+        const typeText =
+          type.type === "TSTypeReference" && type.typeName && type.typeName.name
+            ? type.typeName.name
+            : context.getSourceCode().getText(type);
+
+        if (type) {
+          try {
+            context.report({
+              node,
+              messageId: "useOption",
+              data: {
+                type: typeText,
+              },
+              fix(fixer) {
+                return fixer.replaceText(
+                  node.typeAnnotation,
+                  `Option<${typeText}>`,
+                );
+              },
+            });
+          } catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            // eslint-disable-next-line no-console
+            console.log(type);
+          }
+        }
+      }
+    };
+
+    return {
+      TSTypeAnnotation(node) {
+        checkForOptionType(node);
+      },
+      TSTypeAliasDeclaration(node) {
+        checkForOptionType(node);
+      },
+    };
+  },
+};