projen 0.0.0

package/lib/javascript/bundler.js

@@ -0,0 +1,123 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const component_1 = require("../component");
+const dependencies_1 = require("../dependencies");
+const util_1 = require("./util");
+/**
+ * (experimental) Adds support for bundling JavaScript applications and dependencies into a single file.
+ *
+ * In the future, this will also supports bundling websites.
+ *
+ * @experimental
+ */
+class Bundler extends component_1.Component {
+    /**
+     * (experimental) Creates a `Bundler`.
+     *
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _b, _c;
+        super(project);
+        this.esbuildVersion = options.esbuildVersion;
+        this.bundledir = (_b = options.assetsDir) !== null && _b !== void 0 ? _b : 'assets';
+        this.addToPreCompile = (_c = options.addToPreCompile) !== null && _c !== void 0 ? _c : true;
+    }
+    /**
+     * (experimental) Returns the `Bundler` instance associated with a project or `undefined` if there is no Bundler.
+     *
+     * @param project The project.
+     * @returns A bundler
+     * @experimental
+     */
+    static of(project) {
+        const isBundler = (o) => o instanceof Bundler;
+        return project.components.find(isBundler);
+    }
+    /**
+     * (experimental) Gets or creates the singleton "bundle" task of the project.
+     *
+     * If the project doesn't have a "bundle" task, it will be created and spawned
+     * during the pre-compile phase.
+     *
+     * @experimental
+     */
+    get bundleTask() {
+        if (!this._task) {
+            this.addBundlingSupport();
+            this._task = this.project.tasks.addTask('bundle', {
+                description: 'Prepare assets',
+            });
+            // install the bundle task into the pre-compile phase.
+            if (this.addToPreCompile) {
+                this.project.preCompileTask.spawn(this._task);
+            }
+        }
+        return this._task;
+    }
+    /**
+     * (experimental) Adds a task to the project which bundles a specific entrypoint and all of its dependencies into a single javascript output file.
+     *
+     * @param entrypoint The relative path of the artifact within the project.
+     * @param options Bundling options.
+     * @experimental
+     */
+    addBundle(entrypoint, options) {
+        var _b, _c, _d;
+        const name = util_1.renderBundleName(entrypoint);
+        const outfile = path_1.join(this.bundledir, name, 'index.js');
+        const args = [
+            'esbuild',
+            '--bundle',
+            entrypoint,
+            `--target="${options.target}"`,
+            `--platform="${options.platform}"`,
+            `--outfile="${outfile}"`,
+        ];
+        for (const x of (_b = options.externals) !== null && _b !== void 0 ? _b : []) {
+            args.push(`--external:${x}`);
+        }
+        const sourcemap = (_c = options.sourcemap) !== null && _c !== void 0 ? _c : false;
+        if (sourcemap) {
+            args.push('--sourcemap');
+        }
+        const bundleTask = this.project.addTask(`bundle:${name}`, {
+            description: `Create a JavaScript bundle from ${entrypoint}`,
+            exec: args.join(' '),
+        });
+        this.bundleTask.spawn(bundleTask);
+        let watchTask;
+        const watch = (_d = options.watchTask) !== null && _d !== void 0 ? _d : true;
+        if (watch) {
+            watchTask = this.project.addTask(`bundle:${name}:watch`, {
+                description: `Continuously update the JavaScript bundle from ${entrypoint}`,
+                exec: `${args.join(' ')} --watch`,
+            });
+        }
+        return {
+            bundleTask: bundleTask,
+            watchTask: watchTask,
+            outfile: outfile,
+        };
+    }
+    /**
+     * Add bundling support to a project. This is called implicitly when
+     * `bundleTask` is referenced first. It adds the dependency on `esbuild`,
+     * gitignore/npmignore, etc.
+     */
+    addBundlingSupport() {
+        const ignoreEntry = `/${this.bundledir}/`;
+        this.project.addGitIgnore(ignoreEntry);
+        this.project.addPackageIgnore(`!${ignoreEntry}`); // include in tarball
+        const dep = this.esbuildVersion ? `esbuild@${this.esbuildVersion}` : 'esbuild';
+        this.project.deps.addDependency(dep, dependencies_1.DependencyType.BUILD);
+    }
+}
+exports.Bundler = Bundler;
+_a = JSII_RTTI_SYMBOL_1;
+Bundler[_a] = { fqn: "projen.javascript.Bundler", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundler.js","sourceRoot":"","sources":["../../src/javascript/bundler.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from 'path';\nimport { Component } from '../component';\nimport { DependencyType } from '../dependencies';\nimport { Project } from '../project';\nimport { Task } from '../task';\nimport { renderBundleName } from './util';\n\n                                 \nexport interface BundlerOptions {\n                                                                                                                          \n  readonly esbuildVersion?: string;\n\n                                                                            \n  readonly assetsDir?: string;\n\n                                                                                             \n  readonly addToPreCompile?: boolean;\n}\n\n                                                                                                                                                              \nexport class Bundler extends Component {\n                                                                                                                                                                             \n  public static of(project: Project): Bundler | undefined {\n    const isBundler = (o: Component): o is Bundler => o instanceof Bundler;\n    return project.components.find(isBundler);\n  }\n\n                                                                             \n  public readonly esbuildVersion: string | undefined;\n\n                                       \n  public readonly bundledir: string;\n\n  private _task: Task | undefined;\n  private readonly addToPreCompile: boolean;\n\n                                     \n  constructor(project: Project, options: BundlerOptions = {}) {\n    super(project);\n\n    this.esbuildVersion = options.esbuildVersion;\n    this.bundledir = options.assetsDir ?? 'assets';\n    this.addToPreCompile = options.addToPreCompile ?? true;\n  }\n\n                                                                                                                                                                                                     \n  public get bundleTask(): Task {\n    if (!this._task) {\n      this.addBundlingSupport();\n      this._task = this.project.tasks.addTask('bundle', {\n        description: 'Prepare assets',\n      });\n\n      // install the bundle task into the pre-compile phase.\n      if (this.addToPreCompile) {\n        this.project.preCompileTask.spawn(this._task);\n      }\n    }\n\n    return this._task;\n  }\n\n                                                                                                                                                                                                                                                                            \n  public addBundle(entrypoint: string, options: AddBundleOptions): Bundle {\n    const name = renderBundleName(entrypoint);\n\n    const outfile = join(this.bundledir, name, 'index.js');\n    const args = [\n      'esbuild',\n      '--bundle',\n      entrypoint,\n      `--target=\"${options.target}\"`,\n      `--platform=\"${options.platform}\"`,\n      `--outfile=\"${outfile}\"`,\n    ];\n\n    for (const x of options.externals ?? []) {\n      args.push(`--external:${x}`);\n    }\n\n    const sourcemap = options.sourcemap ?? false;\n    if (sourcemap) {\n      args.push('--sourcemap');\n    }\n\n    const bundleTask = this.project.addTask(`bundle:${name}`, {\n      description: `Create a JavaScript bundle from ${entrypoint}`,\n      exec: args.join(' '),\n    });\n\n    this.bundleTask.spawn(bundleTask);\n\n    let watchTask;\n    const watch = options.watchTask ?? true;\n    if (watch) {\n      watchTask = this.project.addTask(`bundle:${name}:watch`, {\n        description: `Continuously update the JavaScript bundle from ${entrypoint}`,\n        exec: `${args.join(' ')} --watch`,\n      });\n    }\n\n    return {\n      bundleTask: bundleTask,\n      watchTask: watchTask,\n      outfile: outfile,\n    };\n  }\n\n  /**\n   * Add bundling support to a project. This is called implicitly when\n   * `bundleTask` is referenced first. It adds the dependency on `esbuild`,\n   * gitignore/npmignore, etc.\n   */\n  private addBundlingSupport() {\n    const ignoreEntry = `/${this.bundledir}/`;\n    this.project.addGitIgnore(ignoreEntry);\n    this.project.addPackageIgnore(`!${ignoreEntry}`); // include in tarball\n    const dep = this.esbuildVersion ? `esbuild@${this.esbuildVersion}` : 'esbuild';\n    this.project.deps.addDependency(dep, DependencyType.BUILD);\n  }\n}\n\nexport interface Bundle {\n                                                    \n  readonly bundleTask: Task;\n\n                                                  \n  readonly watchTask?: Task;\n\n                                                                        \n  readonly outfile: string;\n}\n\n                                \nexport interface BundlingOptions {\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \n  readonly externals?: string[];\n\n                                                                             \n  readonly sourcemap?: boolean;\n\n                                                                                                                                                                                                                                                \n  readonly watchTask?: boolean;\n}\n\n                                     \nexport interface AddBundleOptions extends BundlingOptions {\n                                                            \n  readonly target: string;\n\n                                                                \n  readonly platform: string;\n}\n\n"]}

package/lib/javascript/eslint.d.ts

@@ -0,0 +1,177 @@
+import { Project } from '..';
+import { Component } from '../component';
+import { NodeProject } from '../javascript';
+/**
+ * @experimental
+ */
+export interface EslintOptions {
+    /**
+     * (experimental) Path to `tsconfig.json` which should be used by eslint.
+     *
+     * @default "./tsconfig.json"
+     * @experimental
+     */
+    readonly tsconfigPath?: string;
+    /**
+     * (experimental) Directories with source files to lint (e.g. [ "src" ]).
+     *
+     * @experimental
+     */
+    readonly dirs: string[];
+    /**
+     * (experimental) Directories with source files that include tests and build tools.
+     *
+     * These
+     * sources are linted but may also import packages from `devDependencies`.
+     *
+     * @default []
+     * @experimental
+     */
+    readonly devdirs?: string[];
+    /**
+     * (experimental) File types that should be linted (e.g. [ ".js", ".ts" ]).
+     *
+     * @default [".ts"]
+     * @experimental
+     */
+    readonly fileExtensions?: string[];
+    /**
+     * (experimental) List of file patterns that should not be linted, using the same syntax as .gitignore patterns.
+     *
+     * @default [ '*.js', '*.d.ts', 'node_modules/', '*.generated.ts', 'coverage' ]
+     * @experimental
+     */
+    readonly ignorePatterns?: string[];
+    /**
+     * (experimental) Should we lint .projenrc.js.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly lintProjenRc?: boolean;
+    /**
+     * (experimental) Enable prettier for code formatting.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly prettier?: boolean;
+    /**
+     * (experimental) Enable import alias for module paths.
+     *
+     * @default undefined
+     * @experimental
+     */
+    readonly aliasMap?: {
+        [key: string]: string;
+    };
+    /**
+     * (experimental) Enable import alias for module paths.
+     *
+     * @default undefined
+     * @experimental
+     */
+    readonly aliasExtensions?: string[];
+    /**
+     * (experimental) Always try to resolve types under `<root>@types` directory even it doesn't contain any source code.
+     *
+     * This prevents `import/no-unresolved` eslint errors when importing a `@types/*` module that would otherwise remain unresolved.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly tsAlwaysTryTypes?: boolean;
+}
+/**
+ * (experimental) eslint rules override.
+ *
+ * @experimental
+ */
+export interface EslintOverride {
+    /**
+     * (experimental) Files or file patterns on which to apply the override.
+     *
+     * @experimental
+     */
+    readonly files: string[];
+    /**
+     * (experimental) The overriden rules.
+     *
+     * @experimental
+     */
+    readonly rules: {
+        [rule: string]: any;
+    };
+}
+/**
+ * (experimental) Represents eslint configuration.
+ *
+ * @experimental
+ */
+export declare class Eslint extends Component {
+    /**
+     * (experimental) Returns the singletone Eslint component of a project or undefined if there is none.
+     *
+     * @experimental
+     */
+    static of(project: Project): Eslint | undefined;
+    /**
+     * (experimental) eslint rules.
+     *
+     * @experimental
+     */
+    readonly rules: {
+        [rule: string]: any[];
+    };
+    /**
+     * (experimental) eslint overrides.
+     *
+     * @experimental
+     */
+    readonly overrides: EslintOverride[];
+    /**
+     * (experimental) Direct access to the eslint configuration (escape hatch).
+     *
+     * @experimental
+     */
+    readonly config: any;
+    /**
+     * (experimental) File patterns that should not be linted.
+     *
+     * @experimental
+     */
+    readonly ignorePatterns: string[];
+    private readonly _allowDevDeps;
+    /**
+     * @experimental
+     */
+    constructor(project: NodeProject, options: EslintOptions);
+    /**
+     * (experimental) Add an eslint rule.
+     *
+     * @experimental
+     */
+    addRules(rules: {
+        [rule: string]: any;
+    }): void;
+    /**
+     * (experimental) Add an eslint override.
+     *
+     * @experimental
+     */
+    addOverride(override: EslintOverride): void;
+    /**
+     * (experimental) Do not lint these files.
+     *
+     * @experimental
+     */
+    addIgnorePattern(pattern: string): void;
+    /**
+     * (experimental) Add a glob file pattern which allows importing dev dependencies.
+     *
+     * @param pattern glob pattern.
+     * @experimental
+     */
+    allowDevDeps(pattern: string): void;
+    private renderDevDepsAllowList;
+}

package/lib/javascript/eslint.js

@@ -0,0 +1,261 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Eslint = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const common_1 = require("../common");
+const component_1 = require("../component");
+const json_1 = require("../json");
+/**
+ * (experimental) Represents eslint configuration.
+ *
+ * @experimental
+ */
+class Eslint extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        var _b, _c, _d, _e, _f, _g;
+        super(project);
+        project.addDevDeps('eslint@^8', '@typescript-eslint/eslint-plugin@^5', '@typescript-eslint/parser@^5', 'eslint-import-resolver-node', 'eslint-import-resolver-typescript', 'eslint-plugin-import', 'json-schema');
+        if (options.prettier) {
+            project.addDevDeps('prettier', 'eslint-plugin-prettier', 'eslint-config-prettier');
+        }
+        if (options.aliasMap) {
+            project.addDevDeps('eslint-import-resolver-alias');
+        }
+        const devdirs = (_b = options.devdirs) !== null && _b !== void 0 ? _b : [];
+        const dirs = [...options.dirs, ...devdirs];
+        const fileExtensions = (_c = options.fileExtensions) !== null && _c !== void 0 ? _c : ['.ts'];
+        this._allowDevDeps = new Set((devdirs !== null && devdirs !== void 0 ? devdirs : []).map(dir => `**/${dir}/**`));
+        const lintProjenRc = (_d = options.lintProjenRc) !== null && _d !== void 0 ? _d : true;
+        const eslint = project.addTask('eslint', {
+            description: 'Runs eslint against the codebase',
+            exec: [
+                'eslint',
+                `--ext ${fileExtensions.join(',')}`,
+                '--fix',
+                '--no-error-on-unmatched-pattern',
+                ...dirs,
+                ...lintProjenRc ? [common_1.PROJEN_RC] : [],
+            ].join(' '),
+        });
+        project.testTask.spawn(eslint);
+        // exclude some files
+        (_e = project.npmignore) === null || _e === void 0 ? void 0 : _e.exclude('/.eslintrc.json');
+        const formattingRules = options.prettier ? {
+            'prettier/prettier': ['error'],
+        } : {
+            // see https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/indent.md
+            'indent': ['off'],
+            '@typescript-eslint/indent': ['error', 2],
+            // Style
+            'quotes': ['error', 'single', { avoidEscape: true }],
+            'comma-dangle': ['error', 'always-multiline'],
+            'comma-spacing': ['error', { before: false, after: true }],
+            'no-multi-spaces': ['error', { ignoreEOLComments: false }],
+            'array-bracket-spacing': ['error', 'never'],
+            'array-bracket-newline': ['error', 'consistent'],
+            'object-curly-spacing': ['error', 'always'],
+            'object-curly-newline': ['error', { multiline: true, consistent: true }],
+            'object-property-newline': ['error', { allowAllPropertiesOnSameLine: true }],
+            'keyword-spacing': ['error'],
+            'brace-style': ['error', '1tbs', { allowSingleLine: true }],
+            'space-before-blocks': ['error'],
+            'curly': ['error', 'multi-line', 'consistent'],
+            '@typescript-eslint/member-delimiter-style': ['error'],
+            // Require semicolons
+            'semi': ['error', 'always'],
+            // Max line lengths
+            'max-len': ['error', {
+                    code: 150,
+                    ignoreUrls: true,
+                    ignoreStrings: true,
+                    ignoreTemplateLiterals: true,
+                    ignoreComments: true,
+                    ignoreRegExpLiterals: true,
+                }],
+            // Don't unnecessarily quote properties
+            'quote-props': ['error', 'consistent-as-needed'],
+        };
+        this.rules = {
+            ...formattingRules,
+            // 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,
+                    peerDependencies: true,
+                },
+            ],
+            // 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
+            'no-duplicate-imports': ['error'],
+            // Cannot shadow names
+            'no-shadow': ['off'],
+            '@typescript-eslint/no-shadow': ['error'],
+            // Required spacing in property declarations (copied from TSLint, defaults are good)
+            'key-spacing': ['error'],
+            // No multiple empty lines
+            'no-multiple-empty-lines': ['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'],
+            // Useless diff results
+            'no-trailing-spaces': ['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',
+                        // Methods
+                        'method',
+                    ],
+                }],
+        };
+        // Overrides for .projenrc.js
+        this.overrides = [
+            {
+                files: [common_1.PROJEN_RC],
+                rules: {
+                    '@typescript-eslint/no-require-imports': 'off',
+                    'import/no-extraneous-dependencies': 'off',
+                },
+            },
+        ];
+        this.ignorePatterns = (_f = options.ignorePatterns) !== null && _f !== void 0 ? _f : [
+            '*.js',
+            `!${common_1.PROJEN_RC}`,
+            '*.d.ts',
+            'node_modules/',
+            '*.generated.ts',
+            'coverage',
+        ];
+        const tsconfig = (_g = options.tsconfigPath) !== null && _g !== void 0 ? _g : './tsconfig.json';
+        const plugins = [
+            '@typescript-eslint',
+            'import',
+            ...(options.prettier ? ['prettier'] : []),
+        ];
+        const extendsConf = [
+            'plugin:import/typescript',
+            ...(options.prettier ? [
+                'prettier',
+                'plugin:prettier/recommended',
+            ] : []),
+        ];
+        this.config = {
+            env: {
+                jest: true,
+                node: true,
+            },
+            root: true,
+            plugins,
+            parser: '@typescript-eslint/parser',
+            parserOptions: {
+                ecmaVersion: 2018,
+                sourceType: 'module',
+                project: tsconfig,
+            },
+            extends: extendsConf,
+            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.rules,
+            overrides: this.overrides,
+        };
+        new json_1.JsonFile(project, '.eslintrc.json', { obj: this.config, marker: false });
+    }
+    /**
+     * (experimental) Returns the singletone Eslint component of a project or undefined if there is none.
+     *
+     * @experimental
+     */
+    static of(project) {
+        const isEslint = (c) => c instanceof Eslint;
+        return project.components.find(isEslint);
+    }
+    /**
+     * (experimental) Add an eslint rule.
+     *
+     * @experimental
+     */
+    addRules(rules) {
+        for (const [k, v] of Object.entries(rules)) {
+            this.rules[k] = v;
+        }
+    }
+    /**
+     * (experimental) Add an eslint override.
+     *
+     * @experimental
+     */
+    addOverride(override) {
+        this.overrides.push(override);
+    }
+    /**
+     * (experimental) Do not lint these files.
+     *
+     * @experimental
+     */
+    addIgnorePattern(pattern) {
+        this.ignorePatterns.push(pattern);
+    }
+    /**
+     * (experimental) Add a glob file pattern which allows importing dev dependencies.
+     *
+     * @param pattern glob pattern.
+     * @experimental
+     */
+    allowDevDeps(pattern) {
+        this._allowDevDeps.add(pattern);
+    }
+    renderDevDepsAllowList() {
+        return Array.from(this._allowDevDeps);
+    }
+}
+exports.Eslint = Eslint;
+_a = JSII_RTTI_SYMBOL_1;
+Eslint[_a] = { fqn: "projen.javascript.Eslint", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eslint.js","sourceRoot":"","sources":["../../src/javascript/eslint.ts"],"names":[],"mappings":"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","sourcesContent":["import { Project } from '..';\nimport { PROJEN_RC } from '../common';\nimport { Component } from '../component';\nimport { NodeProject } from '../javascript';\nimport { JsonFile } from '../json';\n\n\nexport interface EslintOptions {\n                                                                                                        \n  readonly tsconfigPath?: string;\n\n                                                                       \n  readonly dirs: string[];\n\n                                                                                                                                                                                      \n  readonly devdirs?: string[];\n\n                                                                                               \n  readonly fileExtensions?: string[];\n\n                                                                                                                                                                                                           \n  readonly ignorePatterns?: string[];\n\n                                                               \n  readonly lintProjenRc?: boolean;\n\n                                                                        \n  readonly prettier?: boolean;\n\n                                                                             \n  readonly aliasMap?: { [key: string]: string };\n\n                                                                             \n  readonly aliasExtensions?: string[];\n\n                                                                                                                                                                                                                                                                          \n  readonly tsAlwaysTryTypes?: boolean;\n}\n\n                                \nexport interface EslintOverride {\n                                                                      \n  readonly files: string[];\n\n                                    \n  readonly rules: { [rule: string]: any };\n}\n\n                                           \nexport class Eslint extends Component {\n\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  public readonly rules: { [rule: string]: any[] };\n\n                                  \n  public readonly overrides: EslintOverride[];\n\n                                                                         \n  public readonly config: any;\n\n                                                        \n  public readonly ignorePatterns: string[];\n\n  private readonly _allowDevDeps: Set<string>;\n\n  constructor(project: NodeProject, options: EslintOptions) {\n    super(project);\n\n    project.addDevDeps(\n      'eslint@^8',\n      '@typescript-eslint/eslint-plugin@^5',\n      '@typescript-eslint/parser@^5',\n      'eslint-import-resolver-node',\n      'eslint-import-resolver-typescript',\n      'eslint-plugin-import',\n      'json-schema',\n    );\n\n    if (options.prettier) {\n      project.addDevDeps(\n        'prettier',\n        'eslint-plugin-prettier',\n        'eslint-config-prettier',\n      );\n    }\n\n    if (options.aliasMap) {\n      project.addDevDeps('eslint-import-resolver-alias');\n    }\n\n    const devdirs = options.devdirs ?? [];\n\n    const dirs = [...options.dirs, ...devdirs];\n    const fileExtensions = options.fileExtensions ?? ['.ts'];\n\n    this._allowDevDeps = new Set((devdirs ?? []).map(dir => `**/${dir}/**`));\n\n    const lintProjenRc = options.lintProjenRc ?? true;\n\n    const eslint = project.addTask('eslint', {\n      description: 'Runs eslint against the codebase',\n      exec: [\n        'eslint',\n        `--ext ${fileExtensions.join(',')}`,\n        '--fix',\n        '--no-error-on-unmatched-pattern',\n        ...dirs,\n        ...lintProjenRc ? [PROJEN_RC] : [],\n      ].join(' '),\n    });\n\n    project.testTask.spawn(eslint);\n\n    // exclude some files\n    project.npmignore?.exclude('/.eslintrc.json');\n\n    const formattingRules: { [rule: string]: any } = options.prettier ? {\n      'prettier/prettier': ['error'],\n    } : {\n      // see https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/indent.md\n      'indent': ['off'],\n      '@typescript-eslint/indent': ['error', 2],\n\n      // Style\n      'quotes': ['error', 'single', { avoidEscape: true }],\n      'comma-dangle': ['error', 'always-multiline'], // ensures clean diffs, see https://medium.com/@nikgraf/why-you-should-enforce-dangling-commas-for-multiline-statements-d034c98e36f8\n      'comma-spacing': ['error', { before: false, after: true }], // space after, no space before\n      'no-multi-spaces': ['error', { ignoreEOLComments: false }], // no multi spaces\n      'array-bracket-spacing': ['error', 'never'], // [1, 2, 3]\n      'array-bracket-newline': ['error', 'consistent'], // enforce consistent line breaks between brackets\n      'object-curly-spacing': ['error', 'always'], // { key: 'value' }\n      'object-curly-newline': ['error', { multiline: true, consistent: true }], // enforce consistent line breaks between braces\n      'object-property-newline': ['error', { allowAllPropertiesOnSameLine: true }], // enforce \"same line\" or \"multiple line\" on object properties\n      'keyword-spacing': ['error'], // require a space before & after keywords\n      'brace-style': ['error', '1tbs', { allowSingleLine: true }], // enforce one true brace style\n      'space-before-blocks': ['error'], // require space before blocks\n      'curly': ['error', 'multi-line', 'consistent'], // require curly braces for multiline control statements\n      '@typescript-eslint/member-delimiter-style': ['error'],\n\n      // Require semicolons\n      'semi': ['error', 'always'],\n\n      // Max line lengths\n      'max-len': ['error', {\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      // Don't unnecessarily quote properties\n      'quote-props': ['error', 'consistent-as-needed'],\n    };\n\n    this.rules = {\n      ...formattingRules,\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': ['warn', {\n        groups: ['builtin', 'external'],\n        alphabetize: { order: 'asc', caseInsensitive: true },\n      }],\n\n      // Cannot import from the same module twice\n      'no-duplicate-imports': ['error'],\n\n      // Cannot shadow names\n      'no-shadow': ['off'],\n      '@typescript-eslint/no-shadow': ['error'],\n\n      // Required spacing in property declarations (copied from TSLint, defaults are good)\n      'key-spacing': ['error'],\n\n      // No multiple empty lines\n      'no-multiple-empty-lines': ['error'],\n\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      // Useless diff results\n      'no-trailing-spaces': ['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': ['error', {\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    // Overrides for .projenrc.js\n    this.overrides = [\n      {\n        files: [PROJEN_RC],\n        rules: {\n          '@typescript-eslint/no-require-imports': 'off',\n          'import/no-extraneous-dependencies': 'off',\n        },\n      },\n    ];\n\n    this.ignorePatterns = options.ignorePatterns ?? [\n      '*.js',\n      `!${PROJEN_RC}`,\n      '*.d.ts',\n      'node_modules/',\n      '*.generated.ts',\n      'coverage',\n    ];\n\n    const tsconfig = options.tsconfigPath ?? './tsconfig.json';\n\n    const plugins = [\n      '@typescript-eslint',\n      'import',\n      ...(options.prettier ? ['prettier'] : []),\n    ];\n\n    const extendsConf = [\n      'plugin:import/typescript',\n      ...(options.prettier ? [\n        'prettier',\n        'plugin:prettier/recommended',\n      ] : []),\n    ];\n\n    this.config = {\n      env: {\n        jest: true,\n        node: true,\n      },\n      root: true,\n      plugins,\n      parser: '@typescript-eslint/parser',\n      parserOptions: {\n        ecmaVersion: 2018,\n        sourceType: 'module',\n        project: tsconfig,\n      },\n      extends: extendsConf,\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.rules,\n      overrides: this.overrides,\n    };\n\n    new JsonFile(project, '.eslintrc.json', { obj: this.config, marker: false });\n  }\n\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  public addOverride(override: EslintOverride) {\n    this.overrides.push(override);\n  }\n\n                                         \n  public addIgnorePattern(pattern: string) {\n    this.ignorePatterns.push(pattern);\n  }\n\n                                                                                                                   \n  public allowDevDeps(pattern: string) {\n    this._allowDevDeps.add(pattern);\n  }\n\n  private renderDevDepsAllowList() {\n    return Array.from(this._allowDevDeps);\n  }\n}\n"]}

package/lib/javascript/index.d.ts

@@ -0,0 +1,9 @@
+export * from './bundler';
+export * from './eslint';
+export * from './jest';
+export * from './node-package';
+export * from './node-project';
+export * from './npm-config';
+export * from './upgrade-dependencies';
+export * from './projenrc';
+export * from './typescript-config';

package/lib/javascript/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bundler"), exports);
+__exportStar(require("./eslint"), exports);
+__exportStar(require("./jest"), exports);
+__exportStar(require("./node-package"), exports);
+__exportStar(require("./node-project"), exports);
+__exportStar(require("./npm-config"), exports);
+__exportStar(require("./upgrade-dependencies"), exports);
+__exportStar(require("./projenrc"), exports);
+__exportStar(require("./typescript-config"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvamF2YXNjcmlwdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw0Q0FBMEI7QUFDMUIsMkNBQXlCO0FBQ3pCLHlDQUF1QjtBQUN2QixpREFBK0I7QUFDL0IsaURBQStCO0FBQy9CLCtDQUE2QjtBQUM3Qix5REFBdUM7QUFDdkMsNkNBQTJCO0FBQzNCLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnVuZGxlcic7XG5leHBvcnQgKiBmcm9tICcuL2VzbGludCc7XG5leHBvcnQgKiBmcm9tICcuL2plc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlLXBhY2thZ2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlLXByb2plY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9ucG0tY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vdXBncmFkZS1kZXBlbmRlbmNpZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9qZW5yYyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzY3JpcHQtY29uZmlnJztcbiJdfQ==