projen
Version:
CDK for software projects
434 lines • 59.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Eslint = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const prettier_1 = require("./prettier");
const component_1 = require("../component");
const json_1 = require("../json");
const yaml_1 = require("../yaml");
/**
* Represents eslint configuration.
*/
class Eslint extends component_1.Component {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.javascript.Eslint", version: "0.103.12" };
/**
* Returns the singleton Eslint component of a project or undefined if there is none.
*/
static of(project) {
const isEslint = (c) => c instanceof Eslint;
return project.components.find(isEslint);
}
/**
* The underlying config file
*/
file;
/**
* eslint rules.
*/
rules;
/**
* eslint overrides.
*/
overrides = [];
/**
* eslint task.
*/
eslintTask;
/**
* Direct access to the eslint configuration (escape hatch)
*/
config;
/**
* File patterns that should not be linted
*/
ignorePatterns;
_formattingRules;
_allowDevDeps;
_allowDefaultProject = new Set();
_plugins = new Set();
_extends = new Set();
_fileExtensions;
_flagArgs;
_lintPatterns;
nodeProject;
sortExtends;
constructor(project, options) {
super(project);
this.nodeProject = project;
project.addDevDeps("eslint@^9", "@typescript-eslint/eslint-plugin@^8", "@typescript-eslint/parser@^8", "eslint-import-resolver-typescript", "eslint-plugin-import");
if (options.aliasMap) {
project.addDevDeps("eslint-import-resolver-alias");
}
const devdirs = options.devdirs ?? [];
this._lintPatterns = new Set([...options.dirs, ...devdirs]);
this._fileExtensions = new Set(options.fileExtensions ?? [".ts"]);
this._allowDevDeps = new Set((devdirs ?? []).map((dir) => `**/${dir}/**`));
const commandOptions = options.commandOptions ?? {};
const { fix = true, extraArgs: extraFlagArgs = [] } = commandOptions;
this._flagArgs = new Set(extraFlagArgs);
if (fix) {
this._flagArgs.add("--fix");
}
this._flagArgs.add("--no-error-on-unmatched-pattern");
this.sortExtends = options.sortExtends ?? new ExtendsDefaultOrder();
this.eslintTask = project.addTask("eslint", {
description: "Runs eslint against the codebase",
env: {
ESLINT_USE_FLAT_CONFIG: "false",
NODE_NO_WARNINGS: "1", // Suppress eslint warning about legacy config format, as it just confuses users. This will suppress all node warnings, but in practice users cannot action warnings from eslint anyway.
},
});
this.updateTask();
project.testTask.spawn(this.eslintTask);
// exclude some files
project.npmignore?.exclude("/.eslintrc.json");
this._formattingRules = {
// Style
"@stylistic/indent": ["error", 2],
"@stylistic/quotes": ["error", "single", { avoidEscape: true }],
"@stylistic/comma-dangle": ["error", "always-multiline"], // ensures clean diffs, see https://medium.com/@nikgraf/why-you-should-enforce-dangling-commas-for-multiline-statements-d034c98e36f8
"@stylistic/comma-spacing": ["error", { before: false, after: true }], // space after, no space before
"@stylistic/no-multi-spaces": ["error", { ignoreEOLComments: false }], // no multi spaces
"@stylistic/array-bracket-spacing": ["error", "never"], // [1, 2, 3]
"@stylistic/array-bracket-newline": ["error", "consistent"], // enforce consistent line breaks between brackets
"@stylistic/object-curly-spacing": ["error", "always"], // { key: 'value' }
"@stylistic/object-curly-newline": [
"error",
{ multiline: true, consistent: true },
], // enforce consistent line breaks between braces
"@stylistic/object-property-newline": [
"error",
{ allowAllPropertiesOnSameLine: true },
], // enforce "same line" or "multiple line" on object properties
"@stylistic/keyword-spacing": ["error"], // require a space before & after keywords
"@stylistic/brace-style": ["error", "1tbs", { allowSingleLine: true }], // enforce one true brace style
"@stylistic/space-before-blocks": ["error"], // require space before blocks
// @see https://github.com/typescript-eslint/typescript-eslint/issues/8072
"@stylistic/member-delimiter-style": ["error"],
// Require semicolons
"@stylistic/semi": ["error", "always"],
// Max line lengths
"@stylistic/max-len": [
"error",
{
code: 150,
ignoreUrls: true, // Most common reason to disable it
ignoreStrings: true, // These are not fantastic but necessary for error messages
ignoreTemplateLiterals: true,
ignoreComments: true,
ignoreRegExpLiterals: true,
},
],
// Don't unnecessarily quote properties
"@stylistic/quote-props": ["error", "consistent-as-needed"],
// Required spacing in property declarations (copied from TSLint, defaults are good)
"@stylistic/key-spacing": ["error"],
// No multiple empty lines
"@stylistic/no-multiple-empty-lines": ["error"],
// Useless diff results
"@stylistic/no-trailing-spaces": ["error"],
};
this.rules = {
// require curly braces for multiline control statements
curly: ["error", "multi-line", "consistent"],
// Require use of the `import { foo } from 'bar';` form instead of `import foo = require('bar');`
"@typescript-eslint/no-require-imports": "error",
// Require all imported dependencies are actually declared in package.json
"import/no-extraneous-dependencies": [
"error",
{
// Only allow importing devDependencies from "devdirs".
devDependencies: () => this.renderDevDepsAllowList(),
optionalDependencies: false, // Disallow importing optional dependencies (those shouldn't be in use in the project)
peerDependencies: true, // Allow importing peer dependencies (that aren't also direct dependencies)
},
],
// Require all imported libraries actually resolve (!!required for import/no-extraneous-dependencies to work!!)
"import/no-unresolved": ["error"],
// Require an ordering on all imports
"import/order": [
"warn",
{
groups: ["builtin", "external"],
alphabetize: { order: "asc", caseInsensitive: true },
},
],
// Cannot import from the same module twice
"import/no-duplicates": ["error"],
// Cannot shadow names
"no-shadow": ["off"],
"@typescript-eslint/no-shadow": "error",
// One of the easiest mistakes to make
"@typescript-eslint/no-floating-promises": "error",
// Make sure that inside try/catch blocks, promises are 'return await'ed
// (must disable the base rule as it can report incorrect errors)
"no-return-await": ["off"],
"@typescript-eslint/return-await": "error",
// Must use foo.bar instead of foo['bar'] if possible
"dot-notation": ["error"],
// Are you sure | is not a typo for || ?
"no-bitwise": ["error"],
// Member ordering
"@typescript-eslint/member-ordering": [
"error",
{
default: [
"public-static-field",
"public-static-method",
"protected-static-field",
"protected-static-method",
"private-static-field",
"private-static-method",
"field",
// Constructors
"constructor", // = ["public-constructor", "protected-constructor", "private-constructor"]
// Methods
"method",
],
},
],
};
this.ignorePatterns = options.ignorePatterns ?? [
"*.js",
"*.d.ts",
"node_modules/",
"*.generated.ts",
"coverage",
];
const tsconfig = options.tsconfigPath ?? "./tsconfig.json";
const projectService = options.projectService ?? false;
this.addPlugins("@typescript-eslint");
this.addPlugins("import");
this.addExtends("plugin:import/typescript");
this.config = {
env: {
jest: true,
node: true,
},
root: true,
plugins: this._plugins,
parser: "@typescript-eslint/parser",
parserOptions: {
ecmaVersion: 2018,
sourceType: "module",
// Either let typescript-eslint resolve the nearest tsconfig per file
// (project service), or pin all files to a single project.
...(projectService
? { projectService: () => this.renderProjectService(tsconfig) }
: { project: tsconfig }),
},
extends: () => Array.from(this._extends).sort((a, b) => this.sortExtends.compare(a, b)),
settings: {
"import/parsers": {
"@typescript-eslint/parser": [".ts", ".tsx"],
},
"import/resolver": {
...(options.aliasMap && {
alias: {
map: Object.entries(options.aliasMap).map(([k, v]) => [k, v]),
extensions: options.aliasExtensions,
},
}),
node: {},
typescript: {
project: tsconfig,
...(options.tsAlwaysTryTypes !== false && { alwaysTryTypes: true }),
},
},
},
ignorePatterns: this.ignorePatterns,
rules: () => ({ ...this._formattingRules, ...this.rules }),
overrides: this.overrides,
};
if (options.yaml) {
this.file = new yaml_1.YamlFile(project, ".eslintrc.yml", {
obj: this.config,
marker: true,
});
}
else {
this.file = new json_1.JsonFile(project, ".eslintrc.json", {
obj: this.config,
// https://eslint.org/docs/latest/user-guide/configuring/configuration-files#comments-in-configuration-files
marker: true,
allowComments: true,
});
}
// if the user enabled prettier explicitly _or_ if the project has a
// `Prettier` component, we shall tweak our configuration accordingly.
if (options.prettier || prettier_1.Prettier.of(project)) {
this.enablePrettier();
}
else {
this.nodeProject.addDevDeps("@stylistic/eslint-plugin@^2");
this.addPlugins("@stylistic");
}
}
/**
* Returns an immutable copy of the lintPatterns being used by this eslint configuration.
*/
get lintPatterns() {
if (this._lintPatterns && this._lintPatterns.size > 0) {
return [...this._lintPatterns];
}
return [];
}
/**
* Add a file, glob pattern or directory with source files to lint (e.g. [ "src" ])
*/
addLintPattern(pattern) {
this._lintPatterns.add(pattern);
this.updateTask();
}
/**
* Add an eslint rule.
*/
addRules(rules) {
for (const [k, v] of Object.entries(rules)) {
this.rules[k] = v;
}
}
/**
* Adds an eslint plugin
* @param plugins The names of plugins to add
*/
addPlugins(...plugins) {
for (const plugin of plugins) {
this._plugins.add(plugin);
}
}
/**
* Add an eslint override.
*/
addOverride(override) {
this.overrides.push(override);
}
/**
* Do not lint these files.
*/
addIgnorePattern(pattern) {
this.ignorePatterns.push(pattern);
}
/**
* Adds an `extends` item to the eslint configuration.
* @param extendList The list of "extends" to add.
*/
addExtends(...extendList) {
for (const extend of extendList) {
this._extends.add(extend);
}
}
/**
* Add a glob file pattern which allows importing dev dependencies.
* @param pattern glob pattern.
*/
allowDevDeps(pattern) {
this._allowDevDeps.add(pattern);
}
/**
* Allow files matching these patterns to be linted with the typescript-eslint
* "default project" when they are not included by any `tsconfig.json`.
*
* Only has an effect when the project service is enabled (see
* `EslintOptions.projectService`). This is typically used for loose files
* that live outside `src`/`test` (e.g. `.projenrc.ts`).
*
* @see https://typescript-eslint.io/packages/parser/#allowdefaultproject
* @param patterns glob patterns, relative to the project root.
*/
allowDefaultProjectFiles(...patterns) {
for (const pattern of patterns) {
this._allowDefaultProject.add(pattern);
}
}
/**
* Render the value of `parserOptions.projectService`. When loose files have
* been registered via `allowDefaultProjectFiles`, an options object is
* emitted; otherwise the plain `true` shorthand is used.
* @internal
*/
renderProjectService(defaultProject) {
if (this._allowDefaultProject.size === 0) {
return true;
}
return {
allowDefaultProject: Array.from(this._allowDefaultProject),
defaultProject,
};
}
/**
* Enables prettier for code formatting.
*/
enablePrettier() {
this.nodeProject.addDevDeps("prettier", "eslint-plugin-prettier", "eslint-config-prettier");
this._formattingRules = {};
this.addExtends("plugin:prettier/recommended");
}
renderDevDepsAllowList() {
return Array.from(this._allowDevDeps);
}
/**
* Runs eslint once, right after the project is first created, so the generated code is linted (and auto-fixed) immediately.
*/
postProjectCreation(_initProject) {
this.nodeProject.tasks.runTask(this.eslintTask.name);
}
/**
* Update the task with the current list of lint patterns and file extensions
*/
updateTask() {
const taskExecCommand = "eslint";
const argv = [taskExecCommand];
if (this._fileExtensions.size > 0) {
argv.push("--ext", [...this._fileExtensions].join(","));
}
argv.push(...this._flagArgs);
argv.push("$@"); // External args go here
argv.push(...this._lintPatterns);
// read before resetting: it inspects the current step to preserve any
// external edits
const stepOptions = this.buildTaskStepOptions(taskExecCommand);
this.eslintTask.reset();
this.eslintTask.execArgs(argv, stepOptions);
}
/**
* In case of external editing of the eslint task step, we preserve those changes.
* Otherwise, we return the default task step options.
*
* @param taskExecCommand The command that the ESLint tasks executes
* @returns Either the externally edited, or the default task step options
*/
buildTaskStepOptions(taskExecCommand) {
const currentEslintTaskStep = this.eslintTask?.steps?.find((step) => step?.execArgs?.[0] === taskExecCommand ||
step?.exec?.startsWith?.(taskExecCommand));
if (currentEslintTaskStep) {
const { args, condition, cwd, env, name, receiveArgs } = currentEslintTaskStep;
return {
args,
condition,
cwd,
env,
name,
receiveArgs,
};
}
return {
receiveArgs: true,
};
}
}
exports.Eslint = Eslint;
/**
* A compare protocol tp sort the extends array in eslint config using known ESLint best practices.
*
* Places "prettier" plugins at the end of the array
*/
class ExtendsDefaultOrder {
// This is the order that ESLint best practices suggest
static ORDER = ["plugin:prettier/recommended", "prettier"];
compare(a, b) {
return (ExtendsDefaultOrder.ORDER.indexOf(a) -
ExtendsDefaultOrder.ORDER.indexOf(b));
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eslint.js","sourceRoot":"","sources":["../../src/javascript/eslint.ts"],"names":[],"mappings":"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","sourcesContent":["import { Prettier } from \"./prettier\";\nimport type { ICompareString } from \"../compare\";\nimport { Component } from \"../component\";\nimport type { NodeProject } from \"../javascript\";\nimport { JsonFile } from \"../json\";\nimport type { ObjectFile } from \"../object-file\";\nimport type { InitProject, Project } from \"../project\";\nimport type { Task } from \"../task\";\nimport type { TaskStepOptions } from \"../task-model\";\nimport { YamlFile } from \"../yaml\";\n\nexport interface EslintOptions {\n  /**\n   * Path to `tsconfig.json` which should be used by eslint.\n   * @default \"./tsconfig.json\"\n   */\n  readonly tsconfigPath?: string;\n\n  /**\n   * Use the typescript-eslint \"project service\" for typed linting instead of a\n   * single `parserOptions.project`.\n   *\n   * When enabled, typescript-eslint resolves the nearest `tsconfig.json` for\n   * each linted file (the same resolution model used by the TypeScript language\n   * service / `tsserver`). This allows files in different directories (e.g.\n   * `src` and `test`) to be linted against the `tsconfig.json` that actually\n   * includes them, without maintaining a single config that lists every file.\n   *\n   * Requires `@typescript-eslint/*` v8 or newer.\n   *\n   * @see https://typescript-eslint.io/blog/project-service/\n   * @default false\n   */\n  readonly projectService?: boolean;\n\n  /**\n   * Files or glob patterns or directories with source files to lint (e.g. [ \"src\" ])\n   */\n  readonly dirs: string[];\n\n  /**\n   * Files or glob patterns or directories with source files that include tests and build tools\n   *\n   * These sources are linted but may also import packages from `devDependencies`.\n   * @default []\n   */\n  readonly devdirs?: string[];\n  /**\n   * File types that should be linted (e.g. [ \".js\", \".ts\" ])\n   * @default [\".ts\"]\n   */\n  readonly fileExtensions?: string[];\n\n  /**\n   * Options for eslint command executed by eslint task\n   */\n  readonly commandOptions?: EslintCommandOptions;\n\n  /**\n   * List of file patterns that should not be linted, using the same syntax\n   * as .gitignore patterns.\n   *\n   * @default [ '*.js', '*.d.ts', 'node_modules/', '*.generated.ts', 'coverage' ]\n   */\n  readonly ignorePatterns?: string[];\n\n  /**\n   * Enable prettier for code formatting\n   * @default false\n   */\n  readonly prettier?: boolean;\n\n  /**\n   * The extends array in eslint is order dependent.\n   * This option allows to sort the extends array in any way seen fit.\n   *\n   * @default - Use known ESLint best practices to place \"prettier\" plugins at the end of the array\n   */\n  readonly sortExtends?: ICompareString;\n\n  /**\n   * Enable import alias for module paths\n   * @default undefined\n   */\n  readonly aliasMap?: { [key: string]: string };\n\n  /**\n   * Enable import alias for module paths\n   * @default undefined\n   */\n  readonly aliasExtensions?: string[];\n\n  /**\n   * Always try to resolve types under `<root>@types` directory even it doesn't contain any source code.\n   * This prevents `import/no-unresolved` eslint errors when importing a `@types/*` module that would otherwise remain unresolved.\n   * @default true\n   */\n  readonly tsAlwaysTryTypes?: boolean;\n\n  /**\n   * Write eslint configuration as YAML instead of JSON\n   * @default false\n   */\n  readonly yaml?: boolean;\n}\n\nexport interface EslintCommandOptions {\n  /**\n   * Whether to fix eslint issues when running the eslint task\n   * @default true\n   */\n  readonly fix?: boolean;\n\n  /**\n   * Extra flag arguments to pass to eslint command\n   *\n   * Each element is passed to eslint as a single argument, exactly as given: no\n   * shell parses these, so a flag and its value need separate elements\n   * (`[\"--rulesdir\", \"my rules\"]`, not `[\"--rulesdir 'my rules'\"]`) and values\n   * must not be quoted.\n   *\n   * @example [\"--cache\", \"--max-warnings=0\"]\n   */\n  readonly extraArgs?: string[];\n}\n\n/**\n * eslint rules override\n */\nexport interface EslintOverride {\n  /**\n   * Files or file patterns on which to apply the override\n   */\n  readonly files: string[];\n\n  /**\n   * Pattern(s) to exclude from this override.\n   * If a file matches any of the excluded patterns, the configuration won’t apply.\n   */\n  readonly excludedFiles?: string[];\n\n  /**\n   * The overridden rules\n   */\n  readonly rules?: { [rule: string]: any };\n\n  /**\n   * The overridden parser\n   */\n  readonly parser?: string;\n\n  /**\n   * Config(s) to extend in this override\n   */\n  readonly extends?: string[];\n\n  /**\n   * `plugins` override\n   */\n  readonly plugins?: string[];\n}\n\n/**\n * Represents eslint configuration.\n */\nexport class Eslint extends Component {\n  /**\n   * Returns the singleton Eslint component of a project or undefined if there is none.\n   */\n  public static of(project: Project): Eslint | undefined {\n    const isEslint = (c: Component): c is Eslint => c instanceof Eslint;\n    return project.components.find(isEslint);\n  }\n\n  /**\n   * The underlying config file\n   */\n  public readonly file: ObjectFile;\n\n  /**\n   * eslint rules.\n   */\n  public readonly rules: { [rule: string]: any };\n\n  /**\n   * eslint overrides.\n   */\n  public readonly overrides: EslintOverride[] = [];\n\n  /**\n   * eslint task.\n   */\n  public readonly eslintTask: Task;\n\n  /**\n   * Direct access to the eslint configuration (escape hatch)\n   */\n  public readonly config: any;\n\n  /**\n   * File patterns that should not be linted\n   */\n  public readonly ignorePatterns: string[];\n\n  private _formattingRules: Record<string, any>;\n  private readonly _allowDevDeps: Set<string>;\n  private readonly _allowDefaultProject = new Set<string>();\n  private readonly _plugins = new Set<string>();\n  private readonly _extends = new Set<string>();\n  private readonly _fileExtensions: Set<string>;\n  private readonly _flagArgs: Set<string>;\n  private readonly _lintPatterns: Set<string>;\n  private readonly nodeProject: NodeProject;\n  private readonly sortExtends: ICompareString;\n\n  constructor(project: NodeProject, options: EslintOptions) {\n    super(project);\n\n    this.nodeProject = project;\n\n    project.addDevDeps(\n      \"eslint@^9\",\n      \"@typescript-eslint/eslint-plugin@^8\",\n      \"@typescript-eslint/parser@^8\",\n      \"eslint-import-resolver-typescript\",\n      \"eslint-plugin-import\",\n    );\n\n    if (options.aliasMap) {\n      project.addDevDeps(\"eslint-import-resolver-alias\");\n    }\n\n    const devdirs = options.devdirs ?? [];\n\n    this._lintPatterns = new Set([...options.dirs, ...devdirs]);\n    this._fileExtensions = new Set(options.fileExtensions ?? [\".ts\"]);\n\n    this._allowDevDeps = new Set((devdirs ?? []).map((dir) => `**/${dir}/**`));\n\n    const commandOptions = options.commandOptions ?? {};\n    const { fix = true, extraArgs: extraFlagArgs = [] } = commandOptions;\n    this._flagArgs = new Set(extraFlagArgs);\n    if (fix) {\n      this._flagArgs.add(\"--fix\");\n    }\n    this._flagArgs.add(\"--no-error-on-unmatched-pattern\");\n\n    this.sortExtends = options.sortExtends ?? new ExtendsDefaultOrder();\n\n    this.eslintTask = project.addTask(\"eslint\", {\n      description: \"Runs eslint against the codebase\",\n      env: {\n        ESLINT_USE_FLAT_CONFIG: \"false\",\n        NODE_NO_WARNINGS: \"1\", // Suppress eslint warning about legacy config format, as it just confuses users. This will suppress all node warnings, but in practice users cannot action warnings from eslint anyway.\n      },\n    });\n    this.updateTask();\n\n    project.testTask.spawn(this.eslintTask);\n\n    // exclude some files\n    project.npmignore?.exclude(\"/.eslintrc.json\");\n\n    this._formattingRules = {\n      // Style\n      \"@stylistic/indent\": [\"error\", 2],\n      \"@stylistic/quotes\": [\"error\", \"single\", { avoidEscape: true }],\n      \"@stylistic/comma-dangle\": [\"error\", \"always-multiline\"], // ensures clean diffs, see https://medium.com/@nikgraf/why-you-should-enforce-dangling-commas-for-multiline-statements-d034c98e36f8\n      \"@stylistic/comma-spacing\": [\"error\", { before: false, after: true }], // space after, no space before\n      \"@stylistic/no-multi-spaces\": [\"error\", { ignoreEOLComments: false }], // no multi spaces\n      \"@stylistic/array-bracket-spacing\": [\"error\", \"never\"], // [1, 2, 3]\n      \"@stylistic/array-bracket-newline\": [\"error\", \"consistent\"], // enforce consistent line breaks between brackets\n      \"@stylistic/object-curly-spacing\": [\"error\", \"always\"], // { key: 'value' }\n      \"@stylistic/object-curly-newline\": [\n        \"error\",\n        { multiline: true, consistent: true },\n      ], // enforce consistent line breaks between braces\n      \"@stylistic/object-property-newline\": [\n        \"error\",\n        { allowAllPropertiesOnSameLine: true },\n      ], // enforce \"same line\" or \"multiple line\" on object properties\n      \"@stylistic/keyword-spacing\": [\"error\"], // require a space before & after keywords\n      \"@stylistic/brace-style\": [\"error\", \"1tbs\", { allowSingleLine: true }], // enforce one true brace style\n      \"@stylistic/space-before-blocks\": [\"error\"], // require space before blocks\n      // @see https://github.com/typescript-eslint/typescript-eslint/issues/8072\n      \"@stylistic/member-delimiter-style\": [\"error\"],\n\n      // Require semicolons\n      \"@stylistic/semi\": [\"error\", \"always\"],\n\n      // Max line lengths\n      \"@stylistic/max-len\": [\n        \"error\",\n        {\n          code: 150,\n          ignoreUrls: true, // Most common reason to disable it\n          ignoreStrings: true, // These are not fantastic but necessary for error messages\n          ignoreTemplateLiterals: true,\n          ignoreComments: true,\n          ignoreRegExpLiterals: true,\n        },\n      ],\n\n      // Don't unnecessarily quote properties\n      \"@stylistic/quote-props\": [\"error\", \"consistent-as-needed\"],\n\n      // Required spacing in property declarations (copied from TSLint, defaults are good)\n      \"@stylistic/key-spacing\": [\"error\"],\n\n      // No multiple empty lines\n      \"@stylistic/no-multiple-empty-lines\": [\"error\"],\n\n      // Useless diff results\n      \"@stylistic/no-trailing-spaces\": [\"error\"],\n    };\n\n    this.rules = {\n      // require curly braces for multiline control statements\n      curly: [\"error\", \"multi-line\", \"consistent\"],\n\n      // Require use of the `import { foo } from 'bar';` form instead of `import foo = require('bar');`\n      \"@typescript-eslint/no-require-imports\": \"error\",\n\n      // Require all imported dependencies are actually declared in package.json\n      \"import/no-extraneous-dependencies\": [\n        \"error\",\n        {\n          // Only allow importing devDependencies from \"devdirs\".\n          devDependencies: () => this.renderDevDepsAllowList(),\n          optionalDependencies: false, // Disallow importing optional dependencies (those shouldn't be in use in the project)\n          peerDependencies: true, // Allow importing peer dependencies (that aren't also direct dependencies)\n        },\n      ],\n\n      // Require all imported libraries actually resolve (!!required for import/no-extraneous-dependencies to work!!)\n      \"import/no-unresolved\": [\"error\"],\n\n      // Require an ordering on all imports\n      \"import/order\": [\n        \"warn\",\n        {\n          groups: [\"builtin\", \"external\"],\n          alphabetize: { order: \"asc\", caseInsensitive: true },\n        },\n      ],\n\n      // Cannot import from the same module twice\n      \"import/no-duplicates\": [\"error\"],\n\n      // Cannot shadow names\n      \"no-shadow\": [\"off\"],\n      \"@typescript-eslint/no-shadow\": \"error\",\n      // One of the easiest mistakes to make\n      \"@typescript-eslint/no-floating-promises\": \"error\",\n\n      // Make sure that inside try/catch blocks, promises are 'return await'ed\n      // (must disable the base rule as it can report incorrect errors)\n      \"no-return-await\": [\"off\"],\n      \"@typescript-eslint/return-await\": \"error\",\n\n      // Must use foo.bar instead of foo['bar'] if possible\n      \"dot-notation\": [\"error\"],\n\n      // Are you sure | is not a typo for || ?\n      \"no-bitwise\": [\"error\"],\n\n      // Member ordering\n      \"@typescript-eslint/member-ordering\": [\n        \"error\",\n        {\n          default: [\n            \"public-static-field\",\n            \"public-static-method\",\n            \"protected-static-field\",\n            \"protected-static-method\",\n            \"private-static-field\",\n            \"private-static-method\",\n\n            \"field\",\n\n            // Constructors\n            \"constructor\", // = [\"public-constructor\", \"protected-constructor\", \"private-constructor\"]\n\n            // Methods\n            \"method\",\n          ],\n        },\n      ],\n    };\n\n    this.ignorePatterns = options.ignorePatterns ?? [\n      \"*.js\",\n      \"*.d.ts\",\n      \"node_modules/\",\n      \"*.generated.ts\",\n      \"coverage\",\n    ];\n\n    const tsconfig = options.tsconfigPath ?? \"./tsconfig.json\";\n    const projectService = options.projectService ?? false;\n\n    this.addPlugins(\"@typescript-eslint\");\n    this.addPlugins(\"import\");\n    this.addExtends(\"plugin:import/typescript\");\n\n    this.config = {\n      env: {\n        jest: true,\n        node: true,\n      },\n      root: true,\n      plugins: this._plugins,\n      parser: \"@typescript-eslint/parser\",\n      parserOptions: {\n        ecmaVersion: 2018,\n        sourceType: \"module\",\n        // Either let typescript-eslint resolve the nearest tsconfig per file\n        // (project service), or pin all files to a single project.\n        ...(projectService\n          ? { projectService: () => this.renderProjectService(tsconfig) }\n          : { project: tsconfig }),\n      },\n      extends: () =>\n        Array.from(this._extends).sort((a, b) =>\n          this.sortExtends.compare(a, b),\n        ),\n      settings: {\n        \"import/parsers\": {\n          \"@typescript-eslint/parser\": [\".ts\", \".tsx\"],\n        },\n        \"import/resolver\": {\n          ...(options.aliasMap && {\n            alias: {\n              map: Object.entries(options.aliasMap).map(([k, v]) => [k, v]),\n              extensions: options.aliasExtensions,\n            },\n          }),\n          node: {},\n          typescript: {\n            project: tsconfig,\n            ...(options.tsAlwaysTryTypes !== false && { alwaysTryTypes: true }),\n          },\n        },\n      },\n      ignorePatterns: this.ignorePatterns,\n      rules: () => ({ ...this._formattingRules, ...this.rules }),\n      overrides: this.overrides,\n    };\n\n    if (options.yaml) {\n      this.file = new YamlFile(project, \".eslintrc.yml\", {\n        obj: this.config,\n        marker: true,\n      });\n    } else {\n      this.file = new JsonFile(project, \".eslintrc.json\", {\n        obj: this.config,\n        // https://eslint.org/docs/latest/user-guide/configuring/configuration-files#comments-in-configuration-files\n        marker: true,\n        allowComments: true,\n      });\n    }\n\n    // if the user enabled prettier explicitly _or_ if the project has a\n    // `Prettier` component, we shall tweak our configuration accordingly.\n    if (options.prettier || Prettier.of(project)) {\n      this.enablePrettier();\n    } else {\n      this.nodeProject.addDevDeps(\"@stylistic/eslint-plugin@^2\");\n      this.addPlugins(\"@stylistic\");\n    }\n  }\n\n  /**\n   * Returns an immutable copy of the lintPatterns being used by this eslint configuration.\n   */\n  public get lintPatterns(): string[] {\n    if (this._lintPatterns && this._lintPatterns.size > 0) {\n      return [...this._lintPatterns];\n    }\n\n    return [];\n  }\n\n  /**\n   * Add a file, glob pattern or directory with source files to lint (e.g. [ \"src\" ])\n   */\n  public addLintPattern(pattern: string) {\n    this._lintPatterns.add(pattern);\n    this.updateTask();\n  }\n\n  /**\n   * Add an eslint rule.\n   */\n  public addRules(rules: { [rule: string]: any }) {\n    for (const [k, v] of Object.entries(rules)) {\n      this.rules[k] = v;\n    }\n  }\n\n  /**\n   * Adds an eslint plugin\n   * @param plugins The names of plugins to add\n   */\n  public addPlugins(...plugins: string[]) {\n    for (const plugin of plugins) {\n      this._plugins.add(plugin);\n    }\n  }\n\n  /**\n   * Add an eslint override.\n   */\n  public addOverride(override: EslintOverride) {\n    this.overrides.push(override);\n  }\n\n  /**\n   * Do not lint these files.\n   */\n  public addIgnorePattern(pattern: string) {\n    this.ignorePatterns.push(pattern);\n  }\n\n  /**\n   * Adds an `extends` item to the eslint configuration.\n   * @param extendList The list of \"extends\" to add.\n   */\n  public addExtends(...extendList: string[]) {\n    for (const extend of extendList) {\n      this._extends.add(extend);\n    }\n  }\n\n  /**\n   * Add a glob file pattern which allows importing dev dependencies.\n   * @param pattern glob pattern.\n   */\n  public allowDevDeps(pattern: string) {\n    this._allowDevDeps.add(pattern);\n  }\n\n  /**\n   * Allow files matching these patterns to be linted with the typescript-eslint\n   * \"default project\" when they are not included by any `tsconfig.json`.\n   *\n   * Only has an effect when the project service is enabled (see\n   * `EslintOptions.projectService`). This is typically used for loose files\n   * that live outside `src`/`test` (e.g. `.projenrc.ts`).\n   *\n   * @see https://typescript-eslint.io/packages/parser/#allowdefaultproject\n   * @param patterns glob patterns, relative to the project root.\n   */\n  public allowDefaultProjectFiles(...patterns: string[]) {\n    for (const pattern of patterns) {\n      this._allowDefaultProject.add(pattern);\n    }\n  }\n\n  /**\n   * Render the value of `parserOptions.projectService`. When loose files have\n   * been registered via `allowDefaultProjectFiles`, an options object is\n   * emitted; otherwise the plain `true` shorthand is used.\n   * @internal\n   */\n  private renderProjectService(defaultProject: string): boolean | object {\n    if (this._allowDefaultProject.size === 0) {\n      return true;\n    }\n    return {\n      allowDefaultProject: Array.from(this._allowDefaultProject),\n      defaultProject,\n    };\n  }\n\n  /**\n   * Enables prettier for code formatting.\n   */\n  private enablePrettier() {\n    this.nodeProject.addDevDeps(\n      \"prettier\",\n      \"eslint-plugin-prettier\",\n      \"eslint-config-prettier\",\n    );\n\n    this._formattingRules = {};\n\n    this.addExtends(\"plugin:prettier/recommended\");\n  }\n\n  private renderDevDepsAllowList() {\n    return Array.from(this._allowDevDeps);\n  }\n\n  /**\n   * Runs eslint once, right after the project is first created, so the generated code is linted (and auto-fixed) immediately.\n   */\n  public postProjectCreation(_initProject: InitProject) {\n    this.nodeProject.tasks.runTask(this.eslintTask.name);\n  }\n\n  /**\n   * Update the task with the current list of lint patterns and file extensions\n   */\n  private updateTask() {\n    const taskExecCommand = \"eslint\";\n    const argv = [taskExecCommand];\n\n    if (this._fileExtensions.size > 0) {\n      argv.push(\"--ext\", [...this._fileExtensions].join(\",\"));\n    }\n    argv.push(...this._flagArgs);\n    argv.push(\"$@\"); // External args go here\n    argv.push(...this._lintPatterns);\n\n    // read before resetting: it inspects the current step to preserve any\n    // external edits\n    const stepOptions = this.buildTaskStepOptions(taskExecCommand);\n    this.eslintTask.reset();\n    this.eslintTask.execArgs(argv, stepOptions);\n  }\n\n  /**\n   * In case of external editing of the eslint task step, we preserve those changes.\n   * Otherwise, we return the default task step options.\n   *\n   * @param taskExecCommand The command that the ESLint tasks executes\n   * @returns Either the externally edited, or the default task step options\n   */\n  private buildTaskStepOptions(taskExecCommand: string): TaskStepOptions {\n    const currentEslintTaskStep = this.eslintTask?.steps?.find(\n      (step) =>\n        step?.execArgs?.[0] === taskExecCommand ||\n        step?.exec?.startsWith?.(taskExecCommand),\n    );\n\n    if (currentEslintTaskStep) {\n      const { args, condition, cwd, env, name, receiveArgs } =\n        currentEslintTaskStep;\n      return {\n        args,\n        condition,\n        cwd,\n        env,\n        name,\n        receiveArgs,\n      };\n    }\n\n    return {\n      receiveArgs: true,\n    };\n  }\n}\n\n/**\n * A compare protocol tp sort the extends array in eslint config using known ESLint best practices.\n *\n * Places \"prettier\" plugins at the end of the array\n */\nclass ExtendsDefaultOrder implements ICompareString {\n  // This is the order that ESLint best practices suggest\n  private static ORDER = [\"plugin:prettier/recommended\", \"prettier\"];\n\n  public compare(a: string, b: string): number {\n    return (\n      ExtendsDefaultOrder.ORDER.indexOf(a) -\n      ExtendsDefaultOrder.ORDER.indexOf(b)\n    );\n  }\n}\n"]}