projen 0.72.28 → 0.72.30

package/lib/github/github-project.js

@@ -68,5 +68,5 @@ class GitHubProject extends project_1.Project {
 }
 exports.GitHubProject = GitHubProject;
 _a = JSII_RTTI_SYMBOL_1;
-GitHubProject[_a] = { fqn: "projen.github.GitHubProject", version: "0.72.28" };
+GitHubProject[_a] = { fqn: "projen.github.GitHubProject", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github-project.js","sourceRoot":"","sources":["../../src/github/github-project.ts"],"names":[],"mappings":";;;;;AAAA,iDAAiE;AAEjE,qCAAiD;AAGjD,mCAA8C;AAC9C,wCAAqC;AACrC,sCAAmC;AACnC,wCAAkE;AAClE,sCAA4D;AAC5D,sCAAiD;AAuIjD;;;;;;;;GAQG;AACH,MAAa,aAAc,SAAQ,iBAAO;IAyCxC,YAAY,OAA6B;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,qBAAW,CAAC,OAAO,CAAC;QAC9D,kEAAkE;QAClE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,GAAG,MAAM;YAClB,CAAC,CAAC,IAAI,eAAM,CAAC,IAAI,EAAE;gBACf,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,GAAG,OAAO,CAAC,aAAa;aACzB,CAAC;YACJ,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,eAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEpD,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,eAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5D,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY;YACtC,CAAC,CAAC,IAAI,qBAAY,CAAC,IAAI,CAAC;YACxB,CAAC,CAAC,SAAS,CAAC;QAEd,IAAI,OAAO,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACnC,IAAI,iBAAO,CAAC,IAAI,CAAC,CAAC;SACnB;QAED,IAAI,qBAAY,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAEvC,IAAI,OAAO,CAAC,kBAAkB,IAAI,IAAI,CAAC,MAAM,EAAE;YAC7C,IAAI,CAAC,WAAW,GAAG,IAAI,0BAAW,CAChC,IAAI,CAAC,MAAM,EACX,OAAO,CAAC,kBAAkB,CAC3B,CAAC;SACH;QAED,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;QACrC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE;YACxB,IAAI,aAAK,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;SAC9C;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,iBAAiB,CAAC,IAAY;QACnC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;IAC/D,CAAC;;AA/FH,sCAgGC","sourcesContent":["import { AutoApprove, AutoApproveOptions } from \"./auto-approve\";\nimport { AutoMergeOptions } from \"./auto-merge\";\nimport { GitHub, GitHubOptions } from \"./github\";\nimport { GithubCredentials } from \"./github-credentials\";\nimport { MergifyOptions } from \"./mergify\";\nimport { Stale, StaleOptions } from \"./stale\";\nimport { Clobber } from \"../clobber\";\nimport { Gitpod } from \"../gitpod\";\nimport { Project, ProjectOptions, ProjectType } from \"../project\";\nimport { SampleReadme, SampleReadmeProps } from \"../readme\";\nimport { DevContainer, VsCode } from \"../vscode\";\n\n/**\n * Options for `GitHubProject`.\n */\nexport interface GitHubProjectOptions extends ProjectOptions {\n  /**\n   * Add a Gitpod development environment\n   *\n   * @default false\n   */\n  readonly gitpod?: boolean;\n\n  /**\n   * Enable VSCode integration.\n   *\n   * Enabled by default for root projects. Disabled for non-root projects.\n   *\n   * @default true\n   */\n  readonly vscode?: boolean;\n\n  /**\n   * Enable GitHub integration.\n   *\n   * Enabled by default for root projects. Disabled for non-root projects.\n   *\n   * @default true\n   */\n  readonly github?: boolean;\n\n  /**\n   * Options for GitHub integration\n   *\n   * @default - see GitHubOptions\n   */\n  readonly githubOptions?: GitHubOptions;\n\n  /**\n   * Whether mergify should be enabled on this repository or not.\n   *\n   * @default true\n   * @deprecated use `githubOptions.mergify` instead\n   */\n  readonly mergify?: boolean;\n\n  /**\n   * Options for mergify\n   *\n   * @default - default options\n   * @deprecated use `githubOptions.mergifyOptions` instead\n   */\n  readonly mergifyOptions?: MergifyOptions;\n\n  /**\n   * Add a VSCode development environment (used for GitHub Codespaces)\n   *\n   * @default false\n   */\n  readonly devContainer?: boolean;\n\n  /**\n   * Add a `clobber` task which resets the repo to origin.\n   * @default - true, but false for subprojects\n   */\n  readonly clobber?: boolean;\n\n  /**\n   * The README setup.\n   *\n   * @default - { filename: 'README.md', contents: '# replace this' }\n   * @example \"{ filename: 'readme.md', contents: '# title' }\"\n   */\n  readonly readme?: SampleReadmeProps;\n\n  /**\n   * Which type of project this is (library/app).\n   * @default ProjectType.UNKNOWN\n   * @deprecated no longer supported at the base project level\n   */\n  readonly projectType?: ProjectType;\n\n  /**\n   * Enable and configure the 'auto approve' workflow.\n   * @default - auto approve is disabled\n   */\n  readonly autoApproveOptions?: AutoApproveOptions;\n\n  /**\n   * Enable automatic merging on GitHub. Has no effect if `github.mergify`\n   * is set to false.\n   * @default true\n   */\n  readonly autoMerge?: boolean;\n\n  /**\n   * Configure options for automatic merging on GitHub. Has no effect if\n   * `github.mergify` or `autoMerge` is set to false.\n   *\n   * @default - see defaults in `AutoMergeOptions`\n   */\n  readonly autoMergeOptions?: AutoMergeOptions;\n\n  /**\n   * Auto-close stale issues and pull requests. To disable set `stale` to `false`.\n   *\n   * @default - see defaults in `StaleOptions`\n   */\n  readonly staleOptions?: StaleOptions;\n\n  /**\n   * Auto-close of stale issues and pull request. See `staleOptions` for options.\n   *\n   * @default false\n   */\n  readonly stale?: boolean;\n\n  /**\n   * Choose a method of providing GitHub API access for projen workflows.\n   *\n   * @default - use a personal access token named PROJEN_GITHUB_TOKEN\n   */\n  readonly projenCredentials?: GithubCredentials;\n\n  /**\n   * The name of a secret which includes a GitHub Personal Access Token to be\n   * used by projen workflows. This token needs to have the `repo`, `workflows`\n   * and `packages` scope.\n   *\n   * @default \"PROJEN_GITHUB_TOKEN\"\n   * @deprecated use `projenCredentials`\n   */\n  readonly projenTokenSecret?: string;\n}\n\n/**\n * GitHub-based project.\n *\n * @deprecated This is a *temporary* class. At the moment, our base project\n * types such as `NodeProject` and `JavaProject` are derived from this, but we\n * want to be able to use these project types outside of GitHub as well. One of\n * the next steps to address this is to abstract workflows so that different\n * \"engines\" can be used to implement our CI/CD solutions.\n */\nexport class GitHubProject extends Project {\n  /**\n   * Access all github components.\n   *\n   * This will be `undefined` for subprojects.\n   */\n  public readonly github: GitHub | undefined;\n\n  /**\n   * Access all VSCode components.\n   *\n   * This will be `undefined` for subprojects.\n   */\n  public readonly vscode: VsCode | undefined;\n\n  /**\n   * Access for Gitpod\n   *\n   * This will be `undefined` if gitpod boolean is false\n   */\n  public readonly gitpod: Gitpod | undefined;\n\n  /**\n   * Access for .devcontainer.json (used for GitHub Codespaces)\n   *\n   * This will be `undefined` if devContainer boolean is false\n   */\n  public readonly devContainer: DevContainer | undefined;\n\n  /*\n   * Which project type this is.\n   *\n   * @deprecated\n   */\n  public readonly projectType: ProjectType;\n\n  /**\n   * Auto approve set up for this project.\n   */\n  public readonly autoApprove?: AutoApprove;\n\n  constructor(options: GitHubProjectOptions) {\n    super(options);\n\n    this.projectType = options.projectType ?? ProjectType.UNKNOWN;\n    // we only allow these global services to be used in root projects\n    const github = options.github ?? (this.parent ? false : true);\n    this.github = github\n      ? new GitHub(this, {\n          projenTokenSecret: options.projenTokenSecret,\n          projenCredentials: options.projenCredentials,\n          mergify: options.mergify,\n          mergifyOptions: options.mergifyOptions,\n          ...options.githubOptions,\n        })\n      : undefined;\n\n    const vscode = options.vscode ?? (this.parent ? false : true);\n    this.vscode = vscode ? new VsCode(this) : undefined;\n\n    this.gitpod = options.gitpod ? new Gitpod(this) : undefined;\n    this.devContainer = options.devContainer\n      ? new DevContainer(this)\n      : undefined;\n\n    if (options.clobber ?? !this.parent) {\n      new Clobber(this);\n    }\n\n    new SampleReadme(this, options.readme);\n\n    if (options.autoApproveOptions && this.github) {\n      this.autoApprove = new AutoApprove(\n        this.github,\n        options.autoApproveOptions\n      );\n    }\n\n    const stale = options.stale ?? false;\n    if (stale && this.github) {\n      new Stale(this.github, options.staleOptions);\n    }\n  }\n\n  /**\n   * Marks the provided file(s) as being generated. This is achieved using the\n   * github-linguist attributes. Generated files do not count against the\n   * repository statistics and language breakdown.\n   *\n   * @param glob the glob pattern to match (could be a file path).\n   *\n   * @see https://github.com/github/linguist/blob/master/docs/overrides.md\n   */\n  public annotateGenerated(glob: string): void {\n    this.gitattributes.addAttributes(glob, \"linguist-generated\");\n  }\n}\n"]}

package/lib/github/github.js

@@ -88,5 +88,5 @@ class GitHub extends component_1.Component {
 }
 exports.GitHub = GitHub;
 _a = JSII_RTTI_SYMBOL_1;
-GitHub[_a] = { fqn: "projen.github.GitHub", version: "0.72.28" };
+GitHub[_a] = { fqn: "projen.github.GitHub", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../src/github/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitHubActionsProvider } from \"./actions-provider\";\nimport { Dependabot, DependabotOptions } from \"./dependabot\";\nimport { GithubCredentials } from \"./github-credentials\";\nimport { Mergify, MergifyOptions } from \"./mergify\";\nimport { PullRequestTemplate } from \"./pr-template\";\nimport { PullRequestLint, PullRequestLintOptions } from \"./pull-request-lint\";\nimport { GithubWorkflow } from \"./workflows\";\nimport { Component } from \"../component\";\nimport { Project } from \"../project\";\n\nexport interface GitHubOptions {\n  /**\n   * Whether mergify should be enabled on this repository or not.\n   *\n   * @default true\n   */\n  readonly mergify?: boolean;\n\n  /**\n   * Options for Mergify.\n   *\n   * @default - default options\n   */\n  readonly mergifyOptions?: MergifyOptions;\n\n  /**\n   * Enables GitHub workflows. If this is set to `false`, workflows will not be created.\n   *\n   * @default true\n   */\n  readonly workflows?: boolean;\n\n  /**\n   * Add a workflow that performs basic checks for pull requests, like\n   * validating that PRs follow Conventional Commits.\n   *\n   * @default true\n   */\n  readonly pullRequestLint?: boolean;\n\n  /**\n   * Options for configuring a pull request linter.\n   *\n   * @default - see defaults in `PullRequestLintOptions`\n   */\n  readonly pullRequestLintOptions?: PullRequestLintOptions;\n\n  /**\n   * Choose a method of providing GitHub API access for projen workflows.\n   *\n   * @default - use a personal access token named PROJEN_GITHUB_TOKEN\n   */\n  readonly projenCredentials?: GithubCredentials;\n\n  /**\n   * The name of a secret which includes a GitHub Personal Access Token to be\n   * used by projen workflows. This token needs to have the `repo`, `workflows`\n   * and `packages` scope.\n   *\n   * @default \"PROJEN_GITHUB_TOKEN\"\n   * @deprecated - use `projenCredentials`\n   */\n  readonly projenTokenSecret?: string;\n\n  /**\n   * Download files in LFS in workflows\n   *\n   * @default true if the associated project has `lfsPatterns`, `false` otherwise\n   */\n  readonly downloadLfs?: boolean;\n}\n\nexport class GitHub extends Component {\n  /**\n   * Returns the `GitHub` component of a project or `undefined` if the project\n   * does not have a GitHub component.\n   */\n  public static of(project: Project): GitHub | undefined {\n    const isGitHub = (c: Component): c is GitHub => c instanceof GitHub;\n    return project.components.find(isGitHub);\n  }\n\n  /**\n   * The `Mergify` configured on this repository. This is `undefined` if Mergify\n   * was not enabled when creating the repository.\n   */\n  public readonly mergify?: Mergify;\n\n  /**\n   * Are workflows enabled?\n   */\n  public readonly workflowsEnabled: boolean;\n\n  /**\n   * GitHub API authentication method used by projen workflows.\n   */\n  public readonly projenCredentials: GithubCredentials;\n\n  /**\n   *\n   */\n  public readonly actions: GitHubActionsProvider;\n\n  private readonly _downloadLfs?: boolean;\n\n  public constructor(project: Project, options: GitHubOptions = {}) {\n    super(project);\n\n    this.actions = new GitHubActionsProvider();\n\n    this.workflowsEnabled = options.workflows ?? true;\n\n    this._downloadLfs = options.downloadLfs;\n\n    if (options.projenCredentials && options.projenTokenSecret) {\n      throw new Error(\n        \"projenTokenSecret is deprecated, please use projenCredentials instead\"\n      );\n    }\n\n    if (options.projenTokenSecret) {\n      this.projenCredentials = GithubCredentials.fromPersonalAccessToken({\n        secret: options.projenTokenSecret,\n      });\n    } else if (options.projenCredentials) {\n      this.projenCredentials = options.projenCredentials;\n    } else {\n      this.projenCredentials = GithubCredentials.fromPersonalAccessToken({\n        secret: \"PROJEN_GITHUB_TOKEN\",\n      });\n    }\n\n    if (options.mergify ?? true) {\n      this.mergify = new Mergify(this, options.mergifyOptions);\n    }\n\n    if (options.pullRequestLint ?? true) {\n      new PullRequestLint(this, options.pullRequestLintOptions);\n    }\n  }\n\n  /**\n   * All workflows.\n   */\n  public get workflows(): GithubWorkflow[] {\n    const isWorkflow = (c: Component): c is GithubWorkflow =>\n      c instanceof GithubWorkflow;\n    return this.project.components\n      .filter(isWorkflow)\n      .sort((w1, w2) => w1.name.localeCompare(w2.name));\n  }\n\n  /**\n   * Adds a workflow to the project.\n   * @param name Name of the workflow\n   * @returns a GithubWorkflow instance\n   */\n  public addWorkflow(name: string) {\n    const workflow = new GithubWorkflow(this, name);\n    return workflow;\n  }\n\n  public addPullRequestTemplate(...content: string[]) {\n    return new PullRequestTemplate(this, { lines: content });\n  }\n\n  public addDependabot(options?: DependabotOptions) {\n    return new Dependabot(this, options);\n  }\n\n  /**\n   * Finds a GitHub workflow by name. Returns `undefined` if the workflow cannot be found.\n   * @param name The name of the GitHub workflow\n   */\n  public tryFindWorkflow(name: string): undefined | GithubWorkflow {\n    return this.workflows.find((w) => w.name === name);\n  }\n\n  /**\n   * Whether downloading from LFS is enabled for this GitHub project\n   */\n  public get downloadLfs() {\n    return this._downloadLfs ?? this.project.gitattributes.hasLfsPatterns;\n  }\n}\n"]}

package/lib/github/mergify.js

@@ -41,5 +41,5 @@ class Mergify extends component_1.Component {
 }
 exports.Mergify = Mergify;
 _a = JSII_RTTI_SYMBOL_1;
-Mergify[_a] = { fqn: "projen.github.Mergify", version: "0.72.28" };
+Mergify[_a] = { fqn: "projen.github.Mergify", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/github/pr-template.d.ts

@@ -1,4 +1,5 @@
 import { GitHub } from "./github";
+import { Project } from "../project";
 import { TextFile } from "../textfile";
 /**
  * Options for `PullRequestTemplate`.
@@ -15,5 +16,12 @@ export interface PullRequestTemplateOptions {
  * Template for GitHub pull requests.
  */
 export declare class PullRequestTemplate extends TextFile {
+    /**
+     * Returns the `PullRequestTemplate` instance associated with a project or `undefined` if
+     * there is no PullRequestTemplate.
+     * @param project The project
+     * @returns A PullRequestTemplate
+     */
+    static of(project: Project): PullRequestTemplate | undefined;
     constructor(github: GitHub, options?: PullRequestTemplateOptions);
 }

package/lib/github/pr-template.js

@@ -8,6 +8,16 @@ const textfile_1 = require("../textfile");
  * Template for GitHub pull requests.
  */
 class PullRequestTemplate extends textfile_1.TextFile {
+    /**
+     * Returns the `PullRequestTemplate` instance associated with a project or `undefined` if
+     * there is no PullRequestTemplate.
+     * @param project The project
+     * @returns A PullRequestTemplate
+     */
+    static of(project) {
+        const isPrTemplate = (o) => o instanceof PullRequestTemplate;
+        return project.components.find(isPrTemplate);
+    }
     constructor(github, options = {}) {
         super(github.project, ".github/pull_request_template.md", {
             lines: options.lines && options.lines?.length > 0
@@ -21,5 +31,5 @@ class PullRequestTemplate extends textfile_1.TextFile {
 }
 exports.PullRequestTemplate = PullRequestTemplate;
 _a = JSII_RTTI_SYMBOL_1;
-PullRequestTemplate[_a] = { fqn: "projen.github.PullRequestTemplate", version: "0.72.28" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHItdGVtcGxhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2l0aHViL3ByLXRlbXBsYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQ0EsMENBQXVDO0FBY3ZDOztHQUVHO0FBQ0gsTUFBYSxtQkFBb0IsU0FBUSxtQkFBUTtJQUMvQyxZQUFZLE1BQWMsRUFBRSxVQUFzQyxFQUFFO1FBQ2xFLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLGtDQUFrQyxFQUFFO1lBQ3hELEtBQUssRUFDSCxPQUFPLENBQUMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLENBQUM7Z0JBQ3hDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSztnQkFDZixDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7WUFDakIsTUFBTSxFQUFFLEtBQUs7WUFDYixzRUFBc0U7WUFDdEUsU0FBUyxFQUFFLElBQUk7U0FDaEIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7QUFYSCxrREFZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEdpdEh1YiB9IGZyb20gXCIuL2dpdGh1YlwiO1xuaW1wb3J0IHsgVGV4dEZpbGUgfSBmcm9tIFwiLi4vdGV4dGZpbGVcIjtcblxuLyoqXG4gKiBPcHRpb25zIGZvciBgUHVsbFJlcXVlc3RUZW1wbGF0ZWAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUHVsbFJlcXVlc3RUZW1wbGF0ZU9wdGlvbnMge1xuICAvKipcbiAgICogVGhlIGNvbnRlbnRzIG9mIHRoZSB0ZW1wbGF0ZS4gWW91IGNhbiB1c2UgYGFkZExpbmUoKWAgdG8gYWRkIGFkZGl0aW9uYWwgbGluZXMuXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gYSBzdGFuZGFyZCBkZWZhdWx0IHRlbXBsYXRlIHdpbGwgYmUgY3JlYXRlZC5cbiAgICovXG4gIHJlYWRvbmx5IGxpbmVzPzogc3RyaW5nW107XG59XG5cbi8qKlxuICogVGVtcGxhdGUgZm9yIEdpdEh1YiBwdWxsIHJlcXVlc3RzLlxuICovXG5leHBvcnQgY2xhc3MgUHVsbFJlcXVlc3RUZW1wbGF0ZSBleHRlbmRzIFRleHRGaWxlIHtcbiAgY29uc3RydWN0b3IoZ2l0aHViOiBHaXRIdWIsIG9wdGlvbnM6IFB1bGxSZXF1ZXN0VGVtcGxhdGVPcHRpb25zID0ge30pIHtcbiAgICBzdXBlcihnaXRodWIucHJvamVjdCwgXCIuZ2l0aHViL3B1bGxfcmVxdWVzdF90ZW1wbGF0ZS5tZFwiLCB7XG4gICAgICBsaW5lczpcbiAgICAgICAgb3B0aW9ucy5saW5lcyAmJiBvcHRpb25zLmxpbmVzPy5sZW5ndGggPiAwXG4gICAgICAgICAgPyBvcHRpb25zLmxpbmVzXG4gICAgICAgICAgOiBbXCJGaXhlcyAjXCJdLFxuICAgICAgbWFya2VyOiBmYWxzZSxcbiAgICAgIC8vIEdpdEh1YiBuZWVkcyB0byByZWFkIHRoZSBmaWxlIGZyb20gdGhlIHJlcG9zaXRvcnkgaW4gb3JkZXIgdG8gd29yay5cbiAgICAgIGNvbW1pdHRlZDogdHJ1ZSxcbiAgICB9KTtcbiAgfVxufVxuIl19
+PullRequestTemplate[_a] = { fqn: "projen.github.PullRequestTemplate", version: "0.72.30" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/github/pull-request-lint.d.ts

@@ -21,6 +21,20 @@ export interface PullRequestLintOptions {
      * @default ["ubuntu-latest"]
      */
     readonly runsOn?: string[];
+    /**
+     * Require a contributor statement to be included in the PR description.
+     * For example confirming that the contribution has been made by the contributor and complies with the project's license.
+     *
+     * Appends the statement to the end of the Pull Request template.
+     *
+     * @default - no contributor statement is required
+     */
+    readonly contributorStatement?: string;
+    /**
+     * Options for requiring a contributor statement on Pull Requests
+     * @default - none
+     */
+    readonly contributorStatementOptions?: ContributorStatementOptions;
 }
 /**
  * Options for linting that PR titles follow Conventional Commits.
@@ -39,10 +53,28 @@ export interface SemanticTitleOptions {
      */
     readonly requireScope?: boolean;
 }
+/**
+ * Options for requiring a contributor statement on Pull Requests
+ */
+export interface ContributorStatementOptions {
+    /**
+     * Pull requests from these GitHub users are exempted from a contributor statement.
+     * @default - no users are exempted
+     */
+    readonly exemptUsers?: string[];
+    /**
+     * Pull requests with one of these labels are exempted from a contributor statement.
+     * @default - no labels are excluded
+     */
+    readonly exemptLabels?: string[];
+}
 /**
  * Configure validations to run on GitHub pull requests.
  * Only generates a file if at least one linter is configured.
  */
 export declare class PullRequestLint extends Component {
+    private readonly github;
+    private readonly options;
     constructor(github: GitHub, options?: PullRequestLintOptions);
+    preSynthesize(): void;
 }

package/lib/github/pull-request-lint.js

@@ -3,6 +3,7 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PullRequestLint = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const _1 = require(".");
 const workflows_model_1 = require("./workflows-model");
 const component_1 = require("../component");
 /**
@@ -12,8 +13,28 @@ const component_1 = require("../component");
 class PullRequestLint extends component_1.Component {
     constructor(github, options = {}) {
         super(github.project);
+        this.github = github;
+        this.options = options;
+        const checkSemanticTitle = options.semanticTitle ?? true;
+        const checkContributorStatement = Boolean(options.contributorStatement);
         // should only create a workflow if one or more linters are enabled
-        if (options.semanticTitle ?? true) {
+        if (!checkSemanticTitle && !checkContributorStatement) {
+            return;
+        }
+        const workflow = github.addWorkflow("pull-request-lint");
+        workflow.on({
+            pullRequestTarget: {
+                types: [
+                    "labeled",
+                    "opened",
+                    "synchronize",
+                    "reopened",
+                    "ready_for_review",
+                    "edited",
+                ],
+            },
+        });
+        if (checkSemanticTitle) {
             const opts = options.semanticTitleOptions ?? {};
             const types = opts.types ?? ["feat", "fix", "chore"];
             const validateJob = {
@@ -36,24 +57,80 @@ class PullRequestLint extends component_1.Component {
                     },
                 ],
             };
-            const workflow = github.addWorkflow("pull-request-lint");
-            workflow.on({
-                pullRequestTarget: {
-                    types: [
-                        "labeled",
-                        "opened",
-                        "synchronize",
-                        "reopened",
-                        "ready_for_review",
-                        "edited",
-                    ],
-                },
-            });
             workflow.addJobs({ validate: validateJob });
         }
+        if (options.contributorStatement) {
+            const opts = options.contributorStatementOptions ?? {};
+            const users = opts.exemptUsers ?? [];
+            const labels = opts.exemptLabels ?? [];
+            const conditions = [
+                ...labels.map((l) => `contains(github.event.pull_request.labels.*.name, '${l}')`),
+                ...users.map((u) => `github.event.pull_request.user.login == '${u}'`),
+            ];
+            const script = (core) => {
+                const actual = process.env.PR_BODY.replace(/\r?\n/g, "\n");
+                const expected = process.env.EXPECTED.replace(/\r?\n/g, "\n");
+                if (!actual.includes(expected)) {
+                    console.log("%j", actual);
+                    console.log("%j", expected);
+                    core.setFailed(`${process.env.HELP}: ${expected}`);
+                }
+            };
+            const helpMessage = "Contributor statement missing from PR description. Please include the following text in the PR description";
+            const contributorStatement = {
+                name: "Require Contributor Statement",
+                runsOn: options.runsOn ?? ["ubuntu-latest"],
+                permissions: {
+                    pullRequests: workflows_model_1.JobPermission.READ,
+                },
+                if: conditions.length ? `!(${conditions.join(" || ")})` : undefined,
+                env: {
+                    PR_BODY: "${{ github.event.pull_request.body }}",
+                    EXPECTED: options.contributorStatement,
+                    HELP: helpMessage,
+                },
+                steps: [
+                    {
+                        uses: "actions/github-script@v6",
+                        with: {
+                            script: fnBody(script),
+                        },
+                    },
+                ],
+            };
+            workflow.addJobs({ contributorStatement });
+        }
+    }
+    preSynthesize() {
+        if (this.options.contributorStatement) {
+            // Append to PR template in preSynthesize so it's always at the end of the file
+            const prTemplate = _1.PullRequestTemplate.of(this.project) ??
+                this.github.addPullRequestTemplate();
+            prTemplate?.addLine("");
+            prTemplate?.addLine("---");
+            prTemplate?.addLine(this.options.contributorStatement);
+            prTemplate?.addLine("");
+        }
     }
 }
 exports.PullRequestLint = PullRequestLint;
 _a = JSII_RTTI_SYMBOL_1;
-PullRequestLint[_a] = { fqn: "projen.github.PullRequestLint", version: "0.72.28" };
-//# sourceMappingURL=data:application/json;base64,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
+PullRequestLint[_a] = { fqn: "projen.github.PullRequestLint", version: "0.72.30" };
+/**
+ * Helper to generate a JS script as string from a function object
+ * @returns A prettified string of the function's body
+ */
+function fnBody(fn) {
+    const def = fn.toString().replace(/\r?\n/g, "\n");
+    const body = def
+        .substring(def.indexOf("{") + 1, def.lastIndexOf("}"))
+        .split("\n");
+    const minIndentation = Math.min(...body
+        .filter((l) => l.trim()) // ignore empty lines
+        .map((l) => l.search(/\S|$/)));
+    return body
+        .map((l) => l.replace(" ".repeat(minIndentation), ""))
+        .join("\n")
+        .trim();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pull-request-lint.js","sourceRoot":"","sources":["../../src/github/pull-request-lint.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitHub, PullRequestTemplate } from \".\";\nimport { Job, JobPermission } from \"./workflows-model\";\nimport { Component } from \"../component\";\n\n/**\n * Options for PullRequestLint\n */\nexport interface PullRequestLintOptions {\n  /**\n   * Validate that pull request titles follow Conventional Commits.\n   *\n   * @default true\n   * @see https://www.conventionalcommits.org/\n   */\n  readonly semanticTitle?: boolean;\n\n  /**\n   * Options for validating the conventional commit title linter.\n   * @default - title must start with \"feat\", \"fix\", or \"chore\"\n   */\n  readonly semanticTitleOptions?: SemanticTitleOptions;\n\n  /**\n   * Github Runner selection labels\n   * @default [\"ubuntu-latest\"]\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Require a contributor statement to be included in the PR description.\n   * For example confirming that the contribution has been made by the contributor and complies with the project's license.\n   *\n   * Appends the statement to the end of the Pull Request template.\n   *\n   * @default - no contributor statement is required\n   */\n  readonly contributorStatement?: string;\n\n  /**\n   * Options for requiring a contributor statement on Pull Requests\n   * @default - none\n   */\n  readonly contributorStatementOptions?: ContributorStatementOptions;\n}\n\n/**\n * Options for linting that PR titles follow Conventional Commits.\n * @see https://www.conventionalcommits.org/\n */\nexport interface SemanticTitleOptions {\n  /**\n   * Configure a list of commit types that are allowed.\n   * @default [\"feat\", \"fix\", \"chore\"]\n   */\n  readonly types?: string[];\n\n  /**\n   * Configure that a scope must always be provided.\n   * e.g. feat(ui), fix(core)\n   * @default false\n   */\n  readonly requireScope?: boolean;\n}\n\n/**\n * Options for requiring a contributor statement on Pull Requests\n */\nexport interface ContributorStatementOptions {\n  /**\n   * Pull requests from these GitHub users are exempted from a contributor statement.\n   * @default - no users are exempted\n   */\n  readonly exemptUsers?: string[];\n  /**\n   * Pull requests with one of these labels are exempted from a contributor statement.\n   * @default - no labels are excluded\n   */\n  readonly exemptLabels?: string[];\n}\n\n/**\n * Configure validations to run on GitHub pull requests.\n * Only generates a file if at least one linter is configured.\n */\nexport class PullRequestLint extends Component {\n  constructor(\n    private readonly github: GitHub,\n    private readonly options: PullRequestLintOptions = {}\n  ) {\n    super(github.project);\n\n    const checkSemanticTitle = options.semanticTitle ?? true;\n    const checkContributorStatement = Boolean(options.contributorStatement);\n\n    // should only create a workflow if one or more linters are enabled\n    if (!checkSemanticTitle && !checkContributorStatement) {\n      return;\n    }\n\n    const workflow = github.addWorkflow(\"pull-request-lint\");\n    workflow.on({\n      pullRequestTarget: {\n        types: [\n          \"labeled\",\n          \"opened\",\n          \"synchronize\",\n          \"reopened\",\n          \"ready_for_review\",\n          \"edited\",\n        ],\n      },\n    });\n\n    if (checkSemanticTitle) {\n      const opts = options.semanticTitleOptions ?? {};\n      const types = opts.types ?? [\"feat\", \"fix\", \"chore\"];\n\n      const validateJob: Job = {\n        name: \"Validate PR title\",\n        runsOn: options.runsOn ?? [\"ubuntu-latest\"],\n        permissions: {\n          pullRequests: JobPermission.WRITE,\n        },\n        steps: [\n          {\n            uses: \"amannn/action-semantic-pull-request@v5.0.2\",\n            env: {\n              GITHUB_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n            },\n            with: {\n              types: types.join(\"\\n\"),\n              requireScope: opts.requireScope ?? false,\n              githubBaseUrl: \"${{ github.api_url }}\",\n            },\n          },\n        ],\n      };\n\n      workflow.addJobs({ validate: validateJob });\n    }\n\n    if (options.contributorStatement) {\n      const opts = options.contributorStatementOptions ?? {};\n      const users = opts.exemptUsers ?? [];\n      const labels = opts.exemptLabels ?? [];\n\n      const conditions: string[] = [\n        ...labels.map(\n          (l) => `contains(github.event.pull_request.labels.*.name, '${l}')`\n        ),\n        ...users.map((u) => `github.event.pull_request.user.login == '${u}'`),\n      ];\n\n      const script = (core: any) => {\n        const actual = process.env.PR_BODY!.replace(/\\r?\\n/g, \"\\n\");\n        const expected = process.env.EXPECTED!.replace(/\\r?\\n/g, \"\\n\");\n        if (!actual.includes(expected)) {\n          console.log(\"%j\", actual);\n          console.log(\"%j\", expected);\n          core.setFailed(`${process.env.HELP}: ${expected}`);\n        }\n      };\n\n      const helpMessage =\n        \"Contributor statement missing from PR description. Please include the following text in the PR description\";\n      const contributorStatement: Job = {\n        name: \"Require Contributor Statement\",\n        runsOn: options.runsOn ?? [\"ubuntu-latest\"],\n        permissions: {\n          pullRequests: JobPermission.READ,\n        },\n        if: conditions.length ? `!(${conditions.join(\" || \")})` : undefined,\n        env: {\n          PR_BODY: \"${{ github.event.pull_request.body }}\",\n          EXPECTED: options.contributorStatement,\n          HELP: helpMessage,\n        },\n        steps: [\n          {\n            uses: \"actions/github-script@v6\",\n            with: {\n              script: fnBody(script),\n            },\n          },\n        ],\n      };\n\n      workflow.addJobs({ contributorStatement });\n    }\n  }\n\n  public preSynthesize(): void {\n    if (this.options.contributorStatement) {\n      // Append to PR template in preSynthesize so it's always at the end of the file\n      const prTemplate =\n        PullRequestTemplate.of(this.project) ??\n        this.github.addPullRequestTemplate();\n      prTemplate?.addLine(\"\");\n      prTemplate?.addLine(\"---\");\n      prTemplate?.addLine(this.options.contributorStatement);\n      prTemplate?.addLine(\"\");\n    }\n  }\n}\n\n/**\n * Helper to generate a JS script as string from a function object\n * @returns A prettified string of the function's body\n */\nfunction fnBody(fn: (...args: any[]) => any) {\n  const def = fn.toString().replace(/\\r?\\n/g, \"\\n\");\n  const body = def\n    .substring(def.indexOf(\"{\") + 1, def.lastIndexOf(\"}\"))\n    .split(\"\\n\");\n  const minIndentation = Math.min(\n    ...body\n      .filter((l) => l.trim()) // ignore empty lines\n      .map((l) => l.search(/\\S|$/))\n  );\n\n  return body\n    .map((l) => l.replace(\" \".repeat(minIndentation), \"\"))\n    .join(\"\\n\")\n    .trim();\n}\n"]}

package/lib/github/stale.js

@@ -78,5 +78,5 @@ class Stale extends component_1.Component {
 }
 exports.Stale = Stale;
 _a = JSII_RTTI_SYMBOL_1;
-Stale[_a] = { fqn: "projen.github.Stale", version: "0.72.28" };
+Stale[_a] = { fqn: "projen.github.Stale", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stale.js","sourceRoot":"","sources":["../../src/github/stale.ts"],"names":[],"mappings":";;;;;AACA,6CAA8C;AAC9C,uDAAkD;AAClD,4CAAyC;AAiFzC;;;;;;;;;;GAUG;AACH,MAAa,KAAM,SAAQ,qBAAS;IAClC,YAAY,MAAc,EAAE,UAAwB,EAAE;QACpD,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAEtB,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC1C,KAAK,CAAC,EAAE,CAAC;YACP,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;YACjC,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,IAAA,2BAAc,EAAC,OAAO,CAAC,WAAW,EAAE;YACvD,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,cAAc;SACrB,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,IAAA,2BAAc,EAAC,OAAO,CAAC,MAAM,EAAE;YAC5C,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,OAAO;SACd,CAAC,CAAC;QAEH,MAAM,kBAAkB,GAAG,CAAC,YAAuB,EAAE,EAAE;YACrD,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC9C,OAAO,SAAS,CAAC;aAClB;YACD,OAAO,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC,CAAC;QAEF,KAAK,CAAC,OAAO,CAAC;YACZ,KAAK,EAAE;gBACL,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC;gBAC3C,WAAW,EAAE;oBACX,MAAM,EAAE,+BAAa,CAAC,KAAK;oBAC3B,YAAY,EAAE,+BAAa,CAAC,KAAK;iBAClC;gBACD,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,kBAAkB;wBACxB,IAAI,EAAE;4BACJ,iBAAiB;4BACjB,mBAAmB,EAAE,CAAC,CAAC;4BACvB,mBAAmB,EAAE,CAAC,CAAC;4BAEvB,gBAAgB;4BAChB,sBAAsB,EAAE,YAAY,CAAC,eAAe;4BACpD,sBAAsB,EAAE,YAAY,CAAC,eAAe;4BACpD,kBAAkB,EAAE,YAAY,CAAC,YAAY;4BAC7C,kBAAkB,EAAE,YAAY,CAAC,YAAY;4BAC7C,gBAAgB,EAAE,YAAY,CAAC,UAAU;4BACzC,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CAAC,YAAY,CAAC;4BAEjE,SAAS;4BACT,yBAAyB,EAAE,MAAM,CAAC,eAAe;4BACjD,yBAAyB,EAAE,MAAM,CAAC,eAAe;4BACjD,qBAAqB,EAAE,MAAM,CAAC,YAAY;4BAC1C,qBAAqB,EAAE,MAAM,CAAC,YAAY;4BAC1C,mBAAmB,EAAE,MAAM,CAAC,UAAU;4BACtC,qBAAqB,EAAE,kBAAkB,CAAC,MAAM,CAAC,YAAY,CAAC;yBAC/D;qBACF;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;;AA/DH,sBAgEC","sourcesContent":["import { GitHub } from \"./github\";\nimport { renderBehavior } from \"./stale-util\";\nimport { JobPermission } from \"./workflows-model\";\nimport { Component } from \"../component\";\n\n/**\n * Options for `Stale`.\n */\nexport interface StaleOptions {\n  /**\n   * How to handle stale pull requests.\n   *\n   * @default - By default, pull requests with no activity will be marked as\n   * stale after 14 days and closed within 2 days with relevant comments.\n   */\n  readonly pullRequest?: StaleBehavior;\n\n  /**\n   * How to handle stale issues.\n   *\n   * @default - By default, stale issues with no activity will be marked as\n   * stale after 60 days and closed within 7 days.\n   */\n  readonly issues?: StaleBehavior;\n\n  /**\n   * Github Runner selection labels\n   * @default [\"ubuntu-latest\"]\n   */\n  readonly runsOn?: string[];\n}\n\n/**\n * Stale behavior.\n */\nexport interface StaleBehavior {\n  /**\n   * Determines if this behavior is enabled.\n   *\n   * Same as setting `daysBeforeStale` and `daysBeforeClose` to `-1`.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * How many days until the issue or pull request is marked as \"Stale\". Set to -1 to disable.\n   * @default -\n   */\n  readonly daysBeforeStale?: number;\n\n  /**\n   * Days until the issue/PR is closed after it is marked as \"Stale\". Set to -1 to disable.\n   * @default -\n   */\n  readonly daysBeforeClose?: number;\n\n  /**\n   * The comment to add to the issue/PR when it becomes stale.\n   * @default \"This pull request is now marked as stale because hasn\\'t seen activity for a while. Add a comment or it will be closed soon.\"\n   */\n  readonly staleMessage?: string;\n\n  /**\n   * The comment to add to the issue/PR when it's closed\n   *\n   * @default \"Closing this pull request as it hasn\\'t seen activity for a while. Please add a comment @mentioning a maintainer when you are ready to continue.\"\n   */\n  readonly closeMessage?: string;\n\n  /**\n   * The label to apply to the issue/PR when it becomes stale.\n   * @default \"stale\"\n   */\n  readonly staleLabel?: string;\n\n  /**\n   * Label which exempt an issue/PR from becoming stale. Set to `[]` to disable.\n   *\n   * @default - [\"backlog\"]\n   */\n  readonly exemptLabels?: string[];\n}\n\n/**\n * Warns and then closes issues and PRs that have had no activity for a specified amount of time.\n *\n * The default configuration will:\n *\n *  * Add a \"Stale\" label to pull requests after 14 days and closed after 2 days\n *  * Add a \"Stale\" label to issues after 60 days and closed after 7 days\n *  * If a comment is added, the label will be removed and timer is restarted.\n *\n * @see https://github.com/actions/stale\n */\nexport class Stale extends Component {\n  constructor(github: GitHub, options: StaleOptions = {}) {\n    super(github.project);\n\n    const stale = github.addWorkflow(\"stale\");\n    stale.on({\n      schedule: [{ cron: \"0 1 * * *\" }], // at 1am every day\n      workflowDispatch: {},\n    });\n\n    const pullRequests = renderBehavior(options.pullRequest, {\n      stale: 14,\n      close: 2,\n      type: \"pull request\",\n    });\n    const issues = renderBehavior(options.issues, {\n      stale: 60,\n      close: 7,\n      type: \"issue\",\n    });\n\n    const renderExemptLabels = (exemptLabels?: string[]) => {\n      if (!exemptLabels || exemptLabels.length === 0) {\n        return undefined;\n      }\n      return exemptLabels.join(\",\");\n    };\n\n    stale.addJobs({\n      stale: {\n        runsOn: options.runsOn ?? [\"ubuntu-latest\"],\n        permissions: {\n          issues: JobPermission.WRITE,\n          pullRequests: JobPermission.WRITE,\n        },\n        steps: [\n          {\n            uses: \"actions/stale@v4\",\n            with: {\n              // disable global\n              \"days-before-stale\": -1,\n              \"days-before-close\": -1,\n\n              // pull requests\n              \"days-before-pr-stale\": pullRequests.daysBeforeStale,\n              \"days-before-pr-close\": pullRequests.daysBeforeClose,\n              \"stale-pr-message\": pullRequests.staleMessage,\n              \"close-pr-message\": pullRequests.closeMessage,\n              \"stale-pr-label\": pullRequests.staleLabel,\n              \"exempt-pr-labels\": renderExemptLabels(pullRequests.exemptLabels),\n\n              // issues\n              \"days-before-issue-stale\": issues.daysBeforeStale,\n              \"days-before-issue-close\": issues.daysBeforeClose,\n              \"stale-issue-message\": issues.staleMessage,\n              \"close-issue-message\": issues.closeMessage,\n              \"stale-issue-label\": issues.staleLabel,\n              \"exempt-issue-labels\": renderExemptLabels(issues.exemptLabels),\n            },\n          },\n        ],\n      },\n    });\n  }\n}\n"]}

package/lib/github/task-workflow.js

@@ -82,5 +82,5 @@ class TaskWorkflow extends workflows_1.GithubWorkflow {
 }
 exports.TaskWorkflow = TaskWorkflow;
 _a = JSII_RTTI_SYMBOL_1;
-TaskWorkflow[_a] = { fqn: "projen.github.TaskWorkflow", version: "0.72.28" };
+TaskWorkflow[_a] = { fqn: "projen.github.TaskWorkflow", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-workflow.js","sourceRoot":"","sources":["../../src/github/task-workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { GitHub } from \"./github\";\nimport { WorkflowActions } from \"./workflow-actions\";\nimport { GithubWorkflow } from \"./workflows\";\nimport {\n  ContainerOptions,\n  Job,\n  JobPermissions,\n  JobStep,\n  JobStepOutput,\n  Triggers,\n} from \"./workflows-model\";\nimport { Task } from \"../task\";\n\nconst DEFAULT_JOB_ID = \"build\";\n\nexport interface TaskWorkflowOptions {\n  /**\n   * The workflow name.\n   */\n  readonly name: string;\n\n  /**\n   * The primary job id.\n   * @default \"build\"\n   */\n  readonly jobId?: string;\n\n  /**\n   * @default - default image\n   */\n  readonly container?: ContainerOptions;\n\n  /**\n   * Adds an 'if' condition to the workflow.\n   */\n  readonly condition?: string;\n\n  /**\n   * A directory name which contains artifacts to be uploaded (e.g. `dist`).\n   * If this is set, the contents of this directory will be uploaded as an\n   * artifact at the end of the workflow run, even if other steps fail.\n   *\n   * @default - not set\n   */\n  readonly artifactsDirectory?: string;\n\n  /**\n   * The triggers for the workflow.\n   *\n   * @default - by default workflows can only be triggered by manually.\n   */\n  readonly triggers?: Triggers;\n\n  /**\n   * Initial steps to run before the source code checkout.\n   *\n   * @default - not set\n   */\n  readonly preCheckoutSteps?: JobStep[];\n\n  /**\n   * Override for the `with` property of the source code checkout step.\n   *\n   * @default - not set\n   */\n  readonly checkoutWith?: Record<string, any>;\n\n  /**\n   * Steps to run before the main build step.\n   *\n   * @default - not set\n   */\n  readonly preBuildSteps?: JobStep[];\n\n  /**\n   * The main task to be executed.\n   */\n  readonly task: Task;\n\n  /**\n   * Actions to run after the main build step.\n   *\n   * @default - not set\n   */\n  readonly postBuildSteps?: JobStep[];\n\n  /**\n   * Workflow environment variables.\n   * @default {}\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Permissions for the build job.\n   */\n  readonly permissions: JobPermissions;\n\n  /**\n   * Mapping of job output names to values/expressions.\n   *\n   * @default {}\n   */\n  readonly outputs?: { [name: string]: JobStepOutput };\n\n  /**\n   * The git identity to use in this workflow.\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Github Runner selection labels\n   * @default [\"ubuntu-latest\"]\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Whether to download files from Git LFS for this workflow\n   *\n   * @default - Use the setting on the corresponding GitHub project\n   */\n  readonly downloadLfs?: boolean;\n}\n\n/**\n * A GitHub workflow for common build tasks within a project.\n */\nexport class TaskWorkflow extends GithubWorkflow {\n  private readonly github: GitHub;\n  public readonly jobId: string;\n  public readonly artifactsDirectory?: string;\n\n  constructor(github: GitHub, options: TaskWorkflowOptions) {\n    super(github, options.name);\n    this.jobId = options.jobId ?? DEFAULT_JOB_ID;\n    this.github = github;\n    this.artifactsDirectory = options.artifactsDirectory;\n\n    if (options.triggers) {\n      if (options.triggers.issueComment) {\n        // https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#potential-impact-of-a-compromised-runner\n        throw new Error(\n          'Trigger \"issueComment\" should not be used due to a security concern'\n        );\n      }\n\n      this.on(options.triggers);\n    }\n\n    this.on({\n      workflowDispatch: {}, // allow manual triggering\n    });\n\n    const preCheckoutSteps = options.preCheckoutSteps ?? [];\n\n    const checkoutWith: Record<string, any> = {};\n    if (options.downloadLfs ?? github.downloadLfs) {\n      checkoutWith.lfs = true;\n    }\n    // 'checkoutWith' can override 'lfs'\n    Object.assign(checkoutWith, options.checkoutWith ?? {});\n\n    const preBuildSteps = options.preBuildSteps ?? [];\n    const postBuildSteps = options.postBuildSteps ?? [];\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n\n    if (this.artifactsDirectory) {\n      postBuildSteps.push({\n        name: \"Upload artifact\",\n        uses: \"actions/upload-artifact@v3\",\n        // Setting to always will ensure that this step will run even if\n        // the previous ones have failed (e.g. coverage report, internal logs, etc)\n        if: \"always()\",\n        with: {\n          name: this.artifactsDirectory,\n          path: this.artifactsDirectory,\n        },\n      });\n    }\n\n    const job: Job = {\n      runsOn: options.runsOn ?? [\"ubuntu-latest\"],\n      container: options.container,\n      env: options.env,\n      permissions: options.permissions,\n      if: options.condition,\n      outputs: options.outputs,\n      steps: [\n        ...preCheckoutSteps,\n\n        // check out sources.\n        {\n          name: \"Checkout\",\n          uses: \"actions/checkout@v3\",\n          ...(Object.keys(checkoutWith).length > 0\n            ? { with: checkoutWith }\n            : {}),\n        },\n\n        // sets git identity so we can push later\n        ...WorkflowActions.setupGitIdentity(gitIdentity),\n\n        ...preBuildSteps,\n\n        // run the main build task\n        {\n          name: options.task.name,\n          run: this.github.project.runTaskCommand(options.task),\n        },\n\n        ...postBuildSteps,\n      ],\n    };\n\n    this.addJobs({ [this.jobId]: job });\n  }\n}\n\n/**\n * Represents the git identity.\n */\nexport interface GitIdentity {\n  /**\n   * The name of the user.\n   */\n  readonly name: string;\n\n  /**\n   * The email address of the git user.\n   */\n  readonly email: string;\n}\n"]}

package/lib/github/workflow-actions.js

@@ -157,5 +157,5 @@ class WorkflowActions {
 }
 exports.WorkflowActions = WorkflowActions;
 _a = JSII_RTTI_SYMBOL_1;
-WorkflowActions[_a] = { fqn: "projen.github.WorkflowActions", version: "0.72.28" };
+WorkflowActions[_a] = { fqn: "projen.github.WorkflowActions", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-actions.js","sourceRoot":"","sources":["../../src/github/workflow-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitIdentity, GithubCredentials } from \".\";\nimport { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { JobStep } from \"./workflows-model\";\n\nfunction context(value: string) {\n  return `\\${{ ${value} }}`;\n}\n\nconst REPO = context(\"github.repository\");\nconst RUN_ID = context(\"github.run_id\");\nconst SERVER_URL = context(\"github.server_url\");\nconst RUN_URL = `${SERVER_URL}/${REPO}/actions/runs/${RUN_ID}`;\nconst GIT_PATCH_FILE_DEFAULT = \".repo.patch\";\nconst RUNNER_TEMP = \"${{ runner.temp }}\";\n\n/**\n * A set of utility functions for creating GitHub actions in workflows.\n */\nexport class WorkflowActions {\n  /**\n   * Creates a .patch file from the current git diff and uploads it as an\n   * artifact. Use `checkoutWithPatch` to download and apply in another job.\n   *\n   * If a patch was uploaded, the action can optionally fail the job.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static uploadGitPatch(options: UploadGitPatchOptions): JobStep[] {\n    const MUTATIONS_FOUND = `steps.${options.stepId}.outputs.${options.outputName}`;\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    const steps: JobStep[] = [\n      {\n        id: options.stepId,\n        name: options.stepName ?? \"Find mutations\",\n        run: [\n          \"git add .\",\n          `git diff --staged --patch --exit-code > ${GIT_PATCH_FILE} || echo \"${options.outputName}=true\" >> $GITHUB_OUTPUT`,\n        ].join(\"\\n\"),\n      },\n      {\n        if: MUTATIONS_FOUND,\n        name: \"Upload patch\",\n        uses: \"actions/upload-artifact@v3\",\n        with: { name: GIT_PATCH_FILE, path: GIT_PATCH_FILE },\n      },\n    ];\n\n    if (options.mutationError) {\n      steps.push({\n        name: \"Fail build on mutation\",\n        if: MUTATIONS_FOUND,\n        run: [\n          `echo \"::error::${options.mutationError}\"`,\n          `cat ${GIT_PATCH_FILE}`,\n          \"exit 1\",\n        ].join(\"\\n\"),\n      });\n    }\n\n    return steps;\n  }\n\n  /**\n   * Checks out a repository and applies a git patch that was created using\n   * `uploadGitPatch`.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static checkoutWithPatch(\n    options: CheckoutWithPatchOptions = {}\n  ): JobStep[] {\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    return [\n      {\n        name: \"Checkout\",\n        uses: \"actions/checkout@v3\",\n        with: {\n          token: options.token,\n          ref: options.ref,\n          repository: options.repository,\n          ...(options.lfs ? { lfs: true } : {}),\n        },\n      },\n      {\n        name: \"Download patch\",\n        uses: \"actions/download-artifact@v3\",\n        with: { name: GIT_PATCH_FILE, path: RUNNER_TEMP },\n      },\n      {\n        name: \"Apply patch\",\n        run: `[ -s ${RUNNER_TEMP}/${GIT_PATCH_FILE} ] && git apply ${RUNNER_TEMP}/${GIT_PATCH_FILE} || echo \"Empty patch. Skipping.\"`,\n      },\n    ];\n  }\n\n  /**\n   * Configures the git identity (user name and email).\n   * @param id The identity to use\n   * @returns Job steps\n   */\n  public static setupGitIdentity(id: GitIdentity): JobStep[] {\n    return [\n      {\n        name: \"Set git identity\",\n        run: [\n          `git config user.name \"${id.name}\"`,\n          `git config user.email \"${id.email}\"`,\n        ].join(\"\\n\"),\n      },\n    ];\n  }\n\n  /**\n   * A step that creates a pull request based on the current repo state.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static createPullRequest(\n    options: CreatePullRequestOptions\n  ): JobStep[] {\n    const workflowName = options.workflowName;\n    const branchName = options.branchName ?? `github-actions/${workflowName}`;\n    const stepId = options.stepId ?? \"create-pr\";\n    const stepName = options.stepName ?? \"Create Pull Request\";\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n    const committer = `${gitIdentity.name} <${gitIdentity.email}>`;\n    const pullRequestDescription = options.pullRequestDescription\n      .trimEnd()\n      .endsWith(\".\")\n      ? options.pullRequestDescription.trimEnd()\n      : `${options.pullRequestDescription.trimEnd()}.`;\n\n    const title = options.pullRequestTitle;\n    const description = [\n      `${pullRequestDescription} See details in [workflow run].`,\n      \"\",\n      `[Workflow Run]: ${RUN_URL}`,\n      \"\",\n      \"------\",\n      \"\",\n      `*Automatically created by projen via the \"${workflowName}\" workflow*`,\n    ].join(\"\\n\");\n\n    return [\n      {\n        name: stepName,\n        id: stepId,\n        uses: \"peter-evans/create-pull-request@v4\",\n        with: {\n          token: options.credentials?.tokenRef,\n          \"commit-message\": `${title}\\n\\n${description}`,\n          branch: branchName,\n          base: options.baseBranch,\n          title: title,\n          labels: options.labels?.join(\",\") || undefined,\n          assignees: options.assignees?.join(\",\") || undefined,\n          body: description,\n          author: committer,\n          committer: committer,\n          signoff: options.signoff ?? true,\n        },\n      },\n    ];\n  }\n}\n\n/**\n * Options for `checkoutWithPatch`.\n */\nexport interface CheckoutWithPatchOptions {\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n\n  /**\n   * A GitHub token to use when checking out the repository.\n   *\n   * If the intent is to push changes back to the branch, then you must use a\n   * PAT with `repo` (and possibly `workflows`) permissions.\n   * @default - the default GITHUB_TOKEN is implicitly used\n   */\n  readonly token?: string;\n\n  /**\n   * Branch or tag name.\n   * @default - the default branch is implicitly used\n   */\n  readonly ref?: string;\n\n  /**\n   * The repository (owner/repo) to use.\n   * @default - the default repository is implicitly used\n   */\n  readonly repository?: string;\n\n  /**\n   * Whether LFS is enabled for the GitHub repository\n   *\n   * @default false\n   */\n  readonly lfs?: boolean;\n}\n\n/**\n * Options for `uploadGitPatch`.\n */\nexport interface UploadGitPatchOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   */\n  readonly stepId: string;\n\n  /**\n   * The name of the step.\n   * @default \"Find mutations\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n\n  /**\n   * The name of the output to emit. It will be set to `true` if there was a diff.\n   */\n  readonly outputName: string;\n\n  /**\n   * Fail if a mutation was found and print this error message.\n   * @default - do not fail upon mutation\n   */\n  readonly mutationError?: string;\n}\n\nexport interface CreatePullRequestOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   * @default \"create_pr\"\n   */\n  readonly stepId?: string;\n\n  /**\n   * The name of the step displayed on GitHub.\n   * @default \"Create Pull Request\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The job credentials used to create the pull request.\n   *\n   * Provided credentials must have permissions to create a pull request on the repository.\n   */\n  readonly credentials?: GithubCredentials;\n\n  /**\n   * The name of the workflow that will create the PR\n   */\n  readonly workflowName: string;\n\n  /**\n   * The full title used to create the pull request.\n   *\n   * If PR titles are validated in this repo, the title should comply with the respective rules.\n   */\n  readonly pullRequestTitle: string;\n\n  /**\n   * Description added to the pull request.\n   *\n   * Providence information are automatically added.\n   */\n  readonly pullRequestDescription: string;\n\n  /**\n   * Sets the pull request base branch.\n   *\n   * @default - The branch checked out in the workflow.\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * The pull request branch name.\n   *\n   * @default `github-actions/${options.workflowName}`\n   */\n  readonly branchName?: string;\n\n  /**\n   * The git identity used to create the commit.\n   * @default - the default github-actions user\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Add Signed-off-by line by the committer at the end of the commit log message.\n   *\n   * @default true\n   */\n  readonly signoff?: boolean;\n\n  /**\n   * Labels to apply on the PR.\n   *\n   * @default - no labels.\n   */\n  readonly labels?: string[];\n\n  /**\n   * Assignees to add on the PR.\n   *\n   * @default - no assignees\n   */\n  readonly assignees?: string[];\n}\n"]}

package/lib/github/workflow-jobs.js

@@ -41,5 +41,5 @@ class WorkflowJobs {
 }
 exports.WorkflowJobs = WorkflowJobs;
 _a = JSII_RTTI_SYMBOL_1;
-WorkflowJobs[_a] = { fqn: "projen.github.WorkflowJobs", version: "0.72.28" };
+WorkflowJobs[_a] = { fqn: "projen.github.WorkflowJobs", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/github/workflows.js

@@ -119,7 +119,7 @@ class GithubWorkflow extends component_1.Component {
 }
 exports.GithubWorkflow = GithubWorkflow;
 _a = JSII_RTTI_SYMBOL_1;
-GithubWorkflow[_a] = { fqn: "projen.github.GithubWorkflow", version: "0.72.28" };
+GithubWorkflow[_a] = { fqn: "projen.github.GithubWorkflow", version: "0.72.30" };
 function snakeCaseKeys(obj) {
     if (typeof obj !== "object" || obj == null) {
         return obj;

package/lib/gitlab/configuration.js

@@ -245,7 +245,7 @@ class CiConfiguration extends component_1.Component {
 }
 exports.CiConfiguration = CiConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-CiConfiguration[_a] = { fqn: "projen.gitlab.CiConfiguration", version: "0.72.28" };
+CiConfiguration[_a] = { fqn: "projen.gitlab.CiConfiguration", version: "0.72.30" };
 function snakeCaseKeys(obj, skipTopLevel = false) {
     if (typeof obj !== "object" || obj == null) {
         return obj;

package/lib/gitlab/gitlab-configuration.js

@@ -34,5 +34,5 @@ class GitlabConfiguration extends configuration_1.CiConfiguration {
 }
 exports.GitlabConfiguration = GitlabConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-GitlabConfiguration[_a] = { fqn: "projen.gitlab.GitlabConfiguration", version: "0.72.28" };
+GitlabConfiguration[_a] = { fqn: "projen.gitlab.GitlabConfiguration", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/gitlab/nested-configuration.js

@@ -15,5 +15,5 @@ class NestedConfiguration extends configuration_1.CiConfiguration {
 }
 exports.NestedConfiguration = NestedConfiguration;
 _a = JSII_RTTI_SYMBOL_1;
-NestedConfiguration[_a] = { fqn: "projen.gitlab.NestedConfiguration", version: "0.72.28" };
+NestedConfiguration[_a] = { fqn: "projen.gitlab.NestedConfiguration", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVzdGVkLWNvbmZpZ3VyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2l0bGFiL25lc3RlZC1jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQ0EsbURBQWtEO0FBSWxEOztHQUVHO0FBQ0gsTUFBYSxtQkFBb0IsU0FBUSwrQkFBZTtJQUV0RCxZQUNFLE9BQWdCLEVBQ2hCLE1BQTJCLEVBQzNCLElBQVksRUFDWixPQUFnQztRQUVoQyxLQUFLLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztRQUM5QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDOztBQVZILGtEQVdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2lDb25maWd1cmF0aW9uT3B0aW9ucyB9IGZyb20gXCIuXCI7XG5pbXBvcnQgeyBDaUNvbmZpZ3VyYXRpb24gfSBmcm9tIFwiLi9jb25maWd1cmF0aW9uXCI7XG5pbXBvcnQgeyBHaXRsYWJDb25maWd1cmF0aW9uIH0gZnJvbSBcIi4vZ2l0bGFiLWNvbmZpZ3VyYXRpb25cIjtcbmltcG9ydCB7IFByb2plY3QgfSBmcm9tIFwiLi4vcHJvamVjdFwiO1xuXG4vKipcbiAqIEEgR2l0TGFiIENJIGZvciB0ZW1wbGF0ZXMgdGhhdCBhcmUgY3JlYXRlZCBhbmQgaW5jbHVkZWQgaW4gdGhlIGAuZ2l0bGFiLWNpLnltbGAgZmlsZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE5lc3RlZENvbmZpZ3VyYXRpb24gZXh0ZW5kcyBDaUNvbmZpZ3VyYXRpb24ge1xuICBwdWJsaWMgcmVhZG9ubHkgcGFyZW50OiBHaXRsYWJDb25maWd1cmF0aW9uO1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcm9qZWN0OiBQcm9qZWN0LFxuICAgIHBhcmVudDogR2l0bGFiQ29uZmlndXJhdGlvbixcbiAgICBuYW1lOiBzdHJpbmcsXG4gICAgb3B0aW9ucz86IENpQ29uZmlndXJhdGlvbk9wdGlvbnNcbiAgKSB7XG4gICAgc3VwZXIocHJvamVjdCwgbmFtZSwgb3B0aW9ucyk7XG4gICAgdGhpcy5wYXJlbnQgPSBwYXJlbnQ7XG4gIH1cbn1cbiJdfQ==

package/lib/gitpod.js

@@ -241,5 +241,5 @@ class Gitpod extends component_1.Component {
 }
 exports.Gitpod = Gitpod;
 _a = JSII_RTTI_SYMBOL_1;
-Gitpod[_a] = { fqn: "projen.Gitpod", version: "0.72.28" };
+Gitpod[_a] = { fqn: "projen.Gitpod", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gitpod.js","sourceRoot":"","sources":["../src/gitpod.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from \"./component\";\nimport {\n  IDevEnvironment,\n  DevEnvironmentOptions,\n  DevEnvironmentDockerImage,\n} from \"./dev-env\";\nimport { Project } from \"./project\";\nimport { Task } from \"./task\";\nimport { YamlFile } from \"./yaml\";\n\n/**\n * Relative path of Gitpod file to generate\n */\nconst GITPOD_FILE = \".gitpod.yml\";\n\n/**\n * https://www.gitpod.io/docs/configuration/\n * https://www.gitpod.io/docs/config-start-tasks/\n * https://www.gitpod.io/docs/prebuilds/#configure-the-github-app\n * https://www.gitpod.io/docs/vscode-extensions/\n */\n\n/**\n * Configure how the terminal should be opened relative to the previous task.\n */\nexport enum GitpodOpenMode {\n  /**\n   * Opens in the same tab group right after the previous tab\n   */\n  TAB_AFTER = \"tab-after\",\n  /**\n   * Opens in the same tab group left before the previous tab\n   */\n  TAB_BEFORE = \"tab-before\",\n  /**\n   * Splits and adds the terminal to the right\n   */\n  SPLIT_RIGHT = \"split-right\",\n  /**\n   * Splits and adds the terminal to the left\n   */\n  SPLIT_LEFT = \"split-left\",\n  /**\n   * Splits and adds the terminal to the top\n   */\n  SPLIT_TOP = \"split-top\",\n  /**\n   * Splits and adds the terminal to the bottom\n   */\n  SPLIT_BOTTOM = \"split-bottom\",\n}\n\n/**\n * Configure where in the IDE the terminal should be opened.\n */\nexport enum GitpodOpenIn {\n  /**\n   * the bottom panel (default)\n   */\n  BOTTOM = \"bottom\",\n  /**\n   * the left panel\n   */\n  LEFT = \"left\",\n  /**\n   * the right panel\n   */\n  RIGHT = \"right\",\n  /**\n   * the main editor area\n   */\n  MAIN = \"main\",\n}\n\n/**\n * Configure options for a task to be run when opening a Gitpod\n * workspace (e.g. running tests, or starting a dev server).\n *\n * Start Mode         | Execution\n * Fresh Workspace    | before && init && command\n * Restart Workspace  | before && command\n * Snapshot           | before && command\n * Prebuild           | before && init && prebuild\n */\nexport interface GitpodTask {\n  /**\n   * Required. The shell command to run\n   */\n  readonly command: string;\n\n  /**\n   * A name for this task.\n   * @default - task names are omitted when blank\n   */\n  readonly name?: string;\n\n  /**\n   * You can configure how the terminal should be opened relative to the previous task.\n   * @default GitpodOpenMode.TAB_AFTER\n   */\n  readonly openMode?: GitpodOpenMode;\n\n  /**\n   * You can configure where in the IDE the terminal should be opened\n   * @default GitpodOpenIn.BOTTOM\n   */\n  readonly openIn?: GitpodOpenIn;\n\n  /**\n   * In case you need to run something even before init, that is a requirement for both init and command,\n   * you can use the before property.\n   * @default\n   */\n  readonly before?: string;\n\n  /**\n   * The init property can be used to specify shell commands that should only be executed after a workspace\n   * was freshly cloned and needs to be initialized somehow. Such tasks are usually builds or downloading\n   * dependencies. Anything you only want to do once but not when you restart a workspace or start a snapshot.\n   * @default\n   */\n  readonly init?: string;\n\n  /**\n   * The optional prebuild command will be executed during prebuilds. It is meant to run additional long running\n   * processes that could be useful, e.g. running test suites.\n   * @default\n   */\n  readonly prebuild?: string;\n}\n\n/**\n * What to do when a service on a port is detected.\n */\nexport enum GitpodOnOpen {\n  /**\n   * Open a new browser tab\n   */\n  OPEN_BROWSER = \"open-browser\",\n\n  /**\n   * Open a preview on the right side of the IDE\n   */\n  OPEN_PREVIEW = \"open-preview\",\n\n  /**\n   * Show a notification asking the user what to do (default)\n   */\n  NOTIFY = \"notify\",\n\n  /**\n   * Do nothing.\n   */\n  IGNORE = \"ignore\",\n}\n\n/**\n * Whether the port visibility should be private or public\n */\nexport enum GitpodPortVisibility {\n  /**\n   * Allows everyone with the port URL to access the port (default)\n   */\n  PUBLIC = \"public\",\n\n  /**\n   * Only allows users with workspace access to access the port\n   */\n  PRIVATE = \"private\",\n}\n\n/**\n * Options for an exposed port on Gitpod\n */\nexport interface GitpodPort {\n  /**\n   * A port that should be exposed (forwarded) from the container.\n   *\n   * @example \"8080\"\n   */\n  readonly port?: string;\n\n  /**\n   * What to do when a service on a port is detected.\n   *\n   * @default GitpodOnOpen.NOTIFY\n   */\n  readonly onOpen?: GitpodOnOpen;\n\n  /**\n   * Whether the port visibility should be private or public.\n   *\n   * @default GitpodPortVisibility.PUBLIC\n   */\n  readonly visibility?: GitpodPortVisibility;\n}\n\n/**\n * Configure the Gitpod App for prebuilds.\n * Currently only GitHub is supported.\n * @see https://www.gitpod.io/docs/prebuilds/\n */\nexport interface GitpodPrebuilds {\n  /**\n   * Enable for the master/default branch\n   * @default true\n   */\n  readonly master?: boolean;\n\n  /**\n   * Enable for all branches in this repo\n   * @default false\n   */\n  readonly branches?: boolean;\n\n  /**\n   * Enable for pull requests coming from this repo\n   * @default true\n   */\n  readonly pullRequests?: boolean;\n\n  /**\n   * Enable for pull requests coming from forks\n   * @default false\n   */\n  readonly pullRequestsFromForks?: boolean;\n\n  /**\n   * Add a check to pull requests\n   * @default true\n   */\n  readonly addCheck?: boolean;\n\n  /**\n   * Add a \"Review in Gitpod\" button as a comment to pull requests\n   * @default false\n   */\n  readonly addComment?: boolean;\n\n  /**\n   * Add a \"Review in Gitpod\" button to the pull request's description\n   * @default false\n   */\n  readonly addBadge?: boolean;\n\n  /**\n   * Add a label once the prebuild is ready to pull requests\n   * @default false\n   */\n  readonly addLabel?: boolean;\n}\n\n/**\n * Constructor options for the Gitpod component.\n *\n * By default, Gitpod uses the 'gitpod/workspace-full' docker image.\n * @see https://github.com/gitpod-io/workspace-images/blob/master/full/Dockerfile\n *\n * By default, all tasks will be run in parallel. To run the tasks in sequence,\n * create a new task and specify the other tasks as subtasks.\n */\nexport interface GitpodOptions extends DevEnvironmentOptions {\n  /**\n   * Optional Gitpod's Github App integration for prebuilds\n   * If this is not set and Gitpod's Github App is installed, then Gitpod will apply\n   * these defaults: https://www.gitpod.io/docs/prebuilds/#configure-the-github-app\n   * @default undefined\n   */\n  readonly prebuilds?: GitpodPrebuilds;\n}\n\n/**\n * The Gitpod component which emits .gitpod.yml\n */\nexport class Gitpod extends Component implements IDevEnvironment {\n  private dockerImage: DevEnvironmentDockerImage | undefined;\n  private prebuilds: GitpodPrebuilds | undefined;\n  private readonly tasks = new Array<GitpodTask>();\n  private readonly ports = new Array<GitpodPort>();\n  private readonly vscodeExtensions = new Array<string>();\n\n  /**\n   * Direct access to the gitpod configuration (escape hatch)\n   */\n  public readonly config: any;\n\n  constructor(project: Project, options: GitpodOptions = {}) {\n    super(project);\n\n    this.dockerImage = options?.dockerImage;\n\n    if (options?.tasks) {\n      for (const task of options.tasks) {\n        this.addTasks(task);\n      }\n    }\n\n    if (options?.prebuilds) {\n      this.addPrebuilds(options.prebuilds);\n    }\n\n    if (options?.ports) {\n      this.addPorts(...options.ports);\n    }\n\n    if (options?.vscodeExtensions) {\n      this.addVscodeExtensions(...options.vscodeExtensions);\n    }\n\n    this.config = {\n      image: () => this.renderDockerImage(),\n      tasks: this.tasks,\n      github: () => this.renderPrebuilds(),\n      ports: this.ports,\n      vscode: {\n        extensions: this.vscodeExtensions,\n      },\n    };\n\n    new YamlFile(this.project, GITPOD_FILE, {\n      obj: this.config,\n      omitEmpty: true,\n      // GitPod needs to read the file from the repository in order to work.\n      committed: true,\n    });\n  }\n\n  /**\n   * Add a custom Docker image or Dockerfile for the container.\n   *\n   * @param image The Docker image\n   */\n  public addDockerImage(image: DevEnvironmentDockerImage) {\n    if (this.dockerImage) {\n      throw new Error(\"dockerImage cannot be redefined.\");\n    }\n    this.dockerImage = image;\n  }\n\n  /**\n   * Add tasks to run when gitpod starts.\n   *\n   * By default, all tasks will be run in parallel. To run tasks in sequence,\n   * create a new `Task` and specify the other tasks as subtasks.\n   *\n   * @param tasks The new tasks\n   */\n  public addTasks(...tasks: Task[]) {\n    this.tasks.push(\n      ...tasks.map((task) => ({\n        name: task.name,\n        command: `npx projen ${task.name}`,\n      }))\n    );\n  }\n\n  /**\n   * Add a prebuilds configuration for the Gitpod App\n   * @param config The configuration\n   */\n  public addPrebuilds(config: GitpodPrebuilds) {\n    this.prebuilds = config;\n  }\n\n  /**\n   * Add a task with more granular options.\n   *\n   * By default, all tasks will be run in parallel. To run tasks in sequence,\n   * create a new `Task` and set the other tasks as subtasks.\n   *\n   * @param options The task parameters\n   */\n  public addCustomTask(options: GitpodTask) {\n    this.tasks.push({\n      name: options.name,\n      command: options.command,\n      openMode: options.openMode,\n      openIn: options.openIn,\n      before: options.before,\n      init: options.init,\n      prebuild: options.prebuild,\n    });\n  }\n\n  /**\n   * Add ports that should be exposed (forwarded) from the container.\n   *\n   * @param ports The new ports\n   */\n  public addPorts(...ports: string[]) {\n    this.ports.push(...ports.map((port) => ({ port: port })));\n  }\n\n  /**\n   * Add a list of VSCode extensions that should be automatically installed\n   * in the container.\n   *\n   * These must be in the format defined in the Open VSX registry.\n   * @example 'scala-lang.scala@0.3.9:O5XmjwY5Gz+0oDZAmqneJw=='\n   * @see https://www.gitpod.io/docs/vscode-extensions/\n   *\n   * @param extensions The extension IDs\n   */\n  public addVscodeExtensions(...extensions: GitpodCodeExtensionId[]) {\n    this.vscodeExtensions.push(...extensions);\n  }\n\n  private renderDockerImage() {\n    if (this.dockerImage?.image) {\n      return this.dockerImage.image;\n    } else if (this.dockerImage?.dockerFile) {\n      return {\n        file: this.dockerImage.dockerFile,\n      };\n    } else {\n      return undefined;\n    }\n  }\n\n  private renderPrebuilds() {\n    if (this.prebuilds) {\n      return {\n        prebuilds: this.prebuilds,\n      };\n    } else {\n      return undefined;\n    }\n  }\n}\n\n/**\n * VS Code extensions as defined in the Open VSX registry\n * Example: `scala-lang.scala@0.3.9:O5XmjwY5Gz+0oDZAmqneJw==`\n */\ntype GitpodCodeExtensionId = string;\n"]}

package/lib/ignore-file.js

@@ -97,7 +97,7 @@ class IgnoreFile extends file_1.FileBase {
 }
 exports.IgnoreFile = IgnoreFile;
 _a = JSII_RTTI_SYMBOL_1;
-IgnoreFile[_a] = { fqn: "projen.IgnoreFile", version: "0.72.28" };
+IgnoreFile[_a] = { fqn: "projen.IgnoreFile", version: "0.72.30" };
 // O(n) hooray!
 function remove(arr, value) {
     const idx = arr.indexOf(value);

package/lib/ini.js

@@ -26,5 +26,5 @@ class IniFile extends object_file_1.ObjectFile {
 }
 exports.IniFile = IniFile;
 _a = JSII_RTTI_SYMBOL_1;
-IniFile[_a] = { fqn: "projen.IniFile", version: "0.72.28" };
+IniFile[_a] = { fqn: "projen.IniFile", version: "0.72.30" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2luaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDJCQUEyQjtBQUUzQiwrQ0FBOEQ7QUFROUQ7O0dBRUc7QUFDSCxNQUFhLE9BQVEsU0FBUSx3QkFBVTtJQUNyQyxZQUFZLE9BQWdCLEVBQUUsUUFBZ0IsRUFBRSxPQUF1QjtRQUNyRSxLQUFLLENBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRVMsaUJBQWlCLENBQUMsUUFBbUI7UUFDN0MsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQy9DLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDVCxPQUFPLFNBQVMsQ0FBQztTQUNsQjtRQUVELE9BQU87WUFDTCxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDNUMsRUFBRTtZQUNGLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNoQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNmLENBQUM7O0FBaEJILDBCQWlCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIElOSSBmcm9tIFwiaW5pXCI7XG5pbXBvcnQgeyBJUmVzb2x2ZXIgfSBmcm9tIFwiLi9maWxlXCI7XG5pbXBvcnQgeyBPYmplY3RGaWxlLCBPYmplY3RGaWxlT3B0aW9ucyB9IGZyb20gXCIuL29iamVjdC1maWxlXCI7XG5pbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSBcIi4vcHJvamVjdFwiO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIGBJbmlGaWxlYC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbmlGaWxlT3B0aW9ucyBleHRlbmRzIE9iamVjdEZpbGVPcHRpb25zIHt9XG5cbi8qKlxuICogUmVwcmVzZW50cyBhbiBJTkkgZmlsZS5cbiAqL1xuZXhwb3J0IGNsYXNzIEluaUZpbGUgZXh0ZW5kcyBPYmplY3RGaWxlIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCwgZmlsZVBhdGg6IHN0cmluZywgb3B0aW9uczogSW5pRmlsZU9wdGlvbnMpIHtcbiAgICBzdXBlcihwcm9qZWN0LCBmaWxlUGF0aCwgb3B0aW9ucyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgc3ludGhlc2l6ZUNvbnRlbnQocmVzb2x2ZXI6IElSZXNvbHZlcik6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgY29uc3QganNvbiA9IHN1cGVyLnN5bnRoZXNpemVDb250ZW50KHJlc29sdmVyKTtcbiAgICBpZiAoIWpzb24pIHtcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgcmV0dXJuIFtcbiAgICAgIC4uLih0aGlzLm1hcmtlciA/IFtgIyAke3RoaXMubWFya2VyfWBdIDogW10pLFxuICAgICAgXCJcIixcbiAgICAgIElOSS5zdHJpbmdpZnkoSlNPTi5wYXJzZShqc29uKSksXG4gICAgXS5qb2luKFwiXFxuXCIpO1xuICB9XG59XG4iXX0=