projen 0.58.10 → 0.58.13

package/lib/circleci/circleci.js

@@ -0,0 +1,118 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectContainingFieldExactly = exports.Circleci = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const util_1 = require("../util");
+const yaml_1 = require("../yaml");
+/**
+ * Circleci Class to manage `.circleci/config.yml`.
+ * Check projen's docs for more information.
+ *
+ * @see https://circleci.com/docs/2.0/configuration-reference/
+ */
+class Circleci extends component_1.Component {
+    constructor(project, options = {}) {
+        super(project);
+        /**
+         * reduce objects with `identifier` field for WorkflowJobs.
+         * A workflow job can contain `orbParameter` which are passed to orbs.
+         * This map is directly added as `Record<string,any>` to job.
+         * So we gonna add those after the default field of WorkflowJob.
+         * @see https://circleci.com/developer/orbs/orb/circleci/node#usage-install_nodejs
+         * @param jobs
+         */
+        this.renderJobs = (jobs = []) => {
+            let result = [];
+            for (const job of jobs ?? []) {
+                const { identifier, orbParameters, ...reduced } = job;
+                if (exports.isObjectContainingFieldExactly(job, "identifier")) {
+                    result = [...result, identifier];
+                }
+                else {
+                    result = [
+                        ...result,
+                        { [identifier]: { ...reduced, ...orbParameters } },
+                    ];
+                }
+            }
+            return result;
+        };
+        /**
+         * Snake case for listed keys. There are too many exceptions needed to do it recursive without a whitelist.
+         * This list needs to be updated once we add field with snake case like `aws_auth`.
+         * @param input
+         */
+        this.snakeCase = (input) => {
+            const snakeCaseKeyWords = [
+                "awsAuth",
+                "workingDirectory",
+                "resourceClass",
+                "dockerLayerCaching",
+                "noOutputTimeout",
+            ];
+            return util_1.snakeCaseKeys(input, true, snakeCaseKeyWords);
+        };
+        this.options = options;
+        this.orbs = options.orbs ?? {};
+        this.workflows = options.workflows ?? [];
+        this.jobs = options.jobs ?? [];
+        this.file = new yaml_1.YamlFile(project, ".circleci/config.yml", {
+            obj: () => this.renderCircleCi(),
+        });
+    }
+    /**
+     * function to prepare the rendering of the yaml file.
+     * Objects with dynamic keys like workflows and jobs required the field `identifier` to be set.
+     * Those object will be reduced by `identifier` field before rendering
+     * @private
+     */
+    renderCircleCi() {
+        // render dynamic keys for workflow
+        const workflowRecords = {};
+        for (const workflow of this.workflows) {
+            const { identifier, ...reduced } = workflow;
+            reduced.jobs = this.renderJobs(workflow.jobs);
+            workflowRecords[identifier] = this.snakeCase(reduced);
+        }
+        // render dynamic keys for jobs
+        const jobRecords = {};
+        for (const job of this.jobs) {
+            const { identifier, ...reduced } = job;
+            jobRecords[identifier] = this.snakeCase(reduced);
+        }
+        return {
+            version: this.options.version || 2.1,
+            setup: this.options.setup,
+            orbs: this.orbs,
+            jobs: Object.keys(jobRecords).length > 0 ? jobRecords : undefined,
+            workflows: workflowRecords,
+        };
+    }
+    /**
+     * add new workflow to existing pipeline
+     * @param workflow
+     */
+    addWorkflow(workflow) {
+        this.workflows = [...this.workflows, workflow];
+    }
+    /**
+     * Add a Circleci Orb to pipeline. Will throw error if the orb already exists
+     * @param name
+     * @param orb
+     */
+    addOrb(name, orb) {
+        if (this.orbs[name] !== undefined) {
+            throw new Error(`Circleci Config already contains an orb named ${name}.`);
+        }
+        this.orbs[name] = orb;
+    }
+}
+exports.Circleci = Circleci;
+_a = JSII_RTTI_SYMBOL_1;
+Circleci[_a] = { fqn: "projen.circleci.Circleci", version: "0.58.13" };
+exports.isObjectContainingFieldExactly = (obj, field) => {
+    return Object.keys(obj).length == 1 && Object.keys(obj).includes(field);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circleci.js","sourceRoot":"","sources":["../../src/circleci/circleci.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from \"../component\";\nimport { Project } from \"../project\";\nimport { snakeCaseKeys } from \"../util\";\nimport { YamlFile } from \"../yaml\";\nimport { WorkflowJob, Workflow, Job } from \"./model\";\n\n/**\n * Options for class {@link Circleci}\n *\n * @see https://circleci.com/docs/2.0/configuration-reference/\n */\nexport interface CircleCiProps {\n  /**\n   * Contains a map of CirclCi Orbs\n   * ```json\n   * orbs: {\n   *  node: \"circleci/node@5.0.1\"\n   *  slack: \"circleci/slack@4.8.3\"\n   * }\n   * ```\n   */\n  readonly orbs?: Record<string, string>;\n  /**\n   * pipeline version\n   *\n   * @default 2.1\n   * @see https://circleci.com/docs/2.0/configuration-reference/#version\n   */\n  readonly version?: number;\n  /**\n   * List of Workflows of pipeline, e.g.\n   * ```json\n   * workflows: {\n   *   {\n   *     identifier: \"build\",\n   *       jobs: [{\n   *          identifier: \"node/install\",\n   *          context: [\"npm\"],\n   *       }]\n   *   }\n   * }\n   * ```\n   *\n   * @see https://circleci.com/docs/2.0/configuration-reference/#workflows\n   */\n  readonly workflows?: Workflow[];\n  /**\n   * List of Jobs to create unique steps per pipeline, e.g.\n   * ```json\n   * jobs: [{\n   *  identifier: \"compile\",\n   *  docker: { image: \"golang:alpine\" }\n   *  steps: [\"checkout\", run: {command: \"go build .\"}]\n   * }]\n   * ```\n   *\n   * @see https://circleci.com/docs/2.0/configuration-reference/#jobs\n   */\n  readonly jobs?: Job[];\n  /**\n   * The setup field enables you to conditionally trigger configurations from outside\n   * the primary .circleci parent directory, update pipeline parameters, or generate customized configurations.\n   *\n   * @see https://circleci.com/docs/2.0/configuration-reference/#setup\n   */\n  readonly setup?: boolean;\n}\n\n/**\n * Circleci Class to manage `.circleci/config.yml`.\n * Check projen's docs for more information.\n *\n * @see https://circleci.com/docs/2.0/configuration-reference/\n */\nexport class Circleci extends Component {\n  /**\n   * The yaml file for the Circleci pipeline\n   * */\n  public readonly file: YamlFile;\n  /**\n   * internal copy of options to share options between functions\n   * @private\n   */\n  private options: CircleCiProps;\n  /**\n   * internal map of orbs\n   * @private\n   */\n  private readonly orbs: Record<string, string>;\n  /**\n   * internal list of workflows\n   * @private\n   */\n  private workflows: Workflow[];\n  /**\n   * internal list of jobs\n   * @private\n   */\n  private readonly jobs: Job[];\n\n  constructor(project: Project, options: CircleCiProps = {}) {\n    super(project);\n    this.options = options;\n    this.orbs = options.orbs ?? {};\n    this.workflows = options.workflows ?? [];\n    this.jobs = options.jobs ?? [];\n    this.file = new YamlFile(project, \".circleci/config.yml\", {\n      obj: () => this.renderCircleCi(),\n    });\n  }\n\n  /**\n   * function to prepare the rendering of the yaml file.\n   * Objects with dynamic keys like workflows and jobs required the field `identifier` to be set.\n   * Those object will be reduced by `identifier` field before rendering\n   * @private\n   */\n  private renderCircleCi() {\n    // render dynamic keys for workflow\n    const workflowRecords: Record<string, any> = {};\n    for (const workflow of this.workflows) {\n      const { identifier, ...reduced } = workflow;\n      reduced.jobs = this.renderJobs(workflow.jobs);\n      workflowRecords[identifier] = this.snakeCase(reduced);\n    }\n\n    // render dynamic keys for jobs\n    const jobRecords: Record<string, any> = {};\n    for (const job of this.jobs) {\n      const { identifier, ...reduced } = job;\n      jobRecords[identifier] = this.snakeCase(reduced);\n    }\n\n    return {\n      version: this.options.version || 2.1,\n      setup: this.options.setup,\n      orbs: this.orbs,\n      jobs: Object.keys(jobRecords).length > 0 ? jobRecords : undefined,\n      workflows: workflowRecords,\n    };\n  }\n\n  /**\n   * add new workflow to existing pipeline\n   * @param workflow\n   */\n  public addWorkflow(workflow: Workflow) {\n    this.workflows = [...this.workflows, workflow];\n  }\n\n  /**\n   * reduce objects with `identifier` field for WorkflowJobs.\n   * A workflow job can contain `orbParameter` which are passed to orbs.\n   * This map is directly added as `Record<string,any>` to job.\n   * So we gonna add those after the default field of WorkflowJob.\n   * @see https://circleci.com/developer/orbs/orb/circleci/node#usage-install_nodejs\n   * @param jobs\n   */\n  private renderJobs = (jobs: WorkflowJob[] = []): any => {\n    let result: any = [];\n    for (const job of jobs ?? []) {\n      const { identifier, orbParameters, ...reduced } = job;\n      if (isObjectContainingFieldExactly(job, \"identifier\")) {\n        result = [...result, identifier];\n      } else {\n        result = [\n          ...result,\n          { [identifier]: { ...reduced, ...orbParameters } },\n        ];\n      }\n    }\n    return result;\n  };\n\n  /**\n   * Add a Circleci Orb to pipeline. Will throw error if the orb already exists\n   * @param name\n   * @param orb\n   */\n  public addOrb(name: string, orb: string) {\n    if (this.orbs[name] !== undefined) {\n      throw new Error(`Circleci Config already contains an orb named ${name}.`);\n    }\n    this.orbs[name] = orb;\n  }\n\n  /**\n   * Snake case for listed keys. There are too many exceptions needed to do it recursive without a whitelist.\n   * This list needs to be updated once we add field with snake case like `aws_auth`.\n   * @param input\n   */\n  private snakeCase = (input: any): any => {\n    const snakeCaseKeyWords = [\n      \"awsAuth\",\n      \"workingDirectory\",\n      \"resourceClass\",\n      \"dockerLayerCaching\",\n      \"noOutputTimeout\",\n    ];\n    return snakeCaseKeys(input, true, snakeCaseKeyWords);\n  };\n}\n\nexport const isObjectContainingFieldExactly = (\n  obj: any,\n  field: string\n): boolean => {\n  return Object.keys(obj).length == 1 && Object.keys(obj).includes(field);\n};\n"]}

package/lib/circleci/constant.d.ts

@@ -0,0 +1,5 @@
+import { Filter } from "./model";
+/**
+ * constant to create a filter to make a job or workflow only run on master
+ */
+export declare const FilterMainBranchOnly: Filter;

package/lib/circleci/constant.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterMainBranchOnly = void 0;
+/**
+ * constant to create a filter to make a job or workflow only run on master
+ */
+exports.FilterMainBranchOnly = {
+    branches: { only: ["master", "main"] },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2lyY2xlY2kvY29uc3RhbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUE7O0dBRUc7QUFDVSxRQUFBLG9CQUFvQixHQUFXO0lBQzFDLFFBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsRUFBRTtDQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRmlsdGVyIH0gZnJvbSBcIi4vbW9kZWxcIjtcblxuLyoqXG4gKiBjb25zdGFudCB0byBjcmVhdGUgYSBmaWx0ZXIgdG8gbWFrZSBhIGpvYiBvciB3b3JrZmxvdyBvbmx5IHJ1biBvbiBtYXN0ZXJcbiAqL1xuZXhwb3J0IGNvbnN0IEZpbHRlck1haW5CcmFuY2hPbmx5OiBGaWx0ZXIgPSB7XG4gIGJyYW5jaGVzOiB7IG9ubHk6IFtcIm1hc3RlclwiLCBcIm1haW5cIl0gfSxcbn07XG4iXX0=

package/lib/circleci/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./circleci";
+export * from "./constant";
+export * from "./model";

package/lib/circleci/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./circleci"), exports);
+__exportStar(require("./constant"), exports);
+__exportStar(require("./model"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2lyY2xlY2kvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsNkNBQTJCO0FBQzNCLDZDQUEyQjtBQUMzQiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jaXJjbGVjaVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG4iXX0=

package/lib/circleci/model.d.ts

@@ -0,0 +1,240 @@
+/**
+ * Used to represent objects with a dynamic key.
+ * Dynamic are marked with `<>` in configuration reference like '<workflow_name>' and '<job_name>'
+ * This field is required for objects with dynamic keys.
+ */
+interface INamed {
+    /** name of dynamic key **/
+    readonly identifier: string;
+}
+/**
+ * Used for orchestrating all jobs. Each workflow consists of the workflow name as a key and a map as a value.
+ * A name should be unique within the current config.yml.
+ * The top-level keys for the Workflows configuration are version and jobs.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#workflows
+ */
+export interface Workflow extends INamed {
+    readonly jobs?: WorkflowJob[];
+    readonly triggers?: Triggers[];
+    /** when is too dynamic to be casted to interfaces. Check Docu as reference
+     * @see https://circleci.com/docs/2.0/configuration-reference/#logic-statement-examples
+     */
+    readonly when?: any;
+}
+/**
+ * A job may have a type of approval indicating it must be manually approved before downstream jobs may proceed
+ * @see https://circleci.com/docs/2.0/configuration-reference/#type
+ */
+export declare enum JobType {
+    APPROVAL = "approval"
+}
+/**
+ * The resource_class feature allows configuring CPU and RAM resources for each job.
+ * Different resource classes are available for different executors, as described in the tables below.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#resourceclass
+ */
+export declare enum ResourceClass {
+    SMALL = "small",
+    MEDIUM = "medium",
+    MEDIUM_PLUS = "medium+",
+    LARGE_X = "xlarge",
+    LARGE_2X = "2xlarge",
+    LARGE_2X_PLUS = "2xlarge+"
+}
+/**
+ * Specify when to enable or disable the step.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#steps
+ */
+export declare enum JobWhen {
+    ALWAYS = "always",
+    ON_SUCCESS = "on_success",
+    ON_FAIL = "on_fail"
+}
+/**
+ * A Workflow is comprised of one or more uniquely named jobs. Jobs are specified in the jobs map,
+ * see Sample 2.0 config.yml for two examples of a job map.
+ * The name of the job is the key in the map, and the value is a map describing the job.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#jobs
+ */
+export interface Job extends INamed {
+}
+/**
+ * A Job is part of Workflow. A Job can be created with {@link Job} or it can be provided by the orb
+ * @see https://circleci.com/docs/2.0/configuration-reference/#jobs-in-workflow
+ */
+export interface WorkflowJob extends INamed {
+    /** A list of jobs that must succeed for the job to start. */
+    readonly requires?: string[];
+    /** A replacement for the job name. Useful when calling a job multiple times */
+    readonly name?: string;
+    /** The name of the context(s). The initial default name is org-global. Each context name must be unique. */
+    readonly context?: string[];
+    /** A job may have a type of approval indicating it must be manually approved before downstream jobs may proceed. */
+    readonly type?: JobType;
+    /** Job Filters can have the key branches or tags */
+    readonly filter?: Filter;
+    readonly matrix?: Matrix;
+    /** Parameters for making a job explicitly configurable in a workflow. */
+    readonly parameters?: Record<string, string | number | boolean>;
+    /** Parameters passed to job when referencing a job from orb */
+    readonly orbParameters?: Record<string, string | number | boolean>;
+}
+/**
+ * The matrix stanza allows you to run a parameterized job multiple times with different arguments.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#matrix-requires-version-21
+ */
+export interface Matrix {
+    /** A map of parameter names to every value the job should be called with */
+    readonly parameters?: Record<string, string[] | number[]>;
+    /** An alias for the matrix, usable from another job’s requires stanza. Defaults to the name of the job being executed */
+    readonly alias?: string;
+}
+/**
+ * Specifies which triggers will cause this workflow to be executed.
+ * Default behavior is to trigger the workflow when pushing to a branch.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#triggers
+ */
+export interface Triggers {
+    readonly schedule?: Schedule;
+}
+/**
+ *  A workflow may have a schedule indicating it runs at a certain time.
+ *  @see https://circleci.com/docs/2.0/configuration-reference/#schedule
+ */
+export interface Schedule {
+    /** The cron key is defined using POSIX crontab syntax. */
+    readonly cron?: string;
+    readonly filters: Filter;
+}
+/**
+ * The branches key controls whether the current branch should have a schedule trigger created for it,
+ * where current branch is the branch containing the config.yml file with the trigger stanza.
+ * That is, a push on the main branch will only schedule a workflow for the main branch.
+ *
+ * Branches can have the keys only and ignore which either map to a single string naming a branch.
+ * You may also use regular expressions to match against branches by enclosing them with /’s, or map to a list of such strings.
+ * Regular expressions must match the entire string.
+ *
+ * Any branches that match only will run the job.
+ * Any branches that match ignore will not run the job.
+ * If neither only nor ignore are specified then all branches will run the job.
+ * If both only and ignore are specified the only is considered before ignore.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#filters
+ */
+export interface Filter {
+    readonly branches?: FilterConfig;
+    readonly tags?: FilterConfig;
+}
+/**
+ * set an inclusive or exclusive filter
+ * @see https://circleci.com/docs/2.0/configuration-reference/#filters
+ */
+export interface FilterConfig {
+    /** Either a single branch specifier, or a list of branch specifiers */
+    readonly only?: string[];
+    /** Either a single branch specifier, or a list of branch specifiers */
+    readonly ignore?: string[];
+}
+/**
+ * Each job consists of the job’s name as a key and a map as a value. A name should be case insensitive unique within a current jobs list.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#job_name
+ */
+export interface Job {
+    readonly docker?: Docker[];
+    readonly machine?: Machine;
+    readonly macos?: Macos;
+    /** Shell to use for execution command in all steps. Can be overridden by shell in each step */
+    readonly shell?: string;
+    /** Parameters for making a job explicitly configurable in a workflow. */
+    readonly parameters?: Record<string, string>;
+    /** no type support here, for syntax {@see https://circleci.com/docs/2.0/configuration-reference/#steps} */
+    readonly steps?: any[];
+    /** In which directory to run the steps. Will be interpreted as an absolute path. Default: `~/project` */
+    readonly workingDirectory?: string;
+    /** Number of parallel instances of this job to run (default: 1) */
+    readonly parallelism?: number;
+    /** A map of environment variable names and values. */
+    readonly environment?: Record<string, string | number | boolean>;
+    /** {@link ResourceClass} */
+    readonly resourceClass?: ResourceClass | string;
+}
+/**
+ * Options for docker executor
+ * @see https://circleci.com/docs/2.0/configuration-reference/#docker
+ */
+export interface Docker {
+    /** The name of a custom docker image to use */
+    readonly image: string;
+    /** The name the container is reachable by. By default, container services are accessible through localhost */
+    readonly name?: string;
+    /** The command used as executable when launching the container */
+    readonly entrypoint?: string[];
+    /** The command used as pid 1 (or args for entrypoint) when launching the container */
+    readonly command?: string[];
+    /** Which user to run commands as within the Docker container */
+    readonly user?: string;
+    /** A map of environment variable names and values */
+    readonly environment?: Record<string, string | number | boolean>;
+    /** Authentication for registries using standard docker login credentials */
+    readonly auth?: Record<string, string>;
+    /** Authentication for AWS Elastic Container Registry (ECR) */
+    readonly awsAuth?: Record<string, string>;
+}
+export interface Machine {
+    /**
+     * The VM image to use.
+     * @see https://circleci.com/docs/2.0/configuration-reference/#available-machine-images
+     */
+    readonly image: string;
+    /** enable docker layer caching
+     * @see https://circleci.com/docs/2.0/configuration-reference/#available-machine-images
+     */
+    readonly dockerLayerCaching?: string;
+}
+/**
+ * CircleCI supports running jobs on macOS, to allow you to build, test,
+ * and deploy apps for macOS, iOS, tvOS and watchOS. To run a job in a macOS virtual machine,
+ * you must add the macos key to the top-level configuration for the job and specify
+ * the version of Xcode you would like to use.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#macos
+ */
+export interface Macos {
+    /** The version of Xcode that is installed on the virtual machine */
+    readonly xcode: string;
+}
+/**
+ * Execution steps for Job
+ * @see https://circleci.com/docs/2.0/configuration-reference/#steps
+ */
+export interface StepRun {
+    readonly run?: Run;
+}
+/**
+ * Used for invoking all command-line programs, taking either a map of configuration values,
+ * or, when called in its short-form, a string that will be used as both the command and name.
+ * Run commands are executed using non-login shells by default,
+ * so you must explicitly source any dotfiles as part of the command.
+ *
+ * Not used because type incompatible types in steps array
+ *
+ * @see https://circleci.com/docs/2.0/configuration-reference/#run
+ */
+export interface Run {
+    /** Command to run via the shell */
+    readonly command: string;
+    /** Title of the step to be shown in the CircleCI UI (default: full command) */
+    readonly name?: string;
+    /** Shell to use for execution command */
+    readonly shell?: string;
+    /** Additional environmental variables, locally scoped to command */
+    readonly environment?: string;
+    /** Whether this step should run in the background (default: false) */
+    readonly background?: string;
+    /** In which directory to run this step. Will be interpreted relative to the working_directory of the job). (default: .) */
+    readonly workingDirectory?: string;
+    /** Elapsed time the command can run without output such as “20m”, “1.25h”, “5s”. The default is 10 minutes */
+    readonly noOutputTimeout?: string;
+    /** Specify when to enable or disable the step. */
+    readonly when?: JobWhen | string;
+}
+export {};

package/lib/circleci/model.js

@@ -0,0 +1,37 @@
+"use strict";
+// @see https://circleci.com/docs/2.0/configuration-reference
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobWhen = exports.ResourceClass = exports.JobType = void 0;
+/**
+ * A job may have a type of approval indicating it must be manually approved before downstream jobs may proceed
+ * @see https://circleci.com/docs/2.0/configuration-reference/#type
+ */
+var JobType;
+(function (JobType) {
+    JobType["APPROVAL"] = "approval";
+})(JobType = exports.JobType || (exports.JobType = {}));
+/**
+ * The resource_class feature allows configuring CPU and RAM resources for each job.
+ * Different resource classes are available for different executors, as described in the tables below.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#resourceclass
+ */
+var ResourceClass;
+(function (ResourceClass) {
+    ResourceClass["SMALL"] = "small";
+    ResourceClass["MEDIUM"] = "medium";
+    ResourceClass["MEDIUM_PLUS"] = "medium+";
+    ResourceClass["LARGE_X"] = "xlarge";
+    ResourceClass["LARGE_2X"] = "2xlarge";
+    ResourceClass["LARGE_2X_PLUS"] = "2xlarge+";
+})(ResourceClass = exports.ResourceClass || (exports.ResourceClass = {}));
+/**
+ * Specify when to enable or disable the step.
+ * @see https://circleci.com/docs/2.0/configuration-reference/#steps
+ */
+var JobWhen;
+(function (JobWhen) {
+    JobWhen["ALWAYS"] = "always";
+    JobWhen["ON_SUCCESS"] = "on_success";
+    JobWhen["ON_FAIL"] = "on_fail";
+})(JobWhen = exports.JobWhen || (exports.JobWhen = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/circleci/model.ts"],"names":[],"mappings":";AAAA,6DAA6D;;;AA2B7D;;;GAGG;AACH,IAAY,OAEX;AAFD,WAAY,OAAO;IACjB,gCAAqB,CAAA;AACvB,CAAC,EAFW,OAAO,GAAP,eAAO,KAAP,eAAO,QAElB;AAED;;;;GAIG;AACH,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,kCAAiB,CAAA;IACjB,wCAAuB,CAAA;IACvB,mCAAkB,CAAA;IAClB,qCAAoB,CAAA;IACpB,2CAA0B,CAAA;AAC5B,CAAC,EAPW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAOxB;AAED;;;GAGG;AACH,IAAY,OAIX;AAJD,WAAY,OAAO;IACjB,4BAAiB,CAAA;IACjB,oCAAyB,CAAA;IACzB,8BAAmB,CAAA;AACrB,CAAC,EAJW,OAAO,GAAP,eAAO,KAAP,eAAO,QAIlB","sourcesContent":["// @see https://circleci.com/docs/2.0/configuration-reference\n\n/**\n * Used to represent objects with a dynamic key.\n * Dynamic are marked with `<>` in configuration reference like '<workflow_name>' and '<job_name>'\n * This field is required for objects with dynamic keys.\n */\ninterface INamed {\n  /** name of dynamic key **/\n  readonly identifier: string;\n}\n\n/**\n * Used for orchestrating all jobs. Each workflow consists of the workflow name as a key and a map as a value.\n * A name should be unique within the current config.yml.\n * The top-level keys for the Workflows configuration are version and jobs.\n * @see https://circleci.com/docs/2.0/configuration-reference/#workflows\n */\nexport interface Workflow extends INamed {\n  readonly jobs?: WorkflowJob[];\n  readonly triggers?: Triggers[];\n  /** when is too dynamic to be casted to interfaces. Check Docu as reference\n   * @see https://circleci.com/docs/2.0/configuration-reference/#logic-statement-examples\n   */\n  readonly when?: any;\n}\n\n/**\n * A job may have a type of approval indicating it must be manually approved before downstream jobs may proceed\n * @see https://circleci.com/docs/2.0/configuration-reference/#type\n */\nexport enum JobType {\n  APPROVAL = \"approval\",\n}\n\n/**\n * The resource_class feature allows configuring CPU and RAM resources for each job.\n * Different resource classes are available for different executors, as described in the tables below.\n * @see https://circleci.com/docs/2.0/configuration-reference/#resourceclass\n */\nexport enum ResourceClass {\n  SMALL = \"small\",\n  MEDIUM = \"medium\",\n  MEDIUM_PLUS = \"medium+\",\n  LARGE_X = \"xlarge\",\n  LARGE_2X = \"2xlarge\",\n  LARGE_2X_PLUS = \"2xlarge+\",\n}\n\n/**\n * Specify when to enable or disable the step.\n * @see https://circleci.com/docs/2.0/configuration-reference/#steps\n */\nexport enum JobWhen {\n  ALWAYS = \"always\",\n  ON_SUCCESS = \"on_success\",\n  ON_FAIL = \"on_fail\",\n}\n\n/**\n * A Workflow is comprised of one or more uniquely named jobs. Jobs are specified in the jobs map,\n * see Sample 2.0 config.yml for two examples of a job map.\n * The name of the job is the key in the map, and the value is a map describing the job.\n * @see https://circleci.com/docs/2.0/configuration-reference/#jobs\n */\nexport interface Job extends INamed {}\n\n/**\n * A Job is part of Workflow. A Job can be created with {@link Job} or it can be provided by the orb\n * @see https://circleci.com/docs/2.0/configuration-reference/#jobs-in-workflow\n */\nexport interface WorkflowJob extends INamed {\n  /** A list of jobs that must succeed for the job to start. */\n  readonly requires?: string[];\n  /** A replacement for the job name. Useful when calling a job multiple times */\n  readonly name?: string;\n  /** The name of the context(s). The initial default name is org-global. Each context name must be unique. */\n  readonly context?: string[];\n  /** A job may have a type of approval indicating it must be manually approved before downstream jobs may proceed. */\n  readonly type?: JobType;\n  /** Job Filters can have the key branches or tags */\n  readonly filter?: Filter;\n  readonly matrix?: Matrix;\n  /** Parameters for making a job explicitly configurable in a workflow. */\n  readonly parameters?: Record<string, string | number | boolean>;\n  /** Parameters passed to job when referencing a job from orb */\n  readonly orbParameters?: Record<string, string | number | boolean>;\n}\n\n/**\n * The matrix stanza allows you to run a parameterized job multiple times with different arguments.\n * @see https://circleci.com/docs/2.0/configuration-reference/#matrix-requires-version-21\n */\nexport interface Matrix {\n  /** A map of parameter names to every value the job should be called with */\n  readonly parameters?: Record<string, string[] | number[]>;\n  /** An alias for the matrix, usable from another job’s requires stanza. Defaults to the name of the job being executed */\n  readonly alias?: string;\n}\n\n/**\n * Specifies which triggers will cause this workflow to be executed.\n * Default behavior is to trigger the workflow when pushing to a branch.\n * @see https://circleci.com/docs/2.0/configuration-reference/#triggers\n */\nexport interface Triggers {\n  readonly schedule?: Schedule;\n}\n\n/**\n *  A workflow may have a schedule indicating it runs at a certain time.\n *  @see https://circleci.com/docs/2.0/configuration-reference/#schedule\n */\nexport interface Schedule {\n  /** The cron key is defined using POSIX crontab syntax. */\n  readonly cron?: string;\n  readonly filters: Filter;\n}\n\n/**\n * The branches key controls whether the current branch should have a schedule trigger created for it,\n * where current branch is the branch containing the config.yml file with the trigger stanza.\n * That is, a push on the main branch will only schedule a workflow for the main branch.\n *\n * Branches can have the keys only and ignore which either map to a single string naming a branch.\n * You may also use regular expressions to match against branches by enclosing them with /’s, or map to a list of such strings.\n * Regular expressions must match the entire string.\n *\n * Any branches that match only will run the job.\n * Any branches that match ignore will not run the job.\n * If neither only nor ignore are specified then all branches will run the job.\n * If both only and ignore are specified the only is considered before ignore.\n * @see https://circleci.com/docs/2.0/configuration-reference/#filters\n */\nexport interface Filter {\n  readonly branches?: FilterConfig;\n  readonly tags?: FilterConfig;\n}\n\n/**\n * set an inclusive or exclusive filter\n * @see https://circleci.com/docs/2.0/configuration-reference/#filters\n */\nexport interface FilterConfig {\n  /** Either a single branch specifier, or a list of branch specifiers */\n  readonly only?: string[];\n  /** Either a single branch specifier, or a list of branch specifiers */\n  readonly ignore?: string[];\n}\n\n/**\n * Each job consists of the job’s name as a key and a map as a value. A name should be case insensitive unique within a current jobs list.\n * @see https://circleci.com/docs/2.0/configuration-reference/#job_name\n */\nexport interface Job {\n  readonly docker?: Docker[];\n  readonly machine?: Machine;\n  readonly macos?: Macos;\n  /** Shell to use for execution command in all steps. Can be overridden by shell in each step */\n  readonly shell?: string;\n  /** Parameters for making a job explicitly configurable in a workflow. */\n  readonly parameters?: Record<string, string>;\n  /** no type support here, for syntax {@see https://circleci.com/docs/2.0/configuration-reference/#steps} */\n  readonly steps?: any[];\n  /** In which directory to run the steps. Will be interpreted as an absolute path. Default: `~/project` */\n  readonly workingDirectory?: string;\n  /** Number of parallel instances of this job to run (default: 1) */\n  readonly parallelism?: number;\n  /** A map of environment variable names and values. */\n  readonly environment?: Record<string, string | number | boolean>;\n  /** {@link ResourceClass} */\n  readonly resourceClass?: ResourceClass | string;\n}\n\n/**\n * Options for docker executor\n * @see https://circleci.com/docs/2.0/configuration-reference/#docker\n */\nexport interface Docker {\n  /** The name of a custom docker image to use */\n  readonly image: string;\n  /** The name the container is reachable by. By default, container services are accessible through localhost */\n  readonly name?: string;\n  /** The command used as executable when launching the container */\n  readonly entrypoint?: string[];\n  /** The command used as pid 1 (or args for entrypoint) when launching the container */\n  readonly command?: string[];\n  /** Which user to run commands as within the Docker container */\n  readonly user?: string;\n  /** A map of environment variable names and values */\n  readonly environment?: Record<string, string | number | boolean>;\n  /** Authentication for registries using standard docker login credentials */\n  readonly auth?: Record<string, string>;\n  /** Authentication for AWS Elastic Container Registry (ECR) */\n  readonly awsAuth?: Record<string, string>;\n}\n\nexport interface Machine {\n  /**\n   * The VM image to use.\n   * @see https://circleci.com/docs/2.0/configuration-reference/#available-machine-images\n   */\n  readonly image: string;\n  /** enable docker layer caching\n   * @see https://circleci.com/docs/2.0/configuration-reference/#available-machine-images\n   */\n  readonly dockerLayerCaching?: string;\n}\n\n/**\n * CircleCI supports running jobs on macOS, to allow you to build, test,\n * and deploy apps for macOS, iOS, tvOS and watchOS. To run a job in a macOS virtual machine,\n * you must add the macos key to the top-level configuration for the job and specify\n * the version of Xcode you would like to use.\n * @see https://circleci.com/docs/2.0/configuration-reference/#macos\n */\nexport interface Macos {\n  /** The version of Xcode that is installed on the virtual machine */\n  readonly xcode: string;\n}\n\n/**\n * Execution steps for Job\n * @see https://circleci.com/docs/2.0/configuration-reference/#steps\n */\nexport interface StepRun {\n  readonly run?: Run;\n}\n\n/**\n * Used for invoking all command-line programs, taking either a map of configuration values,\n * or, when called in its short-form, a string that will be used as both the command and name.\n * Run commands are executed using non-login shells by default,\n * so you must explicitly source any dotfiles as part of the command.\n *\n * Not used because type incompatible types in steps array\n *\n * @see https://circleci.com/docs/2.0/configuration-reference/#run\n */\nexport interface Run {\n  /** Command to run via the shell */\n  readonly command: string;\n  /** Title of the step to be shown in the CircleCI UI (default: full command) */\n  readonly name?: string;\n  /** Shell to use for execution command */\n  readonly shell?: string;\n  /** Additional environmental variables, locally scoped to command */\n  readonly environment?: string;\n  /** Whether this step should run in the background (default: false) */\n  readonly background?: string;\n  /** In which directory to run this step. Will be interpreted relative to the working_directory of the job). (default: .) */\n  readonly workingDirectory?: string;\n  /** Elapsed time the command can run without output such as “20m”, “1.25h”, “5s”. The default is 10 minutes */\n  readonly noOutputTimeout?: string;\n  /** Specify when to enable or disable the step. */\n  readonly when?: JobWhen | string;\n}\n"]}

package/lib/component.js

@@ -26,5 +26,5 @@ class Component {
 }
 exports.Component = Component;
 _a = JSII_RTTI_SYMBOL_1;
-Component[_a] = { fqn: "projen.Component", version: "0.58.10" };
+Component[_a] = { fqn: "projen.Component", version: "0.58.13" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBOztHQUVHO0FBQ0gsTUFBYSxTQUFTO0lBQ3BCLFlBQTRCLE9BQWdCO1FBQWhCLFlBQU8sR0FBUCxPQUFPLENBQVM7UUFDMUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxhQUFhLEtBQUksQ0FBQztJQUV6Qjs7T0FFRztJQUNJLFVBQVUsS0FBSSxDQUFDO0lBRXRCOztPQUVHO0lBQ0ksY0FBYyxLQUFJLENBQUM7O0FBbEI1Qiw4QkFtQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSBcIi4vcHJvamVjdFwiO1xuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBwcm9qZWN0IGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGNsYXNzIENvbXBvbmVudCB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyByZWFkb25seSBwcm9qZWN0OiBQcm9qZWN0KSB7XG4gICAgcHJvamVjdC5fYWRkQ29tcG9uZW50KHRoaXMpO1xuICB9XG5cbiAgLyoqXG4gICAqIENhbGxlZCBiZWZvcmUgc3ludGhlc2lzLlxuICAgKi9cbiAgcHVibGljIHByZVN5bnRoZXNpemUoKSB7fVxuXG4gIC8qKlxuICAgKiBTeW50aGVzaXplcyBmaWxlcyB0byB0aGUgcHJvamVjdCBvdXRwdXQgZGlyZWN0b3J5LlxuICAgKi9cbiAgcHVibGljIHN5bnRoZXNpemUoKSB7fVxuXG4gIC8qKlxuICAgKiBDYWxsZWQgYWZ0ZXIgc3ludGhlc2lzLiBPcmRlciBpcyAqbm90KiBndWFyYW50ZWVkLlxuICAgKi9cbiAgcHVibGljIHBvc3RTeW50aGVzaXplKCkge31cbn1cbiJdfQ==

package/lib/dependencies.js

@@ -169,7 +169,7 @@ class Dependencies extends component_1.Component {
 }
 exports.Dependencies = Dependencies;
 _a = JSII_RTTI_SYMBOL_1;
-Dependencies[_a] = { fqn: "projen.Dependencies", version: "0.58.10" };
+Dependencies[_a] = { fqn: "projen.Dependencies", version: "0.58.13" };
 /**
  * The project-relative path of the deps manifest file.
  */

package/lib/dev-env.js

@@ -27,5 +27,5 @@ class DevEnvironmentDockerImage {
 }
 exports.DevEnvironmentDockerImage = DevEnvironmentDockerImage;
 _a = JSII_RTTI_SYMBOL_1;
-DevEnvironmentDockerImage[_a] = { fqn: "projen.DevEnvironmentDockerImage", version: "0.58.10" };
+DevEnvironmentDockerImage[_a] = { fqn: "projen.DevEnvironmentDockerImage", version: "0.58.13" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/docker-compose.js

@@ -111,7 +111,7 @@ class DockerCompose extends component_1.Component {
 }
 exports.DockerCompose = DockerCompose;
 _a = JSII_RTTI_SYMBOL_1;
-DockerCompose[_a] = { fqn: "projen.DockerCompose", version: "0.58.10" };
+DockerCompose[_a] = { fqn: "projen.DockerCompose", version: "0.58.13" };
 /**
  * A docker-compose service.
  */
@@ -164,7 +164,7 @@ class DockerComposeService {
 }
 exports.DockerComposeService = DockerComposeService;
 _b = JSII_RTTI_SYMBOL_1;
-DockerComposeService[_b] = { fqn: "projen.DockerComposeService", version: "0.58.10" };
+DockerComposeService[_b] = { fqn: "projen.DockerComposeService", version: "0.58.13" };
 /**
  * Network protocol for port mapping
  */

package/lib/file.js

@@ -103,5 +103,5 @@ class FileBase extends component_1.Component {
 }
 exports.FileBase = FileBase;
 _a = JSII_RTTI_SYMBOL_1;
-FileBase[_a] = { fqn: "projen.FileBase", version: "0.58.10" };
+FileBase[_a] = { fqn: "projen.FileBase", version: "0.58.13" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.js","sourceRoot":"","sources":["../src/file.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"path\";\nimport { removeSync } from \"fs-extra\";\nimport { resolve } from \"./_resolve\";\nimport { PROJEN_MARKER, PROJEN_RC } from \"./common\";\nimport { Component } from \"./component\";\nimport { Project } from \"./project\";\nimport { isExecutable, isWritable, tryReadFileSync, writeFile } from \"./util\";\n\nexport interface FileBaseOptions {\n  /**\n   * Indicates whether this file should be committed to git or ignored. By\n   * default, all generated files are committed and anti-tamper is used to\n   * protect against manual modifications.\n   *\n   * @default true\n   */\n  readonly committed?: boolean;\n\n  /**\n   * Update the project's .gitignore file\n   * @default true\n   */\n  readonly editGitignore?: boolean;\n\n  /**\n   * Whether the generated file should be readonly.\n   *\n   * @default true\n   */\n  readonly readonly?: boolean;\n\n  /**\n   * Whether the generated file should be marked as executable.\n   *\n   * @default false\n   */\n  readonly executable?: boolean;\n\n  /**\n   * Adds the projen marker to the file.\n   *\n   * @default - marker will be included as long as the project is not ejected\n   */\n  readonly marker?: boolean;\n}\n\nexport abstract class FileBase extends Component {\n  /**\n   * The file path, relative to the project root.\n   */\n  public readonly path: string;\n\n  /**\n   * Indicates if the file should be read-only or read-write.\n   */\n  public readonly: boolean;\n\n  /**\n   * Indicates if the file should be marked as executable\n   */\n  public executable: boolean;\n\n  /**\n   * The projen marker, used to identify files as projen-generated.\n   *\n   * Value is undefined if the project is being ejected.\n   */\n  public readonly marker: string | undefined;\n\n  /**\n   * The absolute path of this file.\n   */\n  public readonly absolutePath: string;\n\n  private _changed?: boolean;\n\n  constructor(\n    project: Project,\n    filePath: string,\n    options: FileBaseOptions = {}\n  ) {\n    super(project);\n\n    this.readonly = !project.ejected && (options.readonly ?? true);\n    this.executable = options.executable ?? false;\n    this.path = filePath;\n\n    // `marker` is empty if project is being ejected or if explicitly disabled\n    this.marker =\n      project.ejected || options.marker === false\n        ? undefined\n        : `${PROJEN_MARKER}. To modify, edit ${PROJEN_RC} and run \"npx projen\".`;\n\n    const globPattern = `/${this.path}`;\n    const committed = options.committed ?? true;\n    if (committed && filePath !== \".gitattributes\") {\n      project.root.annotateGenerated(`/${filePath}`);\n    }\n\n    this.absolutePath = path.resolve(project.outdir, filePath);\n\n    // verify file path is unique within project tree\n    const existing = project.root.tryFindFile(this.absolutePath);\n    if (existing && existing !== this) {\n      throw new Error(\n        `there is already a file under ${path.relative(\n          project.root.outdir,\n          this.absolutePath\n        )}`\n      );\n    }\n\n    const editGitignore = options.editGitignore ?? true;\n    if (editGitignore) {\n      this.project.addGitIgnore(`${committed ? \"!\" : \"\"}${globPattern}`);\n    } else {\n      if (options.committed != null) {\n        throw new Error(\n          '\"gitignore\" is disabled, so it does not make sense to specify \"committed\"'\n        );\n      }\n    }\n  }\n\n  /**\n   * Implemented by derived classes and returns the contents of the file to\n   * emit.\n   * @param resolver Call `resolver.resolve(obj)` on any objects in order to\n   * resolve token functions.\n   * @returns the content to synthesize or undefined to skip the file\n   */\n  protected abstract synthesizeContent(resolver: IResolver): string | undefined;\n\n  /**\n   * Writes the file to the project's output directory\n   */\n  public synthesize() {\n    const outdir = this.project.outdir;\n    const filePath = path.join(outdir, this.path);\n    const resolver: IResolver = {\n      resolve: (obj, options) => resolve(obj, options),\n    };\n    const content = this.synthesizeContent(resolver);\n    if (content === undefined) {\n      // remove file (if exists) and skip rest of synthesis\n      removeSync(filePath);\n      return;\n    }\n\n    // check if the file was changed.\n    const prev = tryReadFileSync(filePath);\n    const prevReadonly = !isWritable(filePath);\n    const prevExecutable = isExecutable(filePath);\n    if (\n      prev !== undefined &&\n      content === prev &&\n      prevReadonly === this.readonly &&\n      prevExecutable === this.executable\n    ) {\n      this.project.logger.debug(`no change in ${filePath}`);\n      this._changed = false;\n      return;\n    }\n\n    writeFile(filePath, content, {\n      readonly: this.readonly,\n      executable: this.executable,\n    });\n\n    this.checkForProjenMarker();\n\n    this._changed = true;\n  }\n\n  /**\n   * For debugging, check whether a file was incorrectly generated with\n   * or without the projen marker. The projen marker does not *need* to be\n   * included on projen-generated files, but it's recommended since it signals\n   * that it probably should not be edited directly.\n   */\n  private checkForProjenMarker() {\n    const filePath = path.join(this.project.outdir, this.path);\n    const contents = tryReadFileSync(filePath);\n    const containsMarker = contents?.includes(PROJEN_MARKER);\n    if (this.marker && !containsMarker) {\n      this.project.logger.debug(\n        `note: expected ${this.path} to contain marker but found none.`\n      );\n    } else if (!this.marker && containsMarker) {\n      this.project.logger.debug(\n        `note: expected ${this.path} to not contain marker but found one anyway.`\n      );\n    }\n  }\n\n  /**\n   * Indicates if the file has been changed during synthesis. This property is\n   * only available in `postSynthesize()` hooks. If this is `undefined`, the\n   * file has not been synthesized yet.\n   */\n  public get changed(): boolean | undefined {\n    return this._changed;\n  }\n}\n\n/**\n * API for resolving tokens when synthesizing file content.\n */\nexport interface IResolver {\n  /**\n   * Given a value (object/string/array/whatever, looks up any functions inside\n   * the object and returns an object where all functions are called.\n   * @param value The value to resolve\n   * @package options Resolve options\n   */\n  resolve(value: any, options?: ResolveOptions): any;\n}\n\n/**\n * Resolve options.\n */\nexport interface ResolveOptions {\n  /**\n   * Omits empty arrays and objects.\n   * @default false\n   */\n  readonly omitEmpty?: boolean;\n\n  /**\n   * Context arguments.\n   * @default []\n   */\n  readonly args?: any[];\n}\n\nexport interface IResolvable {\n  /**\n   * Resolves and returns content.\n   */\n  toJSON(): any;\n}\n"]}

package/lib/gitattributes.js

@@ -45,5 +45,5 @@ class GitAttributesFile extends file_1.FileBase {
 }
 exports.GitAttributesFile = GitAttributesFile;
 _a = JSII_RTTI_SYMBOL_1;
-GitAttributesFile[_a] = { fqn: "projen.GitAttributesFile", version: "0.58.10" };
+GitAttributesFile[_a] = { fqn: "projen.GitAttributesFile", version: "0.58.13" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/github/auto-approve.js

@@ -64,5 +64,5 @@ class AutoApprove extends component_1.Component {
 }
 exports.AutoApprove = AutoApprove;
 _a = JSII_RTTI_SYMBOL_1;
-AutoApprove[_a] = { fqn: "projen.github.AutoApprove", version: "0.58.10" };
+AutoApprove[_a] = { fqn: "projen.github.AutoApprove", version: "0.58.13" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1hcHByb3ZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dpdGh1Yi9hdXRvLWFwcHJvdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw0Q0FBeUM7QUFFekMsdURBQXVEO0FBeUN2RDs7R0FFRztBQUNILE1BQWEsV0FBWSxTQUFRLHFCQUFTO0lBR3hDLFlBQVksTUFBYyxFQUFFLFVBQThCLEVBQUU7UUFDMUQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUV0QixJQUFJLENBQUMsS0FBSyxHQUFHLE9BQU8sQ0FBQyxLQUFLLElBQUksY0FBYyxDQUFDO1FBQzdDLE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsSUFBSSxDQUFDLHFCQUFxQixDQUFDLENBQUM7UUFFdEUsSUFBSSxTQUFTLEdBQUcsc0RBQXNELElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQztRQUNyRixJQUFJLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO1lBQ3hCLFNBQVMsSUFBSSxPQUFPLENBQUM7WUFDckIsU0FBUyxJQUFJLFNBQVM7aUJBQ25CLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsNENBQTRDLENBQUMsR0FBRyxDQUFDO2lCQUM1RCxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDaEIsU0FBUyxJQUFJLEdBQUcsQ0FBQztTQUNsQjtRQUVELE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLElBQUksY0FBYyxDQUFDO1FBRWhELE1BQU0sVUFBVSxHQUFRO1lBQ3RCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDO1lBQzNDLFdBQVcsRUFBRTtnQkFDWCxZQUFZLEVBQUUsK0JBQWEsQ0FBQyxLQUFLO2FBQ2xDO1lBQ0QsRUFBRSxFQUFFLFNBQVM7WUFDYixLQUFLLEVBQUU7Z0JBQ0w7b0JBQ0UsSUFBSSxFQUFFLGtDQUFrQztvQkFDeEMsSUFBSSxFQUFFO3dCQUNKLGNBQWMsRUFBRSxnQkFBZ0IsTUFBTSxLQUFLO3FCQUM1QztpQkFDRjthQUNGO1NBQ0YsQ0FBQztRQUVGLE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDcEQsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUNWLDhFQUE4RTtZQUM5RSxpRkFBaUY7WUFDakYsaUZBQWlGO1lBQ2pGLG1GQUFtRjtZQUNuRixtRkFBbUY7WUFDbkYsd0NBQXdDO1lBQ3hDLEVBQUU7WUFDRixrRkFBa0Y7WUFDbEYsd0ZBQXdGO1lBQ3hGLGdGQUFnRjtZQUNoRixpQkFBaUIsRUFBRTtnQkFDakIsS0FBSyxFQUFFO29CQUNMLFNBQVM7b0JBQ1QsUUFBUTtvQkFDUixhQUFhO29CQUNiLFVBQVU7b0JBQ1Ysa0JBQWtCO2lCQUNuQjthQUNGO1NBQ0YsQ0FBQyxDQUFDO1FBQ0gsUUFBUSxDQUFDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzVDLENBQUM7O0FBM0RILGtDQTREQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gXCIuLi9jb21wb25lbnRcIjtcbmltcG9ydCB7IEdpdEh1YiB9IGZyb20gXCIuL2dpdGh1YlwiO1xuaW1wb3J0IHsgSm9iLCBKb2JQZXJtaXNzaW9uIH0gZnJvbSBcIi4vd29ya2Zsb3dzLW1vZGVsXCI7XG5cbi8qKlxuICogT3B0aW9ucyBmb3IgJ0F1dG9BcHByb3ZlJ1xuICovXG5leHBvcnQgaW50ZXJmYWNlIEF1dG9BcHByb3ZlT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBPbmx5IHB1bGwgcmVxdWVzdHMgYXV0aG9yZWQgYnkgdGhlc2UgR2l0aHViIHVzZXJuYW1lcyB3aWxsIGJlIGF1dG8tYXBwcm92ZWQuXG4gICAqIEBkZWZhdWx0IFsnZ2l0aHViLWJvdCddXG4gICAqL1xuICByZWFkb25seSBhbGxvd2VkVXNlcm5hbWVzPzogc3RyaW5nW107XG5cbiAgLyoqXG4gICAqIE9ubHkgcHVsbCByZXF1ZXN0cyB3aXRoIHRoaXMgbGFiZWwgd2lsbCBiZSBhdXRvLWFwcHJvdmVkLlxuICAgKiBAZGVmYXVsdCAnYXV0by1hcHByb3ZlJ1xuICAgKi9cbiAgcmVhZG9ubHkgbGFiZWw/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIEEgR2l0SHViIHNlY3JldCBuYW1lIHdoaWNoIGNvbnRhaW5zIGEgR2l0SHViIEFjY2VzcyBUb2tlblxuICAgKiB3aXRoIHdyaXRlIHBlcm1pc3Npb25zIGZvciB0aGUgYHB1bGxfcmVxdWVzdGAgc2NvcGUuXG4gICAqXG4gICAqIFRoaXMgdG9rZW4gaXMgdXNlZCB0byBhcHByb3ZlIHB1bGwgcmVxdWVzdHMuXG4gICAqXG4gICAqIEdpdGh1YiBmb3JiaWRzIGFuIGlkZW50aXR5IHRvIGFwcHJvdmUgaXRzIG93biBwdWxsIHJlcXVlc3QuXG4gICAqIElmIHlvdXIgcHJvamVjdCBwcm9kdWNlcyBhdXRvbWF0ZWQgcHVsbCByZXF1ZXN0cyB1c2luZyB0aGUgR2l0aHViIGRlZmF1bHQgdG9rZW4gLVxuICAgKiB7QGxpbmsgaHR0cHM6Ly9kb2NzLmdpdGh1Yi5jb20vZW4vYWN0aW9ucy9yZWZlcmVuY2UvYXV0aGVudGljYXRpb24taW4tYS13b3JrZmxvdyBgR0lUSFVCX1RPS0VOYCB9XG4gICAqIC0gdGhhdCB5b3Ugd291bGQgbGlrZSBhdXRvIGFwcHJvdmVkLCBzdWNoIGFzIHdoZW4gdXNpbmcgdGhlIGBkZXBzVXBncmFkZWAgcHJvcGVydHkgaW5cbiAgICogYE5vZGVQcm9qZWN0T3B0aW9uc2AsIHRoZW4geW91IG11c3QgdXNlIGEgZGlmZmVyZW50IHRva2VuIGhlcmUuXG4gICAqXG4gICAqIEBkZWZhdWx0IFwiR0lUSFVCX1RPS0VOXCJcbiAgICovXG4gIHJlYWRvbmx5IHNlY3JldD86IHN0cmluZztcblxuICAvKipcbiAgICogR2l0aHViIFJ1bm5lciBzZWxlY3Rpb24gbGFiZWxzXG4gICAqIEBkZWZhdWx0IFtcInVidW50dS1sYXRlc3RcIl1cbiAgICovXG4gIHJlYWRvbmx5IHJ1bnNPbj86IHN0cmluZ1tdO1xufVxuXG4vKipcbiAqIEF1dG8gYXBwcm92ZSBwdWxsIHJlcXVlc3RzIHRoYXQgbWVldCBhIGNyaXRlcmlhXG4gKi9cbmV4cG9ydCBjbGFzcyBBdXRvQXBwcm92ZSBleHRlbmRzIENvbXBvbmVudCB7XG4gIHB1YmxpYyByZWFkb25seSBsYWJlbDogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKGdpdGh1YjogR2l0SHViLCBvcHRpb25zOiBBdXRvQXBwcm92ZU9wdGlvbnMgPSB7fSkge1xuICAgIHN1cGVyKGdpdGh1Yi5wcm9qZWN0KTtcblxuICAgIHRoaXMubGFiZWwgPSBvcHRpb25zLmxhYmVsID8/IFwiYXV0by1hcHByb3ZlXCI7XG4gICAgY29uc3QgdXNlcm5hbWVzID0gb3B0aW9ucy5hbGxvd2VkVXNlcm5hbWVzID8/IFtcImdpdGh1Yi1hY3Rpb25zW2JvdF1cIl07XG5cbiAgICBsZXQgY29uZGl0aW9uID0gYGNvbnRhaW5zKGdpdGh1Yi5ldmVudC5wdWxsX3JlcXVlc3QubGFiZWxzLioubmFtZSwgJyR7dGhpcy5sYWJlbH0nKWA7XG4gICAgaWYgKHVzZXJuYW1lcy5sZW5ndGggPiAwKSB7XG4gICAgICBjb25kaXRpb24gKz0gXCIgJiYgKFwiO1xuICAgICAgY29uZGl0aW9uICs9IHVzZXJuYW1lc1xuICAgICAgICAubWFwKCh1KSA9PiBgZ2l0aHViLmV2ZW50LnB1bGxfcmVxdWVzdC51c2VyLmxvZ2luID09ICcke3V9J2ApXG4gICAgICAgIC5qb2luKFwiIHx8IFwiKTtcbiAgICAgIGNvbmRpdGlvbiArPSBcIilcIjtcbiAgICB9XG5cbiAgICBjb25zdCBzZWNyZXQgPSBvcHRpb25zLnNlY3JldCA/PyBcIkdJVEhVQl9UT0tFTlwiO1xuXG4gICAgY29uc3QgYXBwcm92ZUpvYjogSm9iID0ge1xuICAgICAgcnVuc09uOiBvcHRpb25zLnJ1bnNPbiA/PyBbXCJ1YnVudHUtbGF0ZXN0XCJdLFxuICAgICAgcGVybWlzc2lvbnM6IHtcbiAgICAgICAgcHVsbFJlcXVlc3RzOiBKb2JQZXJtaXNzaW9uLldSSVRFLFxuICAgICAgfSxcbiAgICAgIGlmOiBjb25kaXRpb24sXG4gICAgICBzdGVwczogW1xuICAgICAgICB7XG4gICAgICAgICAgdXNlczogXCJobWFyci9hdXRvLWFwcHJvdmUtYWN0aW9uQHYyLjIuMVwiLFxuICAgICAgICAgIHdpdGg6IHtcbiAgICAgICAgICAgIFwiZ2l0aHViLXRva2VuXCI6IGBcXCR7eyBzZWNyZXRzLiR7c2VjcmV0fSB9fWAsXG4gICAgICAgICAgfSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgfTtcblxuICAgIGNvbnN0IHdvcmtmbG93ID0gZ2l0aHViLmFkZFdvcmtmbG93KFwiYXV0by1hcHByb3ZlXCIpO1xuICAgIHdvcmtmbG93Lm9uKHtcbiAgICAgIC8vIFRoZSAncHVsbCByZXF1ZXN0JyBldmVudCBnaXZlcyB0aGUgd29ya2Zsb3cgJ3JlYWQtb25seScgcGVybWlzc2lvbnMgb24gc29tZVxuICAgICAgLy8gcHVsbCByZXF1ZXN0cyAoc3VjaCBhcyB0aGUgb25lcyBmcm9tIGRlcGVuZGFib3QpIHdoZW4gdXNpbmcgdGhlIGBHSVRIVUJfVE9LRU5gXG4gICAgICAvLyBzZWN1cml0eSB0b2tlbi4gVGhpcyBwcmV2ZW50cyB0aGUgd29ya2Zsb3cgZnJvbSBhcHByb3ZpbmcgdGhlc2UgcHVsbCByZXF1ZXN0cy5cbiAgICAgIC8vIEdpdGh1YiBoYXMgcGxhY2VkIHRoaXMgZ3VhcmQgc28gYXMgdG8gcHJldmVudCBzZWN1cml0eSBhdHRhY2tzIGJ5IHNpbXBseSBvcGVuaW5nXG4gICAgICAvLyBhIHB1bGwgcmVxdWVzdCBhbmQgdHJpZ2dlcmluZyBhIHdvcmtmbG93IG9uIGEgY29tbWl0IHRoYXQgd2FzIG5vdCB2ZXR0ZWQgdG8gbWFrZVxuICAgICAgLy8gdW5pbnRlbmRlZCBjaGFuZ2VzIHRvIHRoZSByZXBvc2l0b3J5LlxuICAgICAgLy9cbiAgICAgIC8vIEluc3RlYWQgdXNlIHRoZSAncHVsbCByZXF1ZXN0IHRhcmdldCcgZXZlbnQgaGVyZSB0aGF0IGdpdmVzIHRoZSBHaXRodWIgd29ya2Zsb3dcbiAgICAgIC8vICdyZWFkLXdyaXRlJyBwZXJtaXNzaW9ucy4gVGhpcyBpcyBzYWZlIGJlY2F1c2UsIHRoaXMgZXZlbnQsIHVubGlrZSB0aGUgJ3B1bGwgcmVxdWVzdCdcbiAgICAgIC8vIGV2ZW50IHJlZmVyZW5jZXMgdGhlIEJBU0UgY29tbWl0IG9mIHRoZSBwdWxsIHJlcXVlc3QgYW5kIG5vdCB0aGUgSEVBRCBjb21taXQuXG4gICAgICBwdWxsUmVxdWVzdFRhcmdldDoge1xuICAgICAgICB0eXBlczogW1xuICAgICAgICAgIFwibGFiZWxlZFwiLFxuICAgICAgICAgIFwib3BlbmVkXCIsXG4gICAgICAgICAgXCJzeW5jaHJvbml6ZVwiLFxuICAgICAgICAgIFwicmVvcGVuZWRcIixcbiAgICAgICAgICBcInJlYWR5X2Zvcl9yZXZpZXdcIixcbiAgICAgICAgXSxcbiAgICAgIH0sXG4gICAgfSk7XG4gICAgd29ya2Zsb3cuYWRkSm9icyh7IGFwcHJvdmU6IGFwcHJvdmVKb2IgfSk7XG4gIH1cbn1cbiJdfQ==