@dfinity/eslint-config-oisy-wallet 0.2.4 → 0.4.0

package/README.md

@@ -142,6 +142,64 @@ export default [
 
 Note: To override local rules, make sure you have the `eslint-local-rules.cjs` file at the root as described above.
 
+## 📐 Custom Rules
+
+This configuration ships with several custom local rules:
+
+| Rule                                        | Description                                                                                                   |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `local-rules/use-nullish-checks`            | Enforce the use of `isNullish()` / `nonNullish()` instead of direct truthiness checks for nullish assertions. |
+| `local-rules/use-nullish-type-wrapper`      | Enforce proper usage of nullish type wrappers.                                                                |
+| `local-rules/prefer-object-params`          | Prefer a single object parameter over multiple positional parameters.                                         |
+| `local-rules/no-svelte-store-in-api`        | Disallow importing Svelte stores in API modules.                                                              |
+| `local-rules/no-relative-imports`           | Disallow relative imports; prefer alias paths.                                                                |
+| `local-rules/explicit-non-void-return-type` | Require explicit return types for functions that return a value.                                              |
+
+### `use-nullish-checks` Options
+
+The rule accepts an optional configuration object:
+
+| Option                    | Type      | Default | Description                                                                                                                                                                                                                                      |
+| ------------------------- | --------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `includeBooleans`         | `boolean` | `false` | When `true`, also enforce nullish checks on variables typed as `boolean` (or `boolean \| null \| undefined`). Boolean expressions — comparisons, known boolean methods, literals, and negations — are always allowed regardless of this setting. |
+| `allowFindUndefinedCheck` | `boolean` | `false` | When `true`, allow direct nullish comparisons on the result of `.find()` calls (e.g. `array.find(x => x) === undefined`). Useful because `.find()` legitimately returns `undefined` when no match is found.                                      |
+
+Example:
+
+```javascript
+// Enable the rule with boolean variable checking
+"local-rules/use-nullish-checks": ["error", { includeBooleans: true }]
+
+// Allow .find() results to be compared with undefined/null directly
+"local-rules/use-nullish-checks": ["error", { allowFindUndefinedCheck: true }]
+```
+
+With `includeBooleans: true`:
+
+```typescript
+const b: boolean = true;
+
+// ❌ Error — boolean variable should use nonNullish()
+if (b) {
+}
+
+// ✅ OK — boolean expression, always allowed
+if (a === b) {
+}
+```
+
+With `allowFindUndefinedCheck: true`:
+
+```typescript
+// ✅ OK — .find() result compared with undefined is allowed
+if (array.find((item) => item.id === id) === undefined) {
+}
+
+// ✅ OK — .find() result compared with null is allowed
+if (array.find((item) => item.id === id) !== null) {
+}
+```
+
 ## 🛠️ TypeScript Support
 
 If your project uses TypeScript, make sure you have a `tsconfig.json` file in your project root.

package/configs/eslint.rules.mjs

@@ -83,7 +83,6 @@ export const eslintRules = [
           "newlines-between": "never",
         },
       ],
-      "import/no-duplicates": ["error", { "prefer-inline": true }],
       "import/no-relative-parent-imports": "error",
 
       "object-shorthand": "error",
@@ -91,6 +90,7 @@ export const eslintRules = [
       "no-console": ["error", { allow: ["error", "warn"] }],
       "no-continue": "warn",
       "no-delete-var": "error",
+      "no-duplicate-imports": "error",
       "no-else-return": ["warn", { allowElseIf: false }],
       "no-restricted-imports": [
         "error",

package/eslint-local-rules.cjs

@@ -1,6 +1,6 @@
 module.exports = {
   "no-svelte-store-in-api": require("./rules/no-svelte-store-in-api.cjs"),
-  "use-option-type-wrapper": require("./rules/use-option-type-wrapper.cjs"),
+  "use-option-type-wrapper": require("./rules/use-nullish-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.2.4",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "description": "Shared ESLint configurations from the Oisy Wallet team",
   "repository": {
@@ -44,7 +44,8 @@
     "format:check": "prettier --check .",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
-    "test": "vitest --run"
+    "test": "vitest --run",
+    "update:peer": "npm update $(node -e \"const p=require('./package.json');console.log(Object.keys(p.peerDependencies).filter(d=>/eslint|prettier/.test(d)).join(' '))\")"
   },
   "keywords": [
     "eslint",
@@ -70,7 +71,6 @@
     "@typescript-eslint/eslint-plugin": "^8.56.0",
     "@vitest/eslint-plugin": "^1.6.9",
     "eslint": "^9.39.2",
-    "eslint-config-love": "^151.0.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-local-rules": "^3.0.2",
@@ -82,7 +82,8 @@
     "globals": "^17.3.0",
     "prettier": "^3.8.1",
     "prettier-plugin-organize-imports": "^4.3.0",
-    "typescript": "^5"
+    "typescript": "^5",
+    "typescript-eslint": "^8.56.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",

package/rules/use-nullish-checks.cjs

@@ -1,3 +1,21 @@
+const ts = require("typescript");
+
+const NULLISH_UTILS = new Set(["isNullish", "nonNullish"]);
+
+// TODO: shall we expand it with `==` and `!=` ?
+const EQ_OPS = new Set(["==="]);
+const NOT_EQ_OPS = new Set(["!=="]);
+const COMPARISON_OPS = new Set([...EQ_OPS, ...NOT_EQ_OPS]);
+const BOOLEAN_BINARY_OPS = new Set([...COMPARISON_OPS, ">", "<", ">=", "<="]);
+const KNOWN_BOOLEAN_METHODS = new Set([
+  "includes",
+  "startsWith",
+  "endsWith",
+  "test",
+  "some",
+  "every",
+]);
+
 module.exports = {
   meta: {
     type: "suggestion",
@@ -13,39 +31,340 @@ module.exports = {
         "Use nonNullish() instead of direct variable check for nullish checks.",
     },
     fixable: "code",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          includeBooleans: {
+            type: "boolean",
+            description:
+              "When true, also enforce nullish checks on variables typed as boolean or nullish boolean. " +
+              "Boolean expressions (comparisons, known boolean methods, literals, negations) are always allowed. " +
+              "Defaults to false.",
+          },
+          allowFindUndefinedCheck: {
+            type: "boolean",
+            description:
+              "When true, allow direct nullish comparisons on the result of .find() calls " +
+              "(e.g. array.find(x => x) === undefined). " +
+              "Defaults to false.",
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
   },
 
   create: (context) => {
-    const binaryCheck = (node) => {
-      if (node.type === "BinaryExpression") {
-        return (
-          (node.operator === "===" || node.operator === "!==") &&
-          ((node.right.type === "Identifier" &&
-            node.right.name === "undefined") ||
-            (node.right.type === "Literal" && node.right.value === null))
-        );
+    const [options] = context.options;
+
+    const shouldLintBooleans = options?.includeBooleans ?? false;
+
+    const allowFindUndefinedCheck = options?.allowFindUndefinedCheck ?? false;
+
+    const { sourceCode } = context;
+
+    const parserServices = sourceCode?.parserServices ?? context.parserServices;
+
+    const checker = parserServices?.program?.getTypeChecker();
+
+    const isNullishUtilityCall = (node) =>
+      node.type === "CallExpression" &&
+      node.callee.type === "Identifier" &&
+      NULLISH_UTILS.has(node.callee.name);
+
+    const hasKnownBooleanMethodCall = (node) =>
+      node.type === "CallExpression" &&
+      node.callee.type === "MemberExpression" &&
+      node.callee.property.type === "Identifier" &&
+      KNOWN_BOOLEAN_METHODS.has(node.callee.property.name);
+
+    const isBooleanBinaryExpression = (node) =>
+      node.type === "BinaryExpression" && BOOLEAN_BINARY_OPS.has(node.operator);
+
+    const isBooleanTypeAnnotation = (typeAnn) => {
+      if (!typeAnn) {
+        return false;
+      }
+
+      if (typeAnn.type === "TSBooleanKeyword") {
+        return true;
+      }
+
+      if (typeAnn.type !== "TSUnionType") {
+        return false;
+      }
+
+      return typeAnn.types.every(
+        (typeNode) =>
+          typeNode.type === "TSBooleanKeyword" ||
+          typeNode.type === "TSNullKeyword" ||
+          typeNode.type === "TSUndefinedKeyword" ||
+          (typeNode.type === "TSLiteralType" &&
+            typeof typeNode.literal?.value === "boolean"),
+      );
+    };
+
+    const findVariableTypeAnnotation = ({ scope, variableName }) => {
+      if (!scope) {
+        return;
+      }
+
+      const variable = scope.set.get(variableName);
+      const [def] = variable?.defs ?? [];
+
+      const typeAnn =
+        def?.node?.id?.typeAnnotation?.typeAnnotation ??
+        def?.node?.typeAnnotation?.typeAnnotation;
+
+      return (
+        typeAnn ??
+        findVariableTypeAnnotation({ scope: scope.upper, variableName })
+      );
+    };
+
+    const isBooleanTypeFromScope = (node) => {
+      if (node.type === "Literal" && typeof node.value === "boolean") {
+        return true;
+      }
+
+      if (isBooleanBinaryExpression(node)) {
+        return true;
+      }
+
+      if (node.type === "UnaryExpression" && node.operator === "!") {
+        return true;
+      }
+
+      if (isNullishUtilityCall(node)) {
+        return true;
+      }
+
+      if (hasKnownBooleanMethodCall(node)) {
+        return true;
+      }
+
+      if (node.type !== "Identifier") {
+        return false;
+      }
+
+      const initialScope = sourceCode?.getScope
+        ? sourceCode.getScope(node)
+        : context.getScope();
+
+      const typeAnn = findVariableTypeAnnotation({
+        scope: initialScope,
+        variableName: node.name,
+      });
+
+      return isBooleanTypeAnnotation(typeAnn);
+    };
+
+    const isBooleanTypeFromTs = (node) => {
+      if (!checker || !parserServices) {
+        return false;
+      }
+
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+      const type = checker.getTypeAtLocation(tsNode);
+
+      const isStrictBoolean = (typeToCheck) =>
+        (typeToCheck.getFlags() &
+          (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !==
+        0;
+
+      if (isStrictBoolean(type)) {
+        return true;
+      }
+
+      return (
+        type.isUnion() &&
+        type.types.every(
+          (typeToCheck) =>
+            (typeToCheck.getFlags() &
+              (ts.TypeFlags.Boolean |
+                ts.TypeFlags.BooleanLiteral |
+                ts.TypeFlags.Null |
+                ts.TypeFlags.Undefined)) !==
+            0,
+        )
+      );
+    };
+
+    const isBooleanExpression = (node) =>
+      isBooleanBinaryExpression(node) ||
+      hasKnownBooleanMethodCall(node) ||
+      isNullishUtilityCall(node) ||
+      (node.type === "Literal" && typeof node.value === "boolean") ||
+      (node.type === "UnaryExpression" && node.operator === "!");
+
+    const shouldTreatAsBooleanCondition = (node) => {
+      if (shouldLintBooleans) {
+        return isBooleanExpression(node);
+      }
+
+      try {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        return isBooleanTypeFromTs(node) || isBooleanTypeFromScope(node);
+      } catch {
+        return isBooleanTypeFromScope(node);
+      }
+    };
+
+    const isNullishLiteral = (expression) =>
+      (expression.type === "Identifier" && expression.name === "undefined") ||
+      (expression.type === "Literal" && expression.value === null);
+
+    const isFindCall = (node) =>
+      node.type === "CallExpression" &&
+      node.callee.type === "MemberExpression" &&
+      node.callee.property.type === "Identifier" &&
+      node.callee.property.name === "find";
+
+    const getNullishComparisonTarget = (node) => {
+      if (node.type !== "BinaryExpression") {
+        return;
+      }
+
+      if (!COMPARISON_OPS.has(node.operator)) {
+        return;
+      }
+
+      if (isNullishLiteral(node.right)) {
+        return node.left;
+      }
+
+      if (isNullishLiteral(node.left)) {
+        return node.right;
       }
     };
 
-    const binaryReportCheck = (node) => {
+    const getNullishReplacement = (operator) =>
+      EQ_OPS.has(operator) ? "isNullish" : "nonNullish";
+
+    const report = ({ node, messageId, replacementFn, fixNode }) => {
       context.report({
         node,
-        messageId: node.operator === "===" ? "isNullish" : "nonNullish",
+        messageId,
         fix: (fixer) =>
           fixer.replaceText(
             node,
-            `${node.operator === "===" ? "isNullish" : "nonNullish"}(${context.sourceCode.getText(node.left)})`,
+            `${replacementFn}(${sourceCode ? sourceCode.getText(fixNode) : context.getSourceCode().getText(fixNode)})`,
           ),
       });
     };
 
+    const checkCondition = (node) => {
+      if (!node) {
+        return;
+      }
+
+      if (isNullishUtilityCall(node)) {
+        return;
+      }
+
+      if (getNullishComparisonTarget(node)) {
+        return;
+      }
+
+      if (node.type === "UnaryExpression" && node.operator === "!") {
+        return;
+      }
+
+      if (node.type === "LogicalExpression") {
+        checkCondition(node.left);
+
+        checkCondition(node.right);
+
+        return;
+      }
+
+      if (shouldTreatAsBooleanCondition(node)) {
+        return;
+      }
+
+      report({
+        node,
+        messageId: "nonNullish",
+        replacementFn: "nonNullish",
+        fixNode: node,
+      });
+    };
+
+    // ESLint AST puts the condition of if/while/for/ternary in `node.test`, so we analyse that specifically
+    const checkTestCondition = (node) => {
+      if (node.test) {
+        checkCondition(node.test);
+      }
+    };
+
     return {
       BinaryExpression: (node) => {
-        if (binaryCheck(node)) {
-          binaryReportCheck(node);
+        const target = getNullishComparisonTarget(node);
+
+        if (!target) {
+          return;
+        }
+
+        if (allowFindUndefinedCheck && isFindCall(target)) {
+          return;
+        }
+
+        const replacementFn = getNullishReplacement(node.operator);
+
+        report({
+          node,
+          messageId: replacementFn,
+          replacementFn,
+          fixNode: target,
+        });
+      },
+
+      UnaryExpression: (node) => {
+        if (
+          node.operator === "!" &&
+          node.argument.type === "UnaryExpression" &&
+          node.argument.operator === "!"
+        ) {
+          if (shouldTreatAsBooleanCondition(node.argument.argument)) {
+            return;
+          }
+
+          report({
+            node,
+            messageId: "nonNullish",
+            replacementFn: "nonNullish",
+            fixNode: node.argument.argument,
+          });
+
+          return;
+        }
+
+        if (node.operator === "!") {
+          if (shouldTreatAsBooleanCondition(node.argument)) {
+            return;
+          }
+
+          const { parent } = node;
+
+          if (parent?.type === "UnaryExpression" && parent.operator === "!") {
+            return;
+          }
+
+          report({
+            node,
+            messageId: "isNullish",
+            replacementFn: "isNullish",
+            fixNode: node.argument,
+          });
         }
       },
+
+      IfStatement: checkTestCondition,
+      WhileStatement: checkTestCondition,
+      DoWhileStatement: checkTestCondition,
+      ForStatement: checkTestCondition,
+      ConditionalExpression: checkTestCondition,
     };
   },
 };

package/rules/{use-option-type-wrapper.cjs → use-nullish-type-wrapper.cjs}

@@ -2,19 +2,19 @@ module.exports = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Enforce use of Option<T> instead of T | null | undefined",
+      description: "Enforce use of Nullish<T> instead of T | null | undefined",
       category: "Best Practices",
       recommended: false,
     },
     messages: {
-      useOption:
-        "Use Option<{{ type }}> instead of {{ type }} | null | undefined.",
+      useNullish:
+        "Use Nullish<{{ type }}> instead of {{ type }} | null | undefined.",
     },
     fixable: "code",
     schema: [],
   },
   create: (context) => {
-    const checkForOptionType = (node) => {
+    const checkForNullishType = (node) => {
       if (
         node.typeAnnotation.type === "TSUnionType" &&
         node.typeAnnotation.types.length === 3 &&
@@ -34,12 +34,12 @@ module.exports = {
           try {
             context.report({
               node,
-              messageId: "useOption",
+              messageId: "useNullish",
               data: {
                 type: typeText,
               },
               fix: (fixer) =>
-                fixer.replaceText(node.typeAnnotation, `Option<${typeText}>`),
+                fixer.replaceText(node.typeAnnotation, `Nullish<${typeText}>`),
             });
           } catch (e) {
             console.error(e);
@@ -52,10 +52,10 @@ module.exports = {
 
     return {
       TSTypeAnnotation: (node) => {
-        checkForOptionType(node);
+        checkForNullishType(node);
       },
       TSTypeAliasDeclaration: (node) => {
-        checkForOptionType(node);
+        checkForNullishType(node);
       },
     };
   },