@nikovirtala/projen-constructs 0.0.2 → 0.0.4

package/lib/components/lambda-function-construct-generator.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaFunctionConstructGenerator = void 0;
+const path = require("node:path");
+const projen_1 = require("projen");
+class LambdaFunctionConstructGenerator extends projen_1.Component {
+    constructor(project, options) {
+        super(project);
+        this.nodeProject = project;
+        this.sourceDir = options?.sourceDir ?? "src/handlers";
+        this.outputDir = options?.outputDir ?? "src/constructs/lambda";
+        this.filePattern = options?.filePattern ?? "*.lambda.ts";
+        this.esbuildOptions = options?.esbuildOptions ?? {};
+        this.baseConstructImport = options?.baseConstructImport;
+        this.baseConstructClass = options?.baseConstructClass;
+        this.baseConstructPackage = options?.baseConstructPackage;
+        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+        this.bundlerScriptPath = path.join(".projen", `generate-and-bundle-${uniqueId}.ts`);
+        if (options?.addDependencies ?? true) {
+            this.addDependencies(options?.baseConstructPackage);
+        }
+        this.createBundleTask();
+        this.addBundleTaskToWorkflow();
+    }
+    addDependencies(additionalPackage) {
+        this.nodeProject.addDeps("aws-cdk-lib", "constructs");
+        if (additionalPackage && additionalPackage !== "aws-cdk-lib" && additionalPackage !== "constructs") {
+            this.nodeProject.addDeps(additionalPackage);
+        }
+    }
+    createUniqueId(sourceDir, filePattern) {
+        const dirPart = sourceDir.replace(/\//g, "-").replace(/[^\w-]/g, "");
+        const patternPart = filePattern
+            .replace(/\*/g, "")
+            .replace(/\./g, "-")
+            .replace(/[^\w-]/g, "");
+        return `${dirPart}-${patternPart}`.replace(/--+/g, "-").replace(/^-|-$/g, "");
+    }
+    createBundleTask() {
+        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+        const taskName = `generate-and-bundle-${uniqueId}`;
+        let baseConstructArgs = "";
+        if (this.baseConstructImport) {
+            baseConstructArgs += ` --base-construct-import '${this.baseConstructImport}'`;
+        }
+        if (this.baseConstructClass) {
+            baseConstructArgs += ` --base-construct-class '${this.baseConstructClass}'`;
+        }
+        const bundleTask = this.nodeProject.addTask(taskName, {
+            description: `Generate Lambda Function Constructs from ${this.sourceDir}/${this.filePattern} and bundle their handlers`,
+            exec: `tsx --tsconfig tsconfig.dev.json ${this.bundlerScriptPath} --source-dir ${this.sourceDir} --output-dir ${this.outputDir} --file-pattern "${this.filePattern}" --esbuild-options '${JSON.stringify(this.esbuildOptions)}'${baseConstructArgs}`,
+        });
+        this.createBundlerScript();
+        return bundleTask;
+    }
+    createBundlerScript() {
+        const bundlerScript = `// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as esbuild from 'esbuild';
+import * as glob from 'glob';
+import { pascalCase } from 'change-case';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+
+async function main() {
+  const argv = await yargs(hideBin(process.argv))
+    .option('source-dir', { type: 'string', default: 'src/handlers', description: 'Source directory where Lambda Function handlers are located' })
+    .option('output-dir', { type: 'string', default: 'src/constructs/lambda', description: 'Output directory where Lambda Function constructs will be generated' })
+    .option('file-pattern', { type: 'string', default: '*.lambda.ts', description: 'File pattern to identify Lambda Function handlers' })
+    .option('esbuild-options', { type: 'string', default: '{}', description: 'esbuild options as JSON string' })
+    .option('base-construct-import', { type: 'string', description: 'Import statement for the base construct' })
+    .option('base-construct-class', { type: 'string', description: 'Name of the construct class to extend' })
+    .help()
+    .parse();
+
+  const sourceDir = argv['source-dir'];
+  const outputDir = argv['output-dir'];
+  const filePattern = argv['file-pattern'];
+  const esbuildOptions = JSON.parse(argv['esbuild-options'] as string);
+  const baseConstructImport = argv['base-construct-import'] as string | undefined;
+  const baseConstructClass = argv['base-construct-class'] as string | undefined;
+
+  fs.mkdirSync(path.join(process.cwd(), outputDir), { recursive: true });
+
+  const assetsDir = path.join(process.cwd(), 'assets', 'handlers');
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  const handlerFiles = glob.sync(path.join(process.cwd(), sourceDir, filePattern));
+
+  console.log(\`Found \${handlerFiles.length} Lambda Function handler files\`);
+
+  for (const handlerFile of handlerFiles) {
+    const relativePath = path.relative(path.join(process.cwd(), sourceDir), handlerFile);
+    const fileName = path.basename(relativePath, path.extname(relativePath));
+    const functionName = fileName.replace('.lambda', '');
+
+    console.log(\`Processing Lambda Function handler: \${functionName}\`);
+
+    const functionDir = path.join(assetsDir, functionName);
+    fs.mkdirSync(functionDir, { recursive: true });
+
+    const outfile = path.join(functionDir, 'index.js');
+
+    try {
+      await esbuild.build({
+        entryPoints: [handlerFile],
+        bundle: true,
+        minify: true,
+        platform: 'node',
+        target: 'node18',
+        outfile,
+        ...esbuildOptions,
+      });
+
+      console.log(\`Successfully bundled \${functionName} to \${outfile}\`);
+
+      const constructFilePath = path.join(process.cwd(), outputDir, \`\${functionName}.ts\`);
+      const constructCode = generateConstructCode(functionName, relativePath, baseConstructImport, baseConstructClass);
+
+      fs.writeFileSync(constructFilePath, constructCode);
+      console.log(\`Generated construct at \${constructFilePath}\`);
+    } catch (error) {
+      console.error(\`Error processing \${functionName}:\`, error);
+    }
+  }
+}
+
+function generateConstructCode(functionName: string, handlerPath: string, baseConstructImport?: string, baseConstructClass?: string) {
+  const constructName = \`\${pascalCase(functionName)}Function\`;
+
+  const importStatement = baseConstructImport ?? "";
+  const baseClassName = baseConstructClass ?? "aws_lambda.Function";
+
+  const useAwsLambdaRuntime = !baseConstructClass || baseClassName.includes("Function");
+
+  return \`// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+\${importStatement}
+import { aws_lambda } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface \${constructName}Props extends Omit<\${baseClassName === "aws_lambda.Function" ? "aws_lambda.FunctionProps" : \`\${baseClassName}Props\`}, 'code'\${useAwsLambdaRuntime ? " | 'runtime'" : ""} | 'handler'> {
+  \${useAwsLambdaRuntime ? \`/**
+   * Override the default runtime
+   * @default nodejs22.x
+   */
+  readonly runtime?: aws_lambda.Runtime;\` : ""}
+}
+
+export class \${constructName} extends \${baseClassName} {
+  constructor(scope: Construct, id: string, props: \${constructName}Props = {}) {
+    super(scope, id, {
+      ...props,
+      \${useAwsLambdaRuntime ? "runtime: props.runtime ?? aws_lambda.Runtime.NODEJS_22_X," : ""}
+      handler: 'index.handler',
+      code: aws_lambda.Code.fromAsset(path.join(__dirname, '../../../assets/handlers/\${functionName}')),
+    });
+  }
+}
+\`;
+}
+
+main().catch(error => {
+  console.error('Error:', error);
+  process.exit(1);
+});
+`;
+        const src = new projen_1.SourceCode(this.project, this.bundlerScriptPath);
+        const lines = bundlerScript.split("\n");
+        for (const line of lines) {
+            src.line(line);
+        }
+        this.nodeProject.addDevDeps("esbuild", "glob", "yargs", "@types/glob", "@types/yargs", "tsx", "change-case");
+    }
+    addBundleTaskToWorkflow() {
+        const compileTask = this.nodeProject.tasks.tryFind("compile");
+        if (compileTask) {
+            const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+            const taskName = `generate-and-bundle-${uniqueId}`;
+            const bundleTask = this.nodeProject.tasks.tryFind(taskName);
+            if (bundleTask) {
+                compileTask.prependSpawn(bundleTask);
+            }
+        }
+    }
+}
+exports.LambdaFunctionConstructGenerator = LambdaFunctionConstructGenerator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-function-construct-generator.js","sourceRoot":"","sources":["../../src/components/lambda-function-construct-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\";\nimport type { BuildOptions } from \"@mrgrain/cdk-esbuild\";\nimport { Component, SourceCode } from \"projen\";\nimport type { NodeProject } from \"projen/lib/javascript\";\n\nexport interface LambdaFunctionConstructGeneratorOptions {\n    readonly sourceDir?: string;\n    readonly outputDir?: string;\n    readonly filePattern?: string;\n    readonly esbuildOptions?: BuildOptions;\n    readonly addDependencies?: boolean;\n    readonly baseConstructImport?: string;\n    readonly baseConstructClass?: string;\n    readonly baseConstructPackage?: string;\n}\n\nexport class LambdaFunctionConstructGenerator extends Component {\n    public readonly sourceDir: string;\n    public readonly outputDir: string;\n    public readonly filePattern: string;\n    public readonly esbuildOptions: BuildOptions;\n    public readonly baseConstructImport?: string;\n    public readonly baseConstructClass?: string;\n    public readonly baseConstructPackage?: string;\n    private readonly nodeProject: NodeProject;\n    private readonly bundlerScriptPath: string;\n\n    constructor(project: NodeProject, options?: LambdaFunctionConstructGeneratorOptions) {\n        super(project);\n        this.nodeProject = project;\n        this.sourceDir = options?.sourceDir ?? \"src/handlers\";\n        this.outputDir = options?.outputDir ?? \"src/constructs/lambda\";\n        this.filePattern = options?.filePattern ?? \"*.lambda.ts\";\n        this.esbuildOptions = options?.esbuildOptions ?? {};\n        this.baseConstructImport = options?.baseConstructImport;\n        this.baseConstructClass = options?.baseConstructClass;\n        this.baseConstructPackage = options?.baseConstructPackage;\n\n        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n        this.bundlerScriptPath = path.join(\".projen\", `generate-and-bundle-${uniqueId}.ts`);\n\n        if (options?.addDependencies ?? true) {\n            this.addDependencies(options?.baseConstructPackage);\n        }\n\n        this.createBundleTask();\n        this.addBundleTaskToWorkflow();\n    }\n\n    private addDependencies(additionalPackage?: string) {\n        this.nodeProject.addDeps(\"aws-cdk-lib\", \"constructs\");\n\n        if (additionalPackage && additionalPackage !== \"aws-cdk-lib\" && additionalPackage !== \"constructs\") {\n            this.nodeProject.addDeps(additionalPackage);\n        }\n    }\n\n    private createUniqueId(sourceDir: string, filePattern: string): string {\n        const dirPart = sourceDir.replace(/\\//g, \"-\").replace(/[^\\w-]/g, \"\");\n        const patternPart = filePattern\n            .replace(/\\*/g, \"\")\n            .replace(/\\./g, \"-\")\n            .replace(/[^\\w-]/g, \"\");\n        return `${dirPart}-${patternPart}`.replace(/--+/g, \"-\").replace(/^-|-$/g, \"\");\n    }\n\n    private createBundleTask() {\n        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n        const taskName = `generate-and-bundle-${uniqueId}`;\n\n        let baseConstructArgs = \"\";\n        if (this.baseConstructImport) {\n            baseConstructArgs += ` --base-construct-import '${this.baseConstructImport}'`;\n        }\n        if (this.baseConstructClass) {\n            baseConstructArgs += ` --base-construct-class '${this.baseConstructClass}'`;\n        }\n\n        const bundleTask = this.nodeProject.addTask(taskName, {\n            description: `Generate Lambda Function Constructs from ${this.sourceDir}/${this.filePattern} and bundle their handlers`,\n            exec: `tsx --tsconfig tsconfig.dev.json ${this.bundlerScriptPath} --source-dir ${this.sourceDir} --output-dir ${this.outputDir} --file-pattern \"${this.filePattern}\" --esbuild-options '${JSON.stringify(this.esbuildOptions)}'${baseConstructArgs}`,\n        });\n\n        this.createBundlerScript();\n\n        return bundleTask;\n    }\n\n    private createBundlerScript() {\n        const bundlerScript = `// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\n\nimport * as path from 'path';\nimport * as fs from 'fs';\nimport * as esbuild from 'esbuild';\nimport * as glob from 'glob';\nimport { pascalCase } from 'change-case';\nimport yargs from 'yargs/yargs';\nimport { hideBin } from 'yargs/helpers';\n\nasync function main() {\n  const argv = await yargs(hideBin(process.argv))\n    .option('source-dir', { type: 'string', default: 'src/handlers', description: 'Source directory where Lambda Function handlers are located' })\n    .option('output-dir', { type: 'string', default: 'src/constructs/lambda', description: 'Output directory where Lambda Function constructs will be generated' })\n    .option('file-pattern', { type: 'string', default: '*.lambda.ts', description: 'File pattern to identify Lambda Function handlers' })\n    .option('esbuild-options', { type: 'string', default: '{}', description: 'esbuild options as JSON string' })\n    .option('base-construct-import', { type: 'string', description: 'Import statement for the base construct' })\n    .option('base-construct-class', { type: 'string', description: 'Name of the construct class to extend' })\n    .help()\n    .parse();\n\n  const sourceDir = argv['source-dir'];\n  const outputDir = argv['output-dir'];\n  const filePattern = argv['file-pattern'];\n  const esbuildOptions = JSON.parse(argv['esbuild-options'] as string);\n  const baseConstructImport = argv['base-construct-import'] as string | undefined;\n  const baseConstructClass = argv['base-construct-class'] as string | undefined;\n\n  fs.mkdirSync(path.join(process.cwd(), outputDir), { recursive: true });\n\n  const assetsDir = path.join(process.cwd(), 'assets', 'handlers');\n  fs.mkdirSync(assetsDir, { recursive: true });\n\n  const handlerFiles = glob.sync(path.join(process.cwd(), sourceDir, filePattern));\n\n  console.log(\\`Found \\${handlerFiles.length} Lambda Function handler files\\`);\n\n  for (const handlerFile of handlerFiles) {\n    const relativePath = path.relative(path.join(process.cwd(), sourceDir), handlerFile);\n    const fileName = path.basename(relativePath, path.extname(relativePath));\n    const functionName = fileName.replace('.lambda', '');\n\n    console.log(\\`Processing Lambda Function handler: \\${functionName}\\`);\n\n    const functionDir = path.join(assetsDir, functionName);\n    fs.mkdirSync(functionDir, { recursive: true });\n\n    const outfile = path.join(functionDir, 'index.js');\n\n    try {\n      await esbuild.build({\n        entryPoints: [handlerFile],\n        bundle: true,\n        minify: true,\n        platform: 'node',\n        target: 'node18',\n        outfile,\n        ...esbuildOptions,\n      });\n\n      console.log(\\`Successfully bundled \\${functionName} to \\${outfile}\\`);\n\n      const constructFilePath = path.join(process.cwd(), outputDir, \\`\\${functionName}.ts\\`);\n      const constructCode = generateConstructCode(functionName, relativePath, baseConstructImport, baseConstructClass);\n\n      fs.writeFileSync(constructFilePath, constructCode);\n      console.log(\\`Generated construct at \\${constructFilePath}\\`);\n    } catch (error) {\n      console.error(\\`Error processing \\${functionName}:\\`, error);\n    }\n  }\n}\n\nfunction generateConstructCode(functionName: string, handlerPath: string, baseConstructImport?: string, baseConstructClass?: string) {\n  const constructName = \\`\\${pascalCase(functionName)}Function\\`;\n\n  const importStatement = baseConstructImport ?? \"\";\n  const baseClassName = baseConstructClass ?? \"aws_lambda.Function\";\n\n  const useAwsLambdaRuntime = !baseConstructClass || baseClassName.includes(\"Function\");\n\n  return \\`// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\n\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\n\\${importStatement}\nimport { aws_lambda } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\n\nexport interface \\${constructName}Props extends Omit<\\${baseClassName === \"aws_lambda.Function\" ? \"aws_lambda.FunctionProps\" : \\`\\${baseClassName}Props\\`}, 'code'\\${useAwsLambdaRuntime ? \" | 'runtime'\" : \"\"} | 'handler'> {\n  \\${useAwsLambdaRuntime ? \\`/**\n   * Override the default runtime\n   * @default nodejs22.x\n   */\n  readonly runtime?: aws_lambda.Runtime;\\` : \"\"}\n}\n\nexport class \\${constructName} extends \\${baseClassName} {\n  constructor(scope: Construct, id: string, props: \\${constructName}Props = {}) {\n    super(scope, id, {\n      ...props,\n      \\${useAwsLambdaRuntime ? \"runtime: props.runtime ?? aws_lambda.Runtime.NODEJS_22_X,\" : \"\"}\n      handler: 'index.handler',\n      code: aws_lambda.Code.fromAsset(path.join(__dirname, '../../../assets/handlers/\\${functionName}')),\n    });\n  }\n}\n\\`;\n}\n\nmain().catch(error => {\n  console.error('Error:', error);\n  process.exit(1);\n});\n`;\n\n        const src = new SourceCode(this.project, this.bundlerScriptPath);\n        const lines = bundlerScript.split(\"\\n\");\n        for (const line of lines) {\n            src.line(line);\n        }\n\n        this.nodeProject.addDevDeps(\"esbuild\", \"glob\", \"yargs\", \"@types/glob\", \"@types/yargs\", \"tsx\", \"change-case\");\n    }\n\n    private addBundleTaskToWorkflow() {\n        const compileTask = this.nodeProject.tasks.tryFind(\"compile\");\n\n        if (compileTask) {\n            const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n            const taskName = `generate-and-bundle-${uniqueId}`;\n            const bundleTask = this.nodeProject.tasks.tryFind(taskName);\n            if (bundleTask) {\n                compileTask.prependSpawn(bundleTask);\n            }\n        }\n    }\n}\n"]}

package/lib/components/localstack.d.ts

@@ -0,0 +1,11 @@
+import type { IConstruct } from "constructs";
+import { Component } from "projen/lib/component";
+export interface LocalStackOptions {
+    readonly services?: string[];
+    readonly port?: number;
+    readonly debug?: boolean;
+    readonly imageTag?: string;
+}
+export declare class LocalStack extends Component {
+    constructor(scope: IConstruct, options?: LocalStackOptions);
+}

package/lib/components/localstack.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStack = void 0;
+const component_1 = require("projen/lib/component");
+const javascript_1 = require("projen/lib/javascript");
+const colima_1 = require("./colima");
+const homebrew_1 = require("./homebrew");
+class LocalStack extends component_1.Component {
+    constructor(scope, options = {}) {
+        super(scope);
+        const project = javascript_1.NodeProject.of(this);
+        if (!(project instanceof javascript_1.NodeProject)) {
+            throw new Error("LocalStack component requires a NodeProject");
+        }
+        const port = options.port ?? 4566;
+        const debug = options.debug ?? false;
+        new colima_1.Colima(project);
+        let homebrew = homebrew_1.Homebrew.of(project);
+        if (!homebrew) {
+            homebrew = new homebrew_1.Homebrew(project);
+        }
+        homebrew.addPackage("localstack");
+        const colimaTask = project.tasks.tryFind("colima");
+        const envVars = [`LOCALSTACK_PORT=${port}`, `LOCALSTACK_DEBUG=${debug ? "1" : "0"}`];
+        if (options.services) {
+            envVars.push(`SERVICES=${options.services.join(",")}`);
+        }
+        const localstackTask = project.addTask("localstack", {
+            exec: `localstack status | grep -q running || ${envVars.join(" ")} localstack start -d`,
+        });
+        if (colimaTask) {
+            localstackTask.prependSpawn(colimaTask);
+        }
+        project.addDevDeps("aws-cdk-local");
+        const testTask = project.tasks.tryFind("test");
+        if (testTask) {
+            testTask.prependSpawn(localstackTask);
+        }
+    }
+}
+exports.LocalStack = LocalStack;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/typedoc-config.d.ts

@@ -0,0 +1,78 @@
+export interface TypeDocConfiguration {
+    readonly entryPoints?: string[];
+    readonly entryPointStrategy?: EntryPointStrategy;
+    readonly exclude?: string[];
+    readonly excludeExternals?: boolean;
+    readonly excludePrivate?: boolean;
+    readonly excludeProtected?: boolean;
+    readonly excludeInternal?: boolean;
+    readonly out?: string;
+    readonly json?: string;
+    readonly theme?: string;
+    readonly basePath?: string;
+    readonly name?: string;
+    readonly cleanOutputDir?: boolean;
+    readonly includes?: string;
+    readonly media?: string;
+    readonly tsBuildInfo?: string;
+    readonly tsconfig?: string;
+    readonly logLevel?: LogLevel;
+    readonly sort?: string[];
+    readonly sortEntryPoints?: boolean;
+    readonly commentStyle?: CommentStyle;
+    readonly defaultVisibility?: Visibility;
+    readonly defaultCategory?: string;
+    readonly defaultGroup?: string;
+    readonly categorizeByGroup?: boolean;
+    readonly searchGroupBoosts?: Record<string, number>;
+    readonly searchCategoryBoosts?: Record<string, number>;
+    readonly readme?: string;
+    readonly packageJson?: string;
+    readonly gitRevision?: string;
+    readonly gitRemote?: string;
+    readonly sourceLinkTemplate?: string;
+    readonly disableSources?: boolean;
+    readonly disableGit?: boolean;
+    readonly hideGenerator?: boolean;
+    readonly hideParameterTypesInTitle?: boolean;
+    readonly cacheBust?: boolean;
+    readonly searchInComments?: boolean;
+    readonly searchInDocuments?: boolean;
+    readonly validation?: ValidationOptions;
+    readonly requiredToBeDocumented?: string[];
+    readonly treatWarningsAsErrors?: boolean;
+    readonly treatValidationWarningsAsErrors?: boolean;
+    readonly intentionallyNotExported?: string[];
+    readonly externalPattern?: string[];
+    readonly externalSymbolLinkMappings?: Record<string, Record<string, string>>;
+}
+export declare function toJson_TypeDocConfiguration(obj: TypeDocConfiguration | undefined): Record<string, unknown> | undefined;
+export declare enum EntryPointStrategy {
+    RESOLVE = "resolve",
+    EXPAND = "expand",
+    PACKAGES = "packages",
+    MERGE = "merge"
+}
+export declare enum LogLevel {
+    VERBOSE = "Verbose",
+    INFO = "Info",
+    WARN = "Warn",
+    ERROR = "Error",
+    NONE = "None"
+}
+export declare enum CommentStyle {
+    JSDOC = "jsdoc",
+    BLOCK = "block",
+    LINE = "line",
+    ALL = "all"
+}
+export declare enum Visibility {
+    PUBLIC = "public",
+    PROTECTED = "protected",
+    PRIVATE = "private"
+}
+export interface ValidationOptions {
+    readonly notExported?: boolean;
+    readonly notDocumented?: boolean;
+    readonly invalidLink?: boolean;
+}

package/lib/components/typedoc-config.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Visibility = exports.CommentStyle = exports.LogLevel = exports.EntryPointStrategy = void 0;
+exports.toJson_TypeDocConfiguration = toJson_TypeDocConfiguration;
+function toJson_TypeDocConfiguration(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        entryPoints: obj.entryPoints,
+        entryPointStrategy: obj.entryPointStrategy,
+        exclude: obj.exclude,
+        excludeExternals: obj.excludeExternals,
+        excludePrivate: obj.excludePrivate,
+        excludeProtected: obj.excludeProtected,
+        excludeInternal: obj.excludeInternal,
+        out: obj.out,
+        json: obj.json,
+        theme: obj.theme,
+        basePath: obj.basePath,
+        name: obj.name,
+        cleanOutputDir: obj.cleanOutputDir,
+        includes: obj.includes,
+        media: obj.media,
+        tsBuildInfo: obj.tsBuildInfo,
+        tsconfig: obj.tsconfig,
+        logLevel: obj.logLevel,
+        sort: obj.sort,
+        sortEntryPoints: obj.sortEntryPoints,
+        commentStyle: obj.commentStyle,
+        defaultVisibility: obj.defaultVisibility,
+        defaultCategory: obj.defaultCategory,
+        defaultGroup: obj.defaultGroup,
+        categorizeByGroup: obj.categorizeByGroup,
+        searchGroupBoosts: obj.searchGroupBoosts,
+        searchCategoryBoosts: obj.searchCategoryBoosts,
+        readme: obj.readme,
+        packageJson: obj.packageJson,
+        gitRevision: obj.gitRevision,
+        gitRemote: obj.gitRemote,
+        sourceLinkTemplate: obj.sourceLinkTemplate,
+        disableSources: obj.disableSources,
+        disableGit: obj.disableGit,
+        hideGenerator: obj.hideGenerator,
+        hideParameterTypesInTitle: obj.hideParameterTypesInTitle,
+        cacheBust: obj.cacheBust,
+        searchInComments: obj.searchInComments,
+        searchInDocuments: obj.searchInDocuments,
+        validation: obj.validation,
+        requiredToBeDocumented: obj.requiredToBeDocumented,
+        treatWarningsAsErrors: obj.treatWarningsAsErrors,
+        treatValidationWarningsAsErrors: obj.treatValidationWarningsAsErrors,
+        intentionallyNotExported: obj.intentionallyNotExported,
+        externalPattern: obj.externalPattern,
+        externalSymbolLinkMappings: obj.externalSymbolLinkMappings,
+    };
+    const filtered = {};
+    for (const [key, value] of Object.entries(result)) {
+        if (value !== undefined) {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
+var EntryPointStrategy;
+(function (EntryPointStrategy) {
+    EntryPointStrategy["RESOLVE"] = "resolve";
+    EntryPointStrategy["EXPAND"] = "expand";
+    EntryPointStrategy["PACKAGES"] = "packages";
+    EntryPointStrategy["MERGE"] = "merge";
+})(EntryPointStrategy || (exports.EntryPointStrategy = EntryPointStrategy = {}));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["VERBOSE"] = "Verbose";
+    LogLevel["INFO"] = "Info";
+    LogLevel["WARN"] = "Warn";
+    LogLevel["ERROR"] = "Error";
+    LogLevel["NONE"] = "None";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+var CommentStyle;
+(function (CommentStyle) {
+    CommentStyle["JSDOC"] = "jsdoc";
+    CommentStyle["BLOCK"] = "block";
+    CommentStyle["LINE"] = "line";
+    CommentStyle["ALL"] = "all";
+})(CommentStyle || (exports.CommentStyle = CommentStyle = {}));
+var Visibility;
+(function (Visibility) {
+    Visibility["PUBLIC"] = "public";
+    Visibility["PROTECTED"] = "protected";
+    Visibility["PRIVATE"] = "private";
+})(Visibility || (exports.Visibility = Visibility = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typedoc-config.js","sourceRoot":"","sources":["../../src/components/typedoc-config.ts"],"names":[],"mappings":"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","sourcesContent":["export interface TypeDocConfiguration {\n    readonly entryPoints?: string[];\n    readonly entryPointStrategy?: EntryPointStrategy;\n    readonly exclude?: string[];\n    readonly excludeExternals?: boolean;\n    readonly excludePrivate?: boolean;\n    readonly excludeProtected?: boolean;\n    readonly excludeInternal?: boolean;\n    readonly out?: string;\n    readonly json?: string;\n    readonly theme?: string;\n    readonly basePath?: string;\n    readonly name?: string;\n    readonly cleanOutputDir?: boolean;\n    readonly includes?: string;\n    readonly media?: string;\n    readonly tsBuildInfo?: string;\n    readonly tsconfig?: string;\n    readonly logLevel?: LogLevel;\n    readonly sort?: string[];\n    readonly sortEntryPoints?: boolean;\n    readonly commentStyle?: CommentStyle;\n    readonly defaultVisibility?: Visibility;\n    readonly defaultCategory?: string;\n    readonly defaultGroup?: string;\n    readonly categorizeByGroup?: boolean;\n    readonly searchGroupBoosts?: Record<string, number>;\n    readonly searchCategoryBoosts?: Record<string, number>;\n    readonly readme?: string;\n    readonly packageJson?: string;\n    readonly gitRevision?: string;\n    readonly gitRemote?: string;\n    readonly sourceLinkTemplate?: string;\n    readonly disableSources?: boolean;\n    readonly disableGit?: boolean;\n    readonly hideGenerator?: boolean;\n    readonly hideParameterTypesInTitle?: boolean;\n    readonly cacheBust?: boolean;\n    readonly searchInComments?: boolean;\n    readonly searchInDocuments?: boolean;\n    readonly validation?: ValidationOptions;\n    readonly requiredToBeDocumented?: string[];\n    readonly treatWarningsAsErrors?: boolean;\n    readonly treatValidationWarningsAsErrors?: boolean;\n    readonly intentionallyNotExported?: string[];\n    readonly externalPattern?: string[];\n    readonly externalSymbolLinkMappings?: Record<string, Record<string, string>>;\n}\n\nexport function toJson_TypeDocConfiguration(\n    obj: TypeDocConfiguration | undefined,\n): Record<string, unknown> | undefined {\n    if (obj === undefined) {\n        return undefined;\n    }\n    const result: Record<string, unknown> = {\n        entryPoints: obj.entryPoints,\n        entryPointStrategy: obj.entryPointStrategy,\n        exclude: obj.exclude,\n        excludeExternals: obj.excludeExternals,\n        excludePrivate: obj.excludePrivate,\n        excludeProtected: obj.excludeProtected,\n        excludeInternal: obj.excludeInternal,\n        out: obj.out,\n        json: obj.json,\n        theme: obj.theme,\n        basePath: obj.basePath,\n        name: obj.name,\n        cleanOutputDir: obj.cleanOutputDir,\n        includes: obj.includes,\n        media: obj.media,\n        tsBuildInfo: obj.tsBuildInfo,\n        tsconfig: obj.tsconfig,\n        logLevel: obj.logLevel,\n        sort: obj.sort,\n        sortEntryPoints: obj.sortEntryPoints,\n        commentStyle: obj.commentStyle,\n        defaultVisibility: obj.defaultVisibility,\n        defaultCategory: obj.defaultCategory,\n        defaultGroup: obj.defaultGroup,\n        categorizeByGroup: obj.categorizeByGroup,\n        searchGroupBoosts: obj.searchGroupBoosts,\n        searchCategoryBoosts: obj.searchCategoryBoosts,\n        readme: obj.readme,\n        packageJson: obj.packageJson,\n        gitRevision: obj.gitRevision,\n        gitRemote: obj.gitRemote,\n        sourceLinkTemplate: obj.sourceLinkTemplate,\n        disableSources: obj.disableSources,\n        disableGit: obj.disableGit,\n        hideGenerator: obj.hideGenerator,\n        hideParameterTypesInTitle: obj.hideParameterTypesInTitle,\n        cacheBust: obj.cacheBust,\n        searchInComments: obj.searchInComments,\n        searchInDocuments: obj.searchInDocuments,\n        validation: obj.validation,\n        requiredToBeDocumented: obj.requiredToBeDocumented,\n        treatWarningsAsErrors: obj.treatWarningsAsErrors,\n        treatValidationWarningsAsErrors: obj.treatValidationWarningsAsErrors,\n        intentionallyNotExported: obj.intentionallyNotExported,\n        externalPattern: obj.externalPattern,\n        externalSymbolLinkMappings: obj.externalSymbolLinkMappings,\n    };\n    const filtered: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(result)) {\n        if (value !== undefined) {\n            filtered[key] = value;\n        }\n    }\n    return filtered;\n}\n\nexport enum EntryPointStrategy {\n    RESOLVE = \"resolve\",\n    EXPAND = \"expand\",\n    PACKAGES = \"packages\",\n    MERGE = \"merge\",\n}\n\nexport enum LogLevel {\n    VERBOSE = \"Verbose\",\n    INFO = \"Info\",\n    WARN = \"Warn\",\n    ERROR = \"Error\",\n    NONE = \"None\",\n}\n\nexport enum CommentStyle {\n    JSDOC = \"jsdoc\",\n    BLOCK = \"block\",\n    LINE = \"line\",\n    ALL = \"all\",\n}\n\nexport enum Visibility {\n    PUBLIC = \"public\",\n    PROTECTED = \"protected\",\n    PRIVATE = \"private\",\n}\n\nexport interface ValidationOptions {\n    readonly notExported?: boolean;\n    readonly notDocumented?: boolean;\n    readonly invalidLink?: boolean;\n}\n"]}

package/lib/components/typedoc.d.ts

@@ -0,0 +1,18 @@
+import { Component } from "projen/lib/component";
+import type { NodeProject } from "projen/lib/javascript/node-project";
+import { JsonFile } from "projen/lib/json";
+import type { Project } from "projen/lib/project";
+import type { Task } from "projen/lib/task";
+import { type TypeDocConfiguration } from "./typedoc-config";
+export interface TypeDocOptions {
+    readonly version?: string;
+    readonly typeDocConfig?: TypeDocConfiguration;
+}
+export declare class TypeDoc extends Component {
+    static of(project: Project): TypeDoc | undefined;
+    private readonly typeDocConfiguration;
+    readonly task: Task;
+    readonly file: JsonFile;
+    constructor(project: NodeProject, options?: TypeDocOptions);
+}
+export * from "./typedoc-config";

package/lib/components/typedoc.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeDoc = void 0;
+const component_1 = require("projen/lib/component");
+const json_1 = require("projen/lib/json");
+const util_1 = require("projen/lib/util");
+const typedoc_config_1 = require("./typedoc-config");
+const DEFAULT_CONFIG = {
+    entryPointStrategy: typedoc_config_1.EntryPointStrategy.EXPAND,
+    out: "docs/api",
+    exclude: ["**/*.test.ts"],
+    excludePrivate: true,
+    disableSources: true,
+};
+class TypeDoc extends component_1.Component {
+    static of(project) {
+        const isTypeDoc = (c) => c instanceof TypeDoc;
+        return project.components.find(isTypeDoc);
+    }
+    constructor(project, options = {}) {
+        super(project);
+        const typedoc = "typedoc";
+        project.addDevDeps(`${typedoc}@${options.version ?? "^0.28"}`);
+        this.typeDocConfiguration = (0, util_1.deepMerge)([(0, typedoc_config_1.toJson_TypeDocConfiguration)(DEFAULT_CONFIG), (0, typedoc_config_1.toJson_TypeDocConfiguration)(options.typeDocConfig ?? {})], { mergeArrays: true });
+        this.file = new json_1.JsonFile(this, "typedoc.jsonc", {
+            obj: this.typeDocConfiguration,
+            allowComments: true,
+            marker: true,
+            readonly: false,
+        });
+        this.task = project.addTask("typedoc", {
+            description: "Generate TypeDoc documentation",
+            steps: [
+                {
+                    exec: "typedoc",
+                },
+            ],
+        });
+        project.testTask.spawn(this.task);
+    }
+}
+exports.TypeDoc = TypeDoc;
+__exportStar(require("./typedoc-config"), exports);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/vitest-bundled-define-config.d.ts

@@ -0,0 +1 @@
+export { defineConfig } from "vitest/config";

package/lib/components/vitest-bundled-define-config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+var config_1 = require("vitest/config");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return config_1.defineConfig; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidml0ZXN0LWJ1bmRsZWQtZGVmaW5lLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL3ZpdGVzdC1idW5kbGVkLWRlZmluZS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsd0NBQTZDO0FBQXBDLHNHQUFBLFlBQVksT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gXCJ2aXRlc3QvY29uZmlnXCI7XG4iXX0=