projen 0.98.3 → 0.98.5

package/lib/ai-instructions.d.ts

@@ -0,0 +1,147 @@
+import { Component } from "./component";
+import { FileBase, IResolver } from "./file";
+import { Project } from "./project";
+/**
+ * Supported AI coding assistants and their instruction file locations.
+ */
+export declare enum AiAgent {
+    /**
+     * GitHub Copilot - .github/copilot-instructions.md
+     */
+    GITHUB_COPILOT = "GitHub Copilot",
+    /**
+     * Cursor IDE - .cursor/rules/project.md
+     */
+    CURSOR = "Cursor",
+    /**
+     * Claude Code - CLAUDE.md
+     */
+    CLAUDE = "Claude",
+    /**
+     * Amazon Q - .amazonq/rules/project.md
+     */
+    AMAZON_Q = "Amazon Q",
+    /**
+     * Kiro - .kiro/steering/project.md
+     */
+    KIRO = "Kiro"
+}
+/**
+ * Options for configuring AI tool instruction files.
+ */
+export interface AiInstructionsOptions {
+    /**
+     * Which AI agents to generate instruction files for.
+     *
+     * @default - All agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR, AiAgent.CLAUDE, AiAgent.AMAZON_Q]
+     */
+    readonly agents?: AiAgent[];
+    /**
+     * General instructions applicable to all agents.
+     *
+     * @default - no agent specific instructions
+     */
+    readonly instructions?: string[];
+    /**
+     * Per-agent custom instructions. Allows different instructions for different AI tools.
+     *
+     * @default - no agent specific instructions
+     * @example
+     * {
+     *   [AiAgent.GITHUB_COPILOT]: {
+     *     instructions: ["Use descriptive commit messages."]
+     *   },
+     *   [AiAgent.CURSOR]: {
+     *     instructions: ["Prefer functional patterns.", "Always add tests."]
+     *   }
+     * }
+     */
+    readonly agentSpecificInstructions?: Record<string, string[]>;
+    /**
+     * Include default instructions for projen and general best practices.
+     *
+     * Default instructions will only be included for agents provided in the `agents` option.
+     * If `agents` is not provided, default instructions will be included for all agents.
+     *
+     * @default true
+     */
+    readonly includeDefaultInstructions?: boolean;
+}
+/**
+ * Generates instruction files for AI coding assistants with projen-specific guidance.
+ *
+ * This component creates configuration files that help AI tools like GitHub Copilot,
+ * Cursor IDE, Claude Code, and Amazon Q understand that the project is managed by projen
+ * and should follow projen conventions.
+ *
+ * @example
+ * const project = new TypeScriptProject({
+ *   name: "my-project",
+ *   defaultReleaseBranch: "main",
+ * });
+ *
+ * // Basic usage - generates files for all supported AI agents
+ * new AiInstructions(project);
+ *
+ * // Custom usage - specify which agents and add custom instructions
+ * new AiInstructions(project, {
+ *   agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR],
+ *   agentSpecificInstructions: {
+ *     [AiAgent.GITHUB_COPILOT]: ["Always use descriptive commit messages."],
+ *   },
+ * });
+ *
+ * // Add more instructions after instantiation
+ * const ai = new AiInstructions(project);
+ * ai.addInstructions("Use functional programming patterns.");
+ * ai.addInstructions("Always write comprehensive tests.");
+ */
+export declare class AiInstructions extends Component {
+    /**
+     * Returns projen-specific instructions for AI agents.
+     */
+    static projen(project: Project): string;
+    /**
+     * Returns development best practices instructions for AI agents.
+     */
+    static bestPractices(project: Project): string;
+    private readonly agents;
+    private readonly files;
+    constructor(project: Project, options?: AiInstructionsOptions);
+    /**
+     * Create or return the instructions file.
+     */
+    private ensureInstructionsFile;
+    /**
+     * Adds instructions that will be included for all selected AI agents.
+     *
+     * @param instructions The instructions to add.
+     * @example
+     * aiInstructions.addInstructions("Always use TypeScript strict mode.");
+     * aiInstructions.addInstructions("Prefer functional programming.", "Avoid mutations.");
+     */
+    addInstructions(...instructions: string[]): void;
+    /**
+     * Add instructions for a specific AI agent.
+     *
+     * This can also be used to add instructions for an AI agent that was previously not enabled.
+     *
+     * @param agent The AI agent to add instructions for
+     * @param instructions The instruction(s) to add
+     * @example
+     * aiInstructions.addAgentSpecificInstructions(AiAgent.GITHUB_COPILOT, "Use descriptive commit messages.");
+     */
+    addAgentSpecificInstructions(agent: AiAgent, ...instructions: string[]): void;
+    /**
+     * Get the file path for a given AI agent.
+     */
+    private getAgentFilePath;
+}
+export declare class AiInstructionsFile extends FileBase {
+    private readonly instructions;
+    /**
+     * Adds instructions to the instruction file.
+     */
+    addInstructions(...instructions: string[]): void;
+    protected synthesizeContent(resolver: IResolver): string | undefined;
+}

package/lib/ai-instructions.js

@@ -0,0 +1,238 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiInstructionsFile = exports.AiInstructions = exports.AiAgent = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("./component");
+const file_1 = require("./file");
+/**
+ * Supported AI coding assistants and their instruction file locations.
+ */
+var AiAgent;
+(function (AiAgent) {
+    /**
+     * GitHub Copilot - .github/copilot-instructions.md
+     */
+    AiAgent["GITHUB_COPILOT"] = "GitHub Copilot";
+    /**
+     * Cursor IDE - .cursor/rules/project.md
+     */
+    AiAgent["CURSOR"] = "Cursor";
+    /**
+     * Claude Code - CLAUDE.md
+     */
+    AiAgent["CLAUDE"] = "Claude";
+    /**
+     * Amazon Q - .amazonq/rules/project.md
+     */
+    AiAgent["AMAZON_Q"] = "Amazon Q";
+    /**
+     * Kiro - .kiro/steering/project.md
+     */
+    AiAgent["KIRO"] = "Kiro";
+})(AiAgent || (exports.AiAgent = AiAgent = {}));
+/**
+ * Generates instruction files for AI coding assistants with projen-specific guidance.
+ *
+ * This component creates configuration files that help AI tools like GitHub Copilot,
+ * Cursor IDE, Claude Code, and Amazon Q understand that the project is managed by projen
+ * and should follow projen conventions.
+ *
+ * @example
+ * const project = new TypeScriptProject({
+ *   name: "my-project",
+ *   defaultReleaseBranch: "main",
+ * });
+ *
+ * // Basic usage - generates files for all supported AI agents
+ * new AiInstructions(project);
+ *
+ * // Custom usage - specify which agents and add custom instructions
+ * new AiInstructions(project, {
+ *   agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR],
+ *   agentSpecificInstructions: {
+ *     [AiAgent.GITHUB_COPILOT]: ["Always use descriptive commit messages."],
+ *   },
+ * });
+ *
+ * // Add more instructions after instantiation
+ * const ai = new AiInstructions(project);
+ * ai.addInstructions("Use functional programming patterns.");
+ * ai.addInstructions("Always write comprehensive tests.");
+ */
+class AiInstructions extends component_1.Component {
+    /**
+     * Returns projen-specific instructions for AI agents.
+     */
+    static projen(project) {
+        return projenInstructions(project);
+    }
+    /**
+     * Returns development best practices instructions for AI agents.
+     */
+    static bestPractices(project) {
+        return bestPracticesInstructions(project);
+    }
+    constructor(project, options = {}) {
+        super(project);
+        this.files = new Map();
+        this.agents =
+            options.agents ??
+                Object.values(AiAgent).filter((v) => typeof v === "string");
+        // Assert files for declared agents
+        for (const agent of this.agents) {
+            this.ensureInstructionsFile(agent);
+        }
+        if (options.includeDefaultInstructions ?? true) {
+            this.addInstructions(AiInstructions.projen(project), AiInstructions.bestPractices(project));
+        }
+        if (options.instructions) {
+            this.addInstructions(...options.instructions);
+        }
+        if (options.agentSpecificInstructions) {
+            for (const [agent, instructions] of Object.entries(options.agentSpecificInstructions)) {
+                this.addAgentSpecificInstructions(agent, ...instructions);
+            }
+        }
+    }
+    /**
+     * Create or return the instructions file.
+     */
+    ensureInstructionsFile(agent) {
+        if (this.files.has(agent)) {
+            return this.files.get(agent);
+        }
+        const filePath = this.getAgentFilePath(agent);
+        const file = new AiInstructionsFile(this.project, filePath, {
+            committed: true,
+            readonly: true,
+        });
+        this.files.set(agent, file);
+        this.project.addPackageIgnore(file.path);
+        return file;
+    }
+    /**
+     * Adds instructions that will be included for all selected AI agents.
+     *
+     * @param instructions The instructions to add.
+     * @example
+     * aiInstructions.addInstructions("Always use TypeScript strict mode.");
+     * aiInstructions.addInstructions("Prefer functional programming.", "Avoid mutations.");
+     */
+    addInstructions(...instructions) {
+        for (const agent of this.files.keys()) {
+            this.addAgentSpecificInstructions(agent, ...instructions);
+        }
+    }
+    /**
+     * Add instructions for a specific AI agent.
+     *
+     * This can also be used to add instructions for an AI agent that was previously not enabled.
+     *
+     * @param agent The AI agent to add instructions for
+     * @param instructions The instruction(s) to add
+     * @example
+     * aiInstructions.addAgentSpecificInstructions(AiAgent.GITHUB_COPILOT, "Use descriptive commit messages.");
+     */
+    addAgentSpecificInstructions(agent, ...instructions) {
+        const file = this.ensureInstructionsFile(agent);
+        file.addInstructions(...instructions);
+    }
+    /**
+     * Get the file path for a given AI agent.
+     */
+    getAgentFilePath(agent) {
+        switch (agent) {
+            case AiAgent.GITHUB_COPILOT:
+                return ".github/copilot-instructions.md";
+            case AiAgent.CURSOR:
+                return ".cursor/rules/project.md";
+            case AiAgent.CLAUDE:
+                return "CLAUDE.md";
+            case AiAgent.AMAZON_Q:
+                return ".amazonq/rules/project.md";
+            case AiAgent.KIRO:
+                return ".kiro/steering/project.md";
+            default:
+                throw new Error(`Unknown AI agent: ${agent}`);
+        }
+    }
+}
+exports.AiInstructions = AiInstructions;
+_a = JSII_RTTI_SYMBOL_1;
+AiInstructions[_a] = { fqn: "projen.AiInstructions", version: "0.98.5" };
+class AiInstructionsFile extends file_1.FileBase {
+    constructor() {
+        super(...arguments);
+        this.instructions = [];
+    }
+    /**
+     * Adds instructions to the instruction file.
+     */
+    addInstructions(...instructions) {
+        this.instructions.push(...instructions);
+    }
+    synthesizeContent(resolver) {
+        return resolver.resolve(this.instructions).join("\n\n") + "\n";
+    }
+}
+exports.AiInstructionsFile = AiInstructionsFile;
+_b = JSII_RTTI_SYMBOL_1;
+AiInstructionsFile[_b] = { fqn: "projen.AiInstructionsFile", version: "0.98.5" };
+function bestPracticesInstructions(project) {
+    const projenCommand = project.projenCommand;
+    return `# Development Best Practices
+
+- **Always run build after changes**: After modifying any source or test file, run \`${projenCommand} build\` to ensure your changes compile and pass all tests.
+- **Task completion criteria**: A task is not considered complete until:
+  - All tests pass (\`${projenCommand} test\`)
+  - There are no compilation errors (\`${projenCommand} compile\`)
+  - There are no linting errors (usually part of the build, if not, run the linter defined in tasks.json)
+  - The full build succeeds (\`${projenCommand} build\`)`;
+}
+function projenInstructions(project) {
+    const projenCommand = project.projenCommand;
+    return `# Projen-managed Project Instructions
+
+This project is managed by [projen](https://github.com/projen/projen), a project configuration management tool.
+
+## Important Guidelines
+
+### Task Execution
+
+- **Always use projen for task execution**: Run tasks using \`${projenCommand} <task-name>\` instead of directly using npm, yarn, or other package managers.
+- **Check available tasks**: Look in \`.projen/tasks.json\` to see all available tasks, their descriptions, and steps.
+- **Common tasks**:
+  - \`${projenCommand}\` - Synthesize project configuration files
+  - \`${projenCommand} build\` - Builds the project, including running tests
+  - \`${projenCommand} test\` - Runs tests only
+  - \`${projenCommand} compile\` - Compiles the source code only
+
+### File Modifications
+
+- **DO NOT manually edit generated files**: Files marked with a comment like "~~ Generated by projen. To modify..." should never be edited directly.
+- **Modify configuration in .projenrc**: To change project configuration, always edit the \`.projenrc.ts\`, \`.projenrc.py\` or \`.projenrc.json\` etc. file and then run \`${projenCommand}\` to regenerate the project files.
+- **Check .projenrc first**: Before suggesting changes to package.json, tsconfig.json, or other configuration files, always check if these are managed by projen and suggest changes to .projenrc instead.
+
+### Dependencies
+
+- **Add dependencies through projen**: Use the projen configuration to add dependencies instead of manually editing package.json or using npm/yarn install directly.
+- **Example**: In .projenrc, use methods like \`addDeps()\`, \`addDevDeps()\`, or \`addPeerDeps()\` to add dependencies.
+
+### Workflow
+
+1. Make changes to .projenrc configuration file
+2. Run \`${projenCommand}\` to synthesize and update generated files
+3. Review the changes
+4. Commit both .projenrc and the generated files
+
+## Projen Configuration
+
+This project's configuration is defined in the .projenrc file at the root of the repository. All project metadata, dependencies, scripts, and tooling configuration should be managed through this file.
+
+## Additional Resources
+
+- [Projen Documentation](https://projen.io)
+- [Projen GitHub Repository](https://github.com/projen/projen)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-instructions.js","sourceRoot":"","sources":["../src/ai-instructions.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from \"./component\";\nimport { FileBase, IResolver } from \"./file\";\nimport { Project } from \"./project\";\n\n/**\n * Supported AI coding assistants and their instruction file locations.\n */\nexport enum AiAgent {\n  /**\n   * GitHub Copilot - .github/copilot-instructions.md\n   */\n  GITHUB_COPILOT = \"GitHub Copilot\",\n\n  /**\n   * Cursor IDE - .cursor/rules/project.md\n   */\n  CURSOR = \"Cursor\",\n\n  /**\n   * Claude Code - CLAUDE.md\n   */\n  CLAUDE = \"Claude\",\n\n  /**\n   * Amazon Q - .amazonq/rules/project.md\n   */\n  AMAZON_Q = \"Amazon Q\",\n\n  /**\n   * Kiro - .kiro/steering/project.md\n   */\n  KIRO = \"Kiro\",\n}\n\n/**\n * Options for configuring AI tool instruction files.\n */\nexport interface AiInstructionsOptions {\n  /**\n   * Which AI agents to generate instruction files for.\n   *\n   * @default - All agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR, AiAgent.CLAUDE, AiAgent.AMAZON_Q]\n   */\n  readonly agents?: AiAgent[];\n\n  /**\n   * General instructions applicable to all agents.\n   *\n   * @default - no agent specific instructions\n   */\n  readonly instructions?: string[];\n\n  /**\n   * Per-agent custom instructions. Allows different instructions for different AI tools.\n   *\n   * @default - no agent specific instructions\n   * @example\n   * {\n   *   [AiAgent.GITHUB_COPILOT]: {\n   *     instructions: [\"Use descriptive commit messages.\"]\n   *   },\n   *   [AiAgent.CURSOR]: {\n   *     instructions: [\"Prefer functional patterns.\", \"Always add tests.\"]\n   *   }\n   * }\n   */\n  readonly agentSpecificInstructions?: Record<string, string[]>;\n\n  /**\n   * Include default instructions for projen and general best practices.\n   *\n   * Default instructions will only be included for agents provided in the `agents` option.\n   * If `agents` is not provided, default instructions will be included for all agents.\n   *\n   * @default true\n   */\n  readonly includeDefaultInstructions?: boolean;\n}\n\n/**\n * Generates instruction files for AI coding assistants with projen-specific guidance.\n *\n * This component creates configuration files that help AI tools like GitHub Copilot,\n * Cursor IDE, Claude Code, and Amazon Q understand that the project is managed by projen\n * and should follow projen conventions.\n *\n * @example\n * const project = new TypeScriptProject({\n *   name: \"my-project\",\n *   defaultReleaseBranch: \"main\",\n * });\n *\n * // Basic usage - generates files for all supported AI agents\n * new AiInstructions(project);\n *\n * // Custom usage - specify which agents and add custom instructions\n * new AiInstructions(project, {\n *   agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR],\n *   agentSpecificInstructions: {\n *     [AiAgent.GITHUB_COPILOT]: [\"Always use descriptive commit messages.\"],\n *   },\n * });\n *\n * // Add more instructions after instantiation\n * const ai = new AiInstructions(project);\n * ai.addInstructions(\"Use functional programming patterns.\");\n * ai.addInstructions(\"Always write comprehensive tests.\");\n */\nexport class AiInstructions extends Component {\n  /**\n   * Returns projen-specific instructions for AI agents.\n   */\n  public static projen(project: Project): string {\n    return projenInstructions(project);\n  }\n\n  /**\n   * Returns development best practices instructions for AI agents.\n   */\n  public static bestPractices(project: Project): string {\n    return bestPracticesInstructions(project);\n  }\n\n  private readonly agents: AiAgent[];\n  private readonly files: Map<AiAgent, AiInstructionsFile> = new Map();\n\n  constructor(project: Project, options: AiInstructionsOptions = {}) {\n    super(project);\n\n    this.agents =\n      options.agents ??\n      (Object.values(AiAgent).filter(\n        (v) => typeof v === \"string\"\n      ) as AiAgent[]);\n\n    // Assert files for declared agents\n    for (const agent of this.agents) {\n      this.ensureInstructionsFile(agent);\n    }\n\n    if (options.includeDefaultInstructions ?? true) {\n      this.addInstructions(\n        AiInstructions.projen(project),\n        AiInstructions.bestPractices(project)\n      );\n    }\n\n    if (options.instructions) {\n      this.addInstructions(...options.instructions);\n    }\n\n    if (options.agentSpecificInstructions) {\n      for (const [agent, instructions] of Object.entries(\n        options.agentSpecificInstructions\n      )) {\n        this.addAgentSpecificInstructions(agent as AiAgent, ...instructions);\n      }\n    }\n  }\n\n  /**\n   * Create or return the instructions file.\n   */\n  private ensureInstructionsFile(agent: AiAgent): AiInstructionsFile {\n    if (this.files.has(agent)) {\n      return this.files.get(agent)!;\n    }\n\n    const filePath = this.getAgentFilePath(agent);\n    const file = new AiInstructionsFile(this.project, filePath, {\n      committed: true,\n      readonly: true,\n    });\n    this.files.set(agent, file);\n    this.project.addPackageIgnore(file.path);\n    return file;\n  }\n\n  /**\n   * Adds instructions that will be included for all selected AI agents.\n   *\n   * @param instructions The instructions to add.\n   * @example\n   * aiInstructions.addInstructions(\"Always use TypeScript strict mode.\");\n   * aiInstructions.addInstructions(\"Prefer functional programming.\", \"Avoid mutations.\");\n   */\n  public addInstructions(...instructions: string[]): void {\n    for (const agent of this.files.keys()) {\n      this.addAgentSpecificInstructions(agent, ...instructions);\n    }\n  }\n\n  /**\n   * Add instructions for a specific AI agent.\n   *\n   * This can also be used to add instructions for an AI agent that was previously not enabled.\n   *\n   * @param agent The AI agent to add instructions for\n   * @param instructions The instruction(s) to add\n   * @example\n   * aiInstructions.addAgentSpecificInstructions(AiAgent.GITHUB_COPILOT, \"Use descriptive commit messages.\");\n   */\n  public addAgentSpecificInstructions(\n    agent: AiAgent,\n    ...instructions: string[]\n  ): void {\n    const file = this.ensureInstructionsFile(agent);\n    file.addInstructions(...instructions);\n  }\n\n  /**\n   * Get the file path for a given AI agent.\n   */\n  private getAgentFilePath(agent: AiAgent): string {\n    switch (agent) {\n      case AiAgent.GITHUB_COPILOT:\n        return \".github/copilot-instructions.md\";\n      case AiAgent.CURSOR:\n        return \".cursor/rules/project.md\";\n      case AiAgent.CLAUDE:\n        return \"CLAUDE.md\";\n      case AiAgent.AMAZON_Q:\n        return \".amazonq/rules/project.md\";\n      case AiAgent.KIRO:\n        return \".kiro/steering/project.md\";\n      default:\n        throw new Error(`Unknown AI agent: ${agent}`);\n    }\n  }\n}\n\nexport class AiInstructionsFile extends FileBase {\n  private readonly instructions: string[] = [];\n\n  /**\n   * Adds instructions to the instruction file.\n   */\n  public addInstructions(...instructions: string[]): void {\n    this.instructions.push(...instructions);\n  }\n\n  protected synthesizeContent(resolver: IResolver): string | undefined {\n    return resolver.resolve(this.instructions).join(\"\\n\\n\") + \"\\n\";\n  }\n}\n\nfunction bestPracticesInstructions(project: Project): string {\n  const projenCommand = project.projenCommand;\n  return `# Development Best Practices\n\n- **Always run build after changes**: After modifying any source or test file, run \\`${projenCommand} build\\` to ensure your changes compile and pass all tests.\n- **Task completion criteria**: A task is not considered complete until:\n  - All tests pass (\\`${projenCommand} test\\`)\n  - There are no compilation errors (\\`${projenCommand} compile\\`)\n  - There are no linting errors (usually part of the build, if not, run the linter defined in tasks.json)\n  - The full build succeeds (\\`${projenCommand} build\\`)`;\n}\n\nfunction projenInstructions(project: Project): string {\n  const projenCommand = project.projenCommand;\n  return `# Projen-managed Project Instructions\n\nThis project is managed by [projen](https://github.com/projen/projen), a project configuration management tool.\n\n## Important Guidelines\n\n### Task Execution\n\n- **Always use projen for task execution**: Run tasks using \\`${projenCommand} <task-name>\\` instead of directly using npm, yarn, or other package managers.\n- **Check available tasks**: Look in \\`.projen/tasks.json\\` to see all available tasks, their descriptions, and steps.\n- **Common tasks**:\n  - \\`${projenCommand}\\` - Synthesize project configuration files\n  - \\`${projenCommand} build\\` - Builds the project, including running tests\n  - \\`${projenCommand} test\\` - Runs tests only\n  - \\`${projenCommand} compile\\` - Compiles the source code only\n\n### File Modifications\n\n- **DO NOT manually edit generated files**: Files marked with a comment like \"~~ Generated by projen. To modify...\" should never be edited directly.\n- **Modify configuration in .projenrc**: To change project configuration, always edit the \\`.projenrc.ts\\`, \\`.projenrc.py\\` or \\`.projenrc.json\\` etc. file and then run \\`${projenCommand}\\` to regenerate the project files.\n- **Check .projenrc first**: Before suggesting changes to package.json, tsconfig.json, or other configuration files, always check if these are managed by projen and suggest changes to .projenrc instead.\n\n### Dependencies\n\n- **Add dependencies through projen**: Use the projen configuration to add dependencies instead of manually editing package.json or using npm/yarn install directly.\n- **Example**: In .projenrc, use methods like \\`addDeps()\\`, \\`addDevDeps()\\`, or \\`addPeerDeps()\\` to add dependencies.\n\n### Workflow\n\n1. Make changes to .projenrc configuration file\n2. Run \\`${projenCommand}\\` to synthesize and update generated files\n3. Review the changes\n4. Commit both .projenrc and the generated files\n\n## Projen Configuration\n\nThis project's configuration is defined in the .projenrc file at the root of the repository. All project metadata, dependencies, scripts, and tooling configuration should be managed through this file.\n\n## Additional Resources\n\n- [Projen Documentation](https://projen.io)\n- [Projen GitHub Repository](https://github.com/projen/projen)`;\n}\n"]}

package/lib/awscdk/auto-discover.js

@@ -27,7 +27,7 @@ class IntegrationTestAutoDiscover extends cdk_1.IntegrationTestAutoDiscoverBase
 }
 exports.IntegrationTestAutoDiscover = IntegrationTestAutoDiscover;
 _a = JSII_RTTI_SYMBOL_1;
-IntegrationTestAutoDiscover[_a] = { fqn: "projen.awscdk.IntegrationTestAutoDiscover", version: "0.98.3" };
+IntegrationTestAutoDiscover[_a] = { fqn: "projen.awscdk.IntegrationTestAutoDiscover", version: "0.98.5" };
 /**
  * Creates lambdas from entry points discovered in the project's source tree.
  */
@@ -48,7 +48,7 @@ class LambdaAutoDiscover extends cdk_1.AutoDiscoverBase {
 }
 exports.LambdaAutoDiscover = LambdaAutoDiscover;
 _b = JSII_RTTI_SYMBOL_1;
-LambdaAutoDiscover[_b] = { fqn: "projen.awscdk.LambdaAutoDiscover", version: "0.98.3" };
+LambdaAutoDiscover[_b] = { fqn: "projen.awscdk.LambdaAutoDiscover", version: "0.98.5" };
 /**
  * Creates edge lambdas from entry points discovered in the project's source tree.
  */
@@ -70,7 +70,7 @@ class EdgeLambdaAutoDiscover extends cdk_1.AutoDiscoverBase {
 }
 exports.EdgeLambdaAutoDiscover = EdgeLambdaAutoDiscover;
 _c = JSII_RTTI_SYMBOL_1;
-EdgeLambdaAutoDiscover[_c] = { fqn: "projen.awscdk.EdgeLambdaAutoDiscover", version: "0.98.3" };
+EdgeLambdaAutoDiscover[_c] = { fqn: "projen.awscdk.EdgeLambdaAutoDiscover", version: "0.98.5" };
 /**
  * Creates Lambda Extensions from entrypoints discovered in the project's
  * source tree.
@@ -92,7 +92,7 @@ class LambdaExtensionAutoDiscover extends cdk_1.AutoDiscoverBase {
 }
 exports.LambdaExtensionAutoDiscover = LambdaExtensionAutoDiscover;
 _d = JSII_RTTI_SYMBOL_1;
-LambdaExtensionAutoDiscover[_d] = { fqn: "projen.awscdk.LambdaExtensionAutoDiscover", version: "0.98.3" };
+LambdaExtensionAutoDiscover[_d] = { fqn: "projen.awscdk.LambdaExtensionAutoDiscover", version: "0.98.5" };
 /**
  * Discovers and creates integration tests and lambdas from code in the
  * project's source and test trees.
@@ -136,5 +136,5 @@ class AutoDiscover extends component_1.Component {
 }
 exports.AutoDiscover = AutoDiscover;
 _e = JSII_RTTI_SYMBOL_1;
-AutoDiscover[_e] = { fqn: "projen.awscdk.AutoDiscover", version: "0.98.3" };
+AutoDiscover[_e] = { fqn: "projen.awscdk.AutoDiscover", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-discover.js","sourceRoot":"","sources":["../../src/awscdk/auto-discover.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkDeps } from \"./awscdk-deps\";\nimport {\n  IntegrationTest,\n  IntegrationTestCommonOptions,\n} from \"./integration-test\";\nimport {\n  TYPESCRIPT_EDGE_LAMBDA_EXT,\n  TYPESCRIPT_LAMBDA_EXT,\n  TYPESCRIPT_LAMBDA_EXTENSION_EXT,\n} from \"./internal\";\nimport {\n  LambdaExtension,\n  LambdaExtensionCommonOptions,\n} from \"./lambda-extension\";\nimport { LambdaFunction, LambdaFunctionCommonOptions } from \"./lambda-function\";\nimport {\n  AutoDiscoverBase,\n  IntegrationTestAutoDiscoverBase,\n  IntegrationTestAutoDiscoverBaseOptions,\n} from \"../cdk\";\nimport { Component } from \"../component\";\nimport { Project } from \"../project\";\n\n/**\n * Common options for auto discovering project subcomponents.\n */\nexport interface AutoDiscoverCommonOptions {\n  /**\n   * Path to the tsconfig file to use for integration tests.\n   */\n  readonly tsconfigPath: string;\n\n  /**\n   * AWS CDK dependency manager.\n   */\n  readonly cdkDeps: AwsCdkDeps;\n}\n\n/**\n * Options for `IntegrationTestAutoDiscover`\n */\nexport interface IntegrationTestAutoDiscoverOptions\n  extends AutoDiscoverCommonOptions,\n    IntegrationTestAutoDiscoverBaseOptions {\n  /**\n   * Options for integration tests.\n   */\n  readonly integrationTestOptions?: IntegrationTestCommonOptions;\n}\n\n/**\n * Creates integration tests from entry points discovered in the test tree.\n */\nexport class IntegrationTestAutoDiscover extends IntegrationTestAutoDiscoverBase {\n  constructor(project: Project, options: IntegrationTestAutoDiscoverOptions) {\n    super(project, options);\n\n    for (const entrypoint of this.entrypoints) {\n      new IntegrationTest(this.project, {\n        entrypoint,\n        cdkDeps: options.cdkDeps,\n        tsconfigPath: options.tsconfigPath,\n        ...options.integrationTestOptions,\n      });\n    }\n  }\n}\n\n/**\n * Options for `LambdaAutoDiscover`\n */\nexport interface LambdaAutoDiscoverOptions extends AutoDiscoverCommonOptions {\n  /**\n   * Project source tree (relative to project output directory).\n   */\n  readonly srcdir: string;\n\n  /**\n   * Options for AWS Lambda functions.\n   */\n  readonly lambdaOptions?: LambdaFunctionCommonOptions;\n}\n\n/**\n * Creates lambdas from entry points discovered in the project's source tree.\n */\nexport class LambdaAutoDiscover extends AutoDiscoverBase {\n  constructor(project: Project, options: LambdaAutoDiscoverOptions) {\n    super(project, {\n      projectdir: options.srcdir,\n      extension: TYPESCRIPT_LAMBDA_EXT,\n    });\n\n    for (const entrypoint of this.entrypoints) {\n      new LambdaFunction(this.project, {\n        entrypoint,\n        cdkDeps: options.cdkDeps,\n        ...options.lambdaOptions,\n      });\n    }\n  }\n}\n\n/**\n * Options for `EdgeLambdaAutoDiscover`\n */\nexport interface EdgeLambdaAutoDiscoverOptions\n  extends AutoDiscoverCommonOptions {\n  /**\n   * Project source tree (relative to project output directory).\n   */\n  readonly srcdir: string;\n\n  /**\n   * Options for AWS Lambda functions.\n   */\n  readonly lambdaOptions?: LambdaFunctionCommonOptions;\n}\n\n/**\n * Creates edge lambdas from entry points discovered in the project's source tree.\n */\nexport class EdgeLambdaAutoDiscover extends AutoDiscoverBase {\n  constructor(project: Project, options: EdgeLambdaAutoDiscoverOptions) {\n    super(project, {\n      projectdir: options.srcdir,\n      extension: TYPESCRIPT_EDGE_LAMBDA_EXT,\n    });\n\n    for (const entrypoint of this.entrypoints) {\n      new LambdaFunction(this.project, {\n        entrypoint,\n        cdkDeps: options.cdkDeps,\n        ...options.lambdaOptions,\n        edgeLambda: true,\n      });\n    }\n  }\n}\n\n/**\n * Options for `LambdaExtensionAutoDiscover`\n */\nexport interface LambdaExtensionAutoDiscoverOptions\n  extends AutoDiscoverCommonOptions {\n  /**\n   * Project source tree (relative to project output directory).\n   */\n  readonly srcdir: string;\n\n  /**\n   * Options for lambda extensions.\n   */\n  readonly lambdaExtensionOptions?: LambdaExtensionCommonOptions;\n}\n\n/**\n * Creates Lambda Extensions from entrypoints discovered in the project's\n * source tree.\n */\nexport class LambdaExtensionAutoDiscover extends AutoDiscoverBase {\n  constructor(project: Project, options: LambdaExtensionAutoDiscoverOptions) {\n    super(project, {\n      projectdir: options.srcdir,\n      extension: TYPESCRIPT_LAMBDA_EXTENSION_EXT,\n    });\n\n    for (const entrypoint of this.entrypoints) {\n      new LambdaExtension(this.project, {\n        entrypoint,\n        cdkDeps: options.cdkDeps,\n        ...options.lambdaExtensionOptions,\n      });\n    }\n  }\n}\n\n/**\n * Options for `AutoDiscover`\n */\nexport interface AutoDiscoverOptions\n  extends LambdaAutoDiscoverOptions,\n    LambdaExtensionAutoDiscoverOptions,\n    IntegrationTestAutoDiscoverOptions {\n  /**\n   * Auto-discover lambda functions.\n   *\n   * @default true\n   */\n  readonly lambdaAutoDiscover?: boolean;\n\n  /**\n   * Auto-discover edge lambda functions.\n   *\n   * @default true\n   */\n  readonly edgeLambdaAutoDiscover?: boolean;\n\n  /**\n   * Auto-discover lambda extensions.\n   *\n   * @default true\n   */\n  readonly lambdaExtensionAutoDiscover?: boolean;\n\n  /**\n   * Auto-discover integration tests.\n   *\n   * @default true\n   */\n  readonly integrationTestAutoDiscover?: boolean;\n}\n\n/**\n * Discovers and creates integration tests and lambdas from code in the\n * project's source and test trees.\n */\nexport class AutoDiscover extends Component {\n  constructor(project: Project, options: AutoDiscoverOptions) {\n    super(project);\n\n    if (options.lambdaAutoDiscover ?? true) {\n      new LambdaAutoDiscover(this.project, {\n        cdkDeps: options.cdkDeps,\n        tsconfigPath: options.tsconfigPath,\n        srcdir: options.srcdir,\n        lambdaOptions: options.lambdaOptions,\n      });\n    }\n\n    if (options.edgeLambdaAutoDiscover ?? true) {\n      new EdgeLambdaAutoDiscover(this.project, {\n        cdkDeps: options.cdkDeps,\n        tsconfigPath: options.tsconfigPath,\n        srcdir: options.srcdir,\n        lambdaOptions: options.lambdaOptions,\n      });\n    }\n\n    if (options.lambdaExtensionAutoDiscover ?? true) {\n      new LambdaExtensionAutoDiscover(this.project, {\n        cdkDeps: options.cdkDeps,\n        tsconfigPath: options.tsconfigPath,\n        srcdir: options.srcdir,\n        lambdaExtensionOptions: options.lambdaExtensionOptions,\n      });\n    }\n\n    if (options.integrationTestAutoDiscover ?? true) {\n      new IntegrationTestAutoDiscover(this.project, {\n        cdkDeps: options.cdkDeps,\n        testdir: options.testdir,\n        tsconfigPath: options.tsconfigPath,\n        integrationTestOptions: options.integrationTestOptions,\n      });\n    }\n  }\n}\n"]}

package/lib/awscdk/awscdk-app-java.js

@@ -81,5 +81,5 @@ class AwsCdkJavaApp extends java_1.JavaProject {
 }
 exports.AwsCdkJavaApp = AwsCdkJavaApp;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkJavaApp[_a] = { fqn: "projen.awscdk.AwsCdkJavaApp", version: "0.98.3" };
+AwsCdkJavaApp[_a] = { fqn: "projen.awscdk.AwsCdkJavaApp", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/awscdk/awscdk-app-py.js

@@ -58,7 +58,7 @@ class AwsCdkPythonApp extends python_project_1.PythonProject {
 }
 exports.AwsCdkPythonApp = AwsCdkPythonApp;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkPythonApp[_a] = { fqn: "projen.awscdk.AwsCdkPythonApp", version: "0.98.3" };
+AwsCdkPythonApp[_a] = { fqn: "projen.awscdk.AwsCdkPythonApp", version: "0.98.5" };
 class AppCode extends __1.Component {
     constructor(project, fileName, cdkVersion) {
         super(project);

package/lib/awscdk/awscdk-app-ts.js

@@ -187,7 +187,7 @@ class AwsCdkTypeScriptApp extends typescript_1.TypeScriptAppProject {
 }
 exports.AwsCdkTypeScriptApp = AwsCdkTypeScriptApp;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkTypeScriptApp[_a] = { fqn: "projen.awscdk.AwsCdkTypeScriptApp", version: "0.98.3" };
+AwsCdkTypeScriptApp[_a] = { fqn: "projen.awscdk.AwsCdkTypeScriptApp", version: "0.98.5" };
 /**
  * Ensures a path is properly prefixed with './' if it's a relative path
  * @param {string} filePath - The path to normalize

package/lib/awscdk/awscdk-construct.js

@@ -85,11 +85,11 @@ class AwsCdkConstructLibrary extends cdk_1.ConstructLibrary {
 }
 exports.AwsCdkConstructLibrary = AwsCdkConstructLibrary;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkConstructLibrary[_a] = { fqn: "projen.awscdk.AwsCdkConstructLibrary", version: "0.98.3" };
+AwsCdkConstructLibrary[_a] = { fqn: "projen.awscdk.AwsCdkConstructLibrary", version: "0.98.5" };
 /** @deprecated use `AwsCdkConstructLibrary` */
 class ConstructLibraryAws extends AwsCdkConstructLibrary {
 }
 exports.ConstructLibraryAws = ConstructLibraryAws;
 _b = JSII_RTTI_SYMBOL_1;
-ConstructLibraryAws[_b] = { fqn: "projen.awscdk.ConstructLibraryAws", version: "0.98.3" };
+ConstructLibraryAws[_b] = { fqn: "projen.awscdk.ConstructLibraryAws", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awscdk-construct.js","sourceRoot":"","sources":["../../src/awscdk/awscdk-construct.ts"],"names":[],"mappings":";;;;;AAAA,iCAAiC;AACjC,mDAA+C;AAE/C,qDAAgD;AAChD,iDAA6C;AAE7C,gCAAmE;AACnE,kDAAiD;AA4DjD;;;;;;;;GAQG;AACH,MAAa,sBAAuB,SAAQ,sBAAgB;IAG1D,YAAY,OAAsC;QAChD,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;QAEhE,KAAK,CAAC;YACJ,qBAAqB,EACnB,eAAe,KAAK,CAAC;gBACnB,CAAC,CAAC;oBACE,mBAAmB,EAAE,KAAK;iBAC3B;gBACH,CAAC,CAAC,SAAS;YACf,mBAAmB,EAAE,OAAO,CAAC,cAAc,IAAI,OAAO;YACtD,GAAG,OAAO;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,OAAO,GAAG,IAAI,6BAAY,CAAC,IAAI,EAAE;YACpC,oEAAoE;YACpE,cAAc,EAAE,6BAAc,CAAC,IAAI;YACnC,GAAG,OAAO;SACX,CAAC,CAAC;QAEH,IAAI,4BAAY,CAAC,IAAI,EAAE;YACrB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ;YACvC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,IAAI;YACtD,sBAAsB,EAAE,OAAO,CAAC,sBAAsB,IAAI,IAAI;YAC9D,2BAA2B,EAAE,OAAO,CAAC,2BAA2B,IAAI,IAAI;YACxE,2BAA2B,EAAE,OAAO,CAAC,2BAA2B,IAAI,IAAI;SACzE,CAAC,CAAC;QAEH,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;YACpC,IAAI,0BAAW,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACI,kBAAkB,CAAC,GAAG,IAAc;QACzC,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACI,sBAAsB,CAAC,GAAG,IAAc;QAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC,CAAC;IACpD,CAAC;;AA1EH,wDA2EC;;;AAMD,+CAA+C;AAC/C,MAAa,mBAAoB,SAAQ,sBAAsB;;AAA/D,kDAAkE","sourcesContent":["import * as semver from \"semver\";\nimport { AutoDiscover } from \"./auto-discover\";\nimport { AwsCdkDeps, AwsCdkDepsCommonOptions } from \"./awscdk-deps\";\nimport { AwsCdkDepsJs } from \"./awscdk-deps-js\";\nimport { IntegRunner } from \"./integ-runner\";\nimport { LambdaFunctionCommonOptions } from \"./lambda-function\";\nimport { ConstructLibrary, ConstructLibraryOptions } from \"../cdk\";\nimport { DependencyType } from \"../dependencies\";\n\n/**\n * Options for `AwsCdkConstructLibrary`.\n */\nexport interface AwsCdkConstructLibraryOptions\n  extends ConstructLibraryOptions,\n    AwsCdkDepsCommonOptions {\n  /**\n   * Automatically adds an `aws_lambda.Function` for each `.lambda.ts` handler\n   * in your source tree. If this is disabled, you either need to explicitly\n   * call `aws_lambda.Function.autoDiscover()` or define a `new\n   * aws_lambda.Function()` for each handler.\n   *\n   * @default true\n   */\n  readonly lambdaAutoDiscover?: boolean;\n\n  /**\n   * Automatically adds an `cloudfront.experimental.EdgeFunction` for each\n   * `.edge-lambda.ts` handler in your source tree. If this is disabled, you can\n   * manually add an `awscdk.AutoDiscover` component to your project.\n   *\n   * @default true\n   */\n  readonly edgeLambdaAutoDiscover?: boolean;\n\n  /**\n   * Automatically adds an `awscdk.LambdaExtension` for each `.lambda-extension.ts`\n   * entrypoint in your source tree. If this is disabled, you can manually add an\n   * `awscdk.AutoDiscover` component to your project\n   *\n   * @default true\n   */\n  readonly lambdaExtensionAutoDiscover?: boolean;\n\n  /**\n   * Automatically discovers and creates integration tests for each `.integ.ts`\n   * file under your test directory.\n   *\n   * @default true\n   */\n  readonly integrationTestAutoDiscover?: boolean;\n\n  /**\n   * Enable experimental support for the AWS CDK integ-runner.\n   *\n   * @default false\n   * @experimental\n   */\n  readonly experimentalIntegRunner?: boolean;\n\n  /**\n   * Common options for all AWS Lambda functions.\n   *\n   * @default - default options\n   */\n  readonly lambdaOptions?: LambdaFunctionCommonOptions;\n}\n\n/**\n * AWS CDK construct library project\n *\n * A multi-language (jsii) construct library which vends constructs designed to\n * use within the AWS CDK with a friendly workflow and automatic publishing to\n * the construct catalog.\n *\n * @pjid awscdk-construct\n */\nexport class AwsCdkConstructLibrary extends ConstructLibrary {\n  public readonly cdkDeps: AwsCdkDeps;\n\n  constructor(options: AwsCdkConstructLibraryOptions) {\n    const cdkMajorVersion = semver.parse(options.cdkVersion)?.major;\n\n    super({\n      peerDependencyOptions:\n        cdkMajorVersion === 1\n          ? {\n              pinnedDevDependency: false,\n            }\n          : undefined,\n      workflowNodeVersion: options.minNodeVersion ?? \"lts/*\",\n      ...options,\n    });\n\n    this.cdkDeps = new AwsCdkDepsJs(this, {\n      // since this we are a library, dependencies should be added a peers\n      dependencyType: DependencyType.PEER,\n      ...options,\n    });\n\n    new AutoDiscover(this, {\n      srcdir: this.srcdir,\n      testdir: this.testdir,\n      lambdaOptions: options.lambdaOptions,\n      tsconfigPath: this.tsconfigDev.fileName,\n      cdkDeps: this.cdkDeps,\n      lambdaAutoDiscover: options.lambdaAutoDiscover ?? true,\n      edgeLambdaAutoDiscover: options.edgeLambdaAutoDiscover ?? true,\n      lambdaExtensionAutoDiscover: options.lambdaExtensionAutoDiscover ?? true,\n      integrationTestAutoDiscover: options.integrationTestAutoDiscover ?? true,\n    });\n\n    if (options.experimentalIntegRunner) {\n      new IntegRunner(this);\n    }\n  }\n\n  /**\n   * The target CDK version for this library.\n   */\n  public get cdkVersion() {\n    return this.cdkDeps.cdkVersion;\n  }\n\n  /**\n   * @deprecated use `cdkVersion`\n   */\n  public get version() {\n    return this.cdkVersion;\n  }\n\n  /**\n   * Adds dependencies to AWS CDK modules.\n   *\n   * Since this is a library project, dependencies will be added as peer dependencies.\n   *\n   * @param deps names of cdk modules (e.g. `@aws-cdk/aws-lambda`).\n   * @deprecated Not supported in v2. For v1, use `project.cdkDeps.addV1Dependencies()`\n   */\n  public addCdkDependencies(...deps: string[]) {\n    return this.cdkDeps.addV1Dependencies(...deps);\n  }\n\n  /**\n   * Adds AWS CDK modules as dev dependencies.\n   *\n   * @param deps names of cdk modules (e.g. `@aws-cdk/aws-lambda`).\n   * @deprecated Not supported in v2. For v1, use `project.cdkDeps.addV1DevDependencies()`\n   */\n  public addCdkTestDependencies(...deps: string[]) {\n    return this.cdkDeps.addV1DevDependencies(...deps);\n  }\n}\n\n/** @deprecated use `AwsCdkConstructLibraryOptions` */\nexport interface ConstructLibraryAwsOptions\n  extends AwsCdkConstructLibraryOptions {}\n\n/** @deprecated use `AwsCdkConstructLibrary` */\nexport class ConstructLibraryAws extends AwsCdkConstructLibrary {}\n"]}

package/lib/awscdk/awscdk-deps-java.js

@@ -19,5 +19,5 @@ class AwsCdkDepsJava extends awscdk_deps_1.AwsCdkDeps {
 }
 exports.AwsCdkDepsJava = AwsCdkDepsJava;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkDepsJava[_a] = { fqn: "projen.awscdk.AwsCdkDepsJava", version: "0.98.3" };
+AwsCdkDepsJava[_a] = { fqn: "projen.awscdk.AwsCdkDepsJava", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzY2RrLWRlcHMtamF2YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hd3NjZGsvYXdzY2RrLWRlcHMtamF2YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLCtDQUErRDtBQUUvRDs7R0FFRztBQUNILE1BQWEsY0FBZSxTQUFRLHdCQUFVO0lBQ2xDLFlBQVk7UUFDcEIsT0FBTztZQUNMLE1BQU0sRUFBRSw2QkFBNkI7WUFDckMsTUFBTSxFQUFFLG9DQUFvQztZQUM1QyxVQUFVLEVBQUUsZ0NBQWdDO1lBQzVDLFVBQVUsRUFBRSxtQ0FBbUM7U0FDaEQsQ0FBQztJQUNKLENBQUM7O0FBUkgsd0NBU0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBd3NDZGtEZXBzLCBBd3NDZGtQYWNrYWdlTmFtZXMgfSBmcm9tIFwiLi9hd3NjZGstZGVwc1wiO1xuXG4vKipcbiAqIE1hbmFnZXMgZGVwZW5kZW5jaWVzIG9uIHRoZSBBV1MgQ0RLIGZvciBKYXZhIHByb2plY3RzLlxuICovXG5leHBvcnQgY2xhc3MgQXdzQ2RrRGVwc0phdmEgZXh0ZW5kcyBBd3NDZGtEZXBzIHtcbiAgcHJvdGVjdGVkIHBhY2thZ2VOYW1lcygpOiBBd3NDZGtQYWNrYWdlTmFtZXMge1xuICAgIHJldHVybiB7XG4gICAgICBjb3JlVjE6IFwic29mdHdhcmUuYW1hem9uLmF3c2Nkay9jb3JlXCIsXG4gICAgICBjb3JlVjI6IFwic29mdHdhcmUuYW1hem9uLmF3c2Nkay9hd3MtY2RrLWxpYlwiLFxuICAgICAgY29uc3RydWN0czogXCJzb2Z0d2FyZS5jb25zdHJ1Y3RzL2NvbnN0cnVjdHNcIixcbiAgICAgIGFzc2VydGlvbnM6IFwic29mdHdhcmUuYW1hem9uLmF3c2Nkay9hc3NlcnRpb25zXCIsXG4gICAgfTtcbiAgfVxufVxuIl19

package/lib/awscdk/awscdk-deps-js.js

@@ -20,5 +20,5 @@ class AwsCdkDepsJs extends awscdk_deps_1.AwsCdkDeps {
 }
 exports.AwsCdkDepsJs = AwsCdkDepsJs;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkDepsJs[_a] = { fqn: "projen.awscdk.AwsCdkDepsJs", version: "0.98.3" };
+AwsCdkDepsJs[_a] = { fqn: "projen.awscdk.AwsCdkDepsJs", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzY2RrLWRlcHMtanMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXdzY2RrL2F3c2Nkay1kZXBzLWpzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsK0NBQStEO0FBRS9EOztHQUVHO0FBQ0gsTUFBYSxZQUFhLFNBQVEsd0JBQVU7SUFDaEMsWUFBWTtRQUNwQixPQUFPO1lBQ0wsTUFBTSxFQUFFLGVBQWU7WUFDdkIsTUFBTSxFQUFFLGFBQWE7WUFDckIsVUFBVSxFQUFFLFlBQVk7WUFDeEIsTUFBTSxFQUFFLGlCQUFpQjtZQUN6QixVQUFVLEVBQUUscUJBQXFCO1NBQ2xDLENBQUM7SUFDSixDQUFDOztBQVRILG9DQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXdzQ2RrRGVwcywgQXdzQ2RrUGFja2FnZU5hbWVzIH0gZnJvbSBcIi4vYXdzY2RrLWRlcHNcIjtcblxuLyoqXG4gKiBNYW5hZ2VzIGRlcGVuZGVuY2llcyBvbiB0aGUgQVdTIENESyBmb3IgTm9kZS5qcyBwcm9qZWN0cy5cbiAqL1xuZXhwb3J0IGNsYXNzIEF3c0Nka0RlcHNKcyBleHRlbmRzIEF3c0Nka0RlcHMge1xuICBwcm90ZWN0ZWQgcGFja2FnZU5hbWVzKCk6IEF3c0Nka1BhY2thZ2VOYW1lcyB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGNvcmVWMTogXCJAYXdzLWNkay9jb3JlXCIsXG4gICAgICBjb3JlVjI6IFwiYXdzLWNkay1saWJcIixcbiAgICAgIGNvbnN0cnVjdHM6IFwiY29uc3RydWN0c1wiLFxuICAgICAgYXNzZXJ0OiBcIkBhd3MtY2RrL2Fzc2VydFwiLFxuICAgICAgYXNzZXJ0aW9uczogXCJAYXdzLWNkay9hc3NlcnRpb25zXCIsXG4gICAgfTtcbiAgfVxufVxuIl19

package/lib/awscdk/awscdk-deps-py.js

@@ -20,5 +20,5 @@ class AwsCdkDepsPy extends awscdk_deps_1.AwsCdkDeps {
 }
 exports.AwsCdkDepsPy = AwsCdkDepsPy;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkDepsPy[_a] = { fqn: "projen.awscdk.AwsCdkDepsPy", version: "0.98.3" };
+AwsCdkDepsPy[_a] = { fqn: "projen.awscdk.AwsCdkDepsPy", version: "0.98.5" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzY2RrLWRlcHMtcHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXdzY2RrL2F3c2Nkay1kZXBzLXB5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsK0NBQStEO0FBRS9EOztHQUVHO0FBQ0gsTUFBYSxZQUFhLFNBQVEsd0JBQVU7SUFDaEMsWUFBWTtRQUNwQixPQUFPO1lBQ0wsTUFBTSxFQUFFLGNBQWM7WUFDdEIsTUFBTSxFQUFFLGFBQWE7WUFDckIsVUFBVSxFQUFFLFlBQVk7WUFDeEIsTUFBTSxFQUFFLGdCQUFnQjtZQUN4QixVQUFVLEVBQUUsb0JBQW9CO1NBQ2pDLENBQUM7SUFDSixDQUFDOztBQVRILG9DQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXdzQ2RrRGVwcywgQXdzQ2RrUGFja2FnZU5hbWVzIH0gZnJvbSBcIi4vYXdzY2RrLWRlcHNcIjtcblxuLyoqXG4gKiBNYW5hZ2VzIGRlcGVuZGVuY2llcyBvbiB0aGUgQVdTIENESyBmb3IgUHl0aG9uIHByb2plY3RzLlxuICovXG5leHBvcnQgY2xhc3MgQXdzQ2RrRGVwc1B5IGV4dGVuZHMgQXdzQ2RrRGVwcyB7XG4gIHByb3RlY3RlZCBwYWNrYWdlTmFtZXMoKTogQXdzQ2RrUGFja2FnZU5hbWVzIHtcbiAgICByZXR1cm4ge1xuICAgICAgY29yZVYxOiBcImF3c19jZGsuY29yZVwiLFxuICAgICAgY29yZVYyOiBcImF3cy1jZGstbGliXCIsXG4gICAgICBjb25zdHJ1Y3RzOiBcImNvbnN0cnVjdHNcIixcbiAgICAgIGFzc2VydDogXCJhd3NfY2RrLmFzc2VydFwiLFxuICAgICAgYXNzZXJ0aW9uczogXCJhd3NfY2RrLmFzc2VydGlvbnNcIixcbiAgICB9O1xuICB9XG59XG4iXX0=

package/lib/awscdk/awscdk-deps.js

@@ -160,7 +160,7 @@ class AwsCdkDeps extends component_1.Component {
 }
 exports.AwsCdkDeps = AwsCdkDeps;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkDeps[_a] = { fqn: "projen.awscdk.AwsCdkDeps", version: "0.98.3" };
+AwsCdkDeps[_a] = { fqn: "projen.awscdk.AwsCdkDeps", version: "0.98.5" };
 /**
  * Which AWS CDK version a construct library package belongs to.
  */

package/lib/awscdk/cdk-config.js

@@ -19,7 +19,7 @@ class CdkFeatureFlagsV1 {
 }
 exports.CdkFeatureFlagsV1 = CdkFeatureFlagsV1;
 _a = JSII_RTTI_SYMBOL_1;
-CdkFeatureFlagsV1[_a] = { fqn: "projen.awscdk.CdkFeatureFlagsV1", version: "0.98.3" };
+CdkFeatureFlagsV1[_a] = { fqn: "projen.awscdk.CdkFeatureFlagsV1", version: "0.98.5" };
 /**
  * Disable all feature flags.
  */
@@ -55,7 +55,7 @@ class CdkFeatureFlagsV2 {
 }
 exports.CdkFeatureFlagsV2 = CdkFeatureFlagsV2;
 _b = JSII_RTTI_SYMBOL_1;
-CdkFeatureFlagsV2[_b] = { fqn: "projen.awscdk.CdkFeatureFlagsV2", version: "0.98.3" };
+CdkFeatureFlagsV2[_b] = { fqn: "projen.awscdk.CdkFeatureFlagsV2", version: "0.98.5" };
 /**
  * Disable all feature flags.
  */
@@ -79,7 +79,7 @@ class CdkFeatureFlags {
 }
 exports.CdkFeatureFlags = CdkFeatureFlags;
 _c = JSII_RTTI_SYMBOL_1;
-CdkFeatureFlags[_c] = { fqn: "projen.awscdk.CdkFeatureFlags", version: "0.98.3" };
+CdkFeatureFlags[_c] = { fqn: "projen.awscdk.CdkFeatureFlags", version: "0.98.5" };
 /**
  * CDK V1 feature flags configuration.
  * @deprecated CDK V1 is EOS. Upgrade to CDK V2.
@@ -156,7 +156,7 @@ class CdkConfig extends component_1.Component {
 }
 exports.CdkConfig = CdkConfig;
 _d = JSII_RTTI_SYMBOL_1;
-CdkConfig[_d] = { fqn: "projen.awscdk.CdkConfig", version: "0.98.3" };
+CdkConfig[_d] = { fqn: "projen.awscdk.CdkConfig", version: "0.98.5" };
 /**
  * Which approval is required when deploying CDK apps.
  */