projen 0.36.6 → 0.37.1

package/lib/javascript/node-project.js

@@ -0,0 +1,541 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProject = exports.AutoRelease = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const common_1 = require("../common");
+const github_1 = require("../github");
+const constants_1 = require("../github/constants");
+const workflows_model_1 = require("../github/workflows-model");
+const ignore_file_1 = require("../ignore-file");
+const javascript_1 = require("../javascript");
+const license_1 = require("../license");
+const release_1 = require("../release");
+const util_1 = require("../util");
+const version_1 = require("../version");
+const bundler_1 = require("./bundler");
+const jest_1 = require("./jest");
+const node_package_1 = require("./node-package");
+const projenrc_1 = require("./projenrc");
+const PROJEN_SCRIPT = 'projen';
+/**
+ * (experimental) Automatic bump modes.
+ *
+ * @experimental
+ */
+var AutoRelease;
+(function (AutoRelease) {
+    AutoRelease[AutoRelease["EVERY_COMMIT"] = 0] = "EVERY_COMMIT";
+    AutoRelease[AutoRelease["DAILY"] = 1] = "DAILY";
+})(AutoRelease = exports.AutoRelease || (exports.AutoRelease = {}));
+/**
+ * (experimental) Node.js project.
+ *
+ * @experimental
+ * @pjid node
+ */
+class NodeProject extends github_1.GitHubProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13;
+        super(options);
+        this.package = new node_package_1.NodePackage(this, options);
+        this.workflowBootstrapSteps = (_b = options.workflowBootstrapSteps) !== null && _b !== void 0 ? _b : [];
+        this.workflowGitIdentity = (_c = options.workflowGitIdentity) !== null && _c !== void 0 ? _c : constants_1.DEFAULT_GITHUB_ACTIONS_USER;
+        this.runScriptCommand = (() => {
+            switch (this.packageManager) {
+                case node_package_1.NodePackageManager.NPM: return 'npm run';
+                case node_package_1.NodePackageManager.YARN: return 'yarn run';
+                case node_package_1.NodePackageManager.PNPM: return 'pnpm run';
+                default: throw new Error(`unexpected package manager ${this.packageManager}`);
+            }
+        })();
+        this.nodeVersion = (_d = options.workflowNodeVersion) !== null && _d !== void 0 ? _d : this.package.minNodeVersion;
+        // add PATH for all tasks which includes the project's npm .bin list
+        this.tasks.addEnvironment('PATH', '$(npx -c "node -e \\\"console.log(process.env.PATH)\\\"")');
+        this.addLicense(options);
+        this.npmDistTag = this.package.npmDistTag;
+        this.npmRegistry = this.package.npmRegistry;
+        if ((_e = options.npmignoreEnabled) !== null && _e !== void 0 ? _e : true) {
+            this.npmignore = new ignore_file_1.IgnoreFile(this, '.npmignore');
+        }
+        this.addDefaultGitIgnore();
+        if ((_f = options.gitignore) === null || _f === void 0 ? void 0 : _f.length) {
+            for (const i of options.gitignore) {
+                this.gitignore.exclude(i);
+            }
+        }
+        if ((_g = options.npmignore) === null || _g === void 0 ? void 0 : _g.length) {
+            if (!this.npmignore) {
+                throw new Error('.npmignore is not defined for an APP project type. Add "npmIgnore: true" to override this');
+            }
+            for (const i of options.npmignore) {
+                this.npmignore.exclude(i);
+            }
+        }
+        this.setScript(PROJEN_SCRIPT, this.package.projenCommand);
+        (_h = this.npmignore) === null || _h === void 0 ? void 0 : _h.exclude(`/${common_1.PROJEN_RC}`);
+        (_j = this.npmignore) === null || _j === void 0 ? void 0 : _j.exclude(`/${common_1.PROJEN_DIR}/`);
+        this.gitignore.include(`/${common_1.PROJEN_RC}`);
+        const projen = (_k = options.projenDevDependency) !== null && _k !== void 0 ? _k : true;
+        if (projen) {
+            const postfix = options.projenVersion ? `@${options.projenVersion}` : '';
+            this.addDevDeps(`projen${postfix}`);
+        }
+        if (!options.defaultReleaseBranch) {
+            throw new Error('"defaultReleaseBranch" is temporarily a required option while we migrate its default value from "master" to "main"');
+        }
+        const buildEnabled = (_l = options.buildWorkflow) !== null && _l !== void 0 ? _l : (this.parent ? false : true);
+        const mutableBuilds = (_m = options.mutableBuild) !== null && _m !== void 0 ? _m : true;
+        // indicate if we have anti-tamper configured in our workflows. used by e.g. Jest
+        // to decide if we can always run with --updateSnapshot
+        this.antitamper = buildEnabled && ((_o = options.antitamper) !== null && _o !== void 0 ? _o : true);
+        // configure jest if enabled
+        // must be before the build/release workflows
+        if ((_p = options.jest) !== null && _p !== void 0 ? _p : true) {
+            this.jest = new jest_1.Jest(this, options.jestOptions);
+        }
+        if (buildEnabled) {
+            const branch = '${{ github.event.pull_request.head.ref }}';
+            const repo = '${{ github.event.pull_request.head.repo.full_name }}';
+            const buildJobId = 'build';
+            const postBuildSteps = new Array();
+            const gitDiffStepId = 'git_diff';
+            const hasChangesCondName = 'has_changes';
+            const hasChanges = `steps.${gitDiffStepId}.outputs.${hasChangesCondName}`;
+            // disable anti-tamper if build workflow is mutable
+            const antitamperSteps = ((_q = !mutableBuilds) !== null && _q !== void 0 ? _q : this.antitamper) ? [{
+                    // anti-tamper check (fails if there were changes to committed files)
+                    // this will identify any non-committed files generated during build (e.g. test snapshots)
+                    name: 'Anti-tamper check',
+                    run: 'git diff --ignore-space-at-eol --exit-code',
+                }] : [];
+            // run codecov if enabled or a secret token name is passed in
+            // AND jest must be configured
+            if ((options.codeCov || options.codeCovTokenSecret) && ((_r = this.jest) === null || _r === void 0 ? void 0 : _r.config)) {
+                postBuildSteps.push({
+                    name: 'Upload coverage to Codecov',
+                    uses: 'codecov/codecov-action@v1',
+                    with: options.codeCovTokenSecret ? {
+                        token: `\${{ secrets.${options.codeCovTokenSecret} }}`,
+                        directory: this.jest.config.coverageDirectory,
+                    } : {
+                        directory: this.jest.config.coverageDirectory,
+                    },
+                });
+            }
+            // use "git diff --exit code" to check if there were changes in the repo
+            // and create a step output that will be used in subsequent steps.
+            postBuildSteps.push({
+                name: 'Check for changes',
+                id: gitDiffStepId,
+                run: `git diff --exit-code || echo "::set-output name=${hasChangesCondName}::true"`,
+            });
+            // only if we had changes, commit them and push to the repo note that for
+            // forks, this will fail (because the workflow doesn't have permissions.
+            // this indicates to users that they need to update their branch manually.
+            postBuildSteps.push({
+                if: hasChanges,
+                name: 'Commit and push changes (if changed)',
+                run: `git add . && git commit -m "chore: self mutation" && git push origin HEAD:${branch}`,
+            });
+            // if we pushed changes, we need to manually update the status check so
+            // that the PR will be green (we won't get here for forks with updates
+            // because the push would have failed).
+            postBuildSteps.push({
+                if: hasChanges,
+                name: 'Update status check (if changed)',
+                run: [
+                    'gh api',
+                    '-X POST',
+                    `/repos/${repo}/check-runs`,
+                    `-F name="${buildJobId}"`,
+                    '-F head_sha="$(git rev-parse HEAD)"',
+                    '-F status="completed"',
+                    '-F conclusion="success"',
+                ].join(' '),
+                env: {
+                    GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+                },
+            });
+            // if we pushed changes, we need to mark the current commit as failed, so
+            // that GitHub auto-merge does not risk merging this commit before the
+            // event for the new commit has registered.
+            postBuildSteps.push({
+                if: hasChanges,
+                name: 'Cancel workflow (if changed)',
+                run: [
+                    'gh api',
+                    '-X POST',
+                    `/repos/${repo}/actions/runs/\${{ github.run_id }}/cancel`,
+                ].join(' '),
+                env: {
+                    GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+                },
+            });
+            postBuildSteps.push(...antitamperSteps);
+            if (this.github) {
+                this.buildWorkflow = new github_1.TaskWorkflow(this.github, {
+                    gitIdentity: this.workflowGitIdentity,
+                    name: 'build',
+                    jobId: buildJobId,
+                    triggers: {
+                        pullRequest: {},
+                    },
+                    env: {
+                        CI: 'true',
+                    },
+                    permissions: {
+                        checks: workflows_model_1.JobPermission.WRITE,
+                        contents: workflows_model_1.JobPermission.WRITE,
+                        actions: workflows_model_1.JobPermission.WRITE,
+                    },
+                    checkoutWith: mutableBuilds ? {
+                        ref: branch,
+                        repository: repo,
+                    } : undefined,
+                    preBuildSteps: [
+                        ...antitamperSteps,
+                        ...this.installWorkflowSteps,
+                    ],
+                    task: this.buildTask,
+                    postBuildSteps,
+                    container: options.workflowContainerImage ? { image: options.workflowContainerImage } : undefined,
+                });
+                this.buildWorkflowJobId = buildJobId;
+            }
+        }
+        const release = (_t = (_s = options.release) !== null && _s !== void 0 ? _s : options.releaseWorkflow) !== null && _t !== void 0 ? _t : (this.parent ? false : true);
+        if (release) {
+            this.addDevDeps(version_1.Version.STANDARD_VERSION);
+            this.release = new release_1.Release(this, {
+                versionFile: 'package.json',
+                task: this.buildTask,
+                branch: (_u = options.defaultReleaseBranch) !== null && _u !== void 0 ? _u : 'main',
+                ...options,
+                releaseWorkflowSetupSteps: [
+                    ...this.installWorkflowSteps,
+                    ...(_v = options.releaseWorkflowSetupSteps) !== null && _v !== void 0 ? _v : [],
+                ],
+            });
+            this.publisher = this.release.publisher;
+            if ((_w = options.releaseToNpm) !== null && _w !== void 0 ? _w : false) {
+                this.release.publisher.publishToNpm({
+                    distTag: this.package.npmDistTag,
+                    registry: this.package.npmRegistry,
+                    npmTokenSecret: this.package.npmTokenSecret,
+                    codeArtifactOptions: {
+                        accessKeyIdSecret: (_x = options.codeArtifactOptions) === null || _x === void 0 ? void 0 : _x.accessKeyIdSecret,
+                        secretAccessKeySecret: (_y = options.codeArtifactOptions) === null || _y === void 0 ? void 0 : _y.secretAccessKeySecret,
+                        roleToAssume: (_z = options.codeArtifactOptions) === null || _z === void 0 ? void 0 : _z.roleToAssume,
+                    },
+                });
+            }
+        }
+        else {
+            // validate that no release options are selected if the release workflow is disabled.
+            if (options.releaseToNpm) {
+                throw new Error('"releaseToNpm" is not supported for APP projects');
+            }
+            if (options.releaseEveryCommit) {
+                throw new Error('"releaseEveryCommit" is not supported for APP projects');
+            }
+            if (options.releaseSchedule) {
+                throw new Error('"releaseSchedule" is not supported for APP projects');
+            }
+        }
+        if ((_0 = this.github) === null || _0 === void 0 ? void 0 : _0.mergify) {
+            this.autoMerge = new github_1.AutoMerge(this.github, {
+                buildJob: this.buildWorkflowJobId,
+                ...options.autoMergeOptions,
+            });
+        }
+        const dependabot = (_1 = options.dependabot) !== null && _1 !== void 0 ? _1 : false;
+        const depsUpgrade = (_2 = options.depsUpgrade) !== null && _2 !== void 0 ? _2 : !dependabot;
+        if (dependabot && depsUpgrade) {
+            throw new Error("'dependabot' cannot be configured together with 'depsUpgrade'");
+        }
+        if (options.projenUpgradeAutoMerge !== undefined && options.autoApproveProjenUpgrades !== undefined) {
+            throw new Error("'projenUpgradeAutoMerge' cannot be configured together with 'autoApproveProjenUpgrades'");
+        }
+        const projenAutoApprove = (_3 = options.autoApproveProjenUpgrades) !== null && _3 !== void 0 ? _3 : ((_4 = options.projenUpgradeAutoMerge) !== null && _4 !== void 0 ? _4 : false);
+        const depsAutoApprove = (_5 = options.autoApproveUpgrades) !== null && _5 !== void 0 ? _5 : false;
+        if (projenAutoApprove && !this.autoApprove) {
+            throw new Error('Autoamtic approval of projen upgrades requires configuring `autoApproveOptions`');
+        }
+        if (depsAutoApprove && !this.autoApprove) {
+            throw new Error('Autoamtic approval of dependencies upgrades requires configuring `autoApproveOptions`');
+        }
+        const autoApproveLabel = (condition) => { var _b; return (condition && ((_b = this.autoApprove) === null || _b === void 0 ? void 0 : _b.label)) ? [this.autoApprove.label] : undefined; };
+        let ignoresProjen;
+        if (dependabot) {
+            const defaultOptions = {
+                labels: autoApproveLabel(depsAutoApprove),
+            };
+            const dependabotConf = (_6 = this.github) === null || _6 === void 0 ? void 0 : _6.addDependabot(util_1.deepMerge([defaultOptions, (_7 = options.dependabotOptions) !== null && _7 !== void 0 ? _7 : {}]));
+            ignoresProjen = dependabotConf === null || dependabotConf === void 0 ? void 0 : dependabotConf.ignoresProjen;
+        }
+        if (depsUpgrade) {
+            const defaultOptions = {
+                // if projen secret is defined we can also upgrade projen here.
+                ignoreProjen: !options.projenUpgradeSecret,
+                workflowOptions: {
+                    // if projen secret is defined, use it (otherwise default to GITHUB_TOKEN).
+                    secret: options.projenUpgradeSecret,
+                    container: options.workflowContainerImage ? {
+                        image: options.workflowContainerImage,
+                    } : undefined,
+                    labels: autoApproveLabel(depsAutoApprove),
+                    gitIdentity: this.workflowGitIdentity,
+                },
+            };
+            const upgradeDependencies = new javascript_1.UpgradeDependencies(this, util_1.deepMerge([defaultOptions, (_8 = options.depsUpgradeOptions) !== null && _8 !== void 0 ? _8 : {}]));
+            ignoresProjen = upgradeDependencies.ignoresProjen;
+        }
+        // create a dedicated workflow to upgrade projen itself if needed
+        if (ignoresProjen && this.package.packageName !== 'projen') {
+            new javascript_1.UpgradeDependencies(this, {
+                include: ['projen'],
+                taskName: 'upgrade-projen',
+                pullRequestTitle: 'upgrade projen',
+                ignoreProjen: false,
+                workflow: !!options.projenUpgradeSecret,
+                workflowOptions: {
+                    schedule: javascript_1.UpgradeDependenciesSchedule.expressions((_9 = options.projenUpgradeSchedule) !== null && _9 !== void 0 ? _9 : ['0 6 * * *']),
+                    container: options.workflowContainerImage ? { image: options.workflowContainerImage } : undefined,
+                    secret: options.projenUpgradeSecret,
+                    labels: autoApproveLabel(projenAutoApprove),
+                    gitIdentity: this.workflowGitIdentity,
+                },
+            });
+        }
+        if ((_10 = options.pullRequestTemplate) !== null && _10 !== void 0 ? _10 : true) {
+            (_11 = this.github) === null || _11 === void 0 ? void 0 : _11.addPullRequestTemplate(...(_12 = options.pullRequestTemplateContents) !== null && _12 !== void 0 ? _12 : []);
+        }
+        const projenrcJs = (_13 = options.projenrcJs) !== null && _13 !== void 0 ? _13 : !options.projenrcJson;
+        if (projenrcJs) {
+            new projenrc_1.Projenrc(this, options.projenrcJsOptions);
+        }
+        // add a bundler component - this enables things like Lambda bundling and in the future web bundling.
+        this.bundler = new bundler_1.Bundler(this, options.bundlerOptions);
+    }
+    /**
+     * @deprecated use `package.allowLibraryDependencies`
+     */
+    get allowLibraryDependencies() { return this.package.allowLibraryDependencies; }
+    /**
+     * @deprecated use `package.entrypoint`
+     */
+    get entrypoint() { return this.package.entrypoint; }
+    /**
+     * (experimental) Minimum node.js version required by this package.
+     *
+     * @experimental
+     */
+    get minNodeVersion() { return this.package.minNodeVersion; }
+    /**
+     * (experimental) Maximum node version required by this pacakge.
+     *
+     * @experimental
+     */
+    get maxNodeVersion() { return this.package.maxNodeVersion; }
+    /**
+     * (deprecated) The package manager to use.
+     *
+     * @deprecated use `package.packageManager`
+     */
+    get packageManager() { return this.package.packageManager; }
+    /**
+     * @deprecated use `package.addField(x, y)`
+     */
+    get manifest() {
+        return this.package.manifest;
+    }
+    /**
+     * @experimental
+     */
+    addBins(bins) {
+        this.package.addBin(bins);
+    }
+    /**
+     * (experimental) Replaces the contents of an npm package.json script.
+     *
+     * @param name The script name.
+     * @param command The command to execute.
+     * @experimental
+     */
+    setScript(name, command) {
+        this.package.setScript(name, command);
+    }
+    /**
+     * (experimental) Removes the npm script (always successful).
+     *
+     * @param name The name of the script.
+     * @experimental
+     */
+    removeScript(name) {
+        this.package.removeScript(name);
+    }
+    /**
+     * (experimental) Indicates if a script by the name name is defined.
+     *
+     * @param name The name of the script.
+     * @experimental
+     */
+    hasScript(name) {
+        return this.package.hasScript(name);
+    }
+    /**
+     * (deprecated) DEPRECATED.
+     *
+     * @deprecated use `project.compileTask.exec()`
+     */
+    addCompileCommand(...commands) {
+        for (const c of commands) {
+            this.compileTask.exec(c);
+        }
+    }
+    /**
+     * (deprecated) DEPRECATED.
+     *
+     * @deprecated use `project.testTask.exec()`
+     */
+    addTestCommand(...commands) {
+        for (const c of commands) {
+            this.testTask.exec(c);
+        }
+    }
+    /**
+     * (experimental) Directly set fields in `package.json`.
+     *
+     * @param fields The fields to set.
+     * @experimental
+     */
+    addFields(fields) {
+        for (const [name, value] of Object.entries(fields)) {
+            this.package.addField(name, value);
+        }
+    }
+    /**
+     * (experimental) Adds keywords to package.json (deduplicated).
+     *
+     * @param keywords The keywords to add.
+     * @experimental
+     */
+    addKeywords(...keywords) {
+        this.package.addKeywords(...keywords);
+    }
+    /**
+     * @experimental
+     */
+    get installWorkflowSteps() {
+        const install = new Array();
+        // first run the workflow bootstrap steps
+        install.push(...this.workflowBootstrapSteps);
+        if (this.nodeVersion) {
+            install.push({
+                name: 'Setup Node.js',
+                uses: 'actions/setup-node@v2.2.0',
+                with: { 'node-version': this.nodeVersion },
+            });
+        }
+        if (this.package.packageManager === node_package_1.NodePackageManager.PNPM) {
+            install.push({
+                name: 'Setup pnpm',
+                uses: 'pnpm/action-setup@v2.0.1',
+                with: { version: '6.14.7' },
+            });
+        }
+        install.push({
+            name: 'Install dependencies',
+            run: this.package.installCommand,
+        });
+        return install;
+    }
+    /**
+     * (experimental) Defines normal dependencies.
+     *
+     * @param deps Names modules to install.
+     * @experimental
+     */
+    addDeps(...deps) {
+        return this.package.addDeps(...deps);
+    }
+    /**
+     * (experimental) Defines development/test dependencies.
+     *
+     * @param deps Names modules to install.
+     * @experimental
+     */
+    addDevDeps(...deps) {
+        return this.package.addDevDeps(...deps);
+    }
+    /**
+     * (experimental) Defines peer dependencies.
+     *
+     * When adding peer dependencies, a devDependency will also be added on the
+     * pinned version of the declared peer. This will ensure that you are testing
+     * your code against the minimum version required from your consumers.
+     *
+     * @param deps Names modules to install.
+     * @experimental
+     */
+    addPeerDeps(...deps) {
+        return this.package.addPeerDeps(...deps);
+    }
+    /**
+     * (experimental) Defines bundled dependencies.
+     *
+     * Bundled dependencies will be added as normal dependencies as well as to the
+     * `bundledDependencies` section of your `package.json`.
+     *
+     * @param deps Names modules to install.
+     * @experimental
+     */
+    addBundledDeps(...deps) {
+        return this.package.addBundledDeps(...deps);
+    }
+    /**
+     * (experimental) Exclude these files from the bundled package.
+     *
+     * Implemented by project types based on the
+     * packaging mechanism. For example, `NodeProject` delegates this to `.npmignore`.
+     *
+     * @experimental
+     */
+    addPackageIgnore(pattern) {
+        var _b;
+        (_b = this.npmignore) === null || _b === void 0 ? void 0 : _b.addPatterns(pattern);
+    }
+    addLicense(options) {
+        var _b;
+        if (this.package.license) {
+            new license_1.License(this, {
+                spdx: this.package.license,
+                copyrightOwner: (_b = options.copyrightOwner) !== null && _b !== void 0 ? _b : options.authorName,
+                copyrightPeriod: options.copyrightPeriod,
+            });
+        }
+    }
+    addDefaultGitIgnore() {
+        this.gitignore.exclude('# Logs', 'logs', '*.log', 'npm-debug.log*', 'yarn-debug.log*', 'yarn-error.log*', 'lerna-debug.log*', '# Diagnostic reports (https://nodejs.org/api/report.html)', 'report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json', '# Runtime data', 'pids', '*.pid', '*.seed', '*.pid.lock', '# Directory for instrumented libs generated by jscoverage/JSCover', 'lib-cov', '# Coverage directory used by tools like istanbul', 'coverage', '*.lcov', '# nyc test coverage', '.nyc_output', '# Compiled binary addons (https://nodejs.org/api/addons.html)', 'build/Release', '# Dependency directories', 'node_modules/', 'jspm_packages/', '# TypeScript cache', '*.tsbuildinfo', '# Optional eslint cache', '.eslintcache', '# Output of \'npm pack\'', '*.tgz', '# Yarn Integrity file', '.yarn-integrity', '# parcel-bundler cache (https://parceljs.org/)', '.cache');
+    }
+    /**
+     * (experimental) Returns the shell command to execute in order to run a task.
+     *
+     * This will
+     * typically be `npx projen TASK`.
+     *
+     * @param task The task for which the command is required.
+     * @experimental
+     */
+    runTaskCommand(task) {
+        return `${this.package.projenCommand} ${task.name}`;
+    }
+}
+exports.NodeProject = NodeProject;
+_a = JSII_RTTI_SYMBOL_1;
+NodeProject[_a] = { fqn: "projen.javascript.NodeProject", version: "0.37.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-project.js","sourceRoot":"","sources":["../../src/javascript/node-project.ts"],"names":[],"mappings":";;;;;AAAA,sCAAkD;AAClD,sCAAyH;AACzH,mDAAkE;AAClE,+DAAmE;AACnE,gDAA4C;AAC5C,8CAA6G;AAC7G,wCAAqC;AACrC,wCAAuE;AAEvE,kCAAoC;AACpC,wCAAqC;AACrC,uCAAoD;AACpD,iCAA2C;AAC3C,iDAAqF;AACrF,yCAAuD;AAEvD,MAAM,aAAa,GAAG,QAAQ,CAAC;;;;;;AA4G/B,IAAY,WAMX;AAND,WAAY,WAAW;IAErB,6DAAY,CAAA;IAGZ,+CAAK,CAAA;AACP,CAAC,EANW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAMtB;;;;;;;AAGD,MAAa,WAAY,SAAQ,sBAAa;;;;IA+D5C,YAAY,OAA2B;;QACrC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,OAAO,GAAG,IAAI,0BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC9C,IAAI,CAAC,sBAAsB,SAAG,OAAO,CAAC,sBAAsB,mCAAI,EAAE,CAAC;QACnE,IAAI,CAAC,mBAAmB,SAAG,OAAO,CAAC,mBAAmB,mCAAI,uCAA2B,CAAC;QAEtF,IAAI,CAAC,gBAAgB,GAAG,CAAC,GAAG,EAAE;YAC5B,QAAQ,IAAI,CAAC,cAAc,EAAE;gBAC3B,KAAK,iCAAkB,CAAC,GAAG,CAAC,CAAC,OAAO,SAAS,CAAC;gBAC9C,KAAK,iCAAkB,CAAC,IAAI,CAAC,CAAC,OAAO,UAAU,CAAC;gBAChD,KAAK,iCAAkB,CAAC,IAAI,CAAC,CAAC,OAAO,UAAU,CAAC;gBAChD,OAAO,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;aAC/E;QACH,CAAC,CAAC,EAAE,CAAC;QAEL,IAAI,CAAC,WAAW,SAAG,OAAO,CAAC,mBAAmB,mCAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC;QAG9E,oEAAoE;QACpE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,EAAE,2DAA2D,CAAC,CAAC;QAG/F,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAEzB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;QAE5C,UAAI,OAAO,CAAC,gBAAgB,mCAAI,IAAI,EAAE;YACpC,IAAI,CAAC,SAAS,GAAG,IAAI,wBAAU,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SACrD;QAED,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE3B,UAAI,OAAO,CAAC,SAAS,0CAAE,MAAM,EAAE;YAC7B,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS,EAAE;gBACjC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aAC3B;SACF;QAED,UAAI,OAAO,CAAC,SAAS,0CAAE,MAAM,EAAE;YAC7B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,MAAM,IAAI,KAAK,CAAC,2FAA2F,CAAC,CAAC;aAC9G;YAED,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS,EAAE;gBACjC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aAC3B;SACF;QAGD,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QAE1D,MAAA,IAAI,CAAC,SAAS,0CAAE,OAAO,CAAC,IAAI,kBAAS,EAAE,EAAE;QACzC,MAAA,IAAI,CAAC,SAAS,0CAAE,OAAO,CAAC,IAAI,mBAAU,GAAG,EAAE;QAC3C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,kBAAS,EAAE,CAAC,CAAC;QAExC,MAAM,MAAM,SAAG,OAAO,CAAC,mBAAmB,mCAAI,IAAI,CAAC;QACnD,IAAI,MAAM,EAAE;YACV,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzE,IAAI,CAAC,UAAU,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;SACrC;QAED,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,oHAAoH,CAAC,CAAC;SACvI;QAED,MAAM,YAAY,SAAG,OAAO,CAAC,aAAa,mCAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3E,MAAM,aAAa,SAAG,OAAO,CAAC,YAAY,mCAAI,IAAI,CAAC;QAEnD,iFAAiF;QACjF,uDAAuD;QACvD,IAAI,CAAC,UAAU,GAAG,YAAY,IAAI,OAAC,OAAO,CAAC,UAAU,mCAAI,IAAI,CAAC,CAAC;QAE/D,4BAA4B;QAC5B,6CAA6C;QAC7C,UAAI,OAAO,CAAC,IAAI,mCAAI,IAAI,EAAE;YACxB,IAAI,CAAC,IAAI,GAAG,IAAI,WAAI,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;SACjD;QAED,IAAI,YAAY,EAAE;YAChB,MAAM,MAAM,GAAG,2CAA2C,CAAC;YAC3D,MAAM,IAAI,GAAG,sDAAsD,CAAC;YACpE,MAAM,UAAU,GAAG,OAAO,CAAC;YAE3B,MAAM,cAAc,GAAG,IAAI,KAAK,EAAO,CAAC;YACxC,MAAM,aAAa,GAAG,UAAU,CAAC;YACjC,MAAM,kBAAkB,GAAG,aAAa,CAAC;YACzC,MAAM,UAAU,GAAG,SAAS,aAAa,YAAY,kBAAkB,EAAE,CAAC;YAE1E,mDAAmD;YACnD,MAAM,eAAe,GAAG,OAAC,CAAC,aAAa,mCAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC7D,qEAAqE;oBACrE,0FAA0F;oBAC1F,IAAI,EAAE,mBAAmB;oBACzB,GAAG,EAAE,4CAA4C;iBAClD,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAER,6DAA6D;YAC7D,8BAA8B;YAC9B,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,kBAAkB,CAAC,WAAI,IAAI,CAAC,IAAI,0CAAE,MAAM,CAAA,EAAE;gBACxE,cAAc,CAAC,IAAI,CAAC;oBAClB,IAAI,EAAE,4BAA4B;oBAClC,IAAI,EAAE,2BAA2B;oBACjC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC;wBACjC,KAAK,EAAE,gBAAgB,OAAO,CAAC,kBAAkB,KAAK;wBACtD,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB;qBAC9C,CAAC,CAAC,CAAC;wBACF,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB;qBAC9C;iBACF,CAAC,CAAC;aACJ;YAED,wEAAwE;YACxE,kEAAkE;YAClE,cAAc,CAAC,IAAI,CAAC;gBAClB,IAAI,EAAE,mBAAmB;gBACzB,EAAE,EAAE,aAAa;gBACjB,GAAG,EAAE,mDAAmD,kBAAkB,SAAS;aACpF,CAAC,CAAC;YAEH,yEAAyE;YACzE,wEAAwE;YACxE,0EAA0E;YAC1E,cAAc,CAAC,IAAI,CAAC;gBAClB,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE,sCAAsC;gBAC5C,GAAG,EAAE,6EAA6E,MAAM,EAAE;aAC3F,CAAC,CAAC;YAEH,uEAAuE;YACvE,sEAAsE;YACtE,uCAAuC;YACvC,cAAc,CAAC,IAAI,CAAC;gBAClB,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE,kCAAkC;gBACxC,GAAG,EAAE;oBACH,QAAQ;oBACR,SAAS;oBACT,UAAU,IAAI,aAAa;oBAC3B,YAAY,UAAU,GAAG;oBACzB,qCAAqC;oBACrC,uBAAuB;oBACvB,yBAAyB;iBAC1B,CAAC,IAAI,CAAC,GAAG,CAAC;gBACX,GAAG,EAAE;oBACH,YAAY,EAAE,6BAA6B;iBAC5C;aACF,CAAC,CAAC;YAEH,yEAAyE;YACzE,sEAAsE;YACtE,2CAA2C;YAC3C,cAAc,CAAC,IAAI,CAAC;gBAClB,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE,8BAA8B;gBACpC,GAAG,EAAE;oBACH,QAAQ;oBACR,SAAS;oBACT,UAAU,IAAI,4CAA4C;iBAC3D,CAAC,IAAI,CAAC,GAAG,CAAC;gBACX,GAAG,EAAE;oBACH,YAAY,EAAE,6BAA6B;iBAC5C;aACF,CAAC,CAAC;YAEH,cAAc,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,CAAC;YAExC,IAAI,IAAI,CAAC,MAAM,EAAE;gBACf,IAAI,CAAC,aAAa,GAAG,IAAI,qBAAY,CAAC,IAAI,CAAC,MAAM,EAAE;oBACjD,WAAW,EAAE,IAAI,CAAC,mBAAmB;oBACrC,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE,UAAU;oBACjB,QAAQ,EAAE;wBACR,WAAW,EAAE,EAAG;qBACjB;oBACD,GAAG,EAAE;wBACH,EAAE,EAAE,MAAM;qBACX;oBACD,WAAW,EAAE;wBACX,MAAM,EAAE,+BAAa,CAAC,KAAK;wBAC3B,QAAQ,EAAE,+BAAa,CAAC,KAAK;wBAC7B,OAAO,EAAE,+BAAa,CAAC,KAAK;qBAC7B;oBACD,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;wBAC5B,GAAG,EAAE,MAAM;wBACX,UAAU,EAAE,IAAI;qBACjB,CAAC,CAAC,CAAC,SAAS;oBAEb,aAAa,EAAE;wBACb,GAAG,eAAe;wBAClB,GAAG,IAAI,CAAC,oBAAoB;qBAC7B;oBAED,IAAI,EAAE,IAAI,CAAC,SAAS;oBAEpB,cAAc;oBAEd,SAAS,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC,SAAS;iBAClG,CAAC,CAAC;gBACH,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;aACtC;SACF;QAED,MAAM,OAAO,eAAG,OAAO,CAAC,OAAO,mCAAI,OAAO,CAAC,eAAe,mCAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3F,IAAI,OAAO,EAAE;YACX,IAAI,CAAC,UAAU,CAAC,iBAAO,CAAC,gBAAgB,CAAC,CAAC;YAE1C,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAO,CAAC,IAAI,EAAE;gBAC/B,WAAW,EAAE,cAAc;gBAC3B,IAAI,EAAE,IAAI,CAAC,SAAS;gBACpB,MAAM,QAAE,OAAO,CAAC,oBAAoB,mCAAI,MAAM;gBAC9C,GAAG,OAAO;gBAEV,yBAAyB,EAAE;oBACzB,GAAG,IAAI,CAAC,oBAAoB;oBAC5B,SAAG,OAAO,CAAC,yBAAyB,mCAAI,EAAE;iBAC3C;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;YAExC,UAAI,OAAO,CAAC,YAAY,mCAAI,KAAK,EAAE;gBACjC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;oBAChC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;oBAClC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;oBAC3C,mBAAmB,EAAE;wBACnB,iBAAiB,QAAE,OAAO,CAAC,mBAAmB,0CAAE,iBAAiB;wBACjE,qBAAqB,QAAE,OAAO,CAAC,mBAAmB,0CAAE,qBAAqB;wBACzE,YAAY,QAAE,OAAO,CAAC,mBAAmB,0CAAE,YAAY;qBACxD;iBACF,CAAC,CAAC;aACJ;SAEF;aAAM;YACL,qFAAqF;YACrF,IAAI,OAAO,CAAC,YAAY,EAAE;gBACxB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;aACrE;YAED,IAAI,OAAO,CAAC,kBAAkB,EAAE;gBAC9B,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;aAC3E;YAED,IAAI,OAAO,CAAC,eAAe,EAAE;gBAC3B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;aACxE;SACF;QAED,UAAI,IAAI,CAAC,MAAM,0CAAE,OAAO,EAAE;YACxB,IAAI,CAAC,SAAS,GAAG,IAAI,kBAAS,CAAC,IAAI,CAAC,MAAM,EAAE;gBAC1C,QAAQ,EAAE,IAAI,CAAC,kBAAkB;gBACjC,GAAG,OAAO,CAAC,gBAAgB;aAC5B,CAAC,CAAC;SACJ;QAED,MAAM,UAAU,SAAG,OAAO,CAAC,UAAU,mCAAI,KAAK,CAAC;QAC/C,MAAM,WAAW,SAAG,OAAO,CAAC,WAAW,mCAAI,CAAC,UAAU,CAAC;QAEvD,IAAI,UAAU,IAAI,WAAW,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;SAClF;QAED,IAAI,OAAO,CAAC,sBAAsB,KAAK,SAAS,IAAI,OAAO,CAAC,yBAAyB,KAAK,SAAS,EAAE;YACnG,MAAM,IAAI,KAAK,CAAC,yFAAyF,CAAC,CAAC;SAC5G;QAED,MAAM,iBAAiB,SAAG,OAAO,CAAC,yBAAyB,mCAAI,OAAC,OAAO,CAAC,sBAAsB,mCAAI,KAAK,CAAC,CAAC;QACzG,MAAM,eAAe,SAAG,OAAO,CAAC,mBAAmB,mCAAI,KAAK,CAAC;QAE7D,IAAI,iBAAiB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAC1C,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;SACpG;QAED,IAAI,eAAe,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACxC,MAAM,IAAI,KAAK,CAAC,uFAAuF,CAAC,CAAC;SAC1G;QAED,MAAM,gBAAgB,GAAG,CAAC,SAAkB,EAAE,EAAE,WAAC,OAAA,CAAC,SAAS,WAAI,IAAI,CAAC,WAAW,0CAAE,KAAK,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA,EAAA,CAAC;QAE/H,IAAI,aAAa,CAAC;QAClB,IAAI,UAAU,EAAE;YACd,MAAM,cAAc,GAAG;gBACrB,MAAM,EAAE,gBAAgB,CAAC,eAAe,CAAC;aAC1C,CAAC;YACF,MAAM,cAAc,SAAG,IAAI,CAAC,MAAM,0CAAE,aAAa,CAAC,gBAAS,CAAC,CAAC,cAAc,QAAE,OAAO,CAAC,iBAAiB,mCAAI,EAAE,CAAC,CAAC,CAAC,CAAC;YAChH,aAAa,GAAG,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,aAAa,CAAC;SAC/C;QAED,IAAI,WAAW,EAAE;YACf,MAAM,cAAc,GAA+B;gBACjD,+DAA+D;gBAC/D,YAAY,EAAE,CAAC,OAAO,CAAC,mBAAmB;gBAC1C,eAAe,EAAE;oBACf,2EAA2E;oBAC3E,MAAM,EAAE,OAAO,CAAC,mBAAmB;oBACnC,SAAS,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC;wBAC1C,KAAK,EAAE,OAAO,CAAC,sBAAsB;qBACtC,CAAC,CAAC,CAAC,SAAS;oBACb,MAAM,EAAE,gBAAgB,CAAC,eAAe,CAAC;oBACzC,WAAW,EAAE,IAAI,CAAC,mBAAmB;iBACtC;aACF,CAAC;YACF,MAAM,mBAAmB,GAAG,IAAI,gCAAmB,CAAC,IAAI,EAAE,gBAAS,CAAC,CAAC,cAAc,QAAE,OAAO,CAAC,kBAAkB,mCAAI,EAAE,CAAC,CAAC,CAAC,CAAC;YACzH,aAAa,GAAG,mBAAmB,CAAC,aAAa,CAAC;SACnD;QAED,iEAAiE;QACjE,IAAI,aAAa,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,QAAQ,EAAE;YAE1D,IAAI,gCAAmB,CAAC,IAAI,EAAE;gBAC5B,OAAO,EAAE,CAAC,QAAQ,CAAC;gBACnB,QAAQ,EAAE,gBAAgB;gBAC1B,gBAAgB,EAAE,gBAAgB;gBAClC,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB;gBACvC,eAAe,EAAE;oBACf,QAAQ,EAAE,wCAA2B,CAAC,WAAW,OAAC,OAAO,CAAC,qBAAqB,mCAAI,CAAC,WAAW,CAAC,CAAC;oBACjG,SAAS,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC,SAAS;oBACjG,MAAM,EAAE,OAAO,CAAC,mBAAmB;oBACnC,MAAM,EAAE,gBAAgB,CAAC,iBAAiB,CAAC;oBAC3C,WAAW,EAAE,IAAI,CAAC,mBAAmB;iBACtC;aACF,CAAC,CAAC;SACJ;QAED,WAAI,OAAO,CAAC,mBAAmB,qCAAI,IAAI,EAAE;YACvC,OAAA,IAAI,CAAC,MAAM,4CAAE,sBAAsB,CAAC,UAAG,OAAO,CAAC,2BAA2B,qCAAI,EAAE,EAAE;SACnF;QAED,MAAM,UAAU,UAAG,OAAO,CAAC,UAAU,qCAAI,CAAC,OAAO,CAAC,YAAY,CAAC;QAC/D,IAAI,UAAU,EAAE;YACd,IAAI,mBAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;SAC/C;QAED,qGAAqG;QACrG,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAO,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3D,CAAC;;;;IAzYD,IAAW,wBAAwB,KAAc,OAAO,IAAI,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC,CAAC;;;;IAGhG,IAAW,UAAU,KAAa,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;;;;;;IAiBnE,IAAW,cAAc,KAAyB,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;IAGvF,IAAW,cAAc,KAAyB,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;IAcvF,IAAW,cAAc,KAAyB,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;;;;IASvF,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC/B,CAAC;;;;IA2VM,OAAO,CAAC,IAA4B;QACzC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;;;;;;;;IAGM,SAAS,CAAC,IAAY,EAAE,OAAe;QAC5C,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;;;;;;;IAGM,YAAY,CAAC,IAAY;QAC9B,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;;;;;;;IAGM,SAAS,CAAC,IAAY;QAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;;;;;;IAGM,iBAAiB,CAAC,GAAG,QAAkB;QAC5C,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC1B;IACH,CAAC;;;;;;IAGM,cAAc,CAAC,GAAG,QAAkB;QACzC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE;YACxB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACvB;IACH,CAAC;;;;;;;IAGM,SAAS,CAAC,MAA+B;QAC9C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAClD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SACpC;IACH,CAAC;;;;;;;IAGM,WAAW,CAAC,GAAG,QAAkB;QACtC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,CAAC;IACxC,CAAC;;;;IAED,IAAW,oBAAoB;QAC7B,MAAM,OAAO,GAAG,IAAI,KAAK,EAAW,CAAC;QAErC,yCAAyC;QACzC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAE7C,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO,CAAC,IAAI,CAAC;gBACX,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,2BAA2B;gBACjC,IAAI,EAAE,EAAE,cAAc,EAAE,IAAI,CAAC,WAAW,EAAE;aAC3C,CAAC,CAAC;SACJ;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,KAAK,iCAAkB,CAAC,IAAI,EAAE;YAC3D,OAAO,CAAC,IAAI,CAAC;gBACX,IAAI,EAAE,YAAY;gBAClB,IAAI,EAAE,0BAA0B;gBAChC,IAAI,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;aAC5B,CAAC,CAAC;SACJ;QAED,OAAO,CAAC,IAAI,CAAC;YACX,IAAI,EAAE,sBAAsB;YAC5B,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;SACjC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;;;;;;;IAGM,OAAO,CAAC,GAAG,IAAc;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACvC,CAAC;;;;;;;IAGM,UAAU,CAAC,GAAG,IAAc;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;IAC1C,CAAC;;;;;;;;;;;IAGM,WAAW,CAAC,GAAG,IAAc;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3C,CAAC;;;;;;;;;;IAGM,cAAc,CAAC,GAAG,IAAc;QACrC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;IAC9C,CAAC;;;;;;;;;IAEM,gBAAgB,CAAC,OAAe;;QACrC,MAAA,IAAI,CAAC,SAAS,0CAAE,WAAW,CAAC,OAAO,EAAE;IACvC,CAAC;IAEO,UAAU,CAAC,OAA2B;;QAC5C,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACxB,IAAI,iBAAO,CAAC,IAAI,EAAE;gBAChB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;gBAC1B,cAAc,QAAE,OAAO,CAAC,cAAc,mCAAI,OAAO,CAAC,UAAU;gBAC5D,eAAe,EAAE,OAAO,CAAC,eAAe;aACzC,CAAC,CAAC;SACJ;IACH,CAAC;IAEO,mBAAmB;QACzB,IAAI,CAAC,SAAS,CAAC,OAAO,CACpB,QAAQ,EACR,MAAM,EACN,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAElB,2DAA2D,EAC3D,yCAAyC,EAEzC,gBAAgB,EAChB,MAAM,EACN,OAAO,EACP,QAAQ,EACR,YAAY,EAEZ,mEAAmE,EACnE,SAAS,EAET,kDAAkD,EAClD,UAAU,EACV,QAAQ,EAER,qBAAqB,EACrB,aAAa,EAEb,+DAA+D,EAC/D,eAAe,EAEf,0BAA0B,EAC1B,eAAe,EACf,gBAAgB,EAEhB,oBAAoB,EACpB,eAAe,EAGf,yBAAyB,EACzB,cAAc,EAEd,0BAA0B,EAC1B,OAAO,EAEP,uBAAuB,EACvB,iBAAiB,EAEjB,gDAAgD,EAChD,QAAQ,CACT,CAAC;IACJ,CAAC;;;;;;;;;;IAGM,cAAc,CAAC,IAAU;QAC9B,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;IACtD,CAAC;;AAzjBH,kCA0jBC","sourcesContent":["import { PROJEN_DIR, PROJEN_RC } from '../common';\nimport { AutoMerge, DependabotOptions, GitHubProject, GitHubProjectOptions, GitIdentity, TaskWorkflow } from '../github';\nimport { DEFAULT_GITHUB_ACTIONS_USER } from '../github/constants';\nimport { JobPermission, JobStep } from '../github/workflows-model';\nimport { IgnoreFile } from '../ignore-file';\nimport { UpgradeDependencies, UpgradeDependenciesOptions, UpgradeDependenciesSchedule } from '../javascript';\nimport { License } from '../license';\nimport { Release, ReleaseProjectOptions, Publisher } from '../release';\nimport { Task } from '../task';\nimport { deepMerge } from '../util';\nimport { Version } from '../version';\nimport { Bundler, BundlerOptions } from './bundler';\nimport { Jest, JestOptions } from './jest';\nimport { NodePackage, NodePackageManager, NodePackageOptions } from './node-package';\nimport { Projenrc, ProjenrcOptions } from './projenrc';\n\nconst PROJEN_SCRIPT = 'projen';\n\nexport interface NodeProjectOptions extends GitHubProjectOptions, NodePackageOptions, ReleaseProjectOptions {\n                                                                                                                                      \n  readonly copyrightOwner?: string;\n\n                                                                                                  \n  readonly copyrightPeriod?: string;\n\n\n                                                                                                   \n  readonly projenVersion?: string;\n\n                                                                                                      \n  readonly projenDevDependency?: boolean;\n\n                                                                                                    \n  readonly buildWorkflow?: boolean;\n\n                                                                                                                                                                                                                                                                                                                       \n  readonly mutableBuild?: boolean;\n\n                                                                                                                                                                                                                                                \n  readonly codeCov?: boolean;\n\n                                                                                                                                                                                                                                             \n  readonly codeCovTokenSecret?: string;\n\n                                                                                                                                \n  readonly releaseWorkflow?: boolean;\n\n                                                                                                                         \n  readonly release?: boolean;\n\n                                                                               \n  readonly defaultReleaseBranch: string;\n\n                                                                                                                                          \n  readonly workflowBootstrapSteps?: any[];\n\n                                                                                          \n  readonly workflowGitIdentity?: GitIdentity;\n\n                                                                                                   \n  readonly releaseToNpm?: boolean;\n\n                                                                                                           \n  readonly workflowNodeVersion?: string;\n\n                                                                                                                                              \n  readonly dependabot?: boolean;\n\n                                                                             \n  readonly dependabotOptions?: DependabotOptions;\n\n                                                                                                                                                  \n  readonly depsUpgrade?: boolean;\n\n                                                                              \n  readonly depsUpgradeOptions?: UpgradeDependenciesOptions;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \n  readonly projenUpgradeSecret?: string;\n\n                                                                                                                                                                                                                                                                         \n  readonly projenUpgradeAutoMerge?: boolean;\n\n                                                                                                                                                                                                                       \n  readonly autoApproveProjenUpgrades?: boolean;\n\n                                                                                                                                                                                                                      \n  readonly autoApproveUpgrades?: boolean;\n\n                                                                                                          \n  readonly projenUpgradeSchedule?: string[];\n\n                                                                                                                                                   \n  readonly npmignoreEnabled?: boolean;\n\n                                                                                                    \n  readonly npmignore?: string[];\n\n                                                                                \n  readonly pullRequestTemplate?: boolean;\n\n                                                                                                \n  readonly pullRequestTemplateContents?: string[];\n\n                                                 \n  readonly gitignore?: string[];\n\n                                                         \n  readonly jest?: boolean;\n\n                                                             \n  readonly jestOptions?: JestOptions;\n\n                                                                                                                                                                                  \n  readonly projenrcJs?: boolean;\n\n                                                                         \n  readonly projenrcJsOptions?: ProjenrcOptions;\n\n                                       \n  readonly bundlerOptions?: BundlerOptions;\n}\n\n                               \nexport enum AutoRelease {\n                                                                                      \n  EVERY_COMMIT,\n\n                                                                             \n  DAILY\n}\n\n                                           \nexport class NodeProject extends GitHubProject {\n                                                   \n  public readonly package: NodePackage;\n\n                                     \n  public readonly npmignore?: IgnoreFile;\n\n                                                                   \n  public get allowLibraryDependencies(): boolean { return this.package.allowLibraryDependencies; }\n\n                                                     \n  public get entrypoint(): string { return this.package.entrypoint; }\n\n                                     \n  public readonly autoMerge?: AutoMerge;\n\n\n                                                                                          \n  public readonly buildWorkflow?: TaskWorkflow;\n  public readonly buildWorkflowJobId?: string;\n\n                                                                                                                                                                 \n  public readonly publisher?: Publisher;\n\n                                    \n  public readonly release?: Release;\n\n                                                                  \n  public get minNodeVersion(): string | undefined { return this.package.minNodeVersion; }\n\n                                                               \n  public get maxNodeVersion(): string | undefined { return this.package.maxNodeVersion; }\n\n  private readonly nodeVersion?: string;\n\n                                                                \n  public readonly antitamper: boolean;\n\n                                                     \n  protected readonly npmDistTag: string;\n\n                                                      \n  protected readonly npmRegistry: string;\n\n                                                                                               \n  public get packageManager(): NodePackageManager { return this.package.packageManager; }\n\n                                                                                                                 \n  public readonly runScriptCommand: string;\n\n                                                    \n  public readonly jest?: Jest;\n\n                                                         \n  public get manifest() {\n    return this.package.manifest;\n  }\n\n  public readonly bundler: Bundler;\n\n  private readonly workflowBootstrapSteps: JobStep[];\n  private readonly workflowGitIdentity: GitIdentity;\n\n  constructor(options: NodeProjectOptions) {\n    super(options);\n\n    this.package = new NodePackage(this, options);\n    this.workflowBootstrapSteps = options.workflowBootstrapSteps ?? [];\n    this.workflowGitIdentity = options.workflowGitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n\n    this.runScriptCommand = (() => {\n      switch (this.packageManager) {\n        case NodePackageManager.NPM: return 'npm run';\n        case NodePackageManager.YARN: return 'yarn run';\n        case NodePackageManager.PNPM: return 'pnpm run';\n        default: throw new Error(`unexpected package manager ${this.packageManager}`);\n      }\n    })();\n\n    this.nodeVersion = options.workflowNodeVersion ?? this.package.minNodeVersion;\n\n\n    // add PATH for all tasks which includes the project's npm .bin list\n    this.tasks.addEnvironment('PATH', '$(npx -c \"node -e \\\\\\\"console.log(process.env.PATH)\\\\\\\"\")');\n\n\n    this.addLicense(options);\n\n    this.npmDistTag = this.package.npmDistTag;\n    this.npmRegistry = this.package.npmRegistry;\n\n    if (options.npmignoreEnabled ?? true) {\n      this.npmignore = new IgnoreFile(this, '.npmignore');\n    }\n\n    this.addDefaultGitIgnore();\n\n    if (options.gitignore?.length) {\n      for (const i of options.gitignore) {\n        this.gitignore.exclude(i);\n      }\n    }\n\n    if (options.npmignore?.length) {\n      if (!this.npmignore) {\n        throw new Error('.npmignore is not defined for an APP project type. Add \"npmIgnore: true\" to override this');\n      }\n\n      for (const i of options.npmignore) {\n        this.npmignore.exclude(i);\n      }\n    }\n\n\n    this.setScript(PROJEN_SCRIPT, this.package.projenCommand);\n\n    this.npmignore?.exclude(`/${PROJEN_RC}`);\n    this.npmignore?.exclude(`/${PROJEN_DIR}/`);\n    this.gitignore.include(`/${PROJEN_RC}`);\n\n    const projen = options.projenDevDependency ?? true;\n    if (projen) {\n      const postfix = options.projenVersion ? `@${options.projenVersion}` : '';\n      this.addDevDeps(`projen${postfix}`);\n    }\n\n    if (!options.defaultReleaseBranch) {\n      throw new Error('\"defaultReleaseBranch\" is temporarily a required option while we migrate its default value from \"master\" to \"main\"');\n    }\n\n    const buildEnabled = options.buildWorkflow ?? (this.parent ? false : true);\n    const mutableBuilds = options.mutableBuild ?? true;\n\n    // indicate if we have anti-tamper configured in our workflows. used by e.g. Jest\n    // to decide if we can always run with --updateSnapshot\n    this.antitamper = buildEnabled && (options.antitamper ?? true);\n\n    // configure jest if enabled\n    // must be before the build/release workflows\n    if (options.jest ?? true) {\n      this.jest = new Jest(this, options.jestOptions);\n    }\n\n    if (buildEnabled) {\n      const branch = '${{ github.event.pull_request.head.ref }}';\n      const repo = '${{ github.event.pull_request.head.repo.full_name }}';\n      const buildJobId = 'build';\n\n      const postBuildSteps = new Array<any>();\n      const gitDiffStepId = 'git_diff';\n      const hasChangesCondName = 'has_changes';\n      const hasChanges = `steps.${gitDiffStepId}.outputs.${hasChangesCondName}`;\n\n      // disable anti-tamper if build workflow is mutable\n      const antitamperSteps = (!mutableBuilds ?? this.antitamper) ? [{\n        // anti-tamper check (fails if there were changes to committed files)\n        // this will identify any non-committed files generated during build (e.g. test snapshots)\n        name: 'Anti-tamper check',\n        run: 'git diff --ignore-space-at-eol --exit-code',\n      }] : [];\n\n      // run codecov if enabled or a secret token name is passed in\n      // AND jest must be configured\n      if ((options.codeCov || options.codeCovTokenSecret) && this.jest?.config) {\n        postBuildSteps.push({\n          name: 'Upload coverage to Codecov',\n          uses: 'codecov/codecov-action@v1',\n          with: options.codeCovTokenSecret ? {\n            token: `\\${{ secrets.${options.codeCovTokenSecret} }}`,\n            directory: this.jest.config.coverageDirectory,\n          } : {\n            directory: this.jest.config.coverageDirectory,\n          },\n        });\n      }\n\n      // use \"git diff --exit code\" to check if there were changes in the repo\n      // and create a step output that will be used in subsequent steps.\n      postBuildSteps.push({\n        name: 'Check for changes',\n        id: gitDiffStepId,\n        run: `git diff --exit-code || echo \"::set-output name=${hasChangesCondName}::true\"`,\n      });\n\n      // only if we had changes, commit them and push to the repo note that for\n      // forks, this will fail (because the workflow doesn't have permissions.\n      // this indicates to users that they need to update their branch manually.\n      postBuildSteps.push({\n        if: hasChanges,\n        name: 'Commit and push changes (if changed)',\n        run: `git add . && git commit -m \"chore: self mutation\" && git push origin HEAD:${branch}`,\n      });\n\n      // if we pushed changes, we need to manually update the status check so\n      // that the PR will be green (we won't get here for forks with updates\n      // because the push would have failed).\n      postBuildSteps.push({\n        if: hasChanges,\n        name: 'Update status check (if changed)',\n        run: [\n          'gh api',\n          '-X POST',\n          `/repos/${repo}/check-runs`,\n          `-F name=\"${buildJobId}\"`,\n          '-F head_sha=\"$(git rev-parse HEAD)\"',\n          '-F status=\"completed\"',\n          '-F conclusion=\"success\"',\n        ].join(' '),\n        env: {\n          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n        },\n      });\n\n      // if we pushed changes, we need to mark the current commit as failed, so\n      // that GitHub auto-merge does not risk merging this commit before the\n      // event for the new commit has registered.\n      postBuildSteps.push({\n        if: hasChanges,\n        name: 'Cancel workflow (if changed)',\n        run: [\n          'gh api',\n          '-X POST',\n          `/repos/${repo}/actions/runs/\\${{ github.run_id }}/cancel`,\n        ].join(' '),\n        env: {\n          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n        },\n      });\n\n      postBuildSteps.push(...antitamperSteps);\n\n      if (this.github) {\n        this.buildWorkflow = new TaskWorkflow(this.github, {\n          gitIdentity: this.workflowGitIdentity,\n          name: 'build',\n          jobId: buildJobId,\n          triggers: {\n            pullRequest: { },\n          },\n          env: {\n            CI: 'true', // will cause `NodeProject` to execute `yarn install` with `--frozen-lockfile`\n          },\n          permissions: {\n            checks: JobPermission.WRITE,\n            contents: JobPermission.WRITE,\n            actions: JobPermission.WRITE,\n          },\n          checkoutWith: mutableBuilds ? {\n            ref: branch,\n            repository: repo,\n          } : undefined,\n\n          preBuildSteps: [\n            ...antitamperSteps,\n            ...this.installWorkflowSteps, // install dependencies steps\n          ],\n\n          task: this.buildTask,\n\n          postBuildSteps,\n\n          container: options.workflowContainerImage ? { image: options.workflowContainerImage } : undefined,\n        });\n        this.buildWorkflowJobId = buildJobId;\n      }\n    }\n\n    const release = options.release ?? options.releaseWorkflow ?? (this.parent ? false : true);\n    if (release) {\n      this.addDevDeps(Version.STANDARD_VERSION);\n\n      this.release = new Release(this, {\n        versionFile: 'package.json', // this is where \"version\" is set after bump\n        task: this.buildTask,\n        branch: options.defaultReleaseBranch ?? 'main',\n        ...options,\n\n        releaseWorkflowSetupSteps: [\n          ...this.installWorkflowSteps,\n          ...options.releaseWorkflowSetupSteps ?? [],\n        ],\n      });\n\n      this.publisher = this.release.publisher;\n\n      if (options.releaseToNpm ?? false) {\n        this.release.publisher.publishToNpm({\n          distTag: this.package.npmDistTag,\n          registry: this.package.npmRegistry,\n          npmTokenSecret: this.package.npmTokenSecret,\n          codeArtifactOptions: {\n            accessKeyIdSecret: options.codeArtifactOptions?.accessKeyIdSecret,\n            secretAccessKeySecret: options.codeArtifactOptions?.secretAccessKeySecret,\n            roleToAssume: options.codeArtifactOptions?.roleToAssume,\n          },\n        });\n      }\n\n    } else {\n      // validate that no release options are selected if the release workflow is disabled.\n      if (options.releaseToNpm) {\n        throw new Error('\"releaseToNpm\" is not supported for APP projects');\n      }\n\n      if (options.releaseEveryCommit) {\n        throw new Error('\"releaseEveryCommit\" is not supported for APP projects');\n      }\n\n      if (options.releaseSchedule) {\n        throw new Error('\"releaseSchedule\" is not supported for APP projects');\n      }\n    }\n\n    if (this.github?.mergify) {\n      this.autoMerge = new AutoMerge(this.github, {\n        buildJob: this.buildWorkflowJobId,\n        ...options.autoMergeOptions,\n      });\n    }\n\n    const dependabot = options.dependabot ?? false;\n    const depsUpgrade = options.depsUpgrade ?? !dependabot;\n\n    if (dependabot && depsUpgrade) {\n      throw new Error(\"'dependabot' cannot be configured together with 'depsUpgrade'\");\n    }\n\n    if (options.projenUpgradeAutoMerge !== undefined && options.autoApproveProjenUpgrades !== undefined) {\n      throw new Error(\"'projenUpgradeAutoMerge' cannot be configured together with 'autoApproveProjenUpgrades'\");\n    }\n\n    const projenAutoApprove = options.autoApproveProjenUpgrades ?? (options.projenUpgradeAutoMerge ?? false);\n    const depsAutoApprove = options.autoApproveUpgrades ?? false;\n\n    if (projenAutoApprove && !this.autoApprove) {\n      throw new Error('Autoamtic approval of projen upgrades requires configuring `autoApproveOptions`');\n    }\n\n    if (depsAutoApprove && !this.autoApprove) {\n      throw new Error('Autoamtic approval of dependencies upgrades requires configuring `autoApproveOptions`');\n    }\n\n    const autoApproveLabel = (condition: boolean) => (condition && this.autoApprove?.label) ? [this.autoApprove.label] : undefined;\n\n    let ignoresProjen;\n    if (dependabot) {\n      const defaultOptions = {\n        labels: autoApproveLabel(depsAutoApprove),\n      };\n      const dependabotConf = this.github?.addDependabot(deepMerge([defaultOptions, options.dependabotOptions ?? {}]));\n      ignoresProjen = dependabotConf?.ignoresProjen;\n    }\n\n    if (depsUpgrade) {\n      const defaultOptions: UpgradeDependenciesOptions = {\n        // if projen secret is defined we can also upgrade projen here.\n        ignoreProjen: !options.projenUpgradeSecret,\n        workflowOptions: {\n          // if projen secret is defined, use it (otherwise default to GITHUB_TOKEN).\n          secret: options.projenUpgradeSecret,\n          container: options.workflowContainerImage ? {\n            image: options.workflowContainerImage,\n          } : undefined,\n          labels: autoApproveLabel(depsAutoApprove),\n          gitIdentity: this.workflowGitIdentity,\n        },\n      };\n      const upgradeDependencies = new UpgradeDependencies(this, deepMerge([defaultOptions, options.depsUpgradeOptions ?? {}]));\n      ignoresProjen = upgradeDependencies.ignoresProjen;\n    }\n\n    // create a dedicated workflow to upgrade projen itself if needed\n    if (ignoresProjen && this.package.packageName !== 'projen') {\n\n      new UpgradeDependencies(this, {\n        include: ['projen'],\n        taskName: 'upgrade-projen',\n        pullRequestTitle: 'upgrade projen',\n        ignoreProjen: false,\n        workflow: !!options.projenUpgradeSecret,\n        workflowOptions: {\n          schedule: UpgradeDependenciesSchedule.expressions(options.projenUpgradeSchedule ?? ['0 6 * * *']),\n          container: options.workflowContainerImage ? { image: options.workflowContainerImage } : undefined,\n          secret: options.projenUpgradeSecret,\n          labels: autoApproveLabel(projenAutoApprove),\n          gitIdentity: this.workflowGitIdentity,\n        },\n      });\n    }\n\n    if (options.pullRequestTemplate ?? true) {\n      this.github?.addPullRequestTemplate(...options.pullRequestTemplateContents ?? []);\n    }\n\n    const projenrcJs = options.projenrcJs ?? !options.projenrcJson;\n    if (projenrcJs) {\n      new Projenrc(this, options.projenrcJsOptions);\n    }\n\n    // add a bundler component - this enables things like Lambda bundling and in the future web bundling.\n    this.bundler = new Bundler(this, options.bundlerOptions);\n  }\n\n  public addBins(bins: Record<string, string>) {\n    this.package.addBin(bins);\n  }\n\n                                                                                                                                                      \n  public setScript(name: string, command: string) {\n    this.package.setScript(name, command);\n  }\n\n                                                                                                     \n  public removeScript(name: string) {\n    this.package.removeScript(name);\n  }\n\n                                                                                                           \n  public hasScript(name: string) {\n    return this.package.hasScript(name);\n  }\n\n                                                                             \n  public addCompileCommand(...commands: string[]) {\n    for (const c of commands) {\n      this.compileTask.exec(c);\n    }\n  }\n\n                                                                          \n  public addTestCommand(...commands: string[]) {\n    for (const c of commands) {\n      this.testTask.exec(c);\n    }\n  }\n\n                                                                                            \n  public addFields(fields: { [name: string]: any }) {\n    for (const [name, value] of Object.entries(fields)) {\n      this.package.addField(name, value);\n    }\n  }\n\n                                                                                                      \n  public addKeywords(...keywords: string[]) {\n    this.package.addKeywords(...keywords);\n  }\n\n  public get installWorkflowSteps(): JobStep[] {\n    const install = new Array<JobStep>();\n\n    // first run the workflow bootstrap steps\n    install.push(...this.workflowBootstrapSteps);\n\n    if (this.nodeVersion) {\n      install.push({\n        name: 'Setup Node.js',\n        uses: 'actions/setup-node@v2.2.0',\n        with: { 'node-version': this.nodeVersion },\n      });\n    }\n\n    if (this.package.packageManager === NodePackageManager.PNPM) {\n      install.push({\n        name: 'Setup pnpm',\n        uses: 'pnpm/action-setup@v2.0.1',\n        with: { version: '6.14.7' }, // current latest. Should probably become tunable.\n      });\n    }\n\n    install.push({\n      name: 'Install dependencies',\n      run: this.package.installCommand,\n    });\n\n    return install;\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                        \n  public addDeps(...deps: string[]) {\n    return this.package.addDeps(...deps);\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                  \n  public addDevDeps(...deps: string[]) {\n    return this.package.addDevDeps(...deps);\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \n  public addPeerDeps(...deps: string[]) {\n    return this.package.addPeerDeps(...deps);\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n  public addBundledDeps(...deps: string[]) {\n    return this.package.addBundledDeps(...deps);\n  }\n\n  public addPackageIgnore(pattern: string) {\n    this.npmignore?.addPatterns(pattern);\n  }\n\n  private addLicense(options: NodeProjectOptions) {\n    if (this.package.license) {\n      new License(this, {\n        spdx: this.package.license,\n        copyrightOwner: options.copyrightOwner ?? options.authorName,\n        copyrightPeriod: options.copyrightPeriod,\n      });\n    }\n  }\n\n  private addDefaultGitIgnore() {\n    this.gitignore.exclude(\n      '# Logs',\n      'logs',\n      '*.log',\n      'npm-debug.log*',\n      'yarn-debug.log*',\n      'yarn-error.log*',\n      'lerna-debug.log*',\n\n      '# Diagnostic reports (https://nodejs.org/api/report.html)',\n      'report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json',\n\n      '# Runtime data',\n      'pids',\n      '*.pid',\n      '*.seed',\n      '*.pid.lock',\n\n      '# Directory for instrumented libs generated by jscoverage/JSCover',\n      'lib-cov',\n\n      '# Coverage directory used by tools like istanbul',\n      'coverage',\n      '*.lcov',\n\n      '# nyc test coverage',\n      '.nyc_output',\n\n      '# Compiled binary addons (https://nodejs.org/api/addons.html)',\n      'build/Release',\n\n      '# Dependency directories',\n      'node_modules/',\n      'jspm_packages/',\n\n      '# TypeScript cache',\n      '*.tsbuildinfo',\n\n\n      '# Optional eslint cache',\n      '.eslintcache',\n\n      '# Output of \\'npm pack\\'',\n      '*.tgz',\n\n      '# Yarn Integrity file',\n      '.yarn-integrity',\n\n      '# parcel-bundler cache (https://parceljs.org/)',\n      '.cache',\n    );\n  }\n\n                                                                                                                                                                                   \n  public runTaskCommand(task: Task) {\n    return `${this.package.projenCommand} ${task.name}`;\n  }\n}\n\nexport interface NodeWorkflowSteps {\n  readonly antitamper: any[];\n  readonly install: any[];\n}\n"]}