@nikovirtala/projen-constructs 0.1.8 → 0.2.0

package/README.md

@@ -8,21 +8,26 @@ Projen project types with standard configuration for consistent project setup ac
 pnpm add -D @nikovirtala/projen-constructs projen constructs
 ```
 
-## Standard Configuration
+## Features
+
+- **Standard Configuration**: Opinionated defaults for author, release branch, package manager, Node.js, TypeScript, and tooling
+- **Automatic Project Type Discovery**: Generates `ProjectType` enum from Projen's JSII manifest (18 project types)
+- **Component System**: Reusable components (Vitest, Mise, TypeDoc, LocalStack, etc.)
+- **Code Generation**: `ProjectGenerator` creates project classes with standard configuration
+- **ES Modules**: TypeScript and CDK App projects use ES modules (JSII uses CommonJS)
+- **Code Quality**: Biome for formatting and linting
+- **Testing**: Vitest with coverage
+- **Auto-merge**: Enabled with auto-approve
+- **VSCode**: Recommended extensions and settings
+- **mise**: Node version management
 
-All project types include:
+## Standard Configuration
 
 - **Author**: Niko Virtala (niko.virtala@hey.com)
 - **Default Release Branch**: main
 - **Package Manager**: pnpm 10
 - **Node Version**: 22.21.1
 - **TypeScript**: 5.9.3
-- **Module Type**: ES modules (TypeScript and CDK App projects only; JSII projects use CommonJS)
-- **Code Quality**: Biome for formatting and linting
-- **Testing**: Vitest
-- **Auto-merge**: Enabled with auto-approve
-- **VSCode**: Recommended extensions and settings
-- **mise**: Node version management (via Homebrew)
 - **CDK Version**: 2.223.0 (for CDK projects)
 - **JSII Version**: ~5.9.3 (for JSII projects)
 
@@ -235,3 +240,27 @@ new LambdaFunctionCodeBundle(project, {
   extension: ".lambda.ts",
 });
 ```
+
+#### ProjectGenerator
+
+Generates TypeScript project classes with standard configuration.
+
+```typescript
+import { ProjectGenerator, ProjectType } from "@nikovirtala/projen-constructs";
+
+new ProjectGenerator(project, {
+  name: "TypeScriptProject",
+  projectType: ProjectType.TYPESCRIPT,
+  filePath: "./src/projects/typescript.generated.ts",
+  components: [
+    { componentClass: Mise },
+    { componentClass: Vitest }, // Auto-detects VitestOptions from JSII manifest
+  ],
+});
+```
+
+Features:
+- Automatically generates the `ProjectType` enum from Projen's JSII manifest
+- Auto-detects component options types from JSII manifests
+- Validates paths to prevent directory traversal attacks
+- Structured error handling with custom error classes

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

@@ -1,78 +1,399 @@
+/**
+ * TypeDoc configuration
+ *
+ * @see https://typedoc.org/options/
+ */
 export interface TypeDocConfiguration {
+    /**
+     * Specifies the entry points to be documented by TypeDoc.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#entrypoints
+     */
     readonly entryPoints?: string[];
+    /**
+     * Specifies the strategy to be used to convert entry points into documentation.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#entrypointstrategy
+     */
     readonly entryPointStrategy?: EntryPointStrategy;
+    /**
+     * Define patterns to be excluded when expanding directories.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#exclude
+     */
     readonly exclude?: string[];
+    /**
+     * Prevent externally resolved symbols from being documented.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#excludeexternals
+     */
     readonly excludeExternals?: boolean;
+    /**
+     * Prevent private members from being included in the generated documentation.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#excludeprivate
+     */
     readonly excludePrivate?: boolean;
+    /**
+     * Prevent protected members from being included in the generated documentation.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#excludeprotected
+     */
     readonly excludeProtected?: boolean;
+    /**
+     * Prevent symbols that are not exported from being documented.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#excludeinternal
+     */
     readonly excludeInternal?: boolean;
+    /**
+     * Specifies the output directory the documentation should be written to.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#out
+     */
     readonly out?: string;
+    /**
+     * Specify the location the documentation should be written to.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#json
+     */
     readonly json?: string;
+    /**
+     * Specify a theme name to use.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#theme
+     */
     readonly theme?: string;
+    /**
+     * Specify the base path for all urls.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#basepath
+     */
     readonly basePath?: string;
+    /**
+     * Set the name of the project that will be used in the header of the template.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#name
+     */
     readonly name?: string;
+    /**
+     * Prevent TypeDoc from cleaning the output directory specified with --out.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#cleanoutputdir
+     */
     readonly cleanOutputDir?: boolean;
+    /**
+     * Specify the location to look for included documents.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#includes
+     */
     readonly includes?: string;
+    /**
+     * Specify the location with media files that should be copied to the output directory.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#media
+     */
     readonly media?: string;
+    /**
+     * Specify the location and filename a .tsbuildinfo file should be written to.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#tsbuildinfo
+     */
     readonly tsBuildInfo?: string;
+    /**
+     * Specify a TypeScript config file that should be used to load TypeScript configuration.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#tsconfig
+     */
     readonly tsconfig?: string;
+    /**
+     * Specify the logger that should be used.
+     *
+     * @see https://typedoc.org/documents/Options.Other.html#loglevel
+     */
     readonly logLevel?: LogLevel;
+    /**
+     * Specify the sort strategy for documented values.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#sort
+     */
     readonly sort?: string[];
+    /**
+     * Specify the sort strategy for static and instance members.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#sortentrypoints
+     */
     readonly sortEntryPoints?: boolean;
+    /**
+     * Specify the documentation mode TypeDoc should use.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#commentstyle
+     */
     readonly commentStyle?: CommentStyle;
+    /**
+     * Specify the default visibility for members without a visibility tag.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#defaultvisibility
+     */
     readonly defaultVisibility?: Visibility;
+    /**
+     * Specify the default category for reflections without a category.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#defaultcategory
+     */
     readonly defaultCategory?: string;
+    /**
+     * Specify the default group for reflections without a group.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#defaultgroup
+     */
     readonly defaultGroup?: string;
+    /**
+     * Specify the categories that will be used to group reflections.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#categorizebygroup
+     */
     readonly categorizeByGroup?: boolean;
+    /**
+     * Specify the search group boosts.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#searchgroupboosts
+     */
     readonly searchGroupBoosts?: Record<string, number>;
+    /**
+     * Specify the search category boosts.
+     *
+     * @see https://typedoc.org/documents/Options.Organization.html#searchcategoryboosts
+     */
     readonly searchCategoryBoosts?: Record<string, number>;
+    /**
+     * Specify the readme file that should be displayed on the index page.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#readme
+     */
     readonly readme?: string;
+    /**
+     * Specify the package.json file that should be used to determine the package name.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#packagejson
+     */
     readonly packageJson?: string;
+    /**
+     * Specify the git revision that should be used to link to source files.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#gitrevision
+     */
     readonly gitRevision?: string;
+    /**
+     * Specify the git remote that should be used to link to source files.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#gitremote
+     */
     readonly gitRemote?: string;
+    /**
+     * Specify a link template to be used when generating source urls.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#sourcelinktemplate
+     */
     readonly sourceLinkTemplate?: string;
+    /**
+     * Disables automatically linking to source code.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#disablesources
+     */
     readonly disableSources?: boolean;
+    /**
+     * Disables setting the source of reflections when documenting projects within a Git repository.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#disablegit
+     */
     readonly disableGit?: boolean;
+    /**
+     * Do not print the TypeDoc link at the end of the page.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#hidegenerator
+     */
     readonly hideGenerator?: boolean;
+    /**
+     * Hide parameter types in the signature.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#hideparametertypesintitle
+     */
     readonly hideParameterTypesInTitle?: boolean;
+    /**
+     * Include the generation time in links to prevent browsers from using a cached version.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#cachebust
+     */
     readonly cacheBust?: boolean;
+    /**
+     * If set, the search index will also include comments.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#searchincomments
+     */
     readonly searchInComments?: boolean;
+    /**
+     * If set, the search index will also include documents.
+     *
+     * @see https://typedoc.org/documents/Options.Output.html#searchindocuments
+     */
     readonly searchInDocuments?: boolean;
+    /**
+     * Specify validation options.
+     *
+     * @see https://typedoc.org/documents/Options.Validation.html
+     */
     readonly validation?: ValidationOptions;
+    /**
+     * Specify the type of reflections that must be documented.
+     *
+     * @see https://typedoc.org/documents/Options.Validation.html#requiredtobedocumented
+     */
     readonly requiredToBeDocumented?: string[];
+    /**
+     * If set, warnings will be treated as errors.
+     *
+     * @see https://typedoc.org/documents/Options.Validation.html#treatwarningsaserrors
+     */
     readonly treatWarningsAsErrors?: boolean;
+    /**
+     * If set, validation warnings will be treated as errors.
+     *
+     * @see https://typedoc.org/documents/Options.Validation.html#treatvalidationwarningsaserrors
+     */
     readonly treatValidationWarningsAsErrors?: boolean;
+    /**
+     * A list of types that should not produce warnings when not being exported.
+     *
+     * @see https://typedoc.org/documents/Options.Validation.html#intentionallynotexported
+     */
     readonly intentionallyNotExported?: string[];
+    /**
+     * Define patterns for files that should be considered external.
+     *
+     * @see https://typedoc.org/documents/Options.Input.html#externalpattern
+     */
     readonly externalPattern?: string[];
+    /**
+     * Define custom mappings for symbols in external packages.
+     *
+     * @see https://typedoc.org/documents/Options.Comments.html#externalsymbollinkmappings
+     */
     readonly externalSymbolLinkMappings?: Record<string, Record<string, string>>;
 }
+/**
+ * Converts TypeDocConfiguration to JSON representation
+ * @internal
+ */
 export declare function toJson_TypeDocConfiguration(obj: TypeDocConfiguration | undefined): Record<string, unknown> | undefined;
+/**
+ * Specifies the strategy to be used to convert entry points into documentation
+ *
+ * @see https://typedoc.org/documents/Options.Input.html#entrypointstrategy
+ */
 export declare enum EntryPointStrategy {
+    /**
+     * Expects all entry points to be contained within a single package
+     */
     RESOLVE = "resolve",
+    /**
+     * Expects all entry points to be top-level directories
+     */
     EXPAND = "expand",
+    /**
+     * Expects all entry points to be individual files
+     */
     PACKAGES = "packages",
+    /**
+     * Merges multiple projects into a single documentation site
+     */
     MERGE = "merge"
 }
+/**
+ * Specifies the logger that should be used
+ *
+ * @see https://typedoc.org/documents/Options.Other.html#loglevel
+ */
 export declare enum LogLevel {
+    /**
+     * Log all messages including verbose debug information
+     */
     VERBOSE = "Verbose",
+    /**
+     * Log informational messages and above
+     */
     INFO = "Info",
+    /**
+     * Log warnings and errors only
+     */
     WARN = "Warn",
+    /**
+     * Log errors only
+     */
     ERROR = "Error",
+    /**
+     * Disable all logging
+     */
     NONE = "None"
 }
+/**
+ * Specifies the documentation mode TypeDoc should use
+ *
+ * @see https://typedoc.org/documents/Options.Comments.html#commentstyle
+ */
 export declare enum CommentStyle {
+    /**
+     * Parse JSDoc style comments only
+     */
     JSDOC = "jsdoc",
+    /**
+     * Parse block comments
+     */
     BLOCK = "block",
+    /**
+     * Parse line comments (//)
+     */
     LINE = "line",
+    /**
+     * Parse all comment styles
+     */
     ALL = "all"
 }
+/**
+ * Specifies the default visibility for members without a visibility tag
+ *
+ * @see https://typedoc.org/documents/Options.Comments.html#defaultvisibility
+ */
 export declare enum Visibility {
+    /**
+     * Public visibility - accessible from anywhere
+     */
     PUBLIC = "public",
+    /**
+     * Protected visibility - accessible from class and subclasses
+     */
     PROTECTED = "protected",
+    /**
+     * Private visibility - accessible only within the class
+     */
     PRIVATE = "private"
 }
+/**
+ * Validation options
+ *
+ * @see https://typedoc.org/documents/Options.Validation.html
+ */
 export interface ValidationOptions {
+    /**
+     * If set, TypeDoc will produce warnings when a symbol is referenced by the documentation
+     */
     readonly notExported?: boolean;
+    /**
+     * If set, TypeDoc will produce warnings when an exported symbol is not documented
+     */
     readonly notDocumented?: boolean;
+    /**
+     * If set, TypeDoc will produce warnings about \@link tags which will produce broken links
+     */
     readonly invalidLink?: boolean;
 }

package/lib/components/typedoc-config.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Visibility = exports.CommentStyle = exports.LogLevel = exports.EntryPointStrategy = void 0;
 exports.toJson_TypeDocConfiguration = toJson_TypeDocConfiguration;
+/**
+ * Converts TypeDocConfiguration to JSON representation
+ * @internal
+ */
 function toJson_TypeDocConfiguration(obj) {
     if (obj === undefined) {
         return undefined;
@@ -62,32 +66,100 @@ function toJson_TypeDocConfiguration(obj) {
     }
     return filtered;
 }
+/**
+ * Specifies the strategy to be used to convert entry points into documentation
+ *
+ * @see https://typedoc.org/documents/Options.Input.html#entrypointstrategy
+ */
 var EntryPointStrategy;
 (function (EntryPointStrategy) {
+    /**
+     * Expects all entry points to be contained within a single package
+     */
     EntryPointStrategy["RESOLVE"] = "resolve";
+    /**
+     * Expects all entry points to be top-level directories
+     */
     EntryPointStrategy["EXPAND"] = "expand";
+    /**
+     * Expects all entry points to be individual files
+     */
     EntryPointStrategy["PACKAGES"] = "packages";
+    /**
+     * Merges multiple projects into a single documentation site
+     */
     EntryPointStrategy["MERGE"] = "merge";
 })(EntryPointStrategy || (exports.EntryPointStrategy = EntryPointStrategy = {}));
+/**
+ * Specifies the logger that should be used
+ *
+ * @see https://typedoc.org/documents/Options.Other.html#loglevel
+ */
 var LogLevel;
 (function (LogLevel) {
+    /**
+     * Log all messages including verbose debug information
+     */
     LogLevel["VERBOSE"] = "Verbose";
+    /**
+     * Log informational messages and above
+     */
     LogLevel["INFO"] = "Info";
+    /**
+     * Log warnings and errors only
+     */
     LogLevel["WARN"] = "Warn";
+    /**
+     * Log errors only
+     */
     LogLevel["ERROR"] = "Error";
+    /**
+     * Disable all logging
+     */
     LogLevel["NONE"] = "None";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Specifies the documentation mode TypeDoc should use
+ *
+ * @see https://typedoc.org/documents/Options.Comments.html#commentstyle
+ */
 var CommentStyle;
 (function (CommentStyle) {
+    /**
+     * Parse JSDoc style comments only
+     */
     CommentStyle["JSDOC"] = "jsdoc";
+    /**
+     * Parse block comments
+     */
     CommentStyle["BLOCK"] = "block";
+    /**
+     * Parse line comments (//)
+     */
     CommentStyle["LINE"] = "line";
+    /**
+     * Parse all comment styles
+     */
     CommentStyle["ALL"] = "all";
 })(CommentStyle || (exports.CommentStyle = CommentStyle = {}));
+/**
+ * Specifies the default visibility for members without a visibility tag
+ *
+ * @see https://typedoc.org/documents/Options.Comments.html#defaultvisibility
+ */
 var Visibility;
 (function (Visibility) {
+    /**
+     * Public visibility - accessible from anywhere
+     */
     Visibility["PUBLIC"] = "public";
+    /**
+     * Protected visibility - accessible from class and subclasses
+     */
     Visibility["PROTECTED"] = "protected";
+    /**
+     * Private visibility - accessible only within the class
+     */
     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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typedoc-config.js","sourceRoot":"","sources":["../../src/components/typedoc-config.ts"],"names":[],"mappings":";;;AA6UA,kEA6DC;AAjED;;;GAGG;AACH,SAAgB,2BAA2B,CACvC,GAAqC;IAErC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,MAAM,MAAM,GAA4B;QACpC,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;QAC1C,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;QACtC,cAAc,EAAE,GAAG,CAAC,cAAc;QAClC,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;QACtC,eAAe,EAAE,GAAG,CAAC,eAAe;QACpC,GAAG,EAAE,GAAG,CAAC,GAAG;QACZ,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,cAAc,EAAE,GAAG,CAAC,cAAc;QAClC,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,eAAe,EAAE,GAAG,CAAC,eAAe;QACpC,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;QACxC,eAAe,EAAE,GAAG,CAAC,eAAe;QACpC,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;QACxC,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;QACxC,oBAAoB,EAAE,GAAG,CAAC,oBAAoB;QAC9C,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;QAC1C,cAAc,EAAE,GAAG,CAAC,cAAc;QAClC,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,aAAa,EAAE,GAAG,CAAC,aAAa;QAChC,yBAAyB,EAAE,GAAG,CAAC,yBAAyB;QACxD,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;QACtC,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;QACxC,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,sBAAsB,EAAE,GAAG,CAAC,sBAAsB;QAClD,qBAAqB,EAAE,GAAG,CAAC,qBAAqB;QAChD,+BAA+B,EAAE,GAAG,CAAC,+BAA+B;QACpE,wBAAwB,EAAE,GAAG,CAAC,wBAAwB;QACtD,eAAe,EAAE,GAAG,CAAC,eAAe;QACpC,0BAA0B,EAAE,GAAG,CAAC,0BAA0B;KAC7D,CAAC;IACF,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAChD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACtB,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QAC1B,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,IAAY,kBAiBX;AAjBD,WAAY,kBAAkB;IAC1B;;OAEG;IACH,yCAAmB,CAAA;IACnB;;OAEG;IACH,uCAAiB,CAAA;IACjB;;OAEG;IACH,2CAAqB,CAAA;IACrB;;OAEG;IACH,qCAAe,CAAA;AACnB,CAAC,EAjBW,kBAAkB,kCAAlB,kBAAkB,QAiB7B;AAED;;;;GAIG;AACH,IAAY,QAqBX;AArBD,WAAY,QAAQ;IAChB;;OAEG;IACH,+BAAmB,CAAA;IACnB;;OAEG;IACH,yBAAa,CAAA;IACb;;OAEG;IACH,yBAAa,CAAA;IACb;;OAEG;IACH,2BAAe,CAAA;IACf;;OAEG;IACH,yBAAa,CAAA;AACjB,CAAC,EArBW,QAAQ,wBAAR,QAAQ,QAqBnB;AAED;;;;GAIG;AACH,IAAY,YAiBX;AAjBD,WAAY,YAAY;IACpB;;OAEG;IACH,+BAAe,CAAA;IACf;;OAEG;IACH,+BAAe,CAAA;IACf;;OAEG;IACH,6BAAa,CAAA;IACb;;OAEG;IACH,2BAAW,CAAA;AACf,CAAC,EAjBW,YAAY,4BAAZ,YAAY,QAiBvB;AAED;;;;GAIG;AACH,IAAY,UAaX;AAbD,WAAY,UAAU;IAClB;;OAEG;IACH,+BAAiB,CAAA;IACjB;;OAEG;IACH,qCAAuB,CAAA;IACvB;;OAEG;IACH,iCAAmB,CAAA;AACvB,CAAC,EAbW,UAAU,0BAAV,UAAU,QAarB","sourcesContent":["/**\n * TypeDoc configuration\n *\n * @see https://typedoc.org/options/\n */\nexport interface TypeDocConfiguration {\n    /**\n     * Specifies the entry points to be documented by TypeDoc.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#entrypoints\n     */\n    readonly entryPoints?: string[];\n\n    /**\n     * Specifies the strategy to be used to convert entry points into documentation.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#entrypointstrategy\n     */\n    readonly entryPointStrategy?: EntryPointStrategy;\n\n    /**\n     * Define patterns to be excluded when expanding directories.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#exclude\n     */\n    readonly exclude?: string[];\n\n    /**\n     * Prevent externally resolved symbols from being documented.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#excludeexternals\n     */\n    readonly excludeExternals?: boolean;\n\n    /**\n     * Prevent private members from being included in the generated documentation.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#excludeprivate\n     */\n    readonly excludePrivate?: boolean;\n\n    /**\n     * Prevent protected members from being included in the generated documentation.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#excludeprotected\n     */\n    readonly excludeProtected?: boolean;\n\n    /**\n     * Prevent symbols that are not exported from being documented.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#excludeinternal\n     */\n    readonly excludeInternal?: boolean;\n\n    /**\n     * Specifies the output directory the documentation should be written to.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#out\n     */\n    readonly out?: string;\n\n    /**\n     * Specify the location the documentation should be written to.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#json\n     */\n    readonly json?: string;\n\n    /**\n     * Specify a theme name to use.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#theme\n     */\n    readonly theme?: string;\n\n    /**\n     * Specify the base path for all urls.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#basepath\n     */\n    readonly basePath?: string;\n\n    /**\n     * Set the name of the project that will be used in the header of the template.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#name\n     */\n    readonly name?: string;\n\n    /**\n     * Prevent TypeDoc from cleaning the output directory specified with --out.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#cleanoutputdir\n     */\n    readonly cleanOutputDir?: boolean;\n\n    /**\n     * Specify the location to look for included documents.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#includes\n     */\n    readonly includes?: string;\n\n    /**\n     * Specify the location with media files that should be copied to the output directory.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#media\n     */\n    readonly media?: string;\n\n    /**\n     * Specify the location and filename a .tsbuildinfo file should be written to.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#tsbuildinfo\n     */\n    readonly tsBuildInfo?: string;\n\n    /**\n     * Specify a TypeScript config file that should be used to load TypeScript configuration.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#tsconfig\n     */\n    readonly tsconfig?: string;\n\n    /**\n     * Specify the logger that should be used.\n     *\n     * @see https://typedoc.org/documents/Options.Other.html#loglevel\n     */\n    readonly logLevel?: LogLevel;\n\n    /**\n     * Specify the sort strategy for documented values.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#sort\n     */\n    readonly sort?: string[];\n\n    /**\n     * Specify the sort strategy for static and instance members.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#sortentrypoints\n     */\n    readonly sortEntryPoints?: boolean;\n\n    /**\n     * Specify the documentation mode TypeDoc should use.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#commentstyle\n     */\n    readonly commentStyle?: CommentStyle;\n\n    /**\n     * Specify the default visibility for members without a visibility tag.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#defaultvisibility\n     */\n    readonly defaultVisibility?: Visibility;\n\n    /**\n     * Specify the default category for reflections without a category.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#defaultcategory\n     */\n    readonly defaultCategory?: string;\n\n    /**\n     * Specify the default group for reflections without a group.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#defaultgroup\n     */\n    readonly defaultGroup?: string;\n\n    /**\n     * Specify the categories that will be used to group reflections.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#categorizebygroup\n     */\n    readonly categorizeByGroup?: boolean;\n\n    /**\n     * Specify the search group boosts.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#searchgroupboosts\n     */\n    readonly searchGroupBoosts?: Record<string, number>;\n\n    /**\n     * Specify the search category boosts.\n     *\n     * @see https://typedoc.org/documents/Options.Organization.html#searchcategoryboosts\n     */\n    readonly searchCategoryBoosts?: Record<string, number>;\n\n    /**\n     * Specify the readme file that should be displayed on the index page.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#readme\n     */\n    readonly readme?: string;\n\n    /**\n     * Specify the package.json file that should be used to determine the package name.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#packagejson\n     */\n    readonly packageJson?: string;\n\n    /**\n     * Specify the git revision that should be used to link to source files.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#gitrevision\n     */\n    readonly gitRevision?: string;\n\n    /**\n     * Specify the git remote that should be used to link to source files.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#gitremote\n     */\n    readonly gitRemote?: string;\n\n    /**\n     * Specify a link template to be used when generating source urls.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#sourcelinktemplate\n     */\n    readonly sourceLinkTemplate?: string;\n\n    /**\n     * Disables automatically linking to source code.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#disablesources\n     */\n    readonly disableSources?: boolean;\n\n    /**\n     * Disables setting the source of reflections when documenting projects within a Git repository.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#disablegit\n     */\n    readonly disableGit?: boolean;\n\n    /**\n     * Do not print the TypeDoc link at the end of the page.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#hidegenerator\n     */\n    readonly hideGenerator?: boolean;\n\n    /**\n     * Hide parameter types in the signature.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#hideparametertypesintitle\n     */\n    readonly hideParameterTypesInTitle?: boolean;\n\n    /**\n     * Include the generation time in links to prevent browsers from using a cached version.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#cachebust\n     */\n    readonly cacheBust?: boolean;\n\n    /**\n     * If set, the search index will also include comments.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#searchincomments\n     */\n    readonly searchInComments?: boolean;\n\n    /**\n     * If set, the search index will also include documents.\n     *\n     * @see https://typedoc.org/documents/Options.Output.html#searchindocuments\n     */\n    readonly searchInDocuments?: boolean;\n\n    /**\n     * Specify validation options.\n     *\n     * @see https://typedoc.org/documents/Options.Validation.html\n     */\n    readonly validation?: ValidationOptions;\n\n    /**\n     * Specify the type of reflections that must be documented.\n     *\n     * @see https://typedoc.org/documents/Options.Validation.html#requiredtobedocumented\n     */\n    readonly requiredToBeDocumented?: string[];\n\n    /**\n     * If set, warnings will be treated as errors.\n     *\n     * @see https://typedoc.org/documents/Options.Validation.html#treatwarningsaserrors\n     */\n    readonly treatWarningsAsErrors?: boolean;\n\n    /**\n     * If set, validation warnings will be treated as errors.\n     *\n     * @see https://typedoc.org/documents/Options.Validation.html#treatvalidationwarningsaserrors\n     */\n    readonly treatValidationWarningsAsErrors?: boolean;\n\n    /**\n     * A list of types that should not produce warnings when not being exported.\n     *\n     * @see https://typedoc.org/documents/Options.Validation.html#intentionallynotexported\n     */\n    readonly intentionallyNotExported?: string[];\n\n    /**\n     * Define patterns for files that should be considered external.\n     *\n     * @see https://typedoc.org/documents/Options.Input.html#externalpattern\n     */\n    readonly externalPattern?: string[];\n\n    /**\n     * Define custom mappings for symbols in external packages.\n     *\n     * @see https://typedoc.org/documents/Options.Comments.html#externalsymbollinkmappings\n     */\n    readonly externalSymbolLinkMappings?: Record<string, Record<string, string>>;\n}\n\n/**\n * Converts TypeDocConfiguration to JSON representation\n * @internal\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\n/**\n * Specifies the strategy to be used to convert entry points into documentation\n *\n * @see https://typedoc.org/documents/Options.Input.html#entrypointstrategy\n */\nexport enum EntryPointStrategy {\n    /**\n     * Expects all entry points to be contained within a single package\n     */\n    RESOLVE = \"resolve\",\n    /**\n     * Expects all entry points to be top-level directories\n     */\n    EXPAND = \"expand\",\n    /**\n     * Expects all entry points to be individual files\n     */\n    PACKAGES = \"packages\",\n    /**\n     * Merges multiple projects into a single documentation site\n     */\n    MERGE = \"merge\",\n}\n\n/**\n * Specifies the logger that should be used\n *\n * @see https://typedoc.org/documents/Options.Other.html#loglevel\n */\nexport enum LogLevel {\n    /**\n     * Log all messages including verbose debug information\n     */\n    VERBOSE = \"Verbose\",\n    /**\n     * Log informational messages and above\n     */\n    INFO = \"Info\",\n    /**\n     * Log warnings and errors only\n     */\n    WARN = \"Warn\",\n    /**\n     * Log errors only\n     */\n    ERROR = \"Error\",\n    /**\n     * Disable all logging\n     */\n    NONE = \"None\",\n}\n\n/**\n * Specifies the documentation mode TypeDoc should use\n *\n * @see https://typedoc.org/documents/Options.Comments.html#commentstyle\n */\nexport enum CommentStyle {\n    /**\n     * Parse JSDoc style comments only\n     */\n    JSDOC = \"jsdoc\",\n    /**\n     * Parse block comments\n     */\n    BLOCK = \"block\",\n    /**\n     * Parse line comments (//)\n     */\n    LINE = \"line\",\n    /**\n     * Parse all comment styles\n     */\n    ALL = \"all\",\n}\n\n/**\n * Specifies the default visibility for members without a visibility tag\n *\n * @see https://typedoc.org/documents/Options.Comments.html#defaultvisibility\n */\nexport enum Visibility {\n    /**\n     * Public visibility - accessible from anywhere\n     */\n    PUBLIC = \"public\",\n    /**\n     * Protected visibility - accessible from class and subclasses\n     */\n    PROTECTED = \"protected\",\n    /**\n     * Private visibility - accessible only within the class\n     */\n    PRIVATE = \"private\",\n}\n\n/**\n * Validation options\n *\n * @see https://typedoc.org/documents/Options.Validation.html\n */\nexport interface ValidationOptions {\n    /**\n     * If set, TypeDoc will produce warnings when a symbol is referenced by the documentation\n     */\n    readonly notExported?: boolean;\n    /**\n     * If set, TypeDoc will produce warnings when an exported symbol is not documented\n     */\n    readonly notDocumented?: boolean;\n    /**\n     * If set, TypeDoc will produce warnings about \\@link tags which will produce broken links\n     */\n    readonly invalidLink?: boolean;\n}\n"]}

package/lib/components/typedoc.d.ts

@@ -5,13 +5,32 @@ import type { Project } from "projen/lib/project";
 import type { Task } from "projen/lib/task";
 import { type TypeDocConfiguration } from "./typedoc-config";
 export interface TypeDocOptions {
+    /**
+     * Version of TypeDoc to use
+     *
+     * @default "^0.28"
+     */
     readonly version?: string;
+    /**
+     * Full TypeDoc configuration
+     *
+     * This configuration will be merged with the default configuration
+     */
     readonly typeDocConfig?: TypeDocConfiguration;
 }
+/**
+ * TypeDoc component for projen projects
+ */
 export declare class TypeDoc extends Component {
     static of(project: Project): TypeDoc | undefined;
     private readonly typeDocConfiguration;
+    /**
+     * TypeDoc task
+     */
     readonly task: Task;
+    /**
+     * TypeDoc configuration file
+     */
     readonly file: JsonFile;
     constructor(project: NodeProject, options?: TypeDocOptions);
 }