timonel 2.10.2 → 2.12.0

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

@@ -1,5 +1,4 @@
-import type { App } from 'cdk8s';
-import { Chart } from 'cdk8s';
+import { App, Chart } from 'cdk8s';
 import type { ChartProps } from '../types.js';
 export declare function generateUmbrellaChart(name: string): string;
 export declare class UmbrellaChartTemplate extends Chart {
@@ -9,6 +8,18 @@ export declare class UmbrellaChartTemplate extends Chart {
     private configure;
     private _addService;
     private _addSubchart;
+    private _createFlexibleSubchart;
+    private _createFallbackSubchart;
+    private _handleFunctionChart;
+    private _handleObjectChart;
+    private _isRutterInstance;
+    private _isChartInstance;
+    private _processRutterInstance;
+    private _processChartInstance;
+    private _copyTemplates;
+    private _ensureDirectoryExists;
+    private _processAssets;
+    private _cleanupTempDir;
     private _createBasicSubchart;
     writeHelmChart(outputDir: string): void;
 }

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

@@ -1,13 +1,20 @@
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, copyFileSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
-import { Chart, ApiObject } from 'cdk8s';
+import * as jsYaml from 'js-yaml';
+import { App, Chart, ApiObject } from 'cdk8s';
 import { dumpHelmAwareYaml } from '../utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from '../utils/helmHelpers.js';
 import { createFlexibleSubchart } from './flexible-subchart.js';
 export function generateUmbrellaChart(name) {
     return `import { App } from 'cdk8s';
 import { UmbrellaChart } from 'timonel';
+// Import subcharts - add your subchart imports here
 
+/**
+ * Synthesizes the umbrella chart with all subcharts
+ * @param outDir Output directory for generated charts
+ * @since 2.11.0
+ */
 export function synth(outDir: string) {
   const app = new App({
     outdir: outDir,
@@ -20,7 +27,9 @@ export function synth(outDir: string) {
     version: '0.1.0',
     description: '${name} umbrella chart',
     services: [],
-    subcharts: []
+    subcharts: [
+      // Add your subcharts here:
+    ]
   });
 
   // Generate Helm chart files
@@ -95,54 +104,131 @@ export class UmbrellaChartTemplate extends Chart {
     }
     _addSubchart(subchart, index) {
         try {
-            let _subchartInstance;
-            const { name: _name, version: _version, description: _description, ...subchartProps } = subchart;
-            const flexibleSubchart = createFlexibleSubchart(this, `${subchart.name}-${index}`, {
-                name: subchart.name,
-                version: subchart.version || '1.0.0',
-                description: subchart.description || `${subchart.name} subchart`,
-                ...subchartProps,
-            });
+            const flexibleSubchart = this._createFlexibleSubchart(subchart, index);
             if (typeof subchart.chart === 'function') {
-                try {
-                    const subchartInstance = subchart.chart(this, `${subchart.name}-${index}`);
-                    if (subchartInstance.node.children) {
-                        subchartInstance.node.children.forEach((child) => {
-                            if (child instanceof Chart) {
-                                flexibleSubchart.addConstruct(child);
-                            }
-                        });
-                    }
-                }
-                catch {
-                    const subchartInstance = subchart.chart();
-                    if (subchartInstance.node.children) {
-                        subchartInstance.node.children.forEach((child) => {
-                            if (child instanceof Chart) {
-                                flexibleSubchart.addConstruct(child);
-                            }
-                        });
-                    }
-                }
+                this._handleFunctionChart(subchart, index, flexibleSubchart);
             }
             else if (subchart.chart && typeof subchart.chart === 'object') {
-                if (subchart.chart.constructor && subchart.chart.constructor.name !== 'Object') {
-                    flexibleSubchart.addConstruct(subchart.chart);
-                }
-                else {
-                    flexibleSubchart.addManifest(subchart.chart);
-                }
+                this._handleObjectChart(subchart, flexibleSubchart);
             }
             console.log(`Added flexible subchart: ${subchart.name}`);
         }
         catch (_error) {
             console.warn(`Failed to add subchart ${subchart.name}:`, _error);
-            const _fallbackSubchart = createFlexibleSubchart(this, `${subchart.name}-fallback-${index}`, {
-                name: subchart.name,
-                version: subchart.version || '1.0.0',
-                description: `${subchart.name} subchart (fallback)`,
+            this._createFallbackSubchart(subchart, index);
+        }
+    }
+    _createFlexibleSubchart(subchart, index) {
+        const { name: _name, version: _version, description: _description, ...subchartProps } = subchart;
+        return createFlexibleSubchart(this, `${subchart.name}-${index}`, {
+            name: subchart.name,
+            version: subchart.version || '1.0.0',
+            description: subchart.description || `${subchart.name} subchart`,
+            ...subchartProps,
+        });
+    }
+    _createFallbackSubchart(subchart, index) {
+        const _fallbackSubchart = createFlexibleSubchart(this, `${subchart.name}-fallback-${index}`, {
+            name: subchart.name,
+            version: subchart.version || '1.0.0',
+            description: `${subchart.name} subchart (fallback)`,
+        });
+        console.log(`Created fallback subchart: ${subchart.name}`);
+    }
+    _handleFunctionChart(subchart, index, flexibleSubchart) {
+        try {
+            const tempApp = new App({ outdir: 'temp' });
+            const rutterInstance = subchart.chart(tempApp);
+            if (this._isRutterInstance(rutterInstance)) {
+                this._processRutterInstance(subchart, index, rutterInstance, flexibleSubchart);
+            }
+            else if (this._isChartInstance(rutterInstance)) {
+                this._processChartInstance(rutterInstance, flexibleSubchart);
+            }
+        }
+        catch (error) {
+            console.log(`Failed to process subchart ${subchart.name}:`, error);
+        }
+    }
+    _handleObjectChart(subchart, flexibleSubchart) {
+        const chartObj = subchart.chart;
+        if (chartObj.constructor && chartObj.constructor.name !== 'Object') {
+            flexibleSubchart.addConstruct(subchart.chart);
+        }
+        else {
+            flexibleSubchart.addManifest(subchart.chart);
+        }
+    }
+    _isRutterInstance(instance) {
+        return !!(instance && typeof instance.addManifest === 'function');
+    }
+    _isChartInstance(instance) {
+        const obj = instance;
+        const node = obj?.node;
+        return !!(node && node.children);
+    }
+    _processRutterInstance(subchart, index, rutterInstance, flexibleSubchart) {
+        const tempDir = `temp-${subchart.name}-${index}`;
+        const write = rutterInstance.write;
+        write?.(tempDir);
+        this._copyTemplates(subchart.name, tempDir);
+        this._processAssets(rutterInstance, flexibleSubchart);
+        this._cleanupTempDir(tempDir);
+    }
+    _processChartInstance(rutterInstance, flexibleSubchart) {
+        const obj = rutterInstance;
+        const node = obj?.node;
+        const children = node?.children;
+        children?.forEach((child) => {
+            if (child instanceof Chart) {
+                flexibleSubchart.addConstruct(child);
+            }
+        });
+    }
+    _copyTemplates(subchartName, tempDir) {
+        const tempTemplatesDir = join(tempDir, 'templates');
+        const subchartTemplatesDir = join('dist', 'charts', subchartName, 'templates');
+        if (existsSync(tempTemplatesDir)) {
+            this._ensureDirectoryExists(join('dist', 'charts', subchartName));
+            this._ensureDirectoryExists(subchartTemplatesDir);
+            const templateFiles = readdirSync(tempTemplatesDir);
+            templateFiles.forEach((file) => {
+                if (file.endsWith('.yaml') || file.endsWith('.yml') || file.endsWith('.tpl')) {
+                    const sourceFile = join(tempTemplatesDir, file);
+                    const targetFile = join(subchartTemplatesDir, file);
+                    copyFileSync(sourceFile, targetFile);
+                }
             });
-            console.log(`Created fallback subchart: ${subchart.name}`);
+        }
+    }
+    _ensureDirectoryExists(dirPath) {
+        if (!existsSync(dirPath)) {
+            mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    _processAssets(rutterInstance, flexibleSubchart) {
+        const getAssets = rutterInstance.getAssets;
+        const assets = getAssets?.() || [];
+        assets.forEach((asset, assetIndex) => {
+            try {
+                const manifest = jsYaml.load(asset.yaml);
+                if (manifest?.apiVersion && manifest?.kind) {
+                    new ApiObject(flexibleSubchart, `${String(manifest.kind).toLowerCase()}-${assetIndex}`, {
+                        apiVersion: String(manifest.apiVersion),
+                        kind: String(manifest.kind),
+                        metadata: manifest.metadata || {},
+                        spec: manifest.spec || {},
+                    });
+                }
+            }
+            catch (error) {
+                console.log(`Failed to parse asset ${asset.id}:`, error);
+            }
+        });
+    }
+    _cleanupTempDir(tempDir) {
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
         }
     }
     _createBasicSubchart(subchartName, subchartDir) {

package/dist/lib/utils/helmHelpers/envHelpers.d.ts

@@ -0,0 +1,2 @@
+import type { HelperDefinition } from './types.js';
+export declare const ENV_HELPERS: HelperDefinition[];

package/dist/lib/utils/helmHelpers/envHelpers.js

@@ -0,0 +1,97 @@
+export const ENV_HELPERS = [
+    {
+        name: 'env.required',
+        template: `{{- $key := . -}}
+{{- $value := index .Values.env $key -}}
+{{- required (printf "Environment variable %s is required" $key) $value }}`,
+    },
+    {
+        name: 'env.isDev',
+        template: `{{- $env := .Values.environment | default "production" -}}
+{{- or (eq $env "dev") (eq $env "development") }}`,
+    },
+    {
+        name: 'env.isProd',
+        template: `{{- $env := .Values.environment | default "production" -}}
+{{- or (eq $env "prod") (eq $env "production") }}`,
+    },
+    {
+        name: 'env.isStaging',
+        template: `{{- $env := .Values.environment | default "production" -}}
+{{- or (eq $env "staging") (eq $env "stage") }}`,
+    },
+    {
+        name: 'env.isTest',
+        template: `{{- $env := .Values.environment | default "production" -}}
+{{- or (eq $env "test") (eq $env "testing") }}`,
+    },
+    {
+        name: 'config.merge',
+        template: `{{- $base := .base | default dict -}}
+{{- $env := .env | default dict -}}
+{{- $override := .override | default dict -}}
+{{- merge $override $env $base | toJson }}`,
+    },
+    {
+        name: 'config.secretRef',
+        template: `{{- if .fromSecret -}}
+valueFrom:
+  secretKeyRef:
+    name: {{ .fromSecret.name }}
+    key: {{ .fromSecret.key }}
+    {{- if .fromSecret.optional }}
+    optional: true
+    {{- end }}
+{{- else if .fromConfigMap -}}
+valueFrom:
+  configMapKeyRef:
+    name: {{ .fromConfigMap.name }}
+    key: {{ .fromConfigMap.key }}
+    {{- if .fromConfigMap.optional }}
+    optional: true
+    {{- end }}
+{{- else -}}
+value: {{ .value | quote }}
+{{- end }}`,
+    },
+    {
+        name: 'config.envFromSource',
+        template: `{{- if .configMapRef -}}
+configMapRef:
+  name: {{ .configMapRef.name }}
+  {{- if .configMapRef.optional }}
+  optional: true
+  {{- end }}
+{{- else if .secretRef -}}
+secretRef:
+  name: {{ .secretRef.name }}
+  {{- if .secretRef.optional }}
+  optional: true
+  {{- end }}
+{{- end }}`,
+    },
+    {
+        name: 'config.featureFlag',
+        template: `{{- $flag := .flag -}}
+{{- $default := .default | default false -}}
+{{- $envKey := printf "FEATURE_%s" ($flag | upper) -}}
+{{- $envFlag := index .Values.env $envKey | default "" -}}
+{{- $valueFlag := index .Values.features $flag | default "" -}}
+{{- if $valueFlag }}
+{{- $valueFlag }}
+{{- else if $envFlag }}
+{{- $envFlag }}
+{{- else }}
+{{- $default }}
+{{- end }}`,
+    },
+    {
+        name: 'config.debugMode',
+        template: `{{- $debug := .Values.debug | default (index .Values.env "DEBUG") | default false -}}
+{{- if or $debug (include "env.isDev" .) -}}
+true
+{{- else -}}
+false
+{{- end }}`,
+    },
+];

package/dist/lib/utils/helmHelpers/gitopsHelpers.d.ts

@@ -0,0 +1,2 @@
+import type { HelperDefinition } from './types.js';
+export declare const GITOPS_HELPERS: HelperDefinition[];

package/dist/lib/utils/helmHelpers/gitopsHelpers.js

@@ -0,0 +1,132 @@
+export const GITOPS_HELPERS = [
+    {
+        name: 'git.commitSha',
+        template: `{{- .Values.git.commitSha | default "unknown" }}`,
+    },
+    {
+        name: 'git.shortSha',
+        template: `{{- $sha := include "git.commitSha" . -}}
+{{- if ne $sha "unknown" -}}
+{{- $sha | trunc 8 -}}
+{{- else -}}
+unknown
+{{- end }}`,
+    },
+    {
+        name: 'git.branch',
+        template: `{{- .Values.git.branch | default "main" }}`,
+    },
+    {
+        name: 'git.tag',
+        template: `{{- .Values.git.tag | default "" }}`,
+    },
+    {
+        name: 'git.repository',
+        template: `{{- .Values.git.repository | default "unknown/repository" }}`,
+    },
+    {
+        name: 'image.tagWithSha',
+        template: `{{- $repo := .Values.image.repository -}}
+{{- $sha := include "git.shortSha" . -}}
+{{- printf "%s:%s" $repo $sha }}`,
+    },
+    {
+        name: 'image.tagWithVersion',
+        template: `{{- $repo := .Values.image.repository -}}
+{{- $tag := .Values.image.tag | default .Chart.AppVersion | default "latest" -}}
+{{- printf "%s:%s" $repo $tag }}`,
+    },
+    {
+        name: 'image.tagWithBranch',
+        template: `{{- $repo := .Values.image.repository -}}
+{{- $branch := include "git.branch" . | replace "/" "-" | lower -}}
+{{- printf "%s:%s" $repo $branch }}`,
+    },
+    {
+        name: 'ci.buildId',
+        template: `{{- .Values.ci.buildId | default "unknown" }}`,
+    },
+    {
+        name: 'ci.buildUrl',
+        template: `{{- .Values.ci.buildUrl | default "" }}`,
+    },
+    {
+        name: 'ci.jobUrl',
+        template: `{{- .Values.ci.jobUrl | default "" }}`,
+    },
+    {
+        name: 'ci.runner',
+        template: `{{- .Values.ci.runner | default "unknown" }}`,
+    },
+    {
+        name: 'deploy.timestamp',
+        template: `{{- now | date "2006-01-02T15:04:05Z07:00" }}`,
+    },
+    {
+        name: 'deploy.user',
+        template: `{{- .Values.deploy.user | default "automated" }}`,
+    },
+    {
+        name: 'deploy.annotations',
+        template: `deployment.kubernetes.io/revision: "{{ .Release.Revision }}"
+app.kubernetes.io/version: "{{ .Chart.AppVersion }}"
+app.kubernetes.io/part-of: "{{ .Values.application.name | default .Chart.Name }}"
+git.commit: "{{ include "git.commitSha" . }}"
+git.branch: "{{ include "git.branch" . }}"
+git.repository: "{{ include "git.repository" . }}"
+ci.build-id: "{{ include "ci.buildId" . }}"
+ci.build-url: "{{ include "ci.buildUrl" . }}"
+deploy.timestamp: "{{ include "deploy.timestamp" . }}"
+deploy.user: "{{ include "deploy.user" . }}"`,
+    },
+    {
+        name: 'deploy.labels',
+        template: `app.kubernetes.io/version: "{{ .Chart.AppVersion }}"
+app.kubernetes.io/component: "{{ .Values.component | default "application" }}"
+app.kubernetes.io/part-of: "{{ .Values.application.name | default .Chart.Name }}"
+git.branch: "{{ include "git.branch" . | replace "/" "-" | lower }}"
+environment: "{{ .Values.environment | default "development" }}"`,
+    },
+    {
+        name: 'semver.parse',
+        template: `{{- $version := . -}}
+{{- $parts := regexSplit "\\\\." $version -1 -}}
+{{- if eq (len $parts) 3 -}}
+{{- printf "{\\"major\\": %s, \\"minor\\": %s, \\"patch\\": %s}" (index $parts 0) (index $parts 1) (index $parts 2) -}}
+{{- else -}}
+{{- printf "{\\"major\\": 0, \\"minor\\": 0, \\"patch\\": 0}" -}}
+{{- end }}`,
+    },
+    {
+        name: 'semver.bump',
+        template: `{{- $version := .version -}}
+{{- $type := .type | default "patch" -}}
+{{- $parts := regexSplit "\\\\." $version -1 -}}
+{{- if eq (len $parts) 3 -}}
+{{- $major := index $parts 0 | int -}}
+{{- $minor := index $parts 1 | int -}}
+{{- $patch := index $parts 2 | int -}}
+{{- if eq $type "major" -}}
+{{- printf "%d.0.0" (add $major 1) -}}
+{{- else if eq $type "minor" -}}
+{{- printf "%d.%d.0" $major (add $minor 1) -}}
+{{- else -}}
+{{- printf "%d.%d.%d" $major $minor (add $patch 1) -}}
+{{- end -}}
+{{- else -}}
+{{- fail (printf "Invalid semantic version: %s" $version) -}}
+{{- end }}`,
+    },
+    {
+        name: 'rollout.canaryWeight',
+        template: `{{- $weight := .Values.rollout.canary.weight | default 10 -}}
+{{- $env := .Values.environment | default "development" -}}
+{{- if eq $env "production" -}}
+{{- min $weight 5 -}}
+{{- else if eq $env "staging" -}}
+{{- min $weight 50 -}}
+{{- else -}}
+{{- $weight -}}
+{{- end }}`,
+    },
+];

package/dist/lib/utils/helmHelpers/index.d.ts

@@ -0,0 +1,23 @@
+export type { HelperDefinition, HelperCategory, CloudProvider, HelperOptions } from './types.js';
+export { ENV_HELPERS } from './envHelpers.js';
+export { GITOPS_HELPERS } from './gitopsHelpers.js';
+export { OBSERVABILITY_HELPERS } from './observabilityHelpers.js';
+export { VALIDATION_HELPERS } from './validationHelpers.js';
+import type { HelperDefinition, HelperCategory, HelperOptions } from './types.js';
+export declare function getNewHelpersByCategory(category: HelperCategory): HelperDefinition[];
+export declare function getAvailableHelperCategories(): HelperCategory[];
+export declare function getHelpersByCategories(categories: HelperCategory[]): HelperDefinition[];
+export declare function getHelpersByOptions(options: HelperOptions): HelperDefinition[];
+export declare function formatNewHelpers(helpers: HelperDefinition[]): string;
+export declare function generateNewHelpersTemplate(options?: HelperOptions, customHelpers?: HelperDefinition[]): string;
+export declare function getCachedNewHelpersTemplate(options?: HelperOptions, customHelpers?: HelperDefinition[]): string;
+export declare function createNewHelper(name: string, template: string): HelperDefinition;
+export declare function validateHelperNames(helpers: HelperDefinition[]): void;
+export declare function filterHelpersByPattern(helpers: HelperDefinition[], pattern: RegExp): HelperDefinition[];
+export declare function getHelperStatistics(helpers: HelperDefinition[]): {
+    totalHelpers: number;
+    categoryCounts: Record<string, number>;
+    averageTemplateLength: number;
+    longestHelper: string;
+    shortestHelper: string;
+};

package/dist/lib/utils/helmHelpers/index.js

@@ -0,0 +1,132 @@
+export { ENV_HELPERS } from './envHelpers.js';
+export { GITOPS_HELPERS } from './gitopsHelpers.js';
+export { OBSERVABILITY_HELPERS } from './observabilityHelpers.js';
+export { VALIDATION_HELPERS } from './validationHelpers.js';
+import { ENV_HELPERS } from './envHelpers.js';
+import { GITOPS_HELPERS } from './gitopsHelpers.js';
+import { OBSERVABILITY_HELPERS } from './observabilityHelpers.js';
+import { VALIDATION_HELPERS } from './validationHelpers.js';
+const HELPER_CATEGORIES = new Map([
+    ['env', ENV_HELPERS],
+    ['gitops', GITOPS_HELPERS],
+    ['observability', OBSERVABILITY_HELPERS],
+    ['validation', VALIDATION_HELPERS],
+]);
+const COMPILED_HELPERS_CACHE = new Map();
+export function getNewHelpersByCategory(category) {
+    const helpers = HELPER_CATEGORIES.get(category);
+    if (!helpers) {
+        throw new Error(`Unknown helper category: ${category}`);
+    }
+    return [...helpers];
+}
+export function getAvailableHelperCategories() {
+    return Array.from(HELPER_CATEGORIES.keys());
+}
+export function getHelpersByCategories(categories) {
+    const helpers = [];
+    for (const category of categories) {
+        helpers.push(...getNewHelpersByCategory(category));
+    }
+    return helpers;
+}
+export function getHelpersByOptions(options) {
+    const helpers = [];
+    if (options.includeEnv) {
+        helpers.push(...ENV_HELPERS);
+    }
+    if (options.includeGitops) {
+        helpers.push(...GITOPS_HELPERS);
+    }
+    if (options.includeObservability) {
+        helpers.push(...OBSERVABILITY_HELPERS);
+    }
+    if (options.includeValidation) {
+        helpers.push(...VALIDATION_HELPERS);
+    }
+    return helpers;
+}
+export function formatNewHelpers(helpers) {
+    return helpers
+        .map((helper) => `{{/*
+${helper.name}
+*/}}
+{{- define "${helper.name}" -}}
+${helper.template}
+{{- end }}`)
+        .join('\n\n');
+}
+export function generateNewHelpersTemplate(options, customHelpers) {
+    const helpers = [];
+    if (options) {
+        helpers.push(...getHelpersByOptions(options));
+    }
+    if (customHelpers) {
+        helpers.push(...customHelpers);
+    }
+    return formatNewHelpers(helpers);
+}
+export function getCachedNewHelpersTemplate(options, customHelpers) {
+    const cacheKey = JSON.stringify({ options, customHelpers });
+    if (COMPILED_HELPERS_CACHE.has(cacheKey)) {
+        return COMPILED_HELPERS_CACHE.get(cacheKey);
+    }
+    const template = generateNewHelpersTemplate(options, customHelpers);
+    COMPILED_HELPERS_CACHE.set(cacheKey, template);
+    return template;
+}
+export function createNewHelper(name, template) {
+    return { name, template };
+}
+export function validateHelperNames(helpers) {
+    const namePattern = /^[a-zA-Z][a-zA-Z0-9._-]*$/;
+    const duplicates = new Set();
+    const seen = new Set();
+    for (const helper of helpers) {
+        if (!namePattern.test(helper.name)) {
+            throw new Error(`Invalid helper name: "${helper.name}". Names must start with a letter and contain only letters, numbers, dots, underscores, and hyphens.`);
+        }
+        if (seen.has(helper.name)) {
+            duplicates.add(helper.name);
+        }
+        else {
+            seen.add(helper.name);
+        }
+    }
+    if (duplicates.size > 0) {
+        throw new Error(`Duplicate helper names found: ${Array.from(duplicates).join(', ')}`);
+    }
+}
+export function filterHelpersByPattern(helpers, pattern) {
+    return helpers.filter((helper) => pattern.test(helper.name));
+}
+export function getHelperStatistics(helpers) {
+    const categoryMap = new Map();
+    let totalTemplateLength = 0;
+    let longestHelper = '';
+    let shortestHelper = '';
+    let longestLength = 0;
+    let shortestLength = Infinity;
+    for (const helper of helpers) {
+        const category = helper.name.split('.')[0] || 'unknown';
+        const currentCount = categoryMap.get(category) || 0;
+        categoryMap.set(category, currentCount + 1);
+        const templateLength = helper.template.length;
+        totalTemplateLength += templateLength;
+        if (templateLength > longestLength) {
+            longestLength = templateLength;
+            longestHelper = helper.name;
+        }
+        if (templateLength < shortestLength) {
+            shortestLength = templateLength;
+            shortestHelper = helper.name;
+        }
+    }
+    return {
+        totalHelpers: helpers.length,
+        categoryCounts: Object.fromEntries(categoryMap),
+        averageTemplateLength: helpers.length > 0 ? Math.round(totalTemplateLength / helpers.length) : 0,
+        longestHelper,
+        shortestHelper,
+    };
+}

package/dist/lib/utils/helmHelpers/observabilityHelpers.d.ts

@@ -0,0 +1,2 @@
+import type { HelperDefinition } from './types.js';
+export declare const OBSERVABILITY_HELPERS: HelperDefinition[];