Flat Config Utilities

/**
 * Provide type definitions for constructing ESLint flat config items.
 * This function takes flat config item, or an array of them as rest arguments.
 * It also automatically resolves the promise if the config item is a promise.
 * 
 * @param configs - Flat config items or promises of config items
 * @returns FlatConfigComposer for chaining and composition
 */
function defineFlatConfigs(...configs: ResolvableFlatConfig[]): FlatConfigComposer;

type ResolvableFlatConfig = Linter.Config | Promise<Linter.Config>;

import { defineFlatConfigs } from "@nuxt/eslint-config";
import js from "@eslint/js";

// Define multiple flat configs
export default defineFlatConfigs(
  // Basic recommended rules
  js.configs.recommended,
  
  // Custom rules
  {
    rules: {
      "no-unused-vars": "warn",
      "prefer-const": "error"
    }
  },
  
  // Async config (will be resolved automatically)
  import("./custom-config.js"),
  
  // Conditional config
  process.env.NODE_ENV === "development" ? {
    rules: {
      "no-console": "off"
    }
  } : undefined
);

// Chaining with other configs
export default defineFlatConfigs(
  js.configs.recommended
).append({
  files: ["**/*.ts"],
  rules: {
    "@typescript-eslint/no-explicit-any": "warn"
  }
});

interface FlatConfigComposer {
  /**
   * Append additional configurations to the composer
   */
  append(...configs: ResolvableFlatConfig[]): FlatConfigComposer;
  
  /**
   * Set plugin conflicts error handling
   */
  setPluginConflictsError(pluginName?: string, message?: string): FlatConfigComposer;
}

import { defineFlatConfigs } from "@nuxt/eslint-config";

// Building configurations step by step
const config = defineFlatConfigs()
  .append({
    name: "base-rules",
    rules: {
      "no-unused-vars": "warn"
    }
  })
  .append({
    name: "typescript-rules",
    files: ["**/*.ts", "**/*.tsx"],
    rules: {
      "@typescript-eslint/explicit-function-return-type": "error"
    }
  })
  .setPluginConflictsError("import", "Different import plugin instances detected");

export default config;

/**
 * A flat config that can be a direct config object or a promise that resolves to one
 */
type ResolvableFlatConfig = Linter.Config | Promise<Linter.Config>;

/**
 * ESLint Linter.Config for reference
 */
interface Linter.Config {
  name?: string;
  files?: string | string[];
  ignores?: string[];
  languageOptions?: LanguageOptions;
  linterOptions?: LinterOptions;
  processor?: string | Processor;
  plugins?: Record<string, Plugin>;
  rules?: Record<string, RuleLevel | RuleLevelAndOptions>;
  settings?: Record<string, any>;
}

import { defineFlatConfigs } from "@nuxt/eslint-config";

// Mix of sync and async configs
export default defineFlatConfigs(
  // Synchronous config
  {
    name: "sync-config",
    rules: {
      "no-console": "warn"
    }
  },
  
  // Asynchronous config - will be resolved automatically
  import("./async-config.js").then(module => ({
    name: "async-config",
    ...module.default
  })),
  
  // Conditional async config
  process.env.ENABLE_TYPESCRIPT ? 
    import("@typescript-eslint/eslint-plugin").then(plugin => ({
      name: "typescript",
      plugins: {
        "@typescript-eslint": plugin
      }
    })) : 
    undefined
);

import { defineFlatConfigs } from "@nuxt/eslint-config";
import { composer } from "eslint-flat-config-utils";
import gitignore from "eslint-config-flat-gitignore";

// Integration with eslint-flat-config-utils
export default defineFlatConfigs(
  gitignore({ strict: false }),
  
  // Use the composer directly if needed
  ...composer(
    {
      name: "base",
      rules: { "no-console": "warn" }
    },
    {
      name: "typescript",
      files: ["**/*.ts"],
      rules: { "@typescript-eslint/no-explicit-any": "error" }
    }
  )
);