timonel 3.1.1 → 3.1.2

package/dist/lib/templates/flexible-subchart.js

@@ -1,9 +1,17 @@
+/**
+ * @fileoverview Flexible subchart template that supports any cdk8s/cdk8s-plus-33 construct
+ * @since 2.8.4
+ */
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { Chart } from 'cdk8s';
 import { SecurityUtils } from '../security.js';
 import { dumpHelmAwareYaml } from '../utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from '../utils/helmHelpers.js';
+/**
+ * Flexible subchart that can accept any cdk8s construct or function
+ * @since 2.8.4
+ */
 export class FlexibleSubchart extends Chart {
     constructor(scope, id, config) {
         super(scope, id);
@@ -12,23 +20,40 @@ export class FlexibleSubchart extends Chart {
         this._manifests = [];
         this.configure();
     }
+    /**
+     * Add any cdk8s construct
+     * @param construct - Any cdk8s construct
+     * @param id - Unique identifier
+     */
     addConstruct(construct, id) {
         if (construct) {
             this._constructs.push({ construct, id: id || `construct-${this._constructs.length}` });
         }
     }
+    /**
+     * Add any manifest (for addManifest compatibility)
+     * @param manifest - Any manifest object
+     * @param id - Unique identifier
+     */
     addManifest(manifest, id) {
         if (manifest) {
             this._manifests.push({ manifest, id: id || `manifest-${this._manifests.length}` });
         }
     }
+    /**
+     * Configure the subchart with any provided construct or manifest
+     * @private
+     */
     configure() {
+        // Add any provided construct
         if (this.config.construct) {
             this.addConstruct(this.config.construct);
         }
+        // Add any provided manifest
         if (this.config.manifest) {
             this.addManifest(this.config.manifest);
         }
+        // Add any additional properties as constructs
         Object.entries(this.config).forEach(([key, value]) => {
             if (key !== 'name' &&
                 key !== 'version' &&
@@ -40,10 +65,18 @@ export class FlexibleSubchart extends Chart {
             }
         });
     }
+    /**
+     * Write Helm chart files for this subchart
+     * @param outputDir - Directory to write the Helm chart files
+     */
     writeHelmChart(outputDir) {
+        // Ensure output directory exists
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         if (!existsSync(outputDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
             mkdirSync(outputDir, { recursive: true });
         }
+        // Create Chart.yaml for the subchart
         const subchartYaml = {
             apiVersion: 'v2',
             name: this.config.name,
@@ -55,38 +88,56 @@ export class FlexibleSubchart extends Chart {
         const chartYamlPath = SecurityUtils.validatePath(join(outputDir, 'Chart.yaml'), process.cwd(), {
             allowAbsolute: true,
         });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         writeFileSync(chartYamlPath, dumpHelmAwareYaml(subchartYaml));
+        // Create values.yaml for the subchart (filter out functions and non-serializable objects)
         const subchartValues = {
             enabled: true,
             ...Object.fromEntries(Object.entries(this.config).filter(([key, value]) => key !== 'chart' && typeof value !== 'function' && value !== null && value !== undefined)),
         };
         const valuesYamlPath = SecurityUtils.validatePath(join(outputDir, 'values.yaml'), process.cwd(), { allowAbsolute: true });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         writeFileSync(valuesYamlPath, dumpHelmAwareYaml(subchartValues));
+        // Create templates directory
         const templatesDir = SecurityUtils.validatePath(join(outputDir, 'templates'), process.cwd(), {
             allowAbsolute: true,
         });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         if (!existsSync(templatesDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
             mkdirSync(templatesDir, { recursive: true });
         }
+        // Create _helpers.tpl for the subchart
         const helpersTpl = generateHelpersTemplate('aws', undefined, {
             includeKubernetes: true,
             includeSprig: true,
         });
         const helpersTplPath = SecurityUtils.validatePath(join(templatesDir, '_helpers.tpl'), process.cwd(), { allowAbsolute: true });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         writeFileSync(helpersTplPath, helpersTpl);
+        // Generate templates for manifests
         this._manifests.forEach((item) => {
             if (item && typeof item === 'object' && 'manifest' in item && 'id' in item) {
                 const { manifest, id } = item;
                 if (manifest && typeof manifest === 'object') {
                     const templateContent = this._generateManifestTemplate(manifest, id);
                     const manifestPath = SecurityUtils.validatePath(join(templatesDir, `${id}.yaml`), process.cwd(), { allowAbsolute: true });
+                    // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
                     writeFileSync(manifestPath, templateContent);
                 }
             }
         });
         console.log(`Created flexible Helm chart for subchart: ${this.config.name}`);
     }
+    /**
+     * Generate Helm template for a manifest
+     * @param manifest - The manifest object
+     * @param id - Template identifier
+     * @returns Generated template content
+     * @private
+     */
     _generateManifestTemplate(manifest, id) {
+        // Convert the manifest to a Helm template
         if (typeof manifest !== 'object' || manifest === null) {
             return dumpHelmAwareYaml({});
         }
@@ -104,16 +155,35 @@ export class FlexibleSubchart extends Chart {
         };
         return dumpHelmAwareYaml(template);
     }
+    /**
+     * Get all constructs added to this subchart
+     */
     getConstructs() {
         return this._constructs;
     }
+    /**
+     * Get all manifests added to this subchart
+     */
     getManifests() {
         return this._manifests;
     }
 }
+/**
+ * Create a flexible subchart that can accept any construct
+ * @param scope - Parent chart scope
+ * @param id - Unique identifier
+ * @param config - Subchart configuration
+ * @returns FlexibleSubchart instance
+ */
 export function createFlexibleSubchart(scope, id, config) {
     return new FlexibleSubchart(scope, id, config);
 }
+/**
+ * Generate a simple subchart template using Rutter addManifest()
+ * @param name Subchart name
+ * @returns Template string for chart.ts with simple Rutter implementation
+ * @since 2.11.0
+ */
 export function generateFlexibleSubchartTemplate(name) {
     return `import { App } from 'cdk8s';
 import { Rutter, helmInclude, helmIf, helmWith, createHelmExpression as helm } from 'timonel';

package/dist/lib/templates/umbrella-chart.d.ts

@@ -1,10 +1,25 @@
 import { App, Chart } from 'cdk8s';
 import type { ChartProps } from '../types.js';
+/**
+ * Generate an umbrella chart template with direct subchart imports
+ * @param name Chart name
+ * @returns Template string for umbrella.ts
+ * @since 2.11.0
+ */
 export declare function generateUmbrellaChart(name: string): string;
+/**
+ * UmbrellaChart class for managing multiple subcharts
+ * @since 2.8.4
+ */
 export declare class UmbrellaChartTemplate extends Chart {
     private readonly config;
     private _umbrellaRutter?;
     constructor(scope: App, id: string, config: ChartProps);
+    /**
+     * Configure the umbrella chart with basic resources and prepare UmbrellaRutter
+     * @since 2.8.4
+     * @private
+     */
     private configure;
     private _addService;
     private _addSubchart;
@@ -20,6 +35,18 @@ export declare class UmbrellaChartTemplate extends Chart {
     private _ensureDirectoryExists;
     private _processAssets;
     private _cleanupTempDir;
+    /**
+     * Create a basic Helm chart structure for subcharts that don't have writeHelmChart
+     * @since 2.8.4
+     * @param subchartName - Name of the subchart
+     * @param subchartDir - Directory to write the subchart files
+     * @private
+     */
     private _createBasicSubchart;
+    /**
+     * Write Helm chart files using basic Helm structure
+     * @since 2.8.4
+     * @param outputDir - Directory to write the Helm chart files
+     */
     writeHelmChart(outputDir: string): void;
 }

package/dist/lib/templates/umbrella-chart.js

@@ -6,6 +6,12 @@ import { SecurityUtils } from '../security.js';
 import { dumpHelmAwareYaml } from '../utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from '../utils/helmHelpers.js';
 import { createFlexibleSubchart } from './flexible-subchart.js';
+/**
+ * Generate an umbrella chart template with direct subchart imports
+ * @param name Chart name
+ * @returns Template string for umbrella.ts
+ * @since 2.11.0
+ */
 export function generateUmbrellaChart(name) {
     return `import { App } from 'cdk8s';
 import { Rutter, helmInclude, helmIf, helmWith, createHelmExpression as helm } from 'timonel';
@@ -163,13 +169,23 @@ if (import.meta.url === new URL(import.meta.url).href) {
 
 export default synth;`;
 }
+/**
+ * UmbrellaChart class for managing multiple subcharts
+ * @since 2.8.4
+ */
 export class UmbrellaChartTemplate extends Chart {
     constructor(scope, id, config) {
         super(scope, id);
         this.config = config;
         this.configure();
     }
+    /**
+     * Configure the umbrella chart with basic resources and prepare UmbrellaRutter
+     * @since 2.8.4
+     * @private
+     */
     configure() {
+        // Create a basic ConfigMap to indicate the umbrella chart is working
         new ApiObject(this, 'umbrella-info', {
             apiVersion: 'v1',
             kind: 'ConfigMap',
@@ -188,9 +204,12 @@ export class UmbrellaChartTemplate extends Chart {
                 'subcharts.count': String(this.config.subcharts?.length || 0),
             },
         });
+        // Note: Namespace is handled by writeHelmChart() method in templates/namespace.yaml
+        // Add services
         this.config.services?.forEach((svc, index) => {
             this._addService(svc, index);
         });
+        // Add subcharts
         this.config.subcharts?.forEach((subchart, index) => {
             this._addSubchart(subchart, index);
         });
@@ -228,10 +247,12 @@ export class UmbrellaChartTemplate extends Chart {
             else if (subchart.chart && typeof subchart.chart === 'object') {
                 this._handleObjectChart(subchart, flexibleSubchart);
             }
+            // Sanitize subchart name for logging to prevent log injection
             const sanitizedName = subchart.name.replace(/[\r\n]/g, '');
             console.log(`Added flexible subchart: ${sanitizedName}`);
         }
         catch (_error) {
+            // Sanitize subchart name for logging to prevent log injection
             const sanitizedName = subchart.name.replace(/[\r\n]/g, '');
             console.warn(`Failed to add subchart ${sanitizedName}:`, _error);
             this._createFallbackSubchart(subchart, index);
@@ -252,6 +273,7 @@ export class UmbrellaChartTemplate extends Chart {
             version: subchart.version || '1.0.0',
             description: `${subchart.name} subchart (fallback)`,
         });
+        // Sanitize subchart name for logging to prevent log injection
         const sanitizedName = subchart.name.replace(/[\r\n]/g, '');
         console.log(`Created fallback subchart: ${sanitizedName}`);
     }
@@ -267,6 +289,7 @@ export class UmbrellaChartTemplate extends Chart {
             }
         }
         catch (error) {
+            // Sanitize subchart name for logging to prevent log injection
             const sanitizedName = subchart.name.replace(/[\r\n]/g, '');
             console.log(`Failed to process subchart ${sanitizedName}:`, error);
         }
@@ -274,9 +297,11 @@ export class UmbrellaChartTemplate extends Chart {
     _handleObjectChart(subchart, flexibleSubchart) {
         const chartObj = subchart.chart;
         if (chartObj.constructor && chartObj.constructor.name !== 'Object') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- FlexibleSubchart method
             flexibleSubchart.addConstruct(subchart.chart);
         }
         else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- FlexibleSubchart method
             flexibleSubchart.addManifest(subchart.chart);
         }
     }
@@ -302,6 +327,7 @@ export class UmbrellaChartTemplate extends Chart {
         const children = node?.children;
         children?.forEach((child) => {
             if (child instanceof Chart) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- FlexibleSubchart method
                 flexibleSubchart.addConstruct(child);
             }
         });
@@ -309,9 +335,11 @@ export class UmbrellaChartTemplate extends Chart {
     _copyTemplates(subchartName, tempDir) {
         const tempTemplatesDir = join(tempDir, 'templates');
         const subchartTemplatesDir = join('dist', 'charts', subchartName, 'templates');
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
         if (existsSync(tempTemplatesDir)) {
             this._ensureDirectoryExists(join('dist', 'charts', subchartName));
             this._ensureDirectoryExists(subchartTemplatesDir);
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
             const templateFiles = readdirSync(tempTemplatesDir);
             templateFiles.forEach((file) => {
                 if (file.endsWith('.yaml') || file.endsWith('.yml') || file.endsWith('.tpl')) {
@@ -323,7 +351,9 @@ export class UmbrellaChartTemplate extends Chart {
         }
     }
     _ensureDirectoryExists(dirPath) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
         if (!existsSync(dirPath)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
             mkdirSync(dirPath, { recursive: true });
         }
     }
@@ -343,17 +373,27 @@ export class UmbrellaChartTemplate extends Chart {
                 }
             }
             catch (error) {
+                // Sanitize asset id for logging to prevent log injection
                 const sanitizedId = asset.id.replace(/[\r\n]/g, '');
                 console.log(`Failed to parse asset ${sanitizedId}:`, error);
             }
         });
     }
     _cleanupTempDir(tempDir) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
         if (existsSync(tempDir)) {
             rmSync(tempDir, { recursive: true, force: true });
         }
     }
+    /**
+     * Create a basic Helm chart structure for subcharts that don't have writeHelmChart
+     * @since 2.8.4
+     * @param subchartName - Name of the subchart
+     * @param subchartDir - Directory to write the subchart files
+     * @private
+     */
     _createBasicSubchart(subchartName, subchartDir) {
+        // Create Chart.yaml for the subchart
         const subchartYaml = {
             apiVersion: 'v2',
             name: subchartName,
@@ -362,7 +402,9 @@ export class UmbrellaChartTemplate extends Chart {
             version: '1.0.0',
             appVersion: '1.0.0',
         };
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(subchartDir, 'Chart.yaml'), dumpHelmAwareYaml(subchartYaml));
+        // Create values.yaml for the subchart
         const subchartValues = {
             enabled: true,
             replicas: 1,
@@ -371,23 +413,39 @@ export class UmbrellaChartTemplate extends Chart {
                 tag: 'latest',
             },
         };
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(subchartDir, 'values.yaml'), dumpHelmAwareYaml(subchartValues));
+        // Create templates directory
         const templatesDir = join(subchartDir, 'templates');
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         if (!existsSync(templatesDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
             mkdirSync(templatesDir, { recursive: true });
         }
+        // Create _helpers.tpl for the subchart
         const helpersTpl = generateHelpersTemplate('aws', undefined, {
             includeKubernetes: true,
             includeSprig: true,
         });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(templatesDir, '_helpers.tpl'), helpersTpl);
+        // Sanitize subchart name for logging to prevent log injection
         const sanitizedName = subchartName.replace(/[\r\n]/g, '');
         console.log(`Created basic Helm chart structure for subchart: ${sanitizedName}`);
     }
+    /**
+     * Write Helm chart files using basic Helm structure
+     * @since 2.8.4
+     * @param outputDir - Directory to write the Helm chart files
+     */
     writeHelmChart(outputDir) {
+        // Ensure output directory exists
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         if (!existsSync(outputDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
             mkdirSync(outputDir, { recursive: true });
         }
+        // Create Chart.yaml
         const chartYaml = {
             apiVersion: 'v2',
             name: this.config.name,
@@ -401,11 +459,14 @@ export class UmbrellaChartTemplate extends Chart {
                 repository: 'file://./charts/' + subchart.name,
             })) || [],
         };
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(outputDir, 'Chart.yaml'), dumpHelmAwareYaml(chartYaml));
+        // Create values.yaml
         const valuesYaml = {
             global: {
                 namespace: this.config.name,
             },
+            // Add subchart values
             ...Object.fromEntries(this.config.subcharts?.map((subchart) => [
                 subchart.name,
                 {
@@ -413,16 +474,25 @@ export class UmbrellaChartTemplate extends Chart {
                 },
             ]) || []),
         };
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(outputDir, 'values.yaml'), dumpHelmAwareYaml(valuesYaml));
+        // Create charts directory
         const chartsDir = join(outputDir, 'charts');
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         if (!existsSync(chartsDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
             mkdirSync(chartsDir, { recursive: true });
         }
+        // Generate Helm charts for each subchart
+        // eslint-disable-next-line sonarjs/cognitive-complexity
         this.config.subcharts?.forEach((subchart) => {
             const subchartDir = SecurityUtils.validatePath(join(chartsDir, subchart.name), process.cwd(), { allowAbsolute: true });
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
             if (!existsSync(subchartDir)) {
+                // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
                 mkdirSync(subchartDir, { recursive: true });
             }
+            // Create a flexible subchart that can handle any type of input
             const { name: _name, version: _version, description: _description, ...subchartProps } = subchart;
             const flexibleSubchart = createFlexibleSubchart(this, `${subchart.name}-chart`, {
                 name: subchart.name,
@@ -430,10 +500,14 @@ export class UmbrellaChartTemplate extends Chart {
                 description: subchart.description || `${subchart.name} subchart`,
                 ...subchartProps,
             });
+            // Handle different types of chart inputs
             if (typeof subchart.chart === 'function') {
                 try {
+                    // Try calling with scope and id parameters
                     const chartInstance = subchart.chart(this, `${subchart.name}-chart`);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     if (chartInstance && typeof chartInstance.writeHelmChart === 'function') {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         chartInstance.writeHelmChart(subchartDir);
                     }
                     else {
@@ -441,9 +515,12 @@ export class UmbrellaChartTemplate extends Chart {
                     }
                 }
                 catch {
+                    // If that fails, try calling without parameters
                     try {
                         const chartInstance = subchart.chart();
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         if (chartInstance && typeof chartInstance.writeHelmChart === 'function') {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
                             chartInstance.writeHelmChart(subchartDir);
                         }
                         else {
@@ -451,6 +528,7 @@ export class UmbrellaChartTemplate extends Chart {
                         }
                     }
                     catch (fallbackError) {
+                        // Sanitize subchart name for logging to prevent log injection
                         const sanitizedName = subchart.name.replace(/[\r\n]/g, '');
                         console.warn(`Failed to create subchart ${sanitizedName}:`, fallbackError);
                         flexibleSubchart.writeHelmChart(subchartDir);
@@ -458,24 +536,32 @@ export class UmbrellaChartTemplate extends Chart {
                 }
             }
             else if (subchart.chart && typeof subchart.chart === 'object') {
+                // If it's an object, try to use it as a construct or manifest
                 if (subchart.chart.constructor && subchart.chart.constructor.name !== 'Object') {
+                    // It's a cdk8s construct, add it to the flexible subchart
                     flexibleSubchart.addConstruct(subchart.chart);
                 }
                 else {
+                    // It's a manifest object, add it as a manifest
                     flexibleSubchart.addManifest(subchart.chart);
                 }
                 flexibleSubchart.writeHelmChart(subchartDir);
             }
             else {
+                // Use the flexible subchart as fallback
                 flexibleSubchart.writeHelmChart(subchartDir);
             }
         });
+        // Create templates directory
         const templatesDir = SecurityUtils.validatePath(join(outputDir, 'templates'), process.cwd(), {
             allowAbsolute: true,
         });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         if (!existsSync(templatesDir)) {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
             mkdirSync(templatesDir, { recursive: true });
         }
+        // Create shared namespace.yaml in templates
         const namespaceYaml = {
             apiVersion: 'v1',
             kind: 'Namespace',
@@ -490,11 +576,14 @@ export class UmbrellaChartTemplate extends Chart {
             },
         };
         const namespaceYamlPath = SecurityUtils.validatePath(join(templatesDir, 'namespace.yaml'), process.cwd(), { allowAbsolute: true });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- validated path
         writeFileSync(namespaceYamlPath, dumpHelmAwareYaml(namespaceYaml));
+        // Create _helpers.tpl using programmatic generation
         const helpersTpl = generateHelpersTemplate('aws', undefined, {
             includeKubernetes: true,
             includeSprig: true,
         });
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
         writeFileSync(join(templatesDir, '_helpers.tpl'), helpersTpl);
     }
 }

package/dist/lib/types.d.ts

@@ -1,29 +1,55 @@
 import type { Chart } from 'cdk8s';
 import type { TimonelLogger } from './utils/logger.js';
+/**
+ * Configuration used by the legacy `UmbrellaChartTemplate` compatibility API.
+ *
+ * New library code should normally build subcharts with `Rutter` and compose them with
+ * `UmbrellaRutter`. This interface remains public for the template/CLI compatibility layer.
+ */
 export interface ChartProps {
+    /** Helm chart name. */
     name: string;
+    /** Helm chart semantic version. */
     version: string;
+    /** Human-readable chart description. */
     description: string;
+    /** Optional default Kubernetes namespace. */
     namespace?: string;
+    /** Labels applied by compatibility template helpers. */
     labels?: Record<string, string>;
+    /** Annotations applied by compatibility template helpers. */
     annotations?: Record<string, string>;
+    /** Optional service descriptors generated by the umbrella compatibility template. */
     services?: Array<{
         name: string;
         port: number;
         targetPort: number;
     }>;
+    /** Optional subchart descriptors consumed by the umbrella compatibility template. */
     subcharts?: Array<{
         name: string;
         chart: Chart | ((scope: Chart, id: string) => Chart) | unknown;
         version?: string;
         enabled?: boolean;
+        /** Additional template-specific properties. */
         [key: string]: unknown;
     }>;
+    /** Additional template-specific properties retained for compatibility. */
     [key: string]: unknown;
+    /**
+     * Custom logger instance.
+     * @since 2.13.0
+     */
     logger?: TimonelLogger;
 }
+/**
+ * Serializable subchart entry stored by the CLI in `umbrella.config.json`.
+ */
 export interface SubchartProps {
+    /** Subchart name. */
     name: string;
+    /** Subchart version recorded in the CLI configuration. */
     version: string;
+    /** Project-relative path to the subchart TypeScript entry point. */
     path: string;
 }

package/dist/lib/umbrella.d.ts

@@ -1,3 +1,26 @@
+/**
+ * @fileoverview Umbrella chart utilities for managing multiple subcharts as a single unit
+ * @since 2.8.0+
+ */
 import type { UmbrellaRutter, UmbrellaRutterProps } from './umbrellaRutter.js';
+/**
+ * Create an umbrella chart from multiple Rutter instances
+ *
+ * @param props - Umbrella chart configuration
+ * @returns UmbrellaRutter instance for managing subcharts
+ *
+ * @example
+ * ```typescript
+ * const umbrella = createUmbrella({
+ *   meta: { name: 'my-umbrella', version: '1.0.0' },
+ *   subcharts: [
+ *     { name: 'frontend', rutter: frontendChart },
+ *     { name: 'backend', rutter: backendChart }
+ *   ]
+ * });
+ * ```
+ *
+ * @since 2.8.0+
+ */
 export declare function createUmbrella(props: UmbrellaRutterProps): UmbrellaRutter;
 export type { UmbrellaRutterProps, SubchartSpec } from './umbrellaRutter.js';

package/dist/lib/umbrella.js

@@ -1,4 +1,27 @@
+/**
+ * @fileoverview Umbrella chart utilities for managing multiple subcharts as a single unit
+ * @since 2.8.0+
+ */
 import { UmbrellaRutter as UmbrellaRutterClass } from './umbrellaRutter.js';
+/**
+ * Create an umbrella chart from multiple Rutter instances
+ *
+ * @param props - Umbrella chart configuration
+ * @returns UmbrellaRutter instance for managing subcharts
+ *
+ * @example
+ * ```typescript
+ * const umbrella = createUmbrella({
+ *   meta: { name: 'my-umbrella', version: '1.0.0' },
+ *   subcharts: [
+ *     { name: 'frontend', rutter: frontendChart },
+ *     { name: 'backend', rutter: backendChart }
+ *   ]
+ * });
+ * ```
+ *
+ * @since 2.8.0+
+ */
 export function createUmbrella(props) {
     return new UmbrellaRutterClass(props);
 }