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

package/eslint-local-rules.cjs

@@ -1,7 +1,7 @@
 module.exports = {
-  "no-svelte-store-in-api": require("./rules/no-svelte-store-in-api"),
-  "use-option-type-wrapper": require("./rules/use-option-type-wrapper"),
-  "prefer-object-params": require("./rules/prefer-object-params"),
-  "no-relative-imports": require("./rules/no-relative-imports"),
-  "explicit-non-void-return-type": require("./rules/explicit-non-void-return-type"),
+  "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfinity/eslint-config-oisy-wallet",
-  "version": "0.0.5",
+  "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": {
     ".": {

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);
+      },
+    };
+  },
+};