@eienjs/eslint-config 1.2.1 → 1.3.0

package/dist/types.d.ts

@@ -0,0 +1,404 @@
+import { ConfigNames, RuleOptions } from "./typegen.js";
+import { VendoredPrettierOptions } from "./vendored/prettier_types.js";
+import { StylisticCustomizeOptions } from "@stylistic/eslint-plugin";
+import { ParserOptions } from "@typescript-eslint/parser";
+import { FlatGitignoreOptions } from "eslint-config-flat-gitignore";
+import { Options } from "eslint-processor-vue-blocks";
+import { Linter } from "eslint";
+
+//#region src/types.d.ts
+type Awaitable<T> = T | Promise<T>;
+type Rules = Record<string, Linter.RuleEntry | undefined> & RuleOptions;
+/**
+ * An updated version of ESLint's `Linter.Config`, which provides autocompletion
+ * for `rules` and relaxes type limitations for `plugins` and `rules`, because
+ * many plugins still lack proper type definitions.
+ */
+type TypedFlatConfigItem = Omit<Linter.Config, 'plugins' | 'rules'> & {
+  /**
+   * 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>;
+  /**
+   * An object containing the configured rules. When `files` or `ignores` are
+   * specified, these rule configurations are only available to the matching files.
+   */
+  rules?: Rules;
+};
+interface OptionsNuxt extends OptionsOverrides {
+  /**
+   * Version of Nuxt
+   *
+   * @default 4
+   */
+  version?: 3 | 4;
+  /**
+   * Sort keys in nuxt.config to maintain a consistent order
+   *
+   * @default true when `stylistic` is enabled
+   */
+  sortConfigKeys?: boolean;
+  dirs?: {
+    /**
+     * Nuxt source directory
+     */
+    src?: string[];
+    /**
+     * Root directory for nuxt project
+     */
+    root?: string[];
+    /**
+     * Directory for pages
+     */
+    pages?: string[];
+    /**
+     * Directory for layouts
+     */
+    layouts?: string[];
+    /**
+     * Directory for components
+     */
+    components?: string[];
+    /**
+     * Directory for components with prefix
+     * Ignore `vue/multi-word-component-names`
+     */
+    componentsPrefixed?: string[];
+    /**
+     * Directory for composobles
+     */
+    composables?: string[];
+    /**
+     * Directory for plugins
+     */
+    plugins?: string[];
+    /**
+     * Directory for modules
+     */
+    modules?: string[];
+    /**
+     * Directory for middleware
+     */
+    middleware?: string[];
+    /**
+     * Directory for server
+     */
+    servers?: string[];
+    /**
+     * Directory for utils
+     */
+    utils?: string[];
+  };
+}
+interface OptionsAdonisJS extends OptionsOverrides {
+  /**
+   * Override the `dirs` option to provide custom directories of adonisjs app.
+   */
+  dirs?: {
+    root?: string;
+    bin?: string;
+    controllers?: string;
+    exceptions?: string;
+    models?: string;
+    mails?: string;
+    services?: string;
+    listeners?: string;
+    events?: string;
+    middleware?: string;
+    validators?: string;
+    providers?: string;
+    policies?: string;
+    abilities?: string;
+    database?: string;
+    start?: string;
+    tests?: string;
+    config?: string;
+    commands?: string;
+  };
+}
+interface OptionsVue extends OptionsOverrides {
+  /**
+   * Create virtual files for Vue SFC blocks to enable linting.
+   *
+   * @see https://github.com/antfu/eslint-processor-vue-blocks
+   * @default true
+   */
+  sfcBlocks?: boolean | Options;
+  /**
+   * Only check registered components in template casing.
+   *
+   * @default false
+   */
+  componentNameInTemplateCasingOnlyRegistered?: boolean;
+  /**
+   * Ignored components in template casing.
+   *
+   * @default []
+   */
+  componentNameInTemplateCasingIgnores?: string[];
+  /**
+   * Global components in template casing.
+   *
+   * @default []
+   */
+  componentNameInTemplateCasingGlobals?: string[];
+}
+type OptionsTypescript = (OptionsTypeScriptWithTypes & OptionsOverrides) | (OptionsTypeScriptParserOptions & OptionsOverrides);
+interface OptionsFormatters {
+  /**
+   * Enable formatting support for CSS, Less, Sass, and SCSS.
+   *
+   * Currently only support Prettier.
+   */
+  css?: 'prettier' | boolean;
+  /**
+   * Enable formatting support for HTML.
+   *
+   * Currently only support Prettier.
+   */
+  html?: 'prettier' | boolean;
+  /**
+   * Enable formatting support for XML.
+   *
+   * Currently only support Prettier.
+   */
+  xml?: 'prettier' | boolean;
+  /**
+   * Enable formatting support for SVG.
+   *
+   * Currently only support Prettier.
+   */
+  svg?: 'prettier' | boolean;
+  /**
+   * Enable formatting support for Markdown.
+   *
+   * Support both Prettier and dprint.
+   *
+   * When set to `true`, it will use Prettier.
+   */
+  markdown?: 'prettier' | boolean;
+  /**
+   * Custom options for Prettier.
+   *
+   * By default it's controlled by our own config.
+   */
+  prettierOptions?: VendoredPrettierOptions;
+  /**
+   * Enable formatting support for Astro.
+   *
+   * Currently only support Prettier.
+   */
+  astro?: 'prettier' | boolean;
+}
+interface OptionsComponentExts {
+  /**
+   * Additional extensions for components.
+   *
+   * @example ['vue']
+   * @default []
+   */
+  componentExts?: string[];
+}
+interface OptionsTypeScriptParserOptions {
+  /**
+   * Additional parser options for TypeScript.
+   */
+  parserOptions?: Partial<ParserOptions>;
+  /**
+   * Glob patterns for files that should be type aware.
+   * @default ['**\/*.{ts,tsx}']
+   */
+  filesTypeAware?: string[];
+  /**
+   * Glob patterns for files that should not be type aware.
+   * @default ['**\/*.md\/**', '**\/*.astro/*.ts']
+   */
+  ignoresTypeAware?: string[];
+}
+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.
+   */
+  overridesTypeAware?: TypedFlatConfigItem['rules'];
+}
+interface OptionsHasTypeScript {
+  typescript?: boolean;
+}
+interface OptionsStylistic {
+  stylistic?: boolean | StylisticConfig;
+}
+interface StylisticConfig extends Pick<StylisticCustomizeOptions, 'indent' | 'quotes'> {
+  maxLineLength?: number;
+}
+interface OptionsOverrides {
+  overrides?: TypedFlatConfigItem['rules'];
+}
+interface OptionsFiles {
+  /**
+   * Override the `files` option to provide custom globs.
+   */
+  files?: string[];
+}
+interface OptionsRegExp {
+  /**
+   * Override rulelevels
+   */
+  level?: 'error' | 'warn';
+}
+interface OptionsIsInEditor {
+  isInEditor?: boolean;
+}
+interface OptionsConfig extends OptionsComponentExts {
+  /**
+   * Enable gitignore support.
+   *
+   * Passing an object to configure the options.
+   *
+   * @see https://github.com/antfu/eslint-config-flat-gitignore
+   * @default true
+   */
+  gitignore?: boolean | FlatGitignoreOptions;
+  /**
+   * Core rules. Can't be disabled.
+   */
+  javascript?: OptionsOverrides;
+  /**
+   * Enable TypeScript support.
+   *
+   * Passing an object to enable TypeScript Language Server support.
+   *
+   * @default auto-detect based on the dependencies
+   */
+  typescript?: boolean | OptionsTypescript;
+  /**
+   * Options for eslint-plugin-unicorn.
+   *
+   * @default true
+   */
+  unicorn?: boolean | OptionsOverrides;
+  /**
+   * Options for eslint-plugin-import-lite.
+   *
+   * @default true
+   */
+  imports?: boolean | OptionsOverrides;
+  /**
+   * Enable test support.
+   *
+   * @default true
+   */
+  test?: boolean | OptionsOverrides;
+  /**
+   * Enable Vue support.
+   *
+   * @default auto-detect based on the dependencies
+   */
+  vue?: boolean | OptionsVue;
+  /**
+   * Enable JSONC support.
+   *
+   * @default true
+   */
+  jsonc?: boolean | OptionsOverrides;
+  /**
+   * Enable YAML support.
+   *
+   * @default true
+   */
+  yaml?: boolean | OptionsOverrides;
+  /**
+   * Enable TOML support.
+   *
+   * @default true
+   */
+  toml?: boolean | OptionsOverrides;
+  /**
+   * Enable ASTRO support.
+   *
+   * Requires installing:
+   * - `eslint-plugin-astro`
+   *
+   * Requires installing for formatting .astro:
+   * - `prettier-plugin-astro`
+   *
+   * @default false
+   */
+  astro?: boolean | OptionsOverrides;
+  /**
+   * Enable linting for **code snippets** in Markdown.
+   *
+   * For formatting Markdown content, enable also `formatters.markdown`.
+   *
+   * @default true
+   */
+  markdown?: boolean | OptionsOverrides;
+  /**
+   * Enable stylistic rules.
+   *
+   * @see https://eslint.style/
+   * @default true
+   */
+  stylistic?: boolean | (StylisticConfig & OptionsOverrides);
+  /**
+   * Enable regexp rules.
+   *
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/
+   * @default true
+   */
+  regexp?: boolean | (OptionsRegExp & OptionsOverrides);
+  /**
+   * Enable pnpm (workspace/catalogs) support.
+   *
+   * Currently it's disabled by default, as it's still experimental.
+   * In the future it will be smartly enabled based on the project usage.
+   *
+   * @see https://github.com/antfu/pnpm-workspace-utils
+   * @experimental
+   * @default false
+   */
+  pnpm?: boolean;
+  /**
+   * Use external formatters to format files.
+   *
+   * Requires installing:
+   * - `eslint-plugin-format`
+   *
+   * When set to `true`, it will enable all formatters.
+   *
+   * @default false
+   */
+  formatters?: boolean | OptionsFormatters;
+  /**
+   * Control to disable some rules in editors.
+   * @default auto-detect based on the process.env
+   */
+  isInEditor?: boolean;
+  /**
+   * Enable AdonisJS support.
+   *
+   * Requires installing:
+   * - `@adonisjs/eslint-plugin`
+   *
+   * @default false
+   */
+  adonisjs?: boolean | OptionsAdonisJS;
+  /**
+   * Enable Nuxt support.
+   *
+   * Requires installing:
+   * - `@nuxt/eslint-plugin`
+   *
+   * @default false
+   */
+  nuxt?: boolean | OptionsNuxt;
+}
+//#endregion
+export { Awaitable, OptionsAdonisJS, OptionsComponentExts, OptionsConfig, OptionsFiles, OptionsFormatters, OptionsHasTypeScript, OptionsIsInEditor, OptionsNuxt, OptionsOverrides, OptionsRegExp, OptionsStylistic, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes, OptionsTypescript, OptionsVue, Rules, StylisticConfig, TypedFlatConfigItem };

package/dist/utils.d.ts

@@ -0,0 +1,42 @@
+import { Awaitable, TypedFlatConfigItem } from "./types.js";
+
+//#region src/utils.d.ts
+declare const parserPlain: {
+  meta: {
+    name: string;
+  };
+  parseForESLint: (code: string) => {
+    ast: {
+      body: never[];
+      comments: never[];
+      loc: {
+        end: number;
+        start: number;
+      };
+      range: number[];
+      tokens: never[];
+      type: string;
+    };
+    scopeManager: null;
+    services: {
+      isPlain: boolean;
+    };
+    visitorKeys: {
+      Program: never[];
+    };
+  };
+};
+/**
+ * Combine array and non-array configs into a single array.
+ */
+declare function combine(...configs: Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[]>[]): Promise<TypedFlatConfigItem[]>;
+declare function toArray<T>(value: T | T[]): T[];
+declare function interopDefault<T>(m: Awaitable<T>): Promise<T extends {
+  default: infer U;
+} ? U : T>;
+declare function isPackageInScope(name: string): boolean;
+declare function ensurePackages(packages: (string | undefined)[]): Promise<void>;
+declare function isInEditorEnv(): boolean;
+declare function isInGitHooksOrLintStaged(): boolean;
+//#endregion
+export { combine, ensurePackages, interopDefault, isInEditorEnv, isInGitHooksOrLintStaged, isPackageInScope, parserPlain, toArray };

package/dist/utils.js

@@ -0,0 +1,62 @@
+import { isPackageExists } from "local-pkg";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+//#region src/utils.ts
+const scopeUrl = fileURLToPath(new URL(".", import.meta.url));
+const isCwdInScope = isPackageExists("@eienjs/eslint-config");
+const parserPlain = {
+	meta: { name: "parser-plain" },
+	parseForESLint: (code) => ({
+		ast: {
+			body: [],
+			comments: [],
+			loc: {
+				end: code.length,
+				start: 0
+			},
+			range: [0, code.length],
+			tokens: [],
+			type: "Program"
+		},
+		scopeManager: null,
+		services: { isPlain: true },
+		visitorKeys: { Program: [] }
+	})
+};
+/**
+* Combine array and non-array configs into a single array.
+*/
+async function combine(...configs) {
+	return (await Promise.all(configs)).flat();
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default || resolved;
+}
+function isPackageInScope(name) {
+	return isPackageExists(name, { paths: [scopeUrl] });
+}
+async function ensurePackages(packages) {
+	if (process.env.CI || !process.stdout.isTTY || !isCwdInScope) return;
+	const nonExistingPackages = packages.filter((i) => i && !isPackageInScope(i));
+	if (nonExistingPackages.length === 0) return;
+	const p = await import("@clack/prompts");
+	const packagesMissing = nonExistingPackages.join(", ");
+	const packagesMissingPlural = nonExistingPackages.length === 1 ? "Package is" : "Packages are";
+	if (await p.confirm({ message: `${packagesMissingPlural} required for this config: ${packagesMissing}. Do you want to install them?` })) await import("@antfu/install-pkg").then(async (i) => i.installPackage(nonExistingPackages, { dev: true }));
+}
+function isInEditorEnv() {
+	if (process.env.CI) return false;
+	if (isInGitHooksOrLintStaged()) return false;
+	return Boolean(process.env.VSCODE_PID || process.env.VSCODE_CWD || process.env.JETBRAINS_IDE || process.env.VIM || process.env.NVIM);
+}
+function isInGitHooksOrLintStaged() {
+	return Boolean(process.env.GIT_PARAMS || process.env.VSCODE_GIT_COMMAND || process.env.npm_lifecycle_script?.startsWith("lint-staged"));
+}
+
+//#endregion
+export { combine, ensurePackages, interopDefault, isInEditorEnv, isInGitHooksOrLintStaged, isPackageInScope, parserPlain, toArray };

package/dist/vendored/prettier_types.d.ts

@@ -0,0 +1,121 @@
+//#region src/vendored/prettier_types.d.ts
+/**
+ * Vendor types from Prettier so we don't rely on the dependency.
+ */
+type VendoredPrettierOptions = Partial<VendoredPrettierOptionsRequired>;
+interface VendoredPrettierOptionsRequired {
+  /**
+   * Specify the line length that the printer will wrap on.
+   * @default 120
+   */
+  printWidth: number;
+  /**
+   * Specify the number of spaces per indentation-level.
+   */
+  tabWidth: number;
+  /**
+   * Indent lines with tabs instead of spaces
+   */
+  useTabs?: boolean;
+  /**
+   * Print semicolons at the ends of statements.
+   */
+  semi: boolean;
+  /**
+   * Use single quotes instead of double quotes.
+   */
+  singleQuote: boolean;
+  /**
+   * Use single quotes in JSX.
+   */
+  jsxSingleQuote: boolean;
+  /**
+   * Print trailing commas wherever possible.
+   */
+  trailingComma: 'none' | 'es5' | 'all';
+  /**
+   * Print spaces between brackets in object literals.
+   */
+  bracketSpacing: boolean;
+  /**
+   * Put the `>` of a multi-line HTML (HTML, XML, JSX, Vue, Angular) element at the end of the last line instead of being
+   * alone on the next line (does not apply to self closing elements).
+   */
+  bracketSameLine: boolean;
+  /**
+   * Put the `>` of a multi-line JSX element at the end of the last line instead of being alone on the next line.
+   * @deprecated use bracketSameLine instead
+   */
+  jsxBracketSameLine: boolean;
+  /**
+   * Format only a segment of a file.
+   */
+  rangeStart: number;
+  /**
+   * Format only a segment of a file.
+   * @default Number.POSITIVE_INFINITY
+   */
+  rangeEnd: number;
+  /**
+   * By default, Prettier will wrap markdown text as-is since some services use a linebreak-sensitive renderer.
+   * In some cases you may want to rely on editor/viewer soft wrapping instead, so this option allows you to opt out.
+   * @default "preserve"
+   */
+  proseWrap: 'always' | 'never' | 'preserve';
+  /**
+   * Include parentheses around a sole arrow function parameter.
+   * @default "always"
+   */
+  arrowParens: 'avoid' | 'always';
+  /**
+   * Provide ability to support new languages to prettier.
+   */
+  plugins: unknown[];
+  /**
+   * How to handle whitespaces in HTML.
+   * @default "css"
+   */
+  htmlWhitespaceSensitivity: 'css' | 'strict' | 'ignore';
+  /**
+   * Which end of line characters to apply.
+   * @default "lf"
+   */
+  endOfLine: 'auto' | 'lf' | 'crlf' | 'cr';
+  /**
+   * Change when properties in objects are quoted.
+   * @default "as-needed"
+   */
+  quoteProps: 'as-needed' | 'consistent' | 'preserve';
+  /**
+   * Whether or not to indent the code inside <script> and <style> tags in Vue files.
+   * @default false
+   */
+  vueIndentScriptAndStyle: boolean;
+  /**
+   * Enforce single attribute per line in HTML, XML, Vue and JSX.
+   * @default false
+   */
+  singleAttributePerLine: boolean;
+  /**
+   * How to handle whitespaces in XML.
+   * @default "preserve"
+   */
+  xmlQuoteAttributes: 'single' | 'double' | 'preserve';
+  /**
+   * Whether to put a space inside the brackets of self-closing XML elements.
+   * @default true
+   */
+  xmlSelfClosingSpace: boolean;
+  /**
+   * Whether to sort attributes by key in XML elements.
+   * @default false
+   */
+  xmlSortAttributesByKey: boolean;
+  /**
+   * How to handle whitespaces in XML.
+   * @default "ignore"
+   */
+  xmlWhitespaceSensitivity: 'ignore' | 'strict' | 'preserve';
+}
+//#endregion
+export { VendoredPrettierOptions };