@nikovirtala/projen-constructs 0.1.7 → 0.2.0

package/lib/project-generator.js

@@ -1,23 +1,29 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectGenerator = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const jsii_struct_builder_1 = require("@mrgrain/jsii-struct-builder");
-const projen_1 = require("projen");
+const projen = require("projen");
 const errors_1 = require("./errors");
 /**
  * Default components applied to all generated projects
  */
-const DEFAULT_COMPONENTS = [
-    { component: require("./components/mise").Mise },
-    {
-        component: require("./components/vitest").Vitest,
-        optionsProperty: {
-            name: "vitestOptions",
-            type: "@nikovirtala/projen-constructs.VitestOptions",
-            docs: "Vitest configuration",
+function getDefaultComponents() {
+    return [
+        { componentClass: require("./components/mise").Mise },
+        {
+            componentClass: require("./components/vitest").Vitest,
+            optionsProperty: {
+                name: "vitestOptions",
+                type: "@nikovirtala/projen-constructs.VitestOptions",
+                docs: "Vitest configuration",
+            },
         },
-    },
-];
+    ];
+}
 /**
  * Buffer for building indented code with automatic line management
  *
@@ -91,6 +97,8 @@ class CodeBuffer {
  *
  * Generates a complete TypeScript class file including imports, options interface export,
  * class declaration, and constructor with component integration.
+ *
+ * Uses JSII manifest introspection to validate base classes and options interfaces.
  */
 class TypeScriptClassRenderer {
     /**
@@ -98,6 +106,11 @@ class TypeScriptClassRenderer {
      */
     constructor(indent = 4) {
         this.buffer = new CodeBuffer(" ".repeat(indent));
+        /* Load Projen's JSII manifest for base class introspection */
+        const projenPackageJson = require.resolve("projen/package.json");
+        const projenRoot = (0, node_path_1.dirname)(projenPackageJson);
+        const jsiiPath = (0, node_path_1.join)(projenRoot, ".jsii");
+        this.jsiiManifest = JSON.parse((0, node_fs_1.readFileSync)(jsiiPath, "utf-8"));
     }
     /**
      * Renders complete TypeScript class code from options
@@ -112,10 +125,10 @@ class TypeScriptClassRenderer {
         this.buffer.flush();
         /* Derive interface and type names from the class name */
         const optionsInterface = `${options.name}Options`;
-        const baseOptionsFqn = this.getBaseOptionsFqn(options.baseClass);
+        const baseOptionsFqn = this.getBaseOptionsFqn(options.projectType);
         const baseOptionsType = baseOptionsFqn.replace(/^projen\./, "");
         /* Use provided components or fall back to defaults (Mise + Vitest) */
-        const components = options.components ?? DEFAULT_COMPONENTS;
+        const components = options.components ?? getDefaultComponents();
         /* Extract component configuration for constructor generation */
         const { destructure, componentArray } = this.extractComponentOptions(components);
         const imports = this.extractImports(options, optionsInterface);
@@ -125,29 +138,40 @@ class TypeScriptClassRenderer {
         this.renderExport(optionsInterface);
         this.buffer.line();
         this.renderClass(options, optionsInterface, baseOptionsType, destructure, componentArray);
-        this.buffer.line();
         return this.buffer.flush().join("\n");
     }
     /**
-     * Derives the fully qualified options interface name from base class
+     * Derives the fully qualified options interface name from project type
      *
-     * Transforms base class reference into the corresponding Projen options interface name
+     * Transforms project type into the corresponding Projen options interface name
      * by appending "Options" suffix and prefixing with "projen." namespace.
+     * Validates that the base class exists in Projen's JSII manifest.
      *
-     * @param baseClass - Base class in format "module.ClassName"
+     * @param projectType - Project type identifier
      * @returns Fully qualified options interface name
-     * @throws {InvalidBaseClassFormatError} When baseClass format is invalid
+     * @throws {InvalidBaseClassFormatError} When projectType format is invalid or class not found
      *
      * @example
-     * getBaseOptionsFqn("typescript.TypeScriptProject") // "projen.typescript.TypeScriptProjectOptions"
-     * getBaseOptionsFqn("cdk.JsiiProject") // "projen.cdk.JsiiProjectOptions"
+     * getBaseOptionsFqn(ProjectType.TYPESCRIPT) // "projen.typescript.TypeScriptProjectOptions"
+     * getBaseOptionsFqn(ProjectType.JSII) // "projen.cdk.JsiiProjectOptions"
      */
-    getBaseOptionsFqn(baseClass) {
+    getBaseOptionsFqn(projectType) {
+        const baseClass = projectType.valueOf();
         /* Validate base class format: must contain module.ClassName structure */
         if (!baseClass.includes(".")) {
             throw new errors_1.InvalidBaseClassFormatError(baseClass);
         }
-        return `projen.${baseClass}Options`;
+        const baseClassFqn = `projen.${baseClass}`;
+        const optionsFqn = `${baseClassFqn}Options`;
+        /* Validate base class exists in JSII manifest */
+        if (!this.jsiiManifest.types?.[baseClassFqn]) {
+            throw new errors_1.InvalidBaseClassFormatError(`Base class not found in JSII manifest: ${baseClassFqn}`);
+        }
+        /* Validate options interface exists in JSII manifest */
+        if (!this.jsiiManifest.types?.[optionsFqn]) {
+            throw new errors_1.InvalidBaseClassFormatError(`Options interface not found in JSII manifest: ${optionsFqn}`);
+        }
+        return optionsFqn;
     }
     /**
      * Extracts component configuration for constructor code generation
@@ -171,14 +195,15 @@ class TypeScriptClassRenderer {
         const componentParts = [];
         for (const c of components) {
             /* Convert component class name to camelCase variable name (e.g., Vitest -> vitest) */
-            const name = c.component.name.charAt(0).toLowerCase() + c.component.name.slice(1);
+            const name = c.componentClass.name.charAt(0).toLowerCase() + c.componentClass.name.slice(1);
             destructure.push(name);
             /* Build component config object for applyDefaults() call */
-            const parts = [`component: ${c.component.name}`];
-            if (c.optionsProperty) {
+            const parts = [`component: ${c.componentClass.name}`];
+            if (c.optionsProperty && typeof c.optionsProperty !== "boolean") {
                 /* Component has configurable options - include both enabled flag and options */
-                destructure.push(c.optionsProperty.name);
-                parts.push(`enabled: ${name}`, `options: ${c.optionsProperty.name}`);
+                const propName = typeof c.optionsProperty === "string" ? c.optionsProperty : c.optionsProperty.name;
+                destructure.push(propName);
+                parts.push(`enabled: ${name}`, `options: ${propName}`);
             }
             else {
                 /* Component has no options - only include enabled flag */
@@ -204,17 +229,17 @@ class TypeScriptClassRenderer {
      */
     extractImports(options, optionsInterface) {
         const imports = new Map();
-        /* Extract base module name from baseClass (e.g., "typescript" from "typescript.TypeScriptProject") */
-        const baseModule = options.baseClass.split(".")[0];
+        /* Extract base module name from projectType (e.g., "typescript" from "typescript.TypeScriptProject") */
+        const baseModule = options.projectType.valueOf().split(".")[0];
         const optionsFileName = this.getOptionsFileName(optionsInterface);
         /* Projen base module import */
         imports.set("projen", new Set([baseModule]));
         /* Configuration utilities import */
         imports.set("../config", new Set(["applyDefaults", "defaultOptions"]));
         /* Component class imports - derive module path from component class name */
-        const components = options.components ?? DEFAULT_COMPONENTS;
+        const components = options.components ?? getDefaultComponents();
         for (const c of components) {
-            const componentName = c.component.name;
+            const componentName = c.componentClass.name;
             const modulePath = `../components/${componentName.toLowerCase()}`;
             if (!imports.has(modulePath)) {
                 imports.set(modulePath, new Set());
@@ -233,17 +258,17 @@ class TypeScriptClassRenderer {
     /**
      * Derives the config path for accessing default options
      *
-     * Transforms base class reference into the corresponding path in the defaultOptions
+     * Transforms project type into the corresponding path in the defaultOptions
      * configuration object exported from config.ts.
      *
-     * @param baseClass - Base class in format "module.ClassName"
+     * @param projectType - Project type identifier
      * @returns Config path for accessing default options
      *
      * @example
-     * getConfigPath("typescript.TypeScriptProject") // "defaultOptions.typescript.TypeScriptProject"
+     * getConfigPath(ProjectType.TYPESCRIPT) // "defaultOptions.typescript.TypeScriptProject"
      */
-    getConfigPath(baseClass) {
-        return `defaultOptions.${baseClass}`;
+    getConfigPath(projectType) {
+        return `defaultOptions.${projectType.valueOf()}`;
     }
     /**
      * Renders import statements in sorted order
@@ -278,7 +303,6 @@ class TypeScriptClassRenderer {
      */
     renderExport(optionsInterface) {
         const optionsFileName = this.getOptionsFileName(optionsInterface);
-        this.buffer.line();
         this.buffer.line(`export { ${optionsInterface} } from "./${optionsFileName}.generated";`);
     }
     /**
@@ -291,13 +315,12 @@ class TypeScriptClassRenderer {
      * @param componentArray - Code string for component array
      */
     renderClass(options, optionsInterface, baseOptionsType, destructure, componentArray) {
-        this.buffer.line();
         this.buffer.line("/**");
         this.buffer.line(` * ${options.name} with standard configuration and component integration`);
         this.buffer.line(" *");
         this.buffer.line(" * Extends Projen's base class with opinionated defaults and automatic component setup.");
         this.buffer.line(" */");
-        this.buffer.open(`export class ${options.name} extends ${options.baseClass} {`);
+        this.buffer.open(`export class ${options.name} extends ${options.projectType.valueOf()} {`);
         this.renderConstructor(options, optionsInterface, baseOptionsType, destructure, componentArray);
         this.buffer.close("}");
     }
@@ -317,7 +340,7 @@ class TypeScriptClassRenderer {
      * @param componentArray - Code string for component array
      */
     renderConstructor(options, optionsInterface, baseOptionsType, destructure, componentArray) {
-        const configPath = this.getConfigPath(options.baseClass);
+        const configPath = this.getConfigPath(options.projectType);
         this.buffer.line("/**");
         this.buffer.line(" * @param options - Project configuration");
         this.buffer.line(" */");
@@ -358,27 +381,9 @@ class TypeScriptClassRenderer {
  * Projen component that generates TypeScript project classes with standard configuration
  *
  * This component automates the creation of project classes that extend Projen base classes
- * with opinionated defaults and component integration. It generates both:
- * 1. An options interface (via ProjenStruct) that extends the base Projen options
- * 2. A project class that applies default configuration and instantiates components
- *
- * The generated code follows a consistent pattern:
- * - Imports required modules and components
- * - Re-exports the generated options interface
- * - Defines a class extending the Projen base class
- * - Constructor merges defaults with user options and applies components
- *
- * @example
- * ```typescript
- * new ProjectGenerator(project, {
- *   name: "TypeScriptProject",
- *   baseClass: "typescript.TypeScriptProject",
- *   filePath: "src/projects/typescript.generated.ts",
- *   components: [{ component: Vitest, optionsProperty: "vitestOptions" }]
- * });
- * ```
+ * with opinionated defaults and component integration.
  */
-class ProjectGenerator extends projen_1.Component {
+class ProjectGenerator extends projen.Component {
     /**
      * @param project - Projen project instance
      * @param options - Generator configuration
@@ -387,9 +392,14 @@ class ProjectGenerator extends projen_1.Component {
         super(project);
         this.options = options;
         this.renderer = new TypeScriptClassRenderer();
+        /* Generate ProjectType enum once on first instantiation */
+        if (!ProjectGenerator.enumGenerated) {
+            this.generateProjectTypeEnum();
+            ProjectGenerator.enumGenerated = true;
+        }
         /* Generate the options interface using ProjenStruct for JSII compatibility */
         const optionsInterface = `${options.name}Options`;
-        const baseOptionsFqn = this.renderer.getBaseOptionsFqn(options.baseClass);
+        const baseOptionsFqn = this.renderer.getBaseOptionsFqn(options.projectType);
         const optionsFilePath = this.getOptionsFilePath(optionsInterface);
         /* ProjenStruct generates a concrete TypeScript interface from Projen's options
          * This is necessary because JSII doesn't support TypeScript utility types like Omit<>
@@ -406,35 +416,48 @@ class ProjectGenerator extends projen_1.Component {
             struct.omit(...options.omitOptions);
         }
         /* Add component-derived options to the interface */
-        const components = options.components ?? DEFAULT_COMPONENTS;
+        const components = options.components ?? getDefaultComponents();
         const { PrimitiveType } = require("@jsii/spec");
         for (const c of components) {
-            const name = c.component.name.charAt(0).toLowerCase() + c.component.name.slice(1);
+            const name = c.componentClass.name.charAt(0).toLowerCase() + c.componentClass.name.slice(1);
             /* Add enabled flag for the component */
             struct.add({
                 name,
                 type: { primitive: PrimitiveType.Boolean },
                 optional: true,
                 docs: {
-                    summary: `Enable ${c.component.name} component`,
+                    summary: `Enable ${c.componentClass.name} component`,
                     default: "true",
                 },
             });
             /* Add options property if component is configurable */
-            if (c.optionsProperty) {
-                struct.add({
-                    name: c.optionsProperty.name,
-                    type: { fqn: c.optionsProperty.type },
-                    optional: true,
-                    docs: {
-                        summary: c.optionsProperty.docs ?? `${c.component.name} configuration`,
-                        default: `- default ${c.component.name} configuration`,
-                    },
-                });
+            if (c.optionsProperty !== false) {
+                try {
+                    const optionsType = this.resolveComponentOptionsType(c);
+                    if (optionsType && this.isFqnAvailable(optionsType.fqn)) {
+                        struct.add({
+                            name: optionsType.name,
+                            type: { fqn: optionsType.fqn },
+                            optional: true,
+                            docs: {
+                                summary: optionsType.docs ?? `${c.componentClass.name} configuration`,
+                                default: `- default ${c.componentClass.name} configuration`,
+                            },
+                        });
+                    }
+                }
+                catch (error) {
+                    /* Component has no options parameter or resolution failed - skip */
+                    console.warn(JSON.stringify({
+                        message: "Failed to resolve component options type",
+                        component: c.componentClass.name,
+                        error: error instanceof Error ? error.message : String(error),
+                    }));
+                }
             }
         }
         /* Add custom options to the interface */
-        if (options.additionalOptions) {
+        if (options.additionalOptions && options.additionalOptions.length > 0) {
             struct.add(...options.additionalOptions);
         }
     }
@@ -484,15 +507,277 @@ class ProjectGenerator extends projen_1.Component {
             readonly: this.options.readonly ?? true,
         });
     }
+    /**
+     * Checks if an FQN is available in any JSII manifest
+     */
+    isFqnAvailable(fqn) {
+        try {
+            const manifest = this.loadManifestForFqn(fqn);
+            return manifest.types?.[fqn] !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Resolves component options type from JSII manifest
+     *
+     * Auto-detects options from JSII manifest when optionsProperty is undefined.
+     * Returns null only when optionsProperty is explicitly set to false.
+     */
+    resolveComponentOptionsType(component) {
+        /* Normalize optionsProperty to ComponentOptions */
+        let optionsConfig;
+        if (typeof component.optionsProperty === "string") {
+            optionsConfig = { name: component.optionsProperty };
+        }
+        else if (component.optionsProperty && typeof component.optionsProperty === "object") {
+            optionsConfig = component.optionsProperty;
+        }
+        /* Use explicit type if provided */
+        if (optionsConfig?.type) {
+            return {
+                name: optionsConfig.name,
+                fqn: optionsConfig.type,
+                docs: optionsConfig.docs,
+            };
+        }
+        /* Find component in JSII manifests */
+        const componentFqn = component.fqn ?? this.findComponentFqn(component.componentClass.name);
+        const manifest = this.loadManifestForFqn(componentFqn);
+        const classType = manifest.types?.[componentFqn];
+        if (!classType || classType.kind !== "class") {
+            throw new errors_1.ComponentResolutionError(componentFqn, "Component not found in JSII manifest");
+        }
+        const initializer = classType
+            .initializer;
+        if (!initializer?.parameters?.[1]) {
+            return null; /* Component has no options parameter */
+        }
+        const optionsParam = initializer.parameters[1];
+        const optionsFqn = optionsParam.type?.fqn;
+        if (!optionsFqn) {
+            return null; /* Options parameter has no FQN */
+        }
+        const optionsType = manifest.types?.[optionsFqn];
+        const docs = optionsType?.docs?.summary;
+        /* Auto-generate property name if not provided */
+        const name = component.componentClass.name;
+        const defaultName = `${name.charAt(0).toLowerCase()}${name.slice(1)}Options`;
+        const propertyName = optionsConfig?.name ?? defaultName;
+        return { name: propertyName, fqn: optionsFqn, docs };
+    }
+    /**
+     * Finds component FQN by searching all JSII manifests
+     */
+    findComponentFqn(componentName) {
+        /* Try own package first */
+        const ownFqn = `@nikovirtala/projen-constructs.${componentName}`;
+        try {
+            const ownManifest = this.loadOwnManifest();
+            if (ownManifest.types?.[ownFqn]) {
+                return ownFqn;
+            }
+        }
+        catch (error) {
+            /* Own manifest not available yet during development - this is expected */
+            console.warn(JSON.stringify({
+                message: "Own manifest not available",
+                component: componentName,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+        /* Search in node_modules for JSII packages */
+        const nodeModulesPath = (0, node_path_1.join)(__dirname, "../../node_modules");
+        const packages = this.findJsiiPackages(nodeModulesPath);
+        for (const pkg of packages) {
+            try {
+                const manifest = this.loadManifestFromPackage(pkg);
+                for (const fqn of Object.keys(manifest.types ?? {})) {
+                    if (fqn.endsWith(`.${componentName}`)) {
+                        return fqn;
+                    }
+                }
+            }
+            catch (error) {
+                /* Skip packages with invalid manifests - log for debugging */
+                console.warn(JSON.stringify({
+                    message: "Failed to load manifest from package",
+                    package: pkg,
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+            }
+        }
+        throw new errors_1.ComponentResolutionError(componentName, "Component not found in any JSII manifest");
+    }
+    /**
+     * Finds all JSII packages in node_modules
+     */
+    findJsiiPackages(nodeModulesPath) {
+        const packages = [];
+        const { readdirSync, statSync, existsSync } = require("node:fs");
+        if (!existsSync(nodeModulesPath)) {
+            return packages;
+        }
+        const resolvedBase = (0, node_path_1.resolve)(nodeModulesPath);
+        for (const entry of readdirSync(nodeModulesPath)) {
+            const entryPath = (0, node_path_1.resolve)(nodeModulesPath, entry);
+            /* Prevent path traversal attacks */
+            if (!entryPath.startsWith(resolvedBase)) {
+                continue;
+            }
+            if (entry.startsWith("@")) {
+                /* Scoped package - recurse into scope */
+                const scopePath = entryPath;
+                for (const scopedEntry of readdirSync(scopePath)) {
+                    const pkgPath = (0, node_path_1.resolve)(scopePath, scopedEntry);
+                    /* Prevent path traversal attacks */
+                    if (!pkgPath.startsWith(resolvedBase)) {
+                        continue;
+                    }
+                    if (existsSync((0, node_path_1.join)(pkgPath, ".jsii"))) {
+                        packages.push(pkgPath);
+                    }
+                }
+            }
+            else if (statSync(entryPath).isDirectory()) {
+                /* Regular package */
+                if (existsSync((0, node_path_1.join)(entryPath, ".jsii"))) {
+                    packages.push(entryPath);
+                }
+            }
+        }
+        return packages;
+    }
+    /**
+     * Loads JSII manifest for a given FQN
+     *
+     * Extracts package name from FQN. For scoped packages like @scope/package.ClassName,
+     * the package name is everything before the first dot (i.e., @scope/package).
+     */
+    loadManifestForFqn(fqn) {
+        const dotIndex = fqn.indexOf(".");
+        const packageName = dotIndex > 0 ? fqn.substring(0, dotIndex) : fqn;
+        /* Try own package */
+        if (packageName === "@nikovirtala/projen-constructs") {
+            return this.loadOwnManifest();
+        }
+        /* Try node_modules */
+        try {
+            const pkgJsonPath = require.resolve(`${packageName}/package.json`);
+            return this.loadManifestFromPackage((0, node_path_1.dirname)(pkgJsonPath));
+        }
+        catch (error) {
+            throw new errors_1.ManifestLoadError(packageName, error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Loads JSII manifest from a package directory
+     */
+    loadManifestFromPackage(packagePath) {
+        const jsiiPath = (0, node_path_1.join)(packagePath, ".jsii");
+        return JSON.parse((0, node_fs_1.readFileSync)(jsiiPath, "utf-8"));
+    }
+    /**
+     * Loads this package's JSII manifest
+     */
+    loadOwnManifest() {
+        const jsiiPath = (0, node_path_1.join)(__dirname, "../.jsii");
+        return JSON.parse((0, node_fs_1.readFileSync)(jsiiPath, "utf-8"));
+    }
+    /**
+     * Generates ProjectType enum from Projen's JSII manifest
+     */
+    generateProjectTypeEnum() {
+        const projectTypes = this.discoverProjectTypes();
+        const lines = [];
+        lines.push("/**");
+        lines.push(" * Enum defining all supported project types");
+        lines.push(" *");
+        lines.push(" * Each project type corresponds to a generated project class and its configuration");
+        lines.push(" * in the defaultOptions structure.");
+        lines.push(" *");
+        lines.push(" * @generated Automatically generated from Projen's JSII manifest");
+        lines.push(" */");
+        lines.push("export enum ProjectType {");
+        for (const [enumName, value, docs] of projectTypes) {
+            lines.push("    /**");
+            lines.push(`     * ${docs}`);
+            lines.push("     */");
+            lines.push(`    ${enumName} = "${value}",`);
+            lines.push("");
+        }
+        lines.push("}");
+        new projen.TextFile(this.project, "src/project-type.ts", {
+            readonly: true,
+            lines,
+        });
+    }
+    /**
+     * Discovers all project types that extend projen.Project
+     */
+    discoverProjectTypes() {
+        const projectTypes = [];
+        const baseClass = "projen.Project";
+        for (const [fqn, type] of Object.entries(this.renderer.jsiiManifest.types ?? {})) {
+            if (type.kind !== "class") {
+                continue;
+            }
+            const classType = type;
+            if (classType.abstract) {
+                continue;
+            }
+            if (!this.extendsBase(classType, baseClass)) {
+                continue;
+            }
+            const parts = fqn.split(".");
+            if (parts.length < 3 || parts[0] !== "projen") {
+                continue;
+            }
+            const module = parts[1];
+            const className = parts.slice(2).join(".");
+            const enumName = className
+                .replace(/([A-Z])/g, "_$1")
+                .toUpperCase()
+                .replace(/^_/, "");
+            const value = `${module}.${className}`;
+            const docs = classType.docs?.summary ?? className;
+            projectTypes.push([enumName, value, docs]);
+        }
+        return projectTypes.sort((a, b) => a[0].localeCompare(b[0]));
+    }
+    /**
+     * Checks if a class extends the base class
+     */
+    extendsBase(classType, baseClass) {
+        if (classType.inheritancePath) {
+            return classType.inheritancePath.includes(baseClass);
+        }
+        let currentBase = classType.base;
+        while (currentBase) {
+            if (currentBase === baseClass) {
+                return true;
+            }
+            const baseType = this.renderer.jsiiManifest.types?.[currentBase];
+            if (!baseType || baseType.kind !== "class") {
+                break;
+            }
+            currentBase = baseType.base;
+        }
+        return false;
+    }
 }
 exports.ProjectGenerator = ProjectGenerator;
+_a = JSII_RTTI_SYMBOL_1;
+ProjectGenerator[_a] = { fqn: "@nikovirtala/projen-constructs.ProjectGenerator", version: "0.2.0" };
+ProjectGenerator.enumGenerated = false;
 /**
  * Text file for generated TypeScript class code
  *
  * Extends Projen's TextFile to add the generated file marker comment
  * at the beginning of the file.
  */
-class TypeScriptClassFile extends projen_1.TextFile {
+class TypeScriptClassFile extends projen.TextFile {
     /**
      * @param project - Projen project instance
      * @param filePath - Output file path
@@ -506,4 +791,4 @@ class TypeScriptClassFile extends projen_1.TextFile {
         this.addLine(content);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-generator.js","sourceRoot":"","sources":["../src/project-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Property } from \"@jsii/spec\";\nimport { ProjenStruct, Struct } from \"@mrgrain/jsii-struct-builder\";\nimport type { Project, SourceCodeOptions, typescript } from \"projen\";\nimport { Component, TextFile } from \"projen\";\nimport { InvalidBaseClassFormatError, InvalidFilePathError, InvalidIndentLevelError } from \"./errors\";\n\ntype ProjenModule = \"typescript\" | \"cdk\" | \"awscdk\";\ntype ProjenBaseClass<M extends ProjenModule> = `${M}.${string}`;\n\n/**\n * Default components applied to all generated projects\n */\nconst DEFAULT_COMPONENTS: ComponentConfig[] = [\n    { component: require(\"./components/mise\").Mise },\n    {\n        component: require(\"./components/vitest\").Vitest,\n        optionsProperty: {\n            name: \"vitestOptions\",\n            type: \"@nikovirtala/projen-constructs.VitestOptions\",\n            docs: \"Vitest configuration\",\n        },\n    },\n];\n\n/**\n * Configuration for a component to be integrated into a generated project\n *\n * @example\n * ```typescript\n * const config: ComponentConfig = {\n *   component: Vitest,\n *   optionsProperty: \"vitestOptions\"\n * };\n * ```\n */\ninterface ComponentConfig<T extends Component = Component> {\n    /**\n     * Component class constructor\n     */\n    readonly component: new (\n        project: never,\n        options?: never,\n    ) => T;\n\n    /**\n     * Options property configuration for the generated options interface\n     *\n     * When specified, adds an options property to the interface allowing\n     * users to configure the component.\n     */\n    readonly optionsProperty?: {\n        /**\n         * Name of the options property (e.g., \"vitestOptions\")\n         */\n        readonly name: string;\n        /**\n         * Fully qualified type name (e.g., \"@nikovirtala/projen-constructs.VitestOptions\")\n         */\n        readonly type: string;\n        /**\n         * Documentation summary\n         */\n        readonly docs?: string;\n    };\n}\n\n/**\n * Options for ProjectGenerator component\n *\n * Configures the generation of a TypeScript project class that extends a Projen base class\n * with standard configuration and component integration.\n *\n * @example\n * ```typescript\n * new ProjectGenerator(project, {\n *   name: \"TypeScriptProject\",\n *   baseClass: \"typescript.TypeScriptProject\",\n *   filePath: \"src/projects/typescript.generated.ts\",\n *   components: [{ component: Vitest, optionsProperty: \"vitestOptions\" }]\n * });\n * ```\n */\nexport interface ProjectGeneratorOptions<M extends ProjenModule = ProjenModule> extends SourceCodeOptions {\n    /**\n     * Name of the generated class (e.g., \"TypeScriptProject\")\n     *\n     * The options interface will be named `${name}Options`.\n     */\n    readonly name: string;\n\n    /**\n     * Fully qualified base class to extend in format \"module.ClassName\"\n     *\n     * Must be a valid Projen class reference like \"typescript.TypeScriptProject\",\n     * \"cdk.JsiiProject\", or \"awscdk.AwsCdkTypeScriptApp\".\n     *\n     * @example \"typescript.TypeScriptProject\"\n     * @example \"cdk.JsiiProject\"\n     */\n    readonly baseClass: ProjenBaseClass<M>;\n\n    /**\n     * Output file path for the generated class\n     *\n     * Must contain a directory separator. The options interface will be generated\n     * in the same directory with a \".generated.ts\" suffix.\n     *\n     * @example \"src/projects/typescript.generated.ts\"\n     */\n    readonly filePath: string;\n\n    /**\n     * Components to integrate into the project\n     *\n     * Each component will be instantiated during project construction and can be\n     * configured via an optional options property in the generated interface.\n     *\n     * @default [{ component: Mise }, { component: Vitest, optionsProperty: { name: \"vitestOptions\", type: \"...\", docs: \"...\" } }]\n     */\n    readonly components?: ComponentConfig[];\n\n    /**\n     * Additional properties to add to the generated options interface\n     *\n     * Use this to extend the base options with custom properties specific to\n     * your project type.\n     */\n    readonly additionalOptions?: Property[];\n\n    /**\n     * Property names to omit from the base options interface\n     *\n     * Use this to hide base class options that should not be configurable\n     * in the generated project type.\n     */\n    readonly omitOptions?: string[];\n}\n\n/**\n * Buffer for building indented code with automatic line management\n *\n * Maintains indentation level and provides methods for adding lines,\n * opening/closing blocks, and flushing accumulated content.\n */\nclass CodeBuffer {\n    private lines: string[] = [];\n    private indentLevel = 0;\n\n    /**\n     * @param indent - String to use for each indentation level (default: single space)\n     */\n    constructor(private readonly indent = \" \") {}\n\n    /**\n     * Returns all accumulated lines and resets the buffer\n     *\n     * @returns Array of code lines with proper indentation\n     */\n    flush(): string[] {\n        const current = this.lines;\n        this.reset();\n        return current;\n    }\n\n    /**\n     * Adds a line of code at the current indentation level\n     *\n     * @param code - Code to add (optional, adds blank line if omitted)\n     */\n    line(code?: string) {\n        const prefix = this.indent.repeat(this.indentLevel);\n        this.lines.push((prefix + (code ?? \"\")).trimEnd());\n    }\n\n    /**\n     * Opens a new indentation block\n     *\n     * @param code - Optional code to add before increasing indent (e.g., opening brace)\n     */\n    open(code?: string) {\n        if (code) {\n            this.line(code);\n        }\n        this.indentLevel++;\n    }\n\n    /**\n     * Closes the current indentation block\n     *\n     * @param code - Optional code to add after decreasing indent (e.g., closing brace)\n     * @throws {InvalidIndentLevelError} When attempting to decrease indent below zero\n     */\n    close(code?: string) {\n        if (this.indentLevel === 0) {\n            throw new InvalidIndentLevelError();\n        }\n        this.indentLevel--;\n        if (code) {\n            this.line(code);\n        }\n    }\n\n    /**\n     * Resets the buffer to initial state\n     */\n    private reset(): void {\n        this.lines = [];\n        this.indentLevel = 0;\n    }\n}\n\n/**\n * Renders TypeScript class code from ProjectGenerator options\n *\n * Generates a complete TypeScript class file including imports, options interface export,\n * class declaration, and constructor with component integration.\n */\nclass TypeScriptClassRenderer {\n    private buffer: CodeBuffer;\n\n    /**\n     * @param indent - Number of spaces per indentation level (default: 4)\n     */\n    constructor(indent = 4) {\n        this.buffer = new CodeBuffer(\" \".repeat(indent));\n    }\n\n    /**\n     * Renders complete TypeScript class code from options\n     *\n     * Orchestrates the rendering process: derives names, extracts component configuration,\n     * builds import statements, and renders the class structure.\n     *\n     * @param options - Generator configuration\n     * @returns Complete TypeScript class code as a string\n     */\n    render(options: ProjectGeneratorOptions<ProjenModule>): string {\n        this.buffer.flush();\n\n        /* Derive interface and type names from the class name */\n        const optionsInterface = `${options.name}Options`;\n        const baseOptionsFqn = this.getBaseOptionsFqn(options.baseClass);\n        const baseOptionsType = baseOptionsFqn.replace(/^projen\\./, \"\");\n\n        /* Use provided components or fall back to defaults (Mise + Vitest) */\n        const components = options.components ?? DEFAULT_COMPONENTS;\n\n        /* Extract component configuration for constructor generation */\n        const { destructure, componentArray } = this.extractComponentOptions(components);\n        const imports = this.extractImports(options, optionsInterface);\n\n        /* Render all sections of the class file */\n        this.renderImports(imports);\n        this.buffer.line();\n        this.renderExport(optionsInterface);\n        this.buffer.line();\n        this.renderClass(options, optionsInterface, baseOptionsType, destructure, componentArray);\n        this.buffer.line();\n\n        return this.buffer.flush().join(\"\\n\");\n    }\n\n    /**\n     * Derives the fully qualified options interface name from base class\n     *\n     * Transforms base class reference into the corresponding Projen options interface name\n     * by appending \"Options\" suffix and prefixing with \"projen.\" namespace.\n     *\n     * @param baseClass - Base class in format \"module.ClassName\"\n     * @returns Fully qualified options interface name\n     * @throws {InvalidBaseClassFormatError} When baseClass format is invalid\n     *\n     * @example\n     * getBaseOptionsFqn(\"typescript.TypeScriptProject\") // \"projen.typescript.TypeScriptProjectOptions\"\n     * getBaseOptionsFqn(\"cdk.JsiiProject\") // \"projen.cdk.JsiiProjectOptions\"\n     */\n    getBaseOptionsFqn(baseClass: string): string {\n        /* Validate base class format: must contain module.ClassName structure */\n        if (!baseClass.includes(\".\")) {\n            throw new InvalidBaseClassFormatError(baseClass);\n        }\n\n        return `projen.${baseClass}Options`;\n    }\n\n    /**\n     * Extracts component configuration for constructor code generation\n     *\n     * Transforms component configurations into:\n     * 1. Destructure list: variable names to extract from options\n     * 2. Component array: code string for applyDefaults() call\n     *\n     * @param components - Component configurations\n     * @returns Object with destructure array and componentArray code string\n     *\n     * @example\n     * Input: [{ component: Vitest, optionsProperty: { name: \"vitestOptions\", ... } }]\n     * Output: {\n     *   destructure: [\"vitest\", \"vitestOptions\"],\n     *   componentArray: \"[{ component: Vitest, enabled: vitest, options: vitestOptions }]\"\n     * }\n     */\n    private extractComponentOptions(components: ComponentConfig[]): { destructure: string[]; componentArray: string } {\n        const destructure: string[] = [];\n        const componentParts: string[] = [];\n\n        for (const c of components) {\n            /* Convert component class name to camelCase variable name (e.g., Vitest -> vitest) */\n            const name = c.component.name.charAt(0).toLowerCase() + c.component.name.slice(1);\n            destructure.push(name);\n\n            /* Build component config object for applyDefaults() call */\n            const parts = [`component: ${c.component.name}`];\n            if (c.optionsProperty) {\n                /* Component has configurable options - include both enabled flag and options */\n                destructure.push(c.optionsProperty.name);\n                parts.push(`enabled: ${name}`, `options: ${c.optionsProperty.name}`);\n            } else {\n                /* Component has no options - only include enabled flag */\n                parts.push(`enabled: ${name}`);\n            }\n            componentParts.push(`{ ${parts.join(\", \")} }`);\n        }\n\n        return { destructure, componentArray: `[${componentParts.join(\", \")}]` };\n    }\n\n    /**\n     * Builds import statements map for the generated class\n     *\n     * Collects all required imports:\n     * - Projen base module (typescript, cdk, awscdk)\n     * - Config utilities (applyDefaults, defaultOptions)\n     * - Component classes\n     * - Utility functions (deepMerge)\n     * - Generated options interface (type-only import)\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the generated options interface\n     * @returns Map of module paths to sets of imported names\n     */\n    private extractImports(\n        options: ProjectGeneratorOptions<ProjenModule>,\n        optionsInterface: string,\n    ): Map<string, Set<string>> {\n        const imports = new Map<string, Set<string>>();\n\n        /* Extract base module name from baseClass (e.g., \"typescript\" from \"typescript.TypeScriptProject\") */\n        const baseModule = options.baseClass.split(\".\")[0];\n        const optionsFileName = this.getOptionsFileName(optionsInterface);\n\n        /* Projen base module import */\n        imports.set(\"projen\", new Set([baseModule]));\n\n        /* Configuration utilities import */\n        imports.set(\"../config\", new Set([\"applyDefaults\", \"defaultOptions\"]));\n\n        /* Component class imports - derive module path from component class name */\n        const components = options.components ?? DEFAULT_COMPONENTS;\n        for (const c of components) {\n            const componentName = c.component.name;\n            const modulePath = `../components/${componentName.toLowerCase()}`;\n            if (!imports.has(modulePath)) {\n                imports.set(modulePath, new Set());\n            }\n            const moduleImports = imports.get(modulePath);\n            if (moduleImports) {\n                moduleImports.add(componentName);\n            }\n        }\n\n        /* Utility functions import */\n        imports.set(\"../utils\", new Set([\"deepMerge\"]));\n\n        /* Generated options interface import (type-only to avoid circular dependencies) */\n        imports.set(`./${optionsFileName}.generated`, new Set([optionsInterface]));\n\n        return imports;\n    }\n\n    /**\n     * Derives the config path for accessing default options\n     *\n     * Transforms base class reference into the corresponding path in the defaultOptions\n     * configuration object exported from config.ts.\n     *\n     * @param baseClass - Base class in format \"module.ClassName\"\n     * @returns Config path for accessing default options\n     *\n     * @example\n     * getConfigPath(\"typescript.TypeScriptProject\") // \"defaultOptions.typescript.TypeScriptProject\"\n     */\n    private getConfigPath(baseClass: string): string {\n        return `defaultOptions.${baseClass}`;\n    }\n\n    /**\n     * Renders import statements in sorted order\n     *\n     * Sorts imports with external packages first, then relative imports.\n     * Uses type-only imports for generated files to avoid circular dependencies.\n     *\n     * @param imports - Map of module paths to imported names\n     */\n    private renderImports(imports: Map<string, Set<string>>) {\n        /* Sort modules: external packages first, then relative imports alphabetically */\n        const sortedModules = Array.from(imports.keys()).sort((a, b) => {\n            const aIsRelative = a.startsWith(\".\");\n            const bIsRelative = b.startsWith(\".\");\n            if (aIsRelative !== bIsRelative) {\n                return aIsRelative ? 1 : -1;\n            }\n            return a.localeCompare(b);\n        });\n\n        for (const mod of sortedModules) {\n            const names = Array.from(imports.get(mod) || []).sort();\n            /* Use type-only import for generated files to prevent circular dependencies */\n            const isTypeOnly = mod.includes(\".generated\");\n            const importStmt = isTypeOnly ? \"import type\" : \"import\";\n            this.buffer.line(`${importStmt} { ${names.join(\", \")} } from \"${mod}\";`);\n        }\n    }\n\n    /**\n     * Renders re-export statement for the generated options interface\n     *\n     * @param optionsInterface - Name of the options interface to export\n     */\n    private renderExport(optionsInterface: string) {\n        const optionsFileName = this.getOptionsFileName(optionsInterface);\n        this.buffer.line();\n        this.buffer.line(`export { ${optionsInterface} } from \"./${optionsFileName}.generated\";`);\n    }\n\n    /**\n     * Renders the class declaration and constructor\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the options interface\n     * @param baseOptionsType - Base options type without \"projen.\" prefix\n     * @param destructure - Variable names to destructure from options\n     * @param componentArray - Code string for component array\n     */\n    private renderClass(\n        options: ProjectGeneratorOptions<ProjenModule>,\n        optionsInterface: string,\n        baseOptionsType: string,\n        destructure: string[],\n        componentArray: string,\n    ) {\n        this.buffer.line();\n        this.buffer.line(\"/**\");\n        this.buffer.line(` * ${options.name} with standard configuration and component integration`);\n        this.buffer.line(\" *\");\n        this.buffer.line(\" * Extends Projen's base class with opinionated defaults and automatic component setup.\");\n        this.buffer.line(\" */\");\n        this.buffer.open(`export class ${options.name} extends ${options.baseClass} {`);\n        this.renderConstructor(options, optionsInterface, baseOptionsType, destructure, componentArray);\n        this.buffer.close(\"}\");\n    }\n\n    /**\n     * Renders the constructor implementation\n     *\n     * The constructor:\n     * 1. Destructures component flags and options from the options parameter\n     * 2. Merges default configuration with user-provided options\n     * 3. Calls super() with merged options\n     * 4. Applies component defaults via applyDefaults()\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the options interface\n     * @param baseOptionsType - Base options type without \"projen.\" prefix\n     * @param destructure - Variable names to destructure from options\n     * @param componentArray - Code string for component array\n     */\n    private renderConstructor(\n        options: ProjectGeneratorOptions<ProjenModule>,\n        optionsInterface: string,\n        baseOptionsType: string,\n        destructure: string[],\n        componentArray: string,\n    ) {\n        const configPath = this.getConfigPath(options.baseClass);\n        this.buffer.line(\"/**\");\n        this.buffer.line(\" * @param options - Project configuration\");\n        this.buffer.line(\" */\");\n        this.buffer.open(`constructor(options: ${optionsInterface}) {`);\n        this.buffer.line(\"/* Separate component configuration from base Projen options */\");\n        this.buffer.line(`const { ${destructure.join(\", \")}, ...baseOptions } = options;`);\n        this.buffer.line();\n        this.buffer.line(\"/* Merge default configuration with user options and initialize base class */\");\n        this.buffer.line(`super(deepMerge<${baseOptionsType}>(${configPath}, baseOptions));`);\n        this.buffer.line();\n        this.buffer.line(\"/* Apply component defaults and instantiate enabled components */\");\n        this.buffer.line(`applyDefaults(this, ${componentArray});`);\n        this.buffer.close(\"}\");\n    }\n\n    /**\n     * Maps options interface name to file name\n     *\n     * Converts PascalCase interface names to kebab-case file names.\n     * Falls back to lowercase conversion for unmapped interfaces.\n     *\n     * @param optionsInterface - Options interface name\n     * @returns Kebab-case file name without extension\n     *\n     * @example\n     * getOptionsFileName(\"TypeScriptProjectOptions\") // \"typescript-options\"\n     */\n    getOptionsFileName(optionsInterface: string): string {\n        const mapping: Record<string, string> = {\n            TypeScriptProjectOptions: \"typescript-options\",\n            JsiiProjectOptions: \"jsii-options\",\n            AwsCdkTypeScriptAppProjectOptions: \"awscdk-typescript-app-options\",\n            AwsCdkConstructLibraryProjectOptions: \"awscdk-construct-library-options\",\n        };\n        return mapping[optionsInterface] || optionsInterface.toLowerCase();\n    }\n}\n\n/**\n * Projen component that generates TypeScript project classes with standard configuration\n *\n * This component automates the creation of project classes that extend Projen base classes\n * with opinionated defaults and component integration. It generates both:\n * 1. An options interface (via ProjenStruct) that extends the base Projen options\n * 2. A project class that applies default configuration and instantiates components\n *\n * The generated code follows a consistent pattern:\n * - Imports required modules and components\n * - Re-exports the generated options interface\n * - Defines a class extending the Projen base class\n * - Constructor merges defaults with user options and applies components\n *\n * @example\n * ```typescript\n * new ProjectGenerator(project, {\n *   name: \"TypeScriptProject\",\n *   baseClass: \"typescript.TypeScriptProject\",\n *   filePath: \"src/projects/typescript.generated.ts\",\n *   components: [{ component: Vitest, optionsProperty: \"vitestOptions\" }]\n * });\n * ```\n */\nexport class ProjectGenerator extends Component {\n    private renderer: TypeScriptClassRenderer;\n\n    /**\n     * @param project - Projen project instance\n     * @param options - Generator configuration\n     */\n    constructor(\n        project: Project,\n        private readonly options: ProjectGeneratorOptions<ProjenModule>,\n    ) {\n        super(project);\n        this.renderer = new TypeScriptClassRenderer();\n\n        /* Generate the options interface using ProjenStruct for JSII compatibility */\n        const optionsInterface = `${options.name}Options`;\n        const baseOptionsFqn = this.renderer.getBaseOptionsFqn(options.baseClass);\n        const optionsFilePath = this.getOptionsFilePath(optionsInterface);\n\n        /* ProjenStruct generates a concrete TypeScript interface from Projen's options\n         * This is necessary because JSII doesn't support TypeScript utility types like Omit<>\n         * The generated interface can be consumed by other languages (Python, Java, C#, Go) */\n        const struct = new ProjenStruct(this.asTypeScriptProject(project), {\n            name: optionsInterface,\n            filePath: optionsFilePath,\n            outputFileOptions: { readonly: true },\n        })\n            .mixin(Struct.fromFqn(baseOptionsFqn))\n            .withoutDeprecated();\n\n        /* Remove specified options from the base interface */\n        if (options.omitOptions) {\n            struct.omit(...options.omitOptions);\n        }\n\n        /* Add component-derived options to the interface */\n        const components = options.components ?? DEFAULT_COMPONENTS;\n        const { PrimitiveType } = require(\"@jsii/spec\");\n\n        for (const c of components) {\n            const name = c.component.name.charAt(0).toLowerCase() + c.component.name.slice(1);\n\n            /* Add enabled flag for the component */\n            struct.add({\n                name,\n                type: { primitive: PrimitiveType.Boolean },\n                optional: true,\n                docs: {\n                    summary: `Enable ${c.component.name} component`,\n                    default: \"true\",\n                },\n            });\n\n            /* Add options property if component is configurable */\n            if (c.optionsProperty) {\n                struct.add({\n                    name: c.optionsProperty.name,\n                    type: { fqn: c.optionsProperty.type },\n                    optional: true,\n                    docs: {\n                        summary: c.optionsProperty.docs ?? `${c.component.name} configuration`,\n                        default: `- default ${c.component.name} configuration`,\n                    },\n                });\n            }\n        }\n\n        /* Add custom options to the interface */\n        if (options.additionalOptions) {\n            struct.add(...options.additionalOptions);\n        }\n    }\n\n    /**\n     * Casts project to TypeScript project type\n     *\n     * ProjenStruct requires a TypeScriptProject instance. This generator is only used\n     * within TypeScript projects, so the cast is safe in practice.\n     *\n     * Note: Type assertion is necessary here because Projen's type system doesn't provide\n     * a runtime type guard for TypeScriptProject.\n     *\n     * @param project - Projen project instance\n     * @returns TypeScript project instance\n     */\n    private asTypeScriptProject(project: Project): typescript.TypeScriptProject {\n        return project as unknown as typescript.TypeScriptProject;\n    }\n\n    /**\n     * Derives the file path for the generated options interface\n     *\n     * Places the options interface file in the same directory as the class file\n     * with a \".generated.ts\" suffix.\n     *\n     * @param optionsInterface - Name of the options interface\n     * @returns File path for the options interface\n     * @throws {InvalidFilePathError} When filePath doesn't contain a directory separator\n     */\n    private getOptionsFilePath(optionsInterface: string): string {\n        const lastSlash = this.options.filePath.lastIndexOf(\"/\");\n        if (lastSlash === -1) {\n            throw new InvalidFilePathError(this.options.filePath);\n        }\n\n        const dir = this.options.filePath.substring(0, lastSlash);\n        const optionsFileName = this.renderer.getOptionsFileName(optionsInterface);\n        return `${dir}/${optionsFileName}.generated.ts`;\n    }\n\n    /**\n     * Generates the TypeScript class file during Projen synthesis\n     *\n     * Called by Projen during the synthesis phase to generate the project class file.\n     * The file is marked as readonly to prevent manual editing.\n     */\n    preSynthesize(): void {\n        const content = this.renderer.render(this.options);\n\n        new TypeScriptClassFile(this.project, this.options.filePath, content, {\n            readonly: this.options.readonly ?? true,\n        });\n    }\n}\n\n/**\n * Text file for generated TypeScript class code\n *\n * Extends Projen's TextFile to add the generated file marker comment\n * at the beginning of the file.\n */\nclass TypeScriptClassFile extends TextFile {\n    /**\n     * @param project - Projen project instance\n     * @param filePath - Output file path\n     * @param content - TypeScript class code\n     * @param options - Source code options (readonly, etc.)\n     */\n    constructor(project: Project, filePath: string, content: string, options: SourceCodeOptions = {}) {\n        super(project, filePath, options);\n        /* Add generated file marker to prevent manual editing */\n        this.addLine(`// ${this.marker}`);\n        this.addLine(content);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-generator.js","sourceRoot":"","sources":["../src/project-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { dirname, join, resolve } from \"node:path\";\nimport type { Assembly } from \"@jsii/spec\";\nimport { ProjenStruct, Struct } from \"@mrgrain/jsii-struct-builder\";\nimport type { Project, SourceCodeOptions, typescript } from \"projen\";\nimport * as projen from \"projen\";\nimport {\n    ComponentResolutionError,\n    InvalidBaseClassFormatError,\n    InvalidFilePathError,\n    InvalidIndentLevelError,\n    ManifestLoadError,\n} from \"./errors\";\nimport type { ProjectType } from \"./project-type\";\n\n/**\n * Default components applied to all generated projects\n */\nfunction getDefaultComponents(): Component[] {\n    return [\n        { componentClass: require(\"./components/mise\").Mise },\n        {\n            componentClass: require(\"./components/vitest\").Vitest,\n            optionsProperty: {\n                name: \"vitestOptions\",\n                type: \"@nikovirtala/projen-constructs.VitestOptions\",\n                docs: \"Vitest configuration\",\n            },\n        },\n    ];\n}\n\n/**\n * Configuration for a component to be integrated into a generated project\n */\nexport interface Component {\n    /**\n     * Component class reference\n     *\n     * @jsii ignore\n     */\n    readonly componentClass: any;\n\n    /**\n     * Fully qualified name of the component class\n     *\n     * Optional - auto-detected by searching JSII manifests.\n     */\n    readonly fqn?: string;\n\n    /**\n     * Options property configuration for the generated options interface\n     *\n     * Optional - auto-detected from component constructor.\n     * Set to false to disable options property generation.\n     * Set to string or object to customize the property name.\n     */\n    readonly optionsProperty?: string | ComponentOptions | false;\n}\n\n/**\n * Options property configuration\n */\nexport interface ComponentOptions {\n    /**\n     * Name of the options property\n     */\n    readonly name: string;\n    /**\n     * Fully qualified type name (optional, auto-detected from component constructor)\n     */\n    readonly type?: string;\n    /**\n     * Documentation summary (optional, auto-detected from component constructor)\n     */\n    readonly docs?: string;\n}\n\n/**\n * Options for ProjectGenerator component\n *\n * Configures the generation of a TypeScript project class that extends a Projen base class\n * with standard configuration and component integration.\n */\nexport interface ProjectGeneratorOptions extends SourceCodeOptions {\n    /**\n     * Name of the generated class (e.g., \"TypeScriptProject\")\n     *\n     * The options interface will be named `${name}Options`.\n     */\n    readonly name: string;\n\n    /**\n     * Project type identifier\n     *\n     * Specifies which Projen base class to extend and which default configuration to apply.\n     *\n     * @example ProjectType.TYPESCRIPT\n     * @example ProjectType.JSII\n     */\n    readonly projectType: ProjectType;\n\n    /**\n     * Output file path for the generated class\n     *\n     * Must contain a directory separator. The options interface will be generated\n     * in the same directory with a \".generated.ts\" suffix.\n     *\n     * @example \"src/projects/typescript.generated.ts\"\n     */\n    readonly filePath: string;\n\n    /**\n     * Components to integrate into the project\n     *\n     * Each component will be instantiated during project construction and can be\n     * configured via an optional options property in the generated interface.\n     *\n     * @default [{ component: Mise }, { component: Vitest, optionsProperty: { name: \"vitestOptions\", type: \"...\", docs: \"...\" } }]\n     */\n    readonly components?: Component[];\n\n    /**\n     * Additional properties to add to the generated options interface\n     *\n     * Use this to extend the base options with custom properties specific to\n     * your project type.\n     *\n     * @jsii ignore\n     */\n    readonly additionalOptions?: any[];\n\n    /**\n     * Property names to omit from the base options interface\n     *\n     * Use this to hide base class options that should not be configurable\n     * in the generated project type.\n     */\n    readonly omitOptions?: string[];\n}\n\n/**\n * Buffer for building indented code with automatic line management\n *\n * Maintains indentation level and provides methods for adding lines,\n * opening/closing blocks, and flushing accumulated content.\n */\nclass CodeBuffer {\n    private lines: string[] = [];\n    private indentLevel = 0;\n\n    /**\n     * @param indent - String to use for each indentation level (default: single space)\n     */\n    constructor(private readonly indent = \" \") {}\n\n    /**\n     * Returns all accumulated lines and resets the buffer\n     *\n     * @returns Array of code lines with proper indentation\n     */\n    flush(): string[] {\n        const current = this.lines;\n        this.reset();\n        return current;\n    }\n\n    /**\n     * Adds a line of code at the current indentation level\n     *\n     * @param code - Code to add (optional, adds blank line if omitted)\n     */\n    line(code?: string) {\n        const prefix = this.indent.repeat(this.indentLevel);\n        this.lines.push((prefix + (code ?? \"\")).trimEnd());\n    }\n\n    /**\n     * Opens a new indentation block\n     *\n     * @param code - Optional code to add before increasing indent (e.g., opening brace)\n     */\n    open(code?: string) {\n        if (code) {\n            this.line(code);\n        }\n        this.indentLevel++;\n    }\n\n    /**\n     * Closes the current indentation block\n     *\n     * @param code - Optional code to add after decreasing indent (e.g., closing brace)\n     * @throws {InvalidIndentLevelError} When attempting to decrease indent below zero\n     */\n    close(code?: string) {\n        if (this.indentLevel === 0) {\n            throw new InvalidIndentLevelError();\n        }\n        this.indentLevel--;\n        if (code) {\n            this.line(code);\n        }\n    }\n\n    /**\n     * Resets the buffer to initial state\n     */\n    private reset(): void {\n        this.lines = [];\n        this.indentLevel = 0;\n    }\n}\n\n/**\n * Renders TypeScript class code from ProjectGenerator options\n *\n * Generates a complete TypeScript class file including imports, options interface export,\n * class declaration, and constructor with component integration.\n *\n * Uses JSII manifest introspection to validate base classes and options interfaces.\n */\nclass TypeScriptClassRenderer {\n    private buffer: CodeBuffer;\n    public jsiiManifest: Assembly;\n\n    /**\n     * @param indent - Number of spaces per indentation level (default: 4)\n     */\n    constructor(indent = 4) {\n        this.buffer = new CodeBuffer(\" \".repeat(indent));\n        /* Load Projen's JSII manifest for base class introspection */\n        const projenPackageJson = require.resolve(\"projen/package.json\");\n        const projenRoot = dirname(projenPackageJson);\n        const jsiiPath = join(projenRoot, \".jsii\");\n        this.jsiiManifest = JSON.parse(readFileSync(jsiiPath, \"utf-8\"));\n    }\n\n    /**\n     * Renders complete TypeScript class code from options\n     *\n     * Orchestrates the rendering process: derives names, extracts component configuration,\n     * builds import statements, and renders the class structure.\n     *\n     * @param options - Generator configuration\n     * @returns Complete TypeScript class code as a string\n     */\n    render(options: ProjectGeneratorOptions): string {\n        this.buffer.flush();\n\n        /* Derive interface and type names from the class name */\n        const optionsInterface = `${options.name}Options`;\n        const baseOptionsFqn = this.getBaseOptionsFqn(options.projectType);\n        const baseOptionsType = baseOptionsFqn.replace(/^projen\\./, \"\");\n\n        /* Use provided components or fall back to defaults (Mise + Vitest) */\n        const components = options.components ?? getDefaultComponents();\n\n        /* Extract component configuration for constructor generation */\n        const { destructure, componentArray } = this.extractComponentOptions(components);\n        const imports = this.extractImports(options, optionsInterface);\n\n        /* Render all sections of the class file */\n        this.renderImports(imports);\n        this.buffer.line();\n        this.renderExport(optionsInterface);\n        this.buffer.line();\n        this.renderClass(options, optionsInterface, baseOptionsType, destructure, componentArray);\n\n        return this.buffer.flush().join(\"\\n\");\n    }\n\n    /**\n     * Derives the fully qualified options interface name from project type\n     *\n     * Transforms project type into the corresponding Projen options interface name\n     * by appending \"Options\" suffix and prefixing with \"projen.\" namespace.\n     * Validates that the base class exists in Projen's JSII manifest.\n     *\n     * @param projectType - Project type identifier\n     * @returns Fully qualified options interface name\n     * @throws {InvalidBaseClassFormatError} When projectType format is invalid or class not found\n     *\n     * @example\n     * getBaseOptionsFqn(ProjectType.TYPESCRIPT) // \"projen.typescript.TypeScriptProjectOptions\"\n     * getBaseOptionsFqn(ProjectType.JSII) // \"projen.cdk.JsiiProjectOptions\"\n     */\n    getBaseOptionsFqn(projectType: ProjectType): string {\n        const baseClass = projectType.valueOf();\n        /* Validate base class format: must contain module.ClassName structure */\n        if (!baseClass.includes(\".\")) {\n            throw new InvalidBaseClassFormatError(baseClass);\n        }\n\n        const baseClassFqn = `projen.${baseClass}`;\n        const optionsFqn = `${baseClassFqn}Options`;\n\n        /* Validate base class exists in JSII manifest */\n        if (!this.jsiiManifest.types?.[baseClassFqn]) {\n            throw new InvalidBaseClassFormatError(`Base class not found in JSII manifest: ${baseClassFqn}`);\n        }\n\n        /* Validate options interface exists in JSII manifest */\n        if (!this.jsiiManifest.types?.[optionsFqn]) {\n            throw new InvalidBaseClassFormatError(`Options interface not found in JSII manifest: ${optionsFqn}`);\n        }\n\n        return optionsFqn;\n    }\n\n    /**\n     * Extracts component configuration for constructor code generation\n     *\n     * Transforms component configurations into:\n     * 1. Destructure list: variable names to extract from options\n     * 2. Component array: code string for applyDefaults() call\n     *\n     * @param components - Component configurations\n     * @returns Object with destructure array and componentArray code string\n     *\n     * @example\n     * Input: [{ component: Vitest, optionsProperty: { name: \"vitestOptions\", ... } }]\n     * Output: {\n     *   destructure: [\"vitest\", \"vitestOptions\"],\n     *   componentArray: \"[{ component: Vitest, enabled: vitest, options: vitestOptions }]\"\n     * }\n     */\n    private extractComponentOptions(components: Component[]): { destructure: string[]; componentArray: string } {\n        const destructure: string[] = [];\n        const componentParts: string[] = [];\n\n        for (const c of components) {\n            /* Convert component class name to camelCase variable name (e.g., Vitest -> vitest) */\n            const name = c.componentClass.name.charAt(0).toLowerCase() + c.componentClass.name.slice(1);\n            destructure.push(name);\n\n            /* Build component config object for applyDefaults() call */\n            const parts = [`component: ${c.componentClass.name}`];\n            if (c.optionsProperty && typeof c.optionsProperty !== \"boolean\") {\n                /* Component has configurable options - include both enabled flag and options */\n                const propName = typeof c.optionsProperty === \"string\" ? c.optionsProperty : c.optionsProperty.name;\n                destructure.push(propName);\n                parts.push(`enabled: ${name}`, `options: ${propName}`);\n            } else {\n                /* Component has no options - only include enabled flag */\n                parts.push(`enabled: ${name}`);\n            }\n            componentParts.push(`{ ${parts.join(\", \")} }`);\n        }\n\n        return { destructure, componentArray: `[${componentParts.join(\", \")}]` };\n    }\n\n    /**\n     * Builds import statements map for the generated class\n     *\n     * Collects all required imports:\n     * - Projen base module (typescript, cdk, awscdk)\n     * - Config utilities (applyDefaults, defaultOptions)\n     * - Component classes\n     * - Utility functions (deepMerge)\n     * - Generated options interface (type-only import)\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the generated options interface\n     * @returns Map of module paths to sets of imported names\n     */\n    private extractImports(options: ProjectGeneratorOptions, optionsInterface: string): Map<string, Set<string>> {\n        const imports = new Map<string, Set<string>>();\n\n        /* Extract base module name from projectType (e.g., \"typescript\" from \"typescript.TypeScriptProject\") */\n        const baseModule = options.projectType.valueOf().split(\".\")[0];\n        const optionsFileName = this.getOptionsFileName(optionsInterface);\n\n        /* Projen base module import */\n        imports.set(\"projen\", new Set([baseModule]));\n\n        /* Configuration utilities import */\n        imports.set(\"../config\", new Set([\"applyDefaults\", \"defaultOptions\"]));\n\n        /* Component class imports - derive module path from component class name */\n        const components = options.components ?? getDefaultComponents();\n        for (const c of components) {\n            const componentName = c.componentClass.name;\n            const modulePath = `../components/${componentName.toLowerCase()}`;\n            if (!imports.has(modulePath)) {\n                imports.set(modulePath, new Set());\n            }\n            const moduleImports = imports.get(modulePath);\n            if (moduleImports) {\n                moduleImports.add(componentName);\n            }\n        }\n\n        /* Utility functions import */\n        imports.set(\"../utils\", new Set([\"deepMerge\"]));\n\n        /* Generated options interface import (type-only to avoid circular dependencies) */\n        imports.set(`./${optionsFileName}.generated`, new Set([optionsInterface]));\n\n        return imports;\n    }\n\n    /**\n     * Derives the config path for accessing default options\n     *\n     * Transforms project type into the corresponding path in the defaultOptions\n     * configuration object exported from config.ts.\n     *\n     * @param projectType - Project type identifier\n     * @returns Config path for accessing default options\n     *\n     * @example\n     * getConfigPath(ProjectType.TYPESCRIPT) // \"defaultOptions.typescript.TypeScriptProject\"\n     */\n    private getConfigPath(projectType: ProjectType): string {\n        return `defaultOptions.${projectType.valueOf()}`;\n    }\n\n    /**\n     * Renders import statements in sorted order\n     *\n     * Sorts imports with external packages first, then relative imports.\n     * Uses type-only imports for generated files to avoid circular dependencies.\n     *\n     * @param imports - Map of module paths to imported names\n     */\n    private renderImports(imports: Map<string, Set<string>>) {\n        /* Sort modules: external packages first, then relative imports alphabetically */\n        const sortedModules = Array.from(imports.keys()).sort((a, b) => {\n            const aIsRelative = a.startsWith(\".\");\n            const bIsRelative = b.startsWith(\".\");\n            if (aIsRelative !== bIsRelative) {\n                return aIsRelative ? 1 : -1;\n            }\n            return a.localeCompare(b);\n        });\n\n        for (const mod of sortedModules) {\n            const names = Array.from(imports.get(mod) || []).sort();\n            /* Use type-only import for generated files to prevent circular dependencies */\n            const isTypeOnly = mod.includes(\".generated\");\n            const importStmt = isTypeOnly ? \"import type\" : \"import\";\n            this.buffer.line(`${importStmt} { ${names.join(\", \")} } from \"${mod}\";`);\n        }\n    }\n\n    /**\n     * Renders re-export statement for the generated options interface\n     *\n     * @param optionsInterface - Name of the options interface to export\n     */\n    private renderExport(optionsInterface: string) {\n        const optionsFileName = this.getOptionsFileName(optionsInterface);\n        this.buffer.line(`export { ${optionsInterface} } from \"./${optionsFileName}.generated\";`);\n    }\n\n    /**\n     * Renders the class declaration and constructor\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the options interface\n     * @param baseOptionsType - Base options type without \"projen.\" prefix\n     * @param destructure - Variable names to destructure from options\n     * @param componentArray - Code string for component array\n     */\n    private renderClass(\n        options: ProjectGeneratorOptions,\n        optionsInterface: string,\n        baseOptionsType: string,\n        destructure: string[],\n        componentArray: string,\n    ) {\n        this.buffer.line(\"/**\");\n        this.buffer.line(` * ${options.name} with standard configuration and component integration`);\n        this.buffer.line(\" *\");\n        this.buffer.line(\" * Extends Projen's base class with opinionated defaults and automatic component setup.\");\n        this.buffer.line(\" */\");\n        this.buffer.open(`export class ${options.name} extends ${options.projectType.valueOf()} {`);\n        this.renderConstructor(options, optionsInterface, baseOptionsType, destructure, componentArray);\n        this.buffer.close(\"}\");\n    }\n\n    /**\n     * Renders the constructor implementation\n     *\n     * The constructor:\n     * 1. Destructures component flags and options from the options parameter\n     * 2. Merges default configuration with user-provided options\n     * 3. Calls super() with merged options\n     * 4. Applies component defaults via applyDefaults()\n     *\n     * @param options - Generator configuration\n     * @param optionsInterface - Name of the options interface\n     * @param baseOptionsType - Base options type without \"projen.\" prefix\n     * @param destructure - Variable names to destructure from options\n     * @param componentArray - Code string for component array\n     */\n    private renderConstructor(\n        options: ProjectGeneratorOptions,\n        optionsInterface: string,\n        baseOptionsType: string,\n        destructure: string[],\n        componentArray: string,\n    ) {\n        const configPath = this.getConfigPath(options.projectType);\n        this.buffer.line(\"/**\");\n        this.buffer.line(\" * @param options - Project configuration\");\n        this.buffer.line(\" */\");\n        this.buffer.open(`constructor(options: ${optionsInterface}) {`);\n        this.buffer.line(\"/* Separate component configuration from base Projen options */\");\n        this.buffer.line(`const { ${destructure.join(\", \")}, ...baseOptions } = options;`);\n        this.buffer.line();\n        this.buffer.line(\"/* Merge default configuration with user options and initialize base class */\");\n        this.buffer.line(`super(deepMerge<${baseOptionsType}>(${configPath}, baseOptions));`);\n        this.buffer.line();\n        this.buffer.line(\"/* Apply component defaults and instantiate enabled components */\");\n        this.buffer.line(`applyDefaults(this, ${componentArray});`);\n        this.buffer.close(\"}\");\n    }\n\n    /**\n     * Maps options interface name to file name\n     *\n     * Converts PascalCase interface names to kebab-case file names.\n     * Falls back to lowercase conversion for unmapped interfaces.\n     *\n     * @param optionsInterface - Options interface name\n     * @returns Kebab-case file name without extension\n     *\n     * @example\n     * getOptionsFileName(\"TypeScriptProjectOptions\") // \"typescript-options\"\n     */\n    getOptionsFileName(optionsInterface: string): string {\n        const mapping: Record<string, string> = {\n            TypeScriptProjectOptions: \"typescript-options\",\n            JsiiProjectOptions: \"jsii-options\",\n            AwsCdkTypeScriptAppProjectOptions: \"awscdk-typescript-app-options\",\n            AwsCdkConstructLibraryProjectOptions: \"awscdk-construct-library-options\",\n        };\n        return mapping[optionsInterface] || optionsInterface.toLowerCase();\n    }\n}\n\n/**\n * Projen component that generates TypeScript project classes with standard configuration\n *\n * This component automates the creation of project classes that extend Projen base classes\n * with opinionated defaults and component integration.\n */\nexport class ProjectGenerator extends projen.Component {\n    private renderer: TypeScriptClassRenderer;\n    private static enumGenerated = false;\n\n    /**\n     * @param project - Projen project instance\n     * @param options - Generator configuration\n     */\n    constructor(\n        project: Project,\n        private readonly options: ProjectGeneratorOptions,\n    ) {\n        super(project);\n        this.renderer = new TypeScriptClassRenderer();\n\n        /* Generate ProjectType enum once on first instantiation */\n        if (!ProjectGenerator.enumGenerated) {\n            this.generateProjectTypeEnum();\n            ProjectGenerator.enumGenerated = true;\n        }\n\n        /* Generate the options interface using ProjenStruct for JSII compatibility */\n        const optionsInterface = `${options.name}Options`;\n        const baseOptionsFqn = this.renderer.getBaseOptionsFqn(options.projectType);\n        const optionsFilePath = this.getOptionsFilePath(optionsInterface);\n\n        /* ProjenStruct generates a concrete TypeScript interface from Projen's options\n         * This is necessary because JSII doesn't support TypeScript utility types like Omit<>\n         * The generated interface can be consumed by other languages (Python, Java, C#, Go) */\n        const struct = new ProjenStruct(this.asTypeScriptProject(project), {\n            name: optionsInterface,\n            filePath: optionsFilePath,\n            outputFileOptions: { readonly: true },\n        })\n            .mixin(Struct.fromFqn(baseOptionsFqn))\n            .withoutDeprecated();\n\n        /* Remove specified options from the base interface */\n        if (options.omitOptions) {\n            struct.omit(...options.omitOptions);\n        }\n\n        /* Add component-derived options to the interface */\n        const components = options.components ?? getDefaultComponents();\n        const { PrimitiveType } = require(\"@jsii/spec\");\n\n        for (const c of components) {\n            const name = c.componentClass.name.charAt(0).toLowerCase() + c.componentClass.name.slice(1);\n\n            /* Add enabled flag for the component */\n            struct.add({\n                name,\n                type: { primitive: PrimitiveType.Boolean },\n                optional: true,\n                docs: {\n                    summary: `Enable ${c.componentClass.name} component`,\n                    default: \"true\",\n                },\n            });\n\n            /* Add options property if component is configurable */\n            if (c.optionsProperty !== false) {\n                try {\n                    const optionsType = this.resolveComponentOptionsType(c);\n                    if (optionsType && this.isFqnAvailable(optionsType.fqn)) {\n                        struct.add({\n                            name: optionsType.name,\n                            type: { fqn: optionsType.fqn },\n                            optional: true,\n                            docs: {\n                                summary: optionsType.docs ?? `${c.componentClass.name} configuration`,\n                                default: `- default ${c.componentClass.name} configuration`,\n                            },\n                        });\n                    }\n                } catch (error) {\n                    /* Component has no options parameter or resolution failed - skip */\n                    console.warn(\n                        JSON.stringify({\n                            message: \"Failed to resolve component options type\",\n                            component: c.componentClass.name,\n                            error: error instanceof Error ? error.message : String(error),\n                        }),\n                    );\n                }\n            }\n        }\n\n        /* Add custom options to the interface */\n        if (options.additionalOptions && options.additionalOptions.length > 0) {\n            struct.add(...options.additionalOptions);\n        }\n    }\n\n    /**\n     * Casts project to TypeScript project type\n     *\n     * ProjenStruct requires a TypeScriptProject instance. This generator is only used\n     * within TypeScript projects, so the cast is safe in practice.\n     *\n     * Note: Type assertion is necessary here because Projen's type system doesn't provide\n     * a runtime type guard for TypeScriptProject.\n     *\n     * @param project - Projen project instance\n     * @returns TypeScript project instance\n     */\n    private asTypeScriptProject(project: Project): typescript.TypeScriptProject {\n        return project as unknown as typescript.TypeScriptProject;\n    }\n\n    /**\n     * Derives the file path for the generated options interface\n     *\n     * Places the options interface file in the same directory as the class file\n     * with a \".generated.ts\" suffix.\n     *\n     * @param optionsInterface - Name of the options interface\n     * @returns File path for the options interface\n     * @throws {InvalidFilePathError} When filePath doesn't contain a directory separator\n     */\n    private getOptionsFilePath(optionsInterface: string): string {\n        const lastSlash = this.options.filePath.lastIndexOf(\"/\");\n        if (lastSlash === -1) {\n            throw new InvalidFilePathError(this.options.filePath);\n        }\n\n        const dir = this.options.filePath.substring(0, lastSlash);\n        const optionsFileName = this.renderer.getOptionsFileName(optionsInterface);\n        return `${dir}/${optionsFileName}.generated.ts`;\n    }\n\n    /**\n     * Generates the TypeScript class file during Projen synthesis\n     *\n     * Called by Projen during the synthesis phase to generate the project class file.\n     * The file is marked as readonly to prevent manual editing.\n     */\n    preSynthesize(): void {\n        const content = this.renderer.render(this.options);\n\n        new TypeScriptClassFile(this.project, this.options.filePath, content, {\n            readonly: this.options.readonly ?? true,\n        });\n    }\n\n    /**\n     * Checks if an FQN is available in any JSII manifest\n     */\n    private isFqnAvailable(fqn: string): boolean {\n        try {\n            const manifest = this.loadManifestForFqn(fqn);\n            return manifest.types?.[fqn] !== undefined;\n        } catch {\n            return false;\n        }\n    }\n\n    /**\n     * Resolves component options type from JSII manifest\n     *\n     * Auto-detects options from JSII manifest when optionsProperty is undefined.\n     * Returns null only when optionsProperty is explicitly set to false.\n     */\n    private resolveComponentOptionsType(component: Component): { name: string; fqn: string; docs?: string } | null {\n        /* Normalize optionsProperty to ComponentOptions */\n        let optionsConfig: ComponentOptions | undefined;\n        if (typeof component.optionsProperty === \"string\") {\n            optionsConfig = { name: component.optionsProperty };\n        } else if (component.optionsProperty && typeof component.optionsProperty === \"object\") {\n            optionsConfig = component.optionsProperty;\n        }\n\n        /* Use explicit type if provided */\n        if (optionsConfig?.type) {\n            return {\n                name: optionsConfig.name,\n                fqn: optionsConfig.type,\n                docs: optionsConfig.docs,\n            };\n        }\n\n        /* Find component in JSII manifests */\n        const componentFqn = component.fqn ?? this.findComponentFqn(component.componentClass.name);\n        const manifest = this.loadManifestForFqn(componentFqn);\n\n        const classType = manifest.types?.[componentFqn];\n        if (!classType || classType.kind !== \"class\") {\n            throw new ComponentResolutionError(componentFqn, \"Component not found in JSII manifest\");\n        }\n\n        const initializer = (classType as { initializer?: { parameters?: Array<{ type?: { fqn?: string } }> } })\n            .initializer;\n        if (!initializer?.parameters?.[1]) {\n            return null; /* Component has no options parameter */\n        }\n\n        const optionsParam = initializer.parameters[1];\n        const optionsFqn = optionsParam.type?.fqn;\n\n        if (!optionsFqn) {\n            return null; /* Options parameter has no FQN */\n        }\n\n        const optionsType = manifest.types?.[optionsFqn];\n        const docs = (optionsType as { docs?: { summary?: string } } | undefined)?.docs?.summary;\n\n        /* Auto-generate property name if not provided */\n        const name = component.componentClass.name;\n        const defaultName = `${name.charAt(0).toLowerCase()}${name.slice(1)}Options`;\n        const propertyName = optionsConfig?.name ?? defaultName;\n\n        return { name: propertyName, fqn: optionsFqn, docs };\n    }\n\n    /**\n     * Finds component FQN by searching all JSII manifests\n     */\n    private findComponentFqn(componentName: string): string {\n        /* Try own package first */\n        const ownFqn = `@nikovirtala/projen-constructs.${componentName}`;\n        try {\n            const ownManifest = this.loadOwnManifest();\n            if (ownManifest.types?.[ownFqn]) {\n                return ownFqn;\n            }\n        } catch (error) {\n            /* Own manifest not available yet during development - this is expected */\n            console.warn(\n                JSON.stringify({\n                    message: \"Own manifest not available\",\n                    component: componentName,\n                    error: error instanceof Error ? error.message : String(error),\n                }),\n            );\n        }\n\n        /* Search in node_modules for JSII packages */\n        const nodeModulesPath = join(__dirname, \"../../node_modules\");\n        const packages = this.findJsiiPackages(nodeModulesPath);\n\n        for (const pkg of packages) {\n            try {\n                const manifest = this.loadManifestFromPackage(pkg);\n                for (const fqn of Object.keys(manifest.types ?? {})) {\n                    if (fqn.endsWith(`.${componentName}`)) {\n                        return fqn;\n                    }\n                }\n            } catch (error) {\n                /* Skip packages with invalid manifests - log for debugging */\n                console.warn(\n                    JSON.stringify({\n                        message: \"Failed to load manifest from package\",\n                        package: pkg,\n                        error: error instanceof Error ? error.message : String(error),\n                    }),\n                );\n            }\n        }\n\n        throw new ComponentResolutionError(componentName, \"Component not found in any JSII manifest\");\n    }\n\n    /**\n     * Finds all JSII packages in node_modules\n     */\n    private findJsiiPackages(nodeModulesPath: string): string[] {\n        const packages: string[] = [];\n        const { readdirSync, statSync, existsSync } = require(\"node:fs\");\n\n        if (!existsSync(nodeModulesPath)) {\n            return packages;\n        }\n\n        const resolvedBase = resolve(nodeModulesPath);\n\n        for (const entry of readdirSync(nodeModulesPath)) {\n            const entryPath = resolve(nodeModulesPath, entry);\n\n            /* Prevent path traversal attacks */\n            if (!entryPath.startsWith(resolvedBase)) {\n                continue;\n            }\n\n            if (entry.startsWith(\"@\")) {\n                /* Scoped package - recurse into scope */\n                const scopePath = entryPath;\n                for (const scopedEntry of readdirSync(scopePath)) {\n                    const pkgPath = resolve(scopePath, scopedEntry);\n\n                    /* Prevent path traversal attacks */\n                    if (!pkgPath.startsWith(resolvedBase)) {\n                        continue;\n                    }\n\n                    if (existsSync(join(pkgPath, \".jsii\"))) {\n                        packages.push(pkgPath);\n                    }\n                }\n            } else if (statSync(entryPath).isDirectory()) {\n                /* Regular package */\n                if (existsSync(join(entryPath, \".jsii\"))) {\n                    packages.push(entryPath);\n                }\n            }\n        }\n\n        return packages;\n    }\n\n    /**\n     * Loads JSII manifest for a given FQN\n     *\n     * Extracts package name from FQN. For scoped packages like @scope/package.ClassName,\n     * the package name is everything before the first dot (i.e., @scope/package).\n     */\n    private loadManifestForFqn(fqn: string): Assembly {\n        const dotIndex = fqn.indexOf(\".\");\n        const packageName = dotIndex > 0 ? fqn.substring(0, dotIndex) : fqn;\n\n        /* Try own package */\n        if (packageName === \"@nikovirtala/projen-constructs\") {\n            return this.loadOwnManifest();\n        }\n\n        /* Try node_modules */\n        try {\n            const pkgJsonPath = require.resolve(`${packageName}/package.json`);\n            return this.loadManifestFromPackage(dirname(pkgJsonPath));\n        } catch (error) {\n            throw new ManifestLoadError(packageName, error instanceof Error ? error.message : String(error));\n        }\n    }\n\n    /**\n     * Loads JSII manifest from a package directory\n     */\n    private loadManifestFromPackage(packagePath: string): Assembly {\n        const jsiiPath = join(packagePath, \".jsii\");\n        return JSON.parse(readFileSync(jsiiPath, \"utf-8\"));\n    }\n\n    /**\n     * Loads this package's JSII manifest\n     */\n    private loadOwnManifest(): Assembly {\n        const jsiiPath = join(__dirname, \"../.jsii\");\n        return JSON.parse(readFileSync(jsiiPath, \"utf-8\"));\n    }\n\n    /**\n     * Generates ProjectType enum from Projen's JSII manifest\n     */\n    private generateProjectTypeEnum(): void {\n        const projectTypes = this.discoverProjectTypes();\n\n        const lines: string[] = [];\n        lines.push(\"/**\");\n        lines.push(\" * Enum defining all supported project types\");\n        lines.push(\" *\");\n        lines.push(\" * Each project type corresponds to a generated project class and its configuration\");\n        lines.push(\" * in the defaultOptions structure.\");\n        lines.push(\" *\");\n        lines.push(\" * @generated Automatically generated from Projen's JSII manifest\");\n        lines.push(\" */\");\n        lines.push(\"export enum ProjectType {\");\n\n        for (const [enumName, value, docs] of projectTypes) {\n            lines.push(\"    /**\");\n            lines.push(`     * ${docs}`);\n            lines.push(\"     */\");\n            lines.push(`    ${enumName} = \"${value}\",`);\n            lines.push(\"\");\n        }\n\n        lines.push(\"}\");\n\n        new projen.TextFile(this.project, \"src/project-type.ts\", {\n            readonly: true,\n            lines,\n        });\n    }\n\n    /**\n     * Discovers all project types that extend projen.Project\n     */\n    private discoverProjectTypes(): Array<[string, string, string]> {\n        const projectTypes: Array<[string, string, string]> = [];\n        const baseClass = \"projen.Project\";\n\n        for (const [fqn, type] of Object.entries(this.renderer.jsiiManifest.types ?? {})) {\n            if (type.kind !== \"class\") {\n                continue;\n            }\n\n            const classType = type as {\n                abstract?: boolean;\n                base?: string;\n                docs?: { summary?: string };\n            };\n\n            if (classType.abstract) {\n                continue;\n            }\n\n            if (!this.extendsBase(classType, baseClass)) {\n                continue;\n            }\n\n            const parts = fqn.split(\".\");\n            if (parts.length < 3 || parts[0] !== \"projen\") {\n                continue;\n            }\n\n            const module = parts[1];\n            const className = parts.slice(2).join(\".\");\n            const enumName = className\n                .replace(/([A-Z])/g, \"_$1\")\n                .toUpperCase()\n                .replace(/^_/, \"\");\n            const value = `${module}.${className}`;\n            const docs = classType.docs?.summary ?? className;\n\n            projectTypes.push([enumName, value, docs]);\n        }\n\n        return projectTypes.sort((a, b) => a[0].localeCompare(b[0]));\n    }\n\n    /**\n     * Checks if a class extends the base class\n     */\n    private extendsBase(classType: { inheritancePath?: string[]; base?: string }, baseClass: string): boolean {\n        if (classType.inheritancePath) {\n            return classType.inheritancePath.includes(baseClass);\n        }\n\n        let currentBase = classType.base;\n        while (currentBase) {\n            if (currentBase === baseClass) {\n                return true;\n            }\n            const baseType = this.renderer.jsiiManifest.types?.[currentBase];\n            if (!baseType || baseType.kind !== \"class\") {\n                break;\n            }\n            currentBase = (baseType as { base?: string }).base;\n        }\n\n        return false;\n    }\n}\n\n/**\n * Text file for generated TypeScript class code\n *\n * Extends Projen's TextFile to add the generated file marker comment\n * at the beginning of the file.\n */\nclass TypeScriptClassFile extends projen.TextFile {\n    /**\n     * @param project - Projen project instance\n     * @param filePath - Output file path\n     * @param content - TypeScript class code\n     * @param options - Source code options (readonly, etc.)\n     */\n    constructor(project: Project, filePath: string, content: string, options: SourceCodeOptions = {}) {\n        super(project, filePath, options);\n        /* Add generated file marker to prevent manual editing */\n        this.addLine(`// ${this.marker}`);\n        this.addLine(content);\n    }\n}\n"]}