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

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2021 DFINITY LLC.
+   Copyright 2024 DFINITY Stiftung
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/configs/eslint.core.mjs

@@ -0,0 +1,13 @@
+import js from "@eslint/js";
+import ts from "typescript-eslint";
+import prettier from "eslint-config-prettier";
+import { eslintRules } from "./eslint.rules.mjs";
+import { eslintIgnore } from "./eslint.ignore.mjs";
+
+export const eslintCoreConfig = [
+  js.configs.recommended,
+  ...ts.configs.recommended,
+  prettier,
+  ...eslintRules,
+  ...eslintIgnore,
+];

package/configs/eslint.ignore.mjs

@@ -0,0 +1,21 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { nonNullish } from "@dfinity/utils";
+import { includeIgnoreFile } from "@eslint/compat";
+
+const resolveGitIgnorePath = () => {
+  const gitIgnore = join(process.cwd(), ".gitignore");
+
+  if (existsSync(gitIgnore)) {
+    return fileURLToPath(new URL(gitIgnore, import.meta.url));
+  }
+
+  return undefined;
+};
+
+const gitignorePath = resolveGitIgnorePath();
+
+export const eslintIgnore = [
+  ...(nonNullish(gitignorePath) ? [includeIgnoreFile(gitignorePath)] : []),
+];

package/configs/eslint.language.mjs

@@ -0,0 +1,34 @@
+import globals from "globals";
+import ts from "typescript-eslint";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { nonNullish } from "@dfinity/utils";
+
+const resolveProject = () => {
+  const eslintJson = join(process.cwd(), "tsconfig.eslint.json");
+
+  if (existsSync(eslintJson)) {
+    return eslintJson;
+  }
+
+  return join(process.cwd(), "tsconfig.json");
+};
+
+export const languageOptions = (extraFileExtensions) => ({
+  languageOptions: {
+    globals: {
+      ...globals.browser,
+      ...globals.node,
+      NodeJS: true,
+    },
+
+    parser: ts.parser,
+    ecmaVersion: 2020,
+    sourceType: "module",
+
+    parserOptions: {
+      project: [resolveProject()],
+      ...(nonNullish(extraFileExtensions) && { extraFileExtensions }),
+    },
+  },
+});

package/configs/eslint.rules.mjs

@@ -0,0 +1,100 @@
+import localRules from "eslint-plugin-local-rules";
+import preferArrow from "eslint-plugin-prefer-arrow";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { fixupPluginRules, includeIgnoreFile } from "@eslint/compat";
+import _import from "eslint-plugin-import";
+import { fileURLToPath } from "node:url";
+import { nonNullish } from "@dfinity/utils";
+
+const resolveGitIgnorePath = () => {
+  const gitIgnore = join(process.cwd(), ".gitignore");
+
+  if (existsSync(gitIgnore)) {
+    return fileURLToPath(new URL(gitIgnore, import.meta.url));
+  }
+
+  return undefined;
+};
+
+const gitignorePath = resolveGitIgnorePath();
+
+export const eslintRules = [
+  ...(nonNullish(gitignorePath) ? [includeIgnoreFile(gitignorePath)] : []),
+  {
+    plugins: {
+      "local-rules": localRules,
+      "prefer-arrow": preferArrow,
+      import: fixupPluginRules(_import),
+    },
+
+    rules: {
+      "@typescript-eslint/consistent-type-definitions": "error",
+
+      // TODO: Disabled for now to allow the migration of ESLint v9 in OISY, as the rule is not yet enforced.
+      // It should also be introduced as an optional rule.
+      // "@typescript-eslint/consistent-type-imports": "error",
+
+      "@typescript-eslint/no-inferrable-types": "error",
+      "@typescript-eslint/no-unnecessary-type-assertion": "error",
+
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+
+      "@typescript-eslint/prefer-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-reduce-type-parameter": "error",
+      "arrow-body-style": ["warn", "as-needed"],
+      curly: "error",
+
+      // TODO: Disabled for now to allow the migration of ESLint v9 in OISY, as the rule is not yet enforced.
+      // It should also be introduced as an optional rule.
+      // "func-style": "error",
+
+      "local-rules/prefer-object-params": "warn",
+
+      // TODO: Disabled for now to allow the migration of ESLint v9 in OISY, as the rule is not yet enforced.
+      // It should also be introduced as an optional rule.
+      // "local-rules/use-nullish-checks": "warn",
+
+      "local-rules/use-option-type-wrapper": "warn",
+      "import/no-duplicates": ["error", { "prefer-inline": true }],
+      "import/no-relative-parent-imports": "error",
+      "no-console": ["error", { allow: ["error", "warn"] }],
+      "no-continue": "warn",
+      "no-delete-var": "error",
+      "no-else-return": ["warn", { allowElseIf: false }],
+      "no-unused-vars": "off",
+
+      // TODO: Disabled for now to allow the migration of ESLint v9 in OISY, as the rule is not yet enforced.
+      // It should also be introduced as an optional rule.
+      // "prefer-arrow-callback": "error",
+
+      // TODO: Disabled for now to allow the migration of ESLint v9 in OISY, as the rule is not yet enforced.
+      // It should also be introduced as an optional rule.
+      // "prefer-arrow/prefer-arrow-functions": [
+      // "error",
+      // {
+      //  disallowPrototype: true,
+      //  singleReturnOnly: false,
+      //  classPropertiesAllowed: false,
+      // },
+      // ],
+
+      "prefer-template": "error",
+      "require-await": "error",
+    },
+  },
+  {
+    files: ["**/*.ts"],
+
+    rules: {
+      "prefer-const": "error",
+    },
+  },
+];

package/eslint-local-rules.cjs

@@ -1,7 +1,8 @@
 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"),
+  "use-nullish-checks": require("./rules/use-nullish-checks.cjs"),
 };

package/index.mjs

@@ -0,0 +1,4 @@
+import { languageOptions } from "./configs/eslint.language.mjs";
+import { eslintCoreConfig } from "./configs/eslint.core.mjs";
+
+export default [...eslintCoreConfig, languageOptions()];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfinity/eslint-config-oisy-wallet",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "license": "Apache-2.0",
   "description": "Shared ESLint configurations from the Oisy Wallet team",
   "repository": {
@@ -10,21 +10,24 @@
   "bugs": {
     "url": "https://github.com/dfinity/eslint-config-oisy-wallet/issues"
   },
-  "main": "index.cjs",
+  "main": "index.mjs",
   "files": [
+    "README.md",
     "LICENSE",
-    "index.cjs",
-    "svelte.cjs",
-    "eslint-local-rules.cjs"
+    "index.mjs",
+    "svelte.mjs",
+    "configs",
+    "eslint-local-rules.cjs",
+    "rules/**/*.cjs"
   ],
   "exports": {
     ".": {
-      "import": "./index.cjs",
-      "require": "./index.cjs"
+      "import": "./index.mjs",
+      "require": "./index.mjs"
     },
     "./svelte": {
-      "import": "./svelte.cjs",
-      "require": "./svelte.cjs"
+      "import": "./svelte.mjs",
+      "require": "./svelte.mjs"
     },
     "./eslint-local-rules": {
       "import": "./eslint-local-rules.cjs",
@@ -34,7 +37,7 @@
   "scripts": {
     "format": "prettier . --write",
     "format:check": "prettier --check .",
-    "lint": "eslint -c index.cjs . --ext .cjs",
+    "lint": "eslint .",
     "test": "vitest --run"
   },
   "keywords": [
@@ -54,23 +57,29 @@
     "best-practices"
   ],
   "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-plugin-import": "^2.29.1",
+    "@dfinity/utils": "^2.10.0",
+    "@eslint/compat": "^1.2.6",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.20.0",
+    "@typescript-eslint/eslint-plugin": "^8.24.1",
+    "eslint": "^9.20.1",
+    "eslint-config-love": "^118.0.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-local-rules": "^3.0.2",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-prettier": "^5.2.1",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-svelte": "^2.44.0",
-    "prettier": "^3.3.3",
-    "prettier-plugin-organize-imports": "^4.0.0",
+    "eslint-plugin-n": "^17.15.1",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "eslint-plugin-prettier": "^5.2.3",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-svelte": "^2.46.1",
+    "globals": "^15.15.0",
+    "prettier": "^3.5.1",
+    "prettier-plugin-organize-imports": "^4.1.0",
     "typescript": "^5.3.3"
   },
   "devDependencies": {
     "@types/node": "^22.7.3",
-    "@typescript-eslint/rule-tester": "^8.7.0",
-    "vitest": "^2.1.1"
+    "@typescript-eslint/rule-tester": "^8.24.1",
+    "vitest": "^3.0.5"
   }
 }

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

@@ -0,0 +1,82 @@
+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) => ({
+    FunctionDeclaration: (node) => {
+      checkReturnType({ node, context });
+    },
+    FunctionExpression: (node) => {
+      checkReturnType({ node, context });
+    },
+    ArrowFunctionExpression: (node) => {
+      checkReturnType({ node, context });
+    },
+  }),
+};

package/rules/no-relative-imports.cjs

@@ -0,0 +1,27 @@
+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) => ({
+    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,27 @@
+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) => ({
+    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 @@
+const { nonNullish } = require("@dfinity/utils");
+
+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;
+
+      // 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-nullish-checks.cjs

@@ -0,0 +1,51 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce the use of isNullish functions for nullish checks",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      isNullish:
+        "Use isNullish() instead of direct variable check for nullish checks.",
+      nonNullish:
+        "Use nonNullish() instead of direct variable check for nullish checks.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  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 binaryReportCheck = (node) => {
+      context.report({
+        node,
+        messageId: node.operator === "===" ? "isNullish" : "nonNullish",
+        fix: (fixer) =>
+          fixer.replaceText(
+            node,
+            `${node.operator === "===" ? "isNullish" : "nonNullish"}(${context.sourceCode.getText(node.left)})`,
+          ),
+      });
+    };
+
+    return {
+      BinaryExpression: (node) => {
+        if (binaryCheck(node)) {
+          binaryReportCheck(node);
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,62 @@
+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: (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) =>
+                fixer.replaceText(node.typeAnnotation, `Option<${typeText}>`),
+            });
+          } catch (e) {
+            console.error(e);
+            // eslint-disable-next-line no-console
+            console.log(type);
+          }
+        }
+      }
+    };
+
+    return {
+      TSTypeAnnotation: (node) => {
+        checkForOptionType(node);
+      },
+      TSTypeAliasDeclaration: (node) => {
+        checkForOptionType(node);
+      },
+    };
+  },
+};

package/svelte.mjs

@@ -0,0 +1,56 @@
+import svelte from "eslint-plugin-svelte";
+import svelteParser from "svelte-eslint-parser";
+import ts from "typescript-eslint";
+import { join } from "node:path";
+import { nonNullish } from "@dfinity/utils";
+import { languageOptions } from "./configs/eslint.language.mjs";
+import { eslintCoreConfig } from "./configs/eslint.core.mjs";
+
+const svelteConfig = join(process.cwd(), "svelte.config.js");
+
+export default [
+  ...eslintCoreConfig,
+  ...svelte.configs["flat/recommended"],
+  ...svelte.configs["flat/prettier"],
+  languageOptions([".svelte"]),
+  {
+    files: ["**/*.svelte"],
+    languageOptions: {
+      parser: svelteParser,
+      parserOptions: {
+        parser: ts.parser,
+        ...(nonNullish(svelteConfig) && { svelteConfig }),
+      },
+    },
+  },
+
+  {
+    files: ["**/*.svelte"],
+
+    rules: {
+      "import/order": [
+        "error",
+        {
+          alphabetize: {
+            order: "asc",
+          },
+        },
+      ],
+    },
+  },
+  {
+    files: ["scripts/**/*.mjs", "scripts/**/*.ts"],
+
+    rules: {
+      "no-console": "off",
+    },
+  },
+  {
+    rules: {
+      // TODO: Fix after migration to Svelte v5
+      "no-constant-binary-expression": "off",
+      "@typescript-eslint/no-empty-object-type": "off",
+      "@typescript-eslint/no-unused-expressions": "off",
+    },
+  },
+];

package/index.cjs

@@ -1,74 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { join } = require("node:path");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { existsSync } = require("node:fs");
-
-const resolveProject = () => {
-  const eslintJson = join(process.cwd(), "tsconfig.eslint.json");
-
-  if (existsSync(eslintJson)) {
-    return eslintJson;
-  }
-
-  return join(process.cwd(), "tsconfig.json");
-};
-
-module.exports = {
-  root: true,
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier",
-  ],
-  parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint", "eslint-plugin-local-rules", "import"],
-  parserOptions: {
-    sourceType: "module",
-    ecmaVersion: 2020,
-    project: [resolveProject()],
-  },
-  env: {
-    browser: true,
-    es2017: true,
-    node: true,
-  },
-  overrides: [
-    {
-      files: ["*.ts"],
-      rules: {
-        "prefer-const": "error",
-      },
-    },
-  ],
-  rules: {
-    "@typescript-eslint/consistent-type-definitions": "error",
-    "@typescript-eslint/no-inferrable-types": "error",
-    "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unused-vars": [
-      "warn",
-      {
-        argsIgnorePattern: "^_",
-        varsIgnorePattern: "^_",
-        caughtErrorsIgnorePattern: "^_",
-      },
-    ],
-    "@typescript-eslint/prefer-nullish-coalescing": "error",
-    "@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",
-    "import/no-duplicates": ["error", { "prefer-inline": true }],
-    "import/no-relative-parent-imports": "error",
-    "no-console": ["error", { allow: ["error", "warn"] }],
-    "no-continue": "warn",
-    "no-delete-var": "error",
-    "no-else-return": ["warn", { allowElseIf: false }],
-    "no-unused-vars": "off",
-    "prefer-template": "error",
-    "require-await": "error",
-  },
-  globals: {
-    NodeJS: true,
-  },
-};

package/svelte.cjs

@@ -1,32 +0,0 @@
-module.exports = {
-  extends: ["./index.cjs", "plugin:svelte/recommended"],
-  parserOptions: {
-    extraFileExtensions: [".svelte"],
-  },
-  overrides: [
-    {
-      files: ["*.svelte"],
-      parser: "svelte-eslint-parser",
-      parserOptions: {
-        parser: "@typescript-eslint/parser",
-      },
-      rules: {
-        "import/order": [
-          "error",
-          {
-            alphabetize: { order: "asc" },
-          },
-        ],
-      },
-    },
-    {
-      files: ["scripts/**/*.mjs", "scripts/**/*.ts"],
-      rules: {
-        "no-console": "off",
-      },
-    },
-  ],
-  rules: {
-    "local-rules/no-svelte-store-in-api": "error",
-  },
-};