@lqbach/eslint-config 0.7.0 → 0.8.1

package/src/index.ts

@@ -3,10 +3,12 @@ import globals from "globals"
 import {
   configPrettier,
   jsConfig,
+  parserAstro,
   parserJsonc,
   parserTypeScript,
   parserVue,
   parserYaml,
+  pluginAstro,
   pluginJsonc,
   pluginNext,
   pluginPerfectionist,
@@ -150,7 +152,8 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
             "react-hooks": pluginReactHooks,
           },
           rules: {
-            ...pluginReactHooks.configs.recommended.rules,
+            "react-hooks/exhaustive-deps": "warn",
+            "react-hooks/rules-of-hooks": "error",
           },
         }
       : {}
@@ -174,8 +177,8 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
           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,
           },
         }
       : {}
@@ -264,6 +267,38 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
         }
       : {}
 
+  // Astro Config
+  const astroConfig: ConfigObject =
+    (params.astro ?? false)
+      ? {
+          files: ["**/*.astro"],
+          languageOptions: {
+            parser: parserAstro,
+            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> = []
@@ -274,6 +309,7 @@ export default function config(params: ConfigParams = {}): Array<ConfigObject> {
   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

@@ -6,7 +6,9 @@ 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 parserAstro } from "astro-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"
@@ -15,7 +17,5 @@ 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,4 +1,22 @@
+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
@@ -23,19 +41,6 @@ export interface LinterOptions {
   reportUnusedDisableDirectives?: 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 NextJSConfigParams {
   rootDir?: string
 }

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