@purea/eslint-config 0.0.1

package/src/factory.ts

@@ -0,0 +1,70 @@
+import type { Linter } from 'eslint';
+import type { Awaitable, ConfigOptions, FlatConfigItem } from './types';
+
+import { isPackageExists } from 'local-pkg';
+import { ignores, imports, javascript, typescript, stylistic, jsonc, vue } from './configs';
+import { isObject } from './utils';
+
+/**
+ * Create ESLint configuration based on provided options
+ *
+ * @param options - Configuration options
+ * @returns Array of ESLint configurations
+ *
+ * @example
+ * ```typescript
+ * import { useConfig } from '@purea/eslint-config'
+ *
+ * export default useConfig({
+ *   typescript: true,
+ * })
+ * ```
+ */
+export async function useConfig(
+  options: ConfigOptions = {},
+  ...extraConfigs: Awaitable<FlatConfigItem | FlatConfigItem[] | Linter.Config[]>[]
+): Promise<FlatConfigItem[]> {
+  const {
+    ignores: userIgnores = [],
+    imports: enableImports = true,
+    typescript: enableTypeScript = isPackageExists('typescript'),
+    jsonc: enableJsonc = true,
+    vue: enableVue = isPackageExists('vue'),
+  } = options;
+
+  const configs: Awaitable<FlatConfigItem | FlatConfigItem[] | Linter.Config[]>[] = [];
+
+  configs.push(
+    ignores(userIgnores),
+    javascript(),
+    stylistic()
+  );
+
+  // Imports config
+  enableImports && configs.push(imports());
+
+  // TypeScript config
+  if (enableTypeScript) {
+    const typescriptOptions = isObject(enableTypeScript) ? enableTypeScript : {};
+    configs.push(typescript({ ...typescriptOptions }));
+  }
+
+  // Vue config
+  if (enableVue) {
+    const vueOptions = isObject(enableVue) ? enableVue : {};
+    configs.push(vue({
+      typescript: !!enableTypeScript,
+      ...vueOptions,
+    }));
+  }
+
+  // JSONC config
+  enableJsonc && configs.push(jsonc());
+
+  // Extra configs
+  configs.push(...extraConfigs);
+
+  const resolvedConfigs = await Promise.all(configs);
+
+  return resolvedConfigs.flat().filter(Boolean);
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+import { useConfig } from './factory';
+
+export type * from './types';
+
+export * from './configs';
+export * from './factory';
+export * from './utils';
+
+export default useConfig;

package/src/types.ts

@@ -0,0 +1,82 @@
+import type { Linter } from 'eslint';
+
+/**
+  * A type that represents a value that can be either a Promise of T or T itself.
+*/
+export type Awaitable<T> = Promise<T> | T;
+
+/**  Configuration options for the ESLint config */
+export interface ConfigOptions {
+  /**
+  * User ignores patterns
+  * @default []
+  */
+  ignores?: string[]
+  /**
+   * Enable imports rules
+   * @default true
+   */
+  imports?: boolean
+  /**
+   * Enable TypeScript rules
+   * @default true (if TypeScript is detected in the project)
+   */
+  typescript?: boolean | OptionsTypeScriptWithTypes
+  /**
+   * Enable JSONC rules
+   * @default true
+   */
+  jsonc?: boolean
+  /**
+   * Enable Vue rules
+   * @default true (if Vue is detected in the project)
+   */
+  vue?: boolean | VueOptions
+}
+
+export type FlatConfigItem = Omit<Linter.Config, 'plugins'> & {
+  /**
+   * An object containing a name-value mapping of plugin names to plugin objects.
+   * When `files` is specified, these plugins are only available to the matching files.
+   *
+   * @see [Using plugins in your configuration](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new#using-plugins-in-your-configuration)
+   */
+  plugins?: Record<string, unknown>
+};
+
+/** TypeScript options. */
+export type TypeScriptOptions = OptionsTypeScriptWithTypes;
+
+/** Options for TypeScript with types. */
+interface OptionsTypeScriptWithTypes {
+  /**
+   * When this options is provided, type aware rules will be enabled.
+   * @see https://typescript-eslint.io/linting/typed-linting/
+   */
+  tsconfigPath?: string
+
+  /**
+   * Override type aware rules.
+   */
+  overridesTypeAwareRules?: FlatConfigItem['rules']
+}
+
+/** Vue options. */
+export interface VueOptions {
+  /**
+   * Vue version
+   * @default 3
+   */
+  vueVersion?: 2 | 3
+
+  /**
+   * Override Vue-specific rules.
+   */
+  overridesRules?: FlatConfigItem['rules']
+
+  /**
+   * Enable TypeScript rules for Vue SFC
+   * @default false
+   */
+  typescript?: boolean
+}

package/src/utils.ts

@@ -0,0 +1,19 @@
+import type { Awaitable } from './types';
+
+/**
+ * 检查值是否为非空对象
+ * @param value - 要检查的值
+ * @returns 如果值是非空对象则返回 true，否则返回 false
+ */
+export const isObject = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+/**
+ * 导入默认导出
+ * @param importable - 动态导入的 Promise
+ * @returns 返回模块的默认导出或整个模块对象
+ */
+export async function importDefault<T>(importable: Awaitable<T>): Promise<T extends { default: infer U } ? U : T> {
+  const resolved = await importable;
+  if (isObject(resolved) && ('default' in resolved)) return resolved.default as T extends { default: infer U } ? U : T;
+  return resolved as T extends { default: infer U } ? U : T;
+}