@lichthagel/eslint-config 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-PRESENT Jens Gatzweiler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# @lichthagel/eslint-config
+
+Collection of eslint configs I use for my projects.
+
+## Installation
+
+`npm|yarn|pnpm i -D eslint @lichthagel/eslint-config`
+
+## Configuration
+
+```js
+// @ts-check
+
+import lichthagel from "@lichthagel/eslint-config";
+
+/** @type {import("@lichthagel/eslint-config").FlatConfigItem[]} */
+export default [
+  ...await lichthagel({
+    ...options
+  }),
+  ...otherSettings
+];
+```

package/dist/index.cjs

@@ -0,0 +1,562 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  browser: () => browser_default,
+  default: () => factory_default,
+  javascript: () => javascript_default,
+  node: () => node_default,
+  perfectionist: () => perfectionist_default,
+  solid: () => solid_default,
+  stylistic: () => stylistic_default,
+  svelte: () => svelte_default,
+  tailwindcss: () => tailwindcss_default,
+  typescript: () => typescript_default,
+  unicorn: () => unicorn_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/configs/browser.ts
+var import_globals = __toESM(require("globals"), 1);
+var browser_default = [
+  {
+    name: "lichthagel/browser",
+    languageOptions: {
+      globals: {
+        ...import_globals.default.browser,
+        document: "readonly",
+        navigator: "readonly",
+        window: "readonly"
+      }
+    }
+  }
+];
+
+// src/configs/javascript.ts
+var import_js = __toESM(require("@eslint/js"), 1);
+var import_globals2 = __toESM(require("globals"), 1);
+var javascript_default = [
+  { name: "js/recommended", ...import_js.default.configs.recommended },
+  {
+    name: "lichthagel/javascript",
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        ...import_globals2.default.es2022
+      },
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: "module"
+      },
+      sourceType: "module"
+    },
+    rules: {
+      "accessor-pairs": "error",
+      "array-callback-return": "error",
+      "arrow-body-style": "error",
+      "block-scoped-var": "error",
+      "curly": ["error", "all"],
+      "default-case-last": "error",
+      "dot-notation": "error",
+      "eqeqeq": ["error", "smart"],
+      "new-cap": [
+        "error",
+        {
+          capIsNew: false,
+          newIsCap: true,
+          properties: true
+        }
+      ],
+      "no-alert": "error",
+      "no-array-constructor": "error",
+      "no-await-in-loop": "error",
+      "no-bitwise": "error",
+      "no-caller": "error",
+      "no-cond-assign": ["error", "always"],
+      "no-console": ["error", { allow: ["warn", "error"] }],
+      "no-duplicate-imports": "error",
+      "no-eval": "error",
+      "no-extend-native": "error",
+      "no-extra-bind": "error",
+      "no-implied-eval": "error",
+      "no-iterator": "error",
+      "no-label-var": "error",
+      "no-labels": "error",
+      "no-lone-blocks": "error",
+      "no-multi-assign": "error",
+      "no-multi-str": "error",
+      "no-new": "error",
+      "no-new-func": "error",
+      "no-new-wrappers": "error",
+      "no-octal-escape": "error",
+      "no-promise-executor-return": ["error", { allowVoid: true }],
+      "no-proto": "error",
+      "no-restricted-globals": ["error", { name: "global", message: "Use `globalThis` instead." }, { name: "self", message: "Use `globalThis` instead." }],
+      "no-restricted-properties": [
+        "error",
+        { message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.", property: "__proto__" },
+        { message: "Use `Object.defineProperty` instead.", property: "__defineGetter__" },
+        { message: "Use `Object.defineProperty` instead.", property: "__defineSetter__" },
+        { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupGetter__" },
+        { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupSetter__" }
+      ],
+      "no-restricted-syntax": [
+        "error",
+        "DebuggerStatement",
+        "LabeledStatement",
+        "WithStatement",
+        "TSEnumDeclaration[const=true]",
+        "TSExportAssignment"
+      ],
+      "no-self-compare": "error",
+      "no-sequences": "error",
+      "no-template-curly-in-string": "error",
+      "no-throw-literal": "error",
+      "no-undef-init": "error",
+      "no-unmodified-loop-condition": "error",
+      "no-unneeded-ternary": "error",
+      "no-unreachable-loop": "error",
+      "no-unused-expressions": ["error", { allowShortCircuit: true, allowTaggedTemplates: true, allowTernary: true }],
+      "no-useless-call": "error",
+      "no-useless-computed-key": "error",
+      "no-useless-concat": "error",
+      "no-useless-constructor": "error",
+      "no-useless-rename": "error",
+      "no-useless-return": "error",
+      "no-var": "error",
+      "object-shorthand": ["error", "always", { ignoreConstructors: false }],
+      "prefer-arrow-callback": "error",
+      "prefer-const": "error",
+      "prefer-destructuring": ["error", { AssignmentExpression: { array: false, object: false } }],
+      "prefer-exponentiation-operator": "error",
+      "prefer-object-spread": "error",
+      "prefer-promise-reject-errors": "error",
+      "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+      "prefer-rest-params": "error",
+      "prefer-spread": "error",
+      "prefer-template": "error",
+      "require-await": "error",
+      "sort-imports": [
+        "error",
+        {
+          allowSeparatedGroups: true,
+          ignoreCase: false,
+          ignoreDeclarationSort: true
+        }
+      ],
+      "symbol-description": "error",
+      "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
+      "valid-typeof": ["error", { requireStringLiterals: true }],
+      "yoda": "error"
+    }
+  }
+];
+
+// src/configs/node.ts
+var import_globals3 = __toESM(require("globals"), 1);
+var node = async () => {
+  const pluginN = await import("eslint-plugin-n").then((mod) => mod.default);
+  return [
+    pluginN.configs["flat/recommended-module"],
+    {
+      name: "lichthagel/node",
+      languageOptions: {
+        globals: {
+          ...import_globals3.default.node
+        }
+      },
+      rules: {
+        "n/handle-callback-err": ["error", "^.*(e|E)rr(or)?$"],
+        "n/no-new-require": "error",
+        "n/no-path-concat": "error",
+        "n/no-process-env": "error",
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off"
+      }
+    }
+  ];
+};
+var node_default = node;
+
+// src/configs/perfectionist.ts
+var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
+var perfectionist_default = [
+  {
+    name: "perfectionist/recommended-natural",
+    ...import_eslint_plugin_perfectionist.default.configs["recommended-natural"]
+  },
+  {
+    name: "lichthagel/perfectionist",
+    rules: {
+      "perfectionist/sort-imports": [
+        "error",
+        {
+          type: "natural",
+          internalPattern: [
+            "^@/.*",
+            "^~.*",
+            "^$.*",
+            "^#.*"
+          ],
+          matcher: "regex"
+        }
+      ],
+      "perfectionist/sort-object-types": "off",
+      "perfectionist/sort-objects": [
+        "off",
+        {
+          customGroups: {
+            id: ["id", "name", "slug"]
+          },
+          groups: ["id", "unknown"],
+          partitionByComment: true,
+          partitionByNewLine: true
+        }
+      ],
+      "perfectionist/sort-union-types": [
+        "error",
+        {
+          groups: [
+            "named",
+            ["intersection", "union"],
+            "unknown",
+            "nullish"
+          ]
+        }
+      ],
+      "sort-imports": "off"
+    }
+  }
+];
+
+// src/configs/solid.ts
+var solid = async (options = {}) => {
+  const {
+    withTypescript = false
+  } = options;
+  const configSolid = await import("eslint-plugin-solid/configs/recommended").then((mod) => mod.default);
+  return [
+    {
+      name: "solid/recommended",
+      files: ["**/*.jsx", ...withTypescript ? ["**/*.tsx"] : []],
+      ...configSolid
+    }
+  ];
+};
+var solid_default = solid;
+
+// src/configs/stylistic.ts
+var import_eslint_plugin = __toESM(require("@stylistic/eslint-plugin"), 1);
+var stylistic_default = [
+  {
+    name: "stylistic/custom",
+    ...import_eslint_plugin.default.configs.customize({
+      arrowParens: true,
+      braceStyle: "1tbs",
+      commaDangle: "always-multiline",
+      flat: true,
+      indent: 2,
+      jsx: true,
+      quoteProps: "consistent-as-needed",
+      quotes: "double",
+      semi: true
+    })
+  },
+  {
+    name: "lichthagel/stylistic",
+    rules: {
+      // JavaScript
+      "@stylistic/array-bracket-newline": ["error", { minItems: 4, multiline: true }],
+      "@stylistic/array-element-newline": ["error", { minItems: 4, multiline: true }],
+      "@stylistic/curly-newline": ["error", { consistent: true }],
+      "@stylistic/function-call-argument-newline": ["error", "consistent"],
+      "@stylistic/function-call-spacing": ["error", "never"],
+      "@stylistic/function-paren-newline": ["error", "multiline-arguments"],
+      "@stylistic/generator-star-spacing": ["error", { after: false, before: true }],
+      "@stylistic/implicit-arrow-linebreak": ["off", "beside"],
+      "@stylistic/lines-around-comment": [
+        "error",
+        {
+          afterHashbangComment: true,
+          allowArrayStart: true,
+          allowBlockStart: true,
+          allowClassStart: true,
+          allowEnumStart: true,
+          allowInterfaceStart: true,
+          allowModuleStart: true,
+          allowObjectStart: true,
+          allowTypeStart: true,
+          applyDefaultIgnorePatterns: true,
+          beforeBlockComment: true
+        }
+      ],
+      "@stylistic/lines-between-class-members": ["error", "always", { exceptAfterSingleLine: false }],
+      "@stylistic/multiline-ternary": ["error", "always-multiline"],
+      "@stylistic/newline-per-chained-call": ["error", { ignoreChainWithDepth: 2 }],
+      "@stylistic/no-extra-semi": "error",
+      "@stylistic/nonblock-statement-body-position": ["error", "beside"],
+      "@stylistic/object-curly-newline": ["error", { consistent: true, minProperties: 4, multiline: true }],
+      "@stylistic/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+      "@stylistic/one-var-declaration-per-line": ["error", "always"],
+      "@stylistic/operator-linebreak": ["error", "before"],
+      "@stylistic/semi-style": ["error", "last"],
+      "@stylistic/switch-colon-spacing": ["error", { after: true, before: false }],
+      // JSX
+      "@stylistic/jsx-closing-bracket-location": ["error", "line-aligned"],
+      "@stylistic/jsx-curly-brace-presence": ["error", { children: "never", propElementValues: "always", props: "never" }],
+      "@stylistic/jsx-pascal-case": "error",
+      "@stylistic/jsx-props-no-multi-spaces": "error",
+      "@stylistic/jsx-self-closing-comp": "error"
+    }
+  }
+];
+
+// src/configs/svelte.ts
+var SVELTE_FILES = ["**/*.svelte"];
+var svelte = async (options = {}) => {
+  const {
+    disableStylistic = false,
+    withTypescript = false
+  } = options;
+  const pluginSvelte = await import("eslint-plugin-svelte").then((mod) => mod.default);
+  const configs = [
+    ...pluginSvelte.configs["flat/recommended"].map((configItem) => ({
+      name: "svelte/recommended",
+      ...configItem
+    })),
+    {
+      name: "lichthagel/svelte",
+      files: SVELTE_FILES,
+      languageOptions: {
+        parserOptions: {
+          extraFileExtensions: [".svelte"],
+          parser: withTypescript ? "@typescript-eslint/parser" : null,
+          project: true
+        }
+      },
+      rules: {
+        "svelte/block-lang": [
+          "error",
+          {
+            enforceScriptPresent: false,
+            enforceStylePresent: false,
+            script: [withTypescript ? "ts" : null]
+          }
+        ],
+        "svelte/first-attribute-linebreak": [
+          "error",
+          {
+            multiline: "below",
+            singleline: "beside"
+          }
+        ],
+        "svelte/html-closing-bracket-spacing": [
+          "error",
+          {
+            endTag: "never",
+            selfClosingTag: "always",
+            startTag: "never"
+          }
+        ],
+        "svelte/html-quotes": [
+          "error",
+          {
+            prefer: "double"
+          }
+        ],
+        "svelte/indent": [
+          "error",
+          {
+            alignAttributesVertically: true,
+            indent: 2
+          }
+        ],
+        "svelte/infinite-reactive-loop": "error",
+        "svelte/max-attributes-per-line": [
+          "error",
+          {
+            multiline: 1,
+            singleline: 3
+          }
+        ],
+        "svelte/mustache-spacing": "error",
+        "svelte/no-dupe-on-directives": "error",
+        "svelte/no-dupe-use-directives": "error",
+        "svelte/no-export-load-in-svelte-module-in-kit-pages": "error",
+        "svelte/no-goto-without-base": "error",
+        "svelte/no-ignored-unsubscribe": "error",
+        "svelte/no-immutable-reactive-statements": "error",
+        "svelte/no-reactive-functions": "error",
+        "svelte/no-reactive-literals": "error",
+        "svelte/no-spaces-around-equal-signs-in-attribute": "error",
+        "svelte/no-target-blank": "error",
+        "svelte/no-trailing-spaces": "error",
+        "svelte/no-useless-mustaches": "error",
+        "svelte/require-store-callbacks-use-set-param": "error",
+        "svelte/spaced-html-comment": ["error", "always"],
+        "svelte/valid-each-key": "error",
+        ...disableStylistic ? {
+          "@stylistic/indent": "off",
+          // superseded by svelte/indent
+          "@stylistic/no-trailing-spaces": "off"
+          // superseded by svelte/no-trailing-spaces
+        } : {}
+      }
+    }
+  ];
+  return configs;
+};
+var svelte_default = svelte;
+
+// src/configs/tailwindcss.ts
+var tailwindcss = async () => {
+  const pluginTailwind = await import("eslint-plugin-tailwindcss").then((mod) => mod.default);
+  return [
+    ...pluginTailwind.configs["flat/recommended"].map((config) => ({
+      ...config,
+      name: config.name?.replaceAll(":", "/")
+    })),
+    {
+      name: "lichthagel/tailwindcss",
+      rules: {
+        "tailwindcss/classnames-order": "error",
+        "tailwindcss/enforces-negative-arbitrary-values": "error",
+        "tailwindcss/enforces-shorthand": "error",
+        "tailwindcss/no-contradicting-classname": "error",
+        "tailwindcss/no-unnecessary-arbitrary-value": "error"
+      }
+    }
+  ];
+};
+var tailwindcss_default = tailwindcss;
+
+// src/configs/typescript.ts
+var import_typescript_eslint = __toESM(require("typescript-eslint"), 1);
+var typescript_default = [
+  ...import_typescript_eslint.default.configs.recommendedTypeChecked,
+  {
+    name: "lichthagel/typescript",
+    rules: {
+      "@typescript-eslint/array-type": "error",
+      "@typescript-eslint/consistent-indexed-object-style": ["warn", "index-signature"],
+      "@typescript-eslint/consistent-type-assertions": ["warn", { assertionStyle: "as", objectLiteralTypeAssertions: "allow" }],
+      "@typescript-eslint/consistent-type-definitions": ["warn", "type"],
+      "@typescript-eslint/default-param-last": "warn",
+      "@typescript-eslint/explicit-member-accessibility": "error",
+      "@typescript-eslint/method-signature-style": "warn",
+      "@typescript-eslint/no-array-constructor": "error",
+      "default-param-last": "off"
+    }
+  }
+];
+
+// src/configs/unicorn.ts
+var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
+var unicorn_default = [
+  {
+    name: "unicorn/flat/recommended",
+    ...import_eslint_plugin_unicorn.default.configs["flat/recommended"]
+  },
+  {
+    name: "lichthagel/unicorn",
+    rules: {
+      "unicorn/consistent-destructuring": "error",
+      "unicorn/filename-case": [
+        "error",
+        {
+          cases: {
+            camelCase: true,
+            kebabCase: true,
+            pascalCase: true
+          }
+        }
+      ],
+      "unicorn/import-style": "off",
+      "unicorn/no-null": "off",
+      "unicorn/no-useless-undefined": ["error", { checkArguments: false }],
+      "unicorn/prevent-abbreviations": "off"
+    }
+  }
+];
+
+// src/factory.ts
+var lichthagel = async (options = {}) => {
+  const {
+    browser = false,
+    node: node2 = false,
+    solid: solid2 = false,
+    stylistic: stylistic2 = true,
+    svelte: svelte2 = false,
+    tailwindcss: tailwindcss2 = false,
+    typescript = true,
+    ...rest
+  } = options;
+  if (Object.keys(rest).length > 0) {
+    throw new Error(`Unknown options: ${Object.keys(rest).join(", ")}`);
+  }
+  const config = [...javascript_default, ...unicorn_default, ...perfectionist_default];
+  if (stylistic2) {
+    config.push(...stylistic_default);
+  }
+  if (browser) {
+    config.push(...browser_default);
+  }
+  if (node2) {
+    config.push(...await node_default());
+  }
+  if (typescript) {
+    config.push(...typescript_default);
+  }
+  if (solid2) {
+    config.push(...await solid_default({ withTypescript: typescript }));
+  }
+  if (svelte2) {
+    config.push(...await svelte_default({ disableStylistic: stylistic2, withTypescript: typescript }));
+  }
+  if (tailwindcss2) {
+    config.push(...await tailwindcss_default());
+  }
+  return config;
+};
+var factory_default = lichthagel;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  browser,
+  javascript,
+  node,
+  perfectionist,
+  solid,
+  stylistic,
+  svelte,
+  tailwindcss,
+  typescript,
+  unicorn
+});