@lqbach/eslint-config 0.6.1 → 0.8.0

package/src/index.ts

@@ -7,9 +7,12 @@ import {
   parserTypeScript,
   parserVue,
   parserYaml,
+  pluginAstro,
   pluginJsonc,
+  pluginNext,
   pluginPerfectionist,
   pluginReact,
+  pluginReactHooks,
   pluginTypeScript,
   pluginUnusedImports,
   pluginVue,
@@ -45,8 +48,11 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
       "**/web/public",
       "**/studio/build",
       "**/studio/.sanity",
+
+      ...(params.next ? ["**/.next"] : []),
       ...(params.ignores ? params.ignores : []),
     ],
+    name: "lqbach/ignores",
   }
 
   //JavaScript Config
@@ -66,6 +72,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
           sourceType: "module",
         },
       },
+      name: "lqbach/javascript",
       plugins: {
         "unused-imports": pluginUnusedImports,
       },
@@ -86,7 +93,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
 
   // TypeScript Config
   const typescriptConfig: ConfigObject =
-    params.typescript ?? true
+    (params.typescript ?? true)
       ? {
           files: ["**/*.{ts,tsx}"],
           languageOptions: {
@@ -95,6 +102,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
               sourceType: "module",
             },
           },
+          name: "lqbach/typescript",
           plugins: {
             "@typescript-eslint": pluginTypeScript,
           },
@@ -106,7 +114,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
 
   // React Config: turned off by default
   const reactConfig: ConfigObject =
-    params.react ?? false
+    ((params.next || params.react) ?? false)
       ? {
           files: ["**/*.{js,jsx,mjs,cjs,ts,tsx}"],
           languageOptions: {
@@ -120,20 +128,38 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
               },
             },
           },
+          name: "lqbach/react",
           plugins: {
             react: pluginReact,
           },
           rules: {
-            ...pluginReact.configs.flat.recommended.rules,
+            ...pluginReact.configs.flat?.recommended.rules,
             // ignore `css` for emotion usage
             "react/no-unknown-property": ["error", { ignore: ["css"] }],
           },
         }
       : {}
 
+  const reactHooksConfig: ConfigObject =
+    ((params.next ||
+      (typeof params.react !== "boolean" && params.react?.hooks === true)) ??
+    false)
+      ? {
+          files: ["**/*.{js,jsx,mjs,cjs,ts,tsx}"],
+          name: "lqbach/react-hooks",
+          plugins: {
+            "react-hooks": pluginReactHooks,
+          },
+          rules: {
+            "react-hooks/exhaustive-deps": "warn",
+            "react-hooks/rules-of-hooks": "error",
+          },
+        }
+      : {}
+
   // Vue Config: turned off by default
   const vueConfig: ConfigObject =
-    params.vue ?? false
+    (params.vue ?? false)
       ? {
           files: ["**/*.vue"],
           languageOptions: {
@@ -143,26 +169,52 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
               sourceType: "module",
             },
           },
+          name: "lqbach/vue",
           plugins: {
             vue: pluginVue,
           },
           processor: pluginVue.processors[".vue"],
           rules: {
             ...pluginVue.configs["base"].rules,
-            ...pluginVue.configs["vue3-essential"].rules,
-            ...pluginVue.configs["vue3-strongly-recommended"].rules,
+            ...pluginVue.configs["essential"].rules,
+            ...pluginVue.configs["strongly-recommended"].rules,
           },
         }
       : {}
 
+  // NextJS Config
+  const nextConfig: ConfigObject =
+    (params.next ?? false)
+      ? {
+          files: ["**/*.{js,jsx,ts,tsx}"],
+          name: "lqbach/next",
+          plugins: {
+            "@next/next": pluginNext,
+          },
+          rules: {
+            ...pluginNext.configs.recommended.rules,
+            ...pluginNext.configs["core-web-vitals"].rules,
+          },
+          ...(typeof params.next !== "boolean" &&
+            params.next?.rootDir && {
+              settings: {
+                nextjs: {
+                  rootDir: params.next.rootDir,
+                },
+              },
+            }),
+        }
+      : {}
+
   // YAML Config
   const yamlConfig: ConfigObject =
-    params.yaml ?? true
+    (params.yaml ?? true)
       ? {
           files: ["**/*.{yaml, yml}"],
           languageOptions: {
             parser: parserYaml,
           },
+          name: "lqbach/yaml",
           plugins: {
             yml: pluginYaml,
           },
@@ -175,9 +227,10 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
 
   // JSONC Config
   const jsoncConfig: Array<ConfigObject> =
-    params.json ?? true
+    (params.json ?? true)
       ? [
           {
+            name: "lqbach/jsonc-plugin",
             plugins: {
               jsonc: pluginJsonc,
             },
@@ -187,6 +240,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
             languageOptions: {
               parser: parserJsonc,
             },
+            name: "lqbach/json",
             rules: {
               ...pluginJsonc.configs["recommended-with-json"].rules,
               ...pluginJsonc.configs["recommended-with-jsonc"].rules,
@@ -200,8 +254,9 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
 
   // Perfectionist Config
   const perfectionistConfig: ConfigObject =
-    params.perfectionist ?? true
+    (params.perfectionist ?? true)
       ? {
+          name: "lqbach/perfectionist",
           plugins: {
             perfectionist: pluginPerfectionist,
           },
@@ -211,6 +266,37 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
         }
       : {}
 
+  // Astro Config
+  const astroConfig: ConfigObject =
+    (params.astro ?? false)
+      ? {
+          files: ["**/*.astro"],
+          languageOptions: {
+            parserOptions: params.typescript
+              ? {
+                  extraFileExtensions: [".astro"],
+                  parser: parserTypeScript,
+                  sourceType: "module",
+                }
+              : {},
+          },
+          name: "lqbach/astro",
+          plugins: {
+            astro: pluginAstro,
+          },
+          rules: {
+            "astro/missing-client-only-directive-value": "error",
+            "astro/no-conflict-set-directives": "error",
+            "astro/no-deprecated-astro-canonicalurl": "error",
+            "astro/no-deprecated-astro-fetchcontent": "error",
+            "astro/no-deprecated-astro-resolve": "error",
+            "astro/no-deprecated-getentrybyslug": "error",
+            "astro/no-unused-define-vars-in-style": "error",
+            "astro/valid-compile": "error",
+          },
+        }
+      : {}
+
   const prettierConfig: ConfigObject = configPrettier
 
   let config: Array<ConfigObject> = []
@@ -218,7 +304,10 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
   config.push(...javascriptConfig)
   config.push(typescriptConfig)
   config.push(reactConfig)
+  config.push(reactHooksConfig)
   config.push(vueConfig)
+  config.push(nextConfig)
+  config.push(astroConfig)
   config.push(yamlConfig)
   config.push(...jsoncConfig)
   config.push(perfectionistConfig)

package/src/libs.ts

@@ -3,18 +3,18 @@
 // @ts-nocheck
 
 export { default as jsConfig } from "@eslint/js"
+export { default as pluginNext } from "@next/eslint-plugin-next"
 export { default as pluginTypeScript } from "@typescript-eslint/eslint-plugin"
 export { default as parserTypeScript } from "@typescript-eslint/parser"
 export { default as configPrettier } from "eslint-config-prettier"
+export { default as pluginAstro } from "eslint-plugin-astro"
 export { default as pluginJsonc } from "eslint-plugin-jsonc"
 export { default as pluginPerfectionist } from "eslint-plugin-perfectionist"
 export { default as pluginReact } from "eslint-plugin-react"
-
+export { default as pluginReactHooks } from "eslint-plugin-react-hooks"
 export { default as pluginUnusedImports } from "eslint-plugin-unused-imports"
 export { default as pluginVue } from "eslint-plugin-vue"
 export { default as pluginYaml } from "eslint-plugin-yml"
 export { default as parserJsonc } from "jsonc-eslint-parser"
-
 export { default as parserVue } from "vue-eslint-parser"
-
 export { default as parserYaml } from "yaml-eslint-parser"

package/src/types.ts

@@ -1,16 +1,35 @@
+export interface AstroConfigParams {
+  typescript?: boolean
+}
+
+export interface ConfigObject {
+  files?: Array<string>
+  ignores?: Array<string>
+  languageOptions?: LanguageOptions
+  linterOptions?: LinterOptions
+  name?: string
+  plugins?: object
+  processor?: object
+  rules?: object
+  // eslint-disable-next-line
+  settings?: any
+}
+
 export interface ConfigParams {
+  astro?: AstroConfigParams | boolean
   ignores?: Array<string>
   json?: boolean
   markdown?: boolean
+  next?: boolean | NextJSConfigParams
   perfectionist?: boolean
-  react?: boolean
+  react?: boolean | ReactJSConfigParams
   typescript?: boolean
   vue?: boolean
   yaml?: boolean
 }
 
 export interface LanguageOptions {
-  ecmaVersion?: string
+  ecmaVersion?: number | string
   globals?: object
   parser?: object
   parserOptions?: object
@@ -22,13 +41,13 @@ export interface LinterOptions {
   reportUnusedDisableDirectives?: boolean
 }
 
-export interface ConfigObject {
-  files?: Array<string>
-  ignores?: Array<string>
-  languageOptions?: LanguageOptions
-  linterOptions?: LinterOptions
-  plugins?: object
-  processor?: object
-  rules?: object
-  settings?: object
+export interface NextJSConfigParams {
+  rootDir?: string
+}
+
+export interface ReactJSConfigParams {
+  /**
+   * use react hooks
+   */
+  hooks?: boolean
 }

package/test/astro.spec.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "vitest"
+
+import eslintConfig from "../src"
+import { getConfigObjectByName } from "./utils"
+
+const ASTRO_CONFIG_OBJECT_NAME = "lqbach/astro"
+
+// test astro configuration
+describe("test astro eslint configuration", () => {
+  describe("if astro parameter is not true", () => {
+    const config = eslintConfig({ astro: false })
+
+    test("should not have a configuration object lqbach/astro", () => {
+      expect(getConfigObjectByName(ASTRO_CONFIG_OBJECT_NAME, config)).toBe(
+        undefined,
+      )
+    })
+  })
+
+  describe("if astro parameter is true", () => {
+    const config = eslintConfig({ astro: true })
+
+    test("should have a configuration object lqbach/astro", () => {
+      expect(
+        getConfigObjectByName(ASTRO_CONFIG_OBJECT_NAME, config),
+      ).toBeTruthy()
+    })
+
+    test("should target *.astro files", () => {
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.files).toEqual(["**/*.astro"])
+    })
+
+    test("should include astro plugin", () => {
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.plugins).toHaveProperty("astro")
+    })
+
+    test("should include astro recommended rules", () => {
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.rules).toBeDefined()
+      expect(Object.keys(astroConfig?.rules || {})).toContain(
+        "astro/no-conflict-set-directives",
+      )
+    })
+
+    test("should not have typescript parser options when typescript is not enabled", () => {
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.languageOptions?.parserOptions).toEqual({})
+    })
+  })
+
+  describe("if astro parameter is a config object", () => {
+    test("should have a configuration object lqbach/astro when typescript is enabled", () => {
+      const config = eslintConfig({
+        astro: { typescript: true },
+        typescript: true,
+      })
+      expect(
+        getConfigObjectByName(ASTRO_CONFIG_OBJECT_NAME, config),
+      ).toBeTruthy()
+    })
+
+    test("should include typescript parser options when typescript is enabled", () => {
+      const config = eslintConfig({
+        astro: { typescript: true },
+        typescript: true,
+      })
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.languageOptions?.parserOptions).toEqual({
+        extraFileExtensions: [".astro"],
+        parser: expect.any(Object),
+        sourceType: "module",
+      })
+    })
+
+    test("should not include typescript parser options when typescript is disabled", () => {
+      const config = eslintConfig({
+        astro: { typescript: false },
+        typescript: false,
+      })
+      const astroConfig = getConfigObjectByName(
+        ASTRO_CONFIG_OBJECT_NAME,
+        config,
+      )
+      expect(astroConfig?.languageOptions?.parserOptions).toEqual({})
+    })
+  })
+
+  describe("default behavior", () => {
+    test("should not include astro config by default", () => {
+      const config = eslintConfig({})
+      expect(getConfigObjectByName(ASTRO_CONFIG_OBJECT_NAME, config)).toBe(
+        undefined,
+      )
+    })
+
+    test("should not include astro config when astro is undefined", () => {
+      const config = eslintConfig({ astro: undefined })
+      expect(getConfigObjectByName(ASTRO_CONFIG_OBJECT_NAME, config)).toBe(
+        undefined,
+      )
+    })
+  })
+})

package/test/ignore.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "vitest"
+
+import eslintConfig from "../src"
+
+// test tailwind configuration
+describe("test ignore list in eslint configuration", () => {
+  describe("if ignores array is populated", () => {
+    const IGNORE_FILE_NAME = "**/.ignorethisfile"
+
+    const IGNORE_LOCK_FILES = [
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/pnpm-lock.yaml",
+      "**/bun.lockb",
+    ]
+
+    const config = eslintConfig({ ignores: [IGNORE_FILE_NAME] })
+
+    test("should include the ignored file name in an `ignores` object", () => {
+      expect(
+        config.some((obj) => obj.ignores?.includes(IGNORE_FILE_NAME)),
+      ).toBe(true)
+    })
+
+    test("edge case test for random files", () => {
+      expect(config.some((obj) => obj.ignores?.includes("fakefile"))).toBe(
+        false,
+      )
+    })
+
+    test("test lock files are included", () => {
+      expect(
+        IGNORE_LOCK_FILES.every((lock) =>
+          config.some((obj) => obj.ignores?.includes(lock)),
+        ),
+      ).toBe(true)
+    })
+  })
+})

package/test/next.spec.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "vitest"
+
+import eslintConfig from "../src"
+import { getConfigObjectByName } from "./utils"
+
+const NEXT_CONFIG_OBJECT_NAME = "lqbach/next"
+
+// test tailwind configuration
+describe("test nextjs eslint configuration", () => {
+  describe("if next parameter is not true", () => {
+    const config = eslintConfig({ next: false })
+
+    test("should not include the ignored folder **/.next in the `ignores` object", () => {
+      expect(config.some((obj) => obj.ignores?.includes("**/.next"))).toBe(true)
+    })
+    test("should not have a configuration object lqbach/next", () => {
+      expect(getConfigObjectByName(NEXT_CONFIG_OBJECT_NAME, config)).toBe(
+        undefined,
+      )
+    })
+  })
+  describe("if next parameter is true", () => {
+    const config = eslintConfig({ next: true })
+
+    test("should include react config", () => {
+      expect(getConfigObjectByName("lqbach/react", config)).toBeTruthy()
+    })
+    test("should include react hooks config", () => {
+      expect(getConfigObjectByName("lqbach/react-hooks", config)).toBeTruthy()
+    })
+
+    test("should include the ignored folder **/.next in the `ignores` object", () => {
+      expect(
+        getConfigObjectByName("lqbach/ignores", config)?.ignores?.includes(
+          "**/.next",
+        ),
+      ).toBe(true)
+    })
+  })
+  describe("if next parameter is a config object", () => {
+    test("should include react config", () => {
+      const config = eslintConfig({ next: { rootDir: "packages/example" } })
+      expect(getConfigObjectByName("lqbach/react", config)).toBeTruthy()
+    })
+    test("should include react hooks config", () => {
+      const config = eslintConfig({ next: { rootDir: "packages/example" } })
+      expect(getConfigObjectByName("lqbach/react-hooks", config)).toBeTruthy()
+    })
+    test("should parse rootDir properly", () => {
+      const config = eslintConfig({ next: { rootDir: "packages/example" } })
+      expect(
+        getConfigObjectByName("lqbach/next", config)?.settings?.nextjs?.rootDir,
+      ).toEqual("packages/example")
+    })
+  })
+})

package/test/utils.ts

@@ -0,0 +1,16 @@
+import type { ConfigObject } from "../src/types"
+
+/**
+ *
+ * @param name A name for the configuration object. Use naming convention recommended by ESLint (https://eslint.org/docs/latest/use/configure/configuration-files#configuration-naming-conventions)
+ * @param config ESLint config
+ * @returns config object based on the configuration object name
+ */
+export const getConfigObjectByName = (
+  name: string,
+  config: Array<ConfigObject>,
+) => {
+  return config.find((configObj) => {
+    return configObj.name === name
+  })
+}