timonel 2.14.0-beta.1 → 3.0.0-beta.1

package/dist/lib/utils/helmYamlSerializer.js

@@ -1,5 +1,33 @@
-import { Document, Scalar, isMap, isScalar, visit } from 'yaml';
+import { Document, Scalar, isMap, isScalar, visit, Pair } from 'yaml';
 import { isHelmConstruct, isHelmExpression, createHelmExpression, } from './helmControlStructures.js';
+import { isHelmValue, isHelmFieldConditional, isHelmRange, isHelmWith, } from './valuesRef.js';
+const FIELD_CONDITIONAL = '__FIELD_CONDITIONAL__:';
+const FIELD_WITH = '__FIELD_WITH__:';
+const FIELD_WITH_MARKER = '__FIELD_WITH_MARKER__:';
+function simpleHelmYaml(obj) {
+    function convertToPlain(value) {
+        if (isHelmValue(value)) {
+            return `{{ ${value.__path} }}`;
+        }
+        if (isHelmExpression(value)) {
+            return value.value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(convertToPlain);
+        }
+        if (value !== null && typeof value === 'object') {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = convertToPlain(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    const plain = convertToPlain(obj);
+    const doc = new Document(plain);
+    return doc.toString({ lineWidth: 0 });
+}
 function serializeElseIfChain(elseContent, openTag, closeTag) {
     let result = '';
     let currentElse = elseContent;
@@ -14,6 +42,9 @@ function serializeElseIfChain(elseContent, openTag, closeTag) {
     return { result, remainingElse: currentElse };
 }
 function serializeHelmConstruct(construct) {
+    if (construct.type === 'fieldConditional') {
+        throw new Error('fieldConditional should not be serialized directly. It must be handled in preprocessHelmConstructs.');
+    }
     const trimLeft = construct.options?.trimLeft ?? true;
     const trimRight = construct.options?.trimRight ?? true;
     const openTag = `{{${trimLeft ? '-' : ''} `;
@@ -21,22 +52,117 @@ function serializeHelmConstruct(construct) {
     switch (construct.type) {
         case 'if': {
             const data = construct.data;
-            let result = `${openTag}if ${data.condition}${closeTag}\n`;
+            const isInline = construct.options?.inline ?? false;
+            const newline = isInline ? '' : '\n';
+            const space = isInline ? ' ' : '';
+            let result = `${openTag}if ${data.condition}${closeTag}${newline}`;
             result += serializeHelmContent(data.then);
             if (data.else !== undefined) {
-                const { result: elseIfResult, remainingElse } = serializeElseIfChain(data.else, openTag, closeTag);
-                result += elseIfResult;
-                if (remainingElse !== undefined) {
-                    result += `\n${openTag}else${closeTag}\n`;
-                    result += serializeHelmContent(remainingElse);
+                if (isInline) {
+                    result += `${space}${openTag}else${closeTag}${space}`;
+                    result += serializeHelmContent(data.else);
+                }
+                else {
+                    const { result: elseIfResult, remainingElse } = serializeElseIfChain(data.else, openTag, closeTag);
+                    result += elseIfResult;
+                    if (remainingElse !== undefined) {
+                        result += `\n${openTag}else${closeTag}\n`;
+                        result += serializeHelmContent(remainingElse);
+                    }
                 }
             }
-            result += `\n${openTag}end${closeTag}`;
+            result += `${newline}${openTag}end${closeTag}`;
             return result;
         }
         case 'fragment': {
             const data = construct.data;
-            return data.map((item) => serializeHelmContent(item)).join('\n');
+            const strings = [];
+            const objects = [];
+            for (const item of data) {
+                if (typeof item === 'object' &&
+                    item !== null &&
+                    !Array.isArray(item) &&
+                    !isHelmConstruct(item) &&
+                    !isHelmExpression(item)) {
+                    objects.push(item);
+                }
+                else {
+                    const serialized = serializeHelmContent(item);
+                    if (serialized.trim().length > 0) {
+                        strings.push(serialized);
+                    }
+                }
+            }
+            if (strings.length > 0 && objects.length > 0) {
+                const combinedObject = objects.reduce((acc, obj) => {
+                    if (typeof obj === 'object' && obj !== null) {
+                        return { ...acc, ...obj };
+                    }
+                    return acc;
+                }, {});
+                const preprocessed = preprocessHelmConstructs(combinedObject);
+                const doc = new Document(preprocessed);
+                visit(doc, (_key, node) => {
+                    if (isMap(node)) {
+                        const isHelmExpr = node.items.some((pair) => isScalar(pair.key) &&
+                            pair.key.value === '__helmExpression' &&
+                            isScalar(pair.value) &&
+                            pair.value.value === true);
+                        if (isHelmExpr) {
+                            const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
+                            if (valuePair && isScalar(valuePair.value)) {
+                                const value = String(valuePair.value.value);
+                                const scalar = new Scalar(value);
+                                if (value.trim().startsWith('{{') && value.includes('\n')) {
+                                    scalar.type = 'BLOCK_LITERAL';
+                                }
+                                else {
+                                    scalar.type = 'QUOTE_DOUBLE';
+                                }
+                                return scalar;
+                            }
+                        }
+                    }
+                    return undefined;
+                });
+                let objectYaml = doc.toString({ lineWidth: 0 }).trim();
+                return [...strings, objectYaml].filter((s) => s.trim().length > 0).join('\n');
+            }
+            if (objects.length > 0) {
+                const combinedObject = objects.reduce((acc, obj) => {
+                    if (typeof obj === 'object' && obj !== null) {
+                        return { ...acc, ...obj };
+                    }
+                    return acc;
+                }, {});
+                const preprocessed = preprocessHelmConstructs(combinedObject);
+                const doc = new Document(preprocessed);
+                visit(doc, (_key, node) => {
+                    if (isMap(node)) {
+                        const isHelmExpr = node.items.some((pair) => isScalar(pair.key) &&
+                            pair.key.value === '__helmExpression' &&
+                            isScalar(pair.value) &&
+                            pair.value.value === true);
+                        if (isHelmExpr) {
+                            const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
+                            if (valuePair && isScalar(valuePair.value)) {
+                                const value = String(valuePair.value.value);
+                                const scalar = new Scalar(value);
+                                if (value.trim().startsWith('{{') && value.includes('\n')) {
+                                    scalar.type = 'BLOCK_LITERAL';
+                                }
+                                else {
+                                    scalar.type = 'QUOTE_DOUBLE';
+                                }
+                                return scalar;
+                            }
+                        }
+                    }
+                    return undefined;
+                });
+                return doc.toString({ lineWidth: 0 }).trim();
+            }
+            return strings.filter((s) => s.trim().length > 0).join('\n');
         }
         case 'range': {
             const data = construct.data;
@@ -58,7 +184,7 @@ function serializeHelmConstruct(construct) {
             if (data.pipe) {
                 result += ` | ${data.pipe}`;
             }
-            result += `${closeTag}`;
+            result += closeTag;
             return result;
         }
         case 'define': {
@@ -104,15 +230,47 @@ function serializeHelmContent(content) {
         return String(content);
     }
     if (typeof content === 'object') {
-        const doc = new Document(content);
+        const preprocessed = preprocessHelmConstructs(content);
+        const doc = new Document(preprocessed);
         let yaml = doc.toString({ lineWidth: 0 });
         yaml = yaml.trim();
         return yaml;
     }
     return '';
 }
-function preprocessHelmConstructs(obj) {
+export function preprocessHelmConstructs(obj) {
+    if (isHelmValue(obj)) {
+        const value = obj;
+        return createHelmExpression(`{{ ${value.__path} }}`);
+    }
+    if (isHelmFieldConditional(obj)) {
+        return obj;
+    }
+    if (isHelmRange(obj)) {
+        const range = obj;
+        const sourcePath = range.source.__path;
+        const itemProxy = { __path: '$item' };
+        const indexProxy = { __path: '$index' };
+        const content = range.callback(itemProxy, indexProxy);
+        const processedContent = preprocessHelmConstructs(content);
+        const contentDoc = new Document(processedContent);
+        const contentStr = contentDoc.toString({ lineWidth: 0 }).trim();
+        return createHelmExpression(`{{- range ${sourcePath} }}\n${contentStr}\n{{- end }}`);
+    }
+    if (isHelmWith(obj)) {
+        return obj;
+    }
     if (isHelmConstruct(obj)) {
+        if (obj.type === 'fieldConditional') {
+            return obj;
+        }
+        if (obj.type === 'if') {
+            const ifData = obj.data;
+            const isInline = obj.options?.inline ?? false;
+            if (!isInline && (ifData.else === undefined || !('else' in ifData))) {
+                return obj;
+            }
+        }
         const helmTemplate = serializeHelmConstruct(obj);
         return createHelmExpression(helmTemplate);
     }
@@ -125,6 +283,111 @@ function preprocessHelmConstructs(obj) {
         }
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
+            if (isHelmWith(value)) {
+                const withBlock = value;
+                const source = withBlock.source;
+                const sourcePath = source?.__path;
+                if (!sourcePath) {
+                    throw new Error('HelmWith source must have a valid __path');
+                }
+                const ctxProxy = { __path: '.' };
+                const content = withBlock.callback(ctxProxy);
+                let contentStr;
+                if (isHelmExpression(content)) {
+                    contentStr = content.value;
+                }
+                else {
+                    const processedContent = preprocessHelmConstructs(content);
+                    const contentDoc = new Document(processedContent);
+                    contentStr = contentDoc.toString({ lineWidth: 0 }).trim();
+                }
+                const template = `{{- with ${sourcePath} }}\n${key}:\n  ${contentStr}\n{{- end }}`;
+                const marker = `__FIELD_WITH__:${key}:${template}`;
+                result[`__fieldWithTemplate_${key}`] = createHelmExpression(marker);
+                continue;
+            }
+            if (isHelmConstruct(value) && value.type === 'if') {
+                const ifData = value.data;
+                const isInline = value.options?.inline ?? false;
+                if (!isInline && (ifData.else === undefined || !('else' in ifData))) {
+                    const preprocessedThen = preprocessHelmConstructs(ifData.then);
+                    let thenValueStr = '';
+                    let isMultilineObject = false;
+                    if (isHelmExpression(preprocessedThen)) {
+                        thenValueStr = preprocessedThen.value.trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    else if (typeof preprocessedThen === 'string') {
+                        thenValueStr = preprocessedThen.trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    else if (Array.isArray(preprocessedThen)) {
+                        const tempDoc = new Document(preprocessedThen);
+                        thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                        isMultilineObject = true;
+                    }
+                    else {
+                        const tempDoc = new Document(preprocessedThen);
+                        thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    const constructOptions = isHelmConstruct(value) ? value.options : undefined;
+                    const trimLeft = constructOptions?.trimLeft ?? true;
+                    const openTag = `{{${trimLeft ? '-' : ''} `;
+                    const closeTag = ` ${(constructOptions?.trimRight ?? true) ? '-' : ''}}}`;
+                    let formattedContent;
+                    if (isMultilineObject) {
+                        const indentedValue = thenValueStr
+                            .split('\n')
+                            .map((line) => '    ' + line)
+                            .join('\n');
+                        formattedContent = `${key}:\n${indentedValue}`;
+                    }
+                    else {
+                        formattedContent = `${key}: ${thenValueStr}`;
+                    }
+                    const conditionalTemplate = `${openTag}if ${ifData.condition}${closeTag}\n  ${formattedContent}\n${openTag}end${closeTag}`;
+                    result[key] = createHelmExpression(`__FIELD_CONDITIONAL__:${key}:${conditionalTemplate}`);
+                    continue;
+                }
+            }
+            if (isHelmFieldConditional(value)) {
+                const fieldCond = value;
+                const condition = fieldCond.condition.__condition;
+                const thenValueStr = simpleHelmYaml(fieldCond.thenValue).trim();
+                const isMultilineObject = thenValueStr.includes('\n');
+                const startsWithDash = thenValueStr.trimStart().startsWith('-');
+                let formattedContent;
+                if (isMultilineObject || startsWithDash) {
+                    const lines = thenValueStr.split('\n');
+                    const indentedValue = lines.map((line) => '  ' + line).join('\n');
+                    formattedContent = `${key}:\n${indentedValue}`;
+                }
+                else {
+                    formattedContent = `${key}: ${thenValueStr}`;
+                }
+                const conditionalTemplate = `{{- if ${condition} }}\n${formattedContent}\n{{- end }}`;
+                result[key] = createHelmExpression(`__FIELD_CONDITIONAL__:${key}:${conditionalTemplate}`);
+                continue;
+            }
+            if (isHelmConstruct(value) && value.type === 'fieldConditional') {
+                const fieldData = value.data;
+                const preprocessedThen = preprocessHelmConstructs(fieldData.then);
+                let thenValueStr = '';
+                if (isHelmExpression(preprocessedThen)) {
+                    thenValueStr = preprocessedThen.value;
+                }
+                else if (typeof preprocessedThen === 'string') {
+                    thenValueStr = preprocessedThen;
+                }
+                else {
+                    const tempDoc = new Document(preprocessedThen);
+                    thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                }
+                const conditionalTemplate = `{{- if ${fieldData.condition} }}\n  ${fieldData.fieldKey}: ${thenValueStr}\n{{- end }}`;
+                result[`__fieldConditionalTemplate_${fieldData.fieldKey}`] = conditionalTemplate;
+                continue;
+            }
             result[key] = preprocessHelmConstructs(value);
         }
         return result;
@@ -144,10 +407,22 @@ export function dumpHelmAwareYaml(obj, options = {}) {
                 const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
                 if (valuePair && isScalar(valuePair.value)) {
                     const value = String(valuePair.value.value);
+                    if (value.startsWith(FIELD_CONDITIONAL) ||
+                        value.startsWith(FIELD_WITH) ||
+                        value.startsWith(FIELD_WITH_MARKER)) {
+                        const scalar = new Scalar(value);
+                        scalar.type = 'BLOCK_LITERAL';
+                        return scalar;
+                    }
                     const scalar = new Scalar(value);
-                    if (value.trim().startsWith('{{') && value.includes('\n')) {
+                    const isMultilineTemplate = value.includes('\n') && value.trim().startsWith('{{');
+                    const isWithOrRange = value.trim().startsWith('{{- with ') || value.trim().startsWith('{{- range ');
+                    if (isMultilineTemplate && !isWithOrRange) {
                         scalar.type = 'BLOCK_LITERAL';
                     }
+                    else if (isWithOrRange) {
+                        scalar.type = 'PLAIN';
+                    }
                     else {
                         scalar.type = 'QUOTE_DOUBLE';
                     }
@@ -157,13 +432,214 @@ export function dumpHelmAwareYaml(obj, options = {}) {
         }
         return undefined;
     });
-    const toStringOptions = {};
+    const toStringOptions = { lineWidth: 0 };
     if (options.lineWidth !== undefined) {
         toStringOptions.lineWidth = options.lineWidth;
     }
+    const templatePairs = [];
+    visit(doc, (_key, node) => {
+        if (isMap(node)) {
+            for (let i = 0; i < node.items.length; i++) {
+                const pair = node.items[i];
+                if (pair && isScalar(pair.key)) {
+                    const keyStr = String(pair.key.value);
+                    if (keyStr.startsWith('__fieldConditionalTemplate_') && isScalar(pair.value)) {
+                        const template = String(pair.value.value);
+                        const fieldKey = keyStr.replace('__fieldConditionalTemplate_', '');
+                        templatePairs.push({ parent: node, index: i, template, fieldKey });
+                    }
+                }
+            }
+        }
+        return undefined;
+    });
+    for (let i = templatePairs.length - 1; i >= 0; i--) {
+        const templatePair = templatePairs[i];
+        if (!templatePair)
+            continue;
+        const { parent, index, template } = templatePair;
+        parent.items.splice(index, 1);
+        const tempDoc = new Document({ __temp: template });
+        const _tempYaml = tempDoc.toString({ lineWidth: 0 });
+        const templateScalar = new Scalar(template);
+        templateScalar.type = 'BLOCK_LITERAL';
+        const specialKeyScalar = new Scalar('__fieldConditionalContent');
+        const templatePairObj = new Pair(specialKeyScalar, templateScalar);
+        parent.items.splice(index, 0, templatePairObj);
+    }
     let result = doc.toString(toStringOptions);
+    while (result.includes('__fieldConditionalContent:')) {
+        const markerIndex = result.indexOf('__fieldConditionalContent:');
+        if (markerIndex === -1)
+            break;
+        const lineStart = result.lastIndexOf('\n', markerIndex);
+        const lineBeforeMarker = result.substring(lineStart + 1, markerIndex);
+        const indentMatch = lineBeforeMarker.match(/^(\s*)/);
+        const baseIndent = indentMatch && indentMatch[1] ? indentMatch[1] : '';
+        const afterMarker = result.substring(markerIndex);
+        let pipeLineMatch = afterMarker.match(/^__fieldConditionalContent:\s*(\|-?)\s*\n(\s*)/);
+        let pipeOnSameLine = true;
+        if (!pipeLineMatch) {
+            pipeLineMatch = afterMarker.match(/^__fieldConditionalContent:\s*\n(\s*)(\|-?)\s*\n/);
+            pipeOnSameLine = false;
+        }
+        if (!pipeLineMatch)
+            break;
+        const pipeChar = pipeOnSameLine ? pipeLineMatch[1] : pipeLineMatch[2];
+        const pipeIndent = pipeOnSameLine ? pipeLineMatch[2] || '' : pipeLineMatch[1] || '';
+        if (!pipeChar)
+            break;
+        const pipeIndex = markerIndex + pipeLineMatch[0].length;
+        const afterPipe = result.substring(pipeIndex);
+        const templateStartMatch = afterPipe.match(/^\n(\s*)(\{\{-)/);
+        if (!templateStartMatch) {
+            const templateStartMatchNoNewline = afterPipe.match(/^(\s*)(\{\{-)/);
+            if (!templateStartMatchNoNewline)
+                break;
+            const _templateIndent = templateStartMatchNoNewline[1] || '';
+            const templateStart = templateStartMatchNoNewline[2];
+            if (!templateStart)
+                break;
+            const templateStartIndex = pipeIndex + templateStartMatchNoNewline[0].length;
+            const templateSection = result.substring(templateStartIndex);
+            const endMatch = templateSection.match(/(\{\{-?\s*end\s*-?\}\})/);
+            if (!endMatch)
+                break;
+            const endIndex = endMatch.index;
+            if (endIndex === undefined)
+                break;
+            const templateEndIndex = templateStartIndex + endIndex + endMatch[0].length;
+            const templateContent = result.substring(templateStartIndex, templateEndIndex);
+            const beforeMarker = result.substring(0, lineStart + 1);
+            const afterTemplate = result.substring(templateEndIndex);
+            const pipeIndentEscaped = pipeIndent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const adjustedTemplate = templateContent.replace(new RegExp(`^${pipeIndentEscaped}`, 'gm'), baseIndent);
+            result = beforeMarker + adjustedTemplate + afterTemplate;
+            continue;
+        }
+        const _templateIndent = templateStartMatch[1] || '';
+        const templateStart = templateStartMatch[2];
+        if (!templateStart)
+            break;
+        const templateStartIndex = pipeIndex + templateStartMatch[0].length;
+        const templateSection = result.substring(templateStartIndex);
+        const endMatch = templateSection.match(/(\{\{-?\s*end\s*-?\}\})/);
+        if (!endMatch)
+            break;
+        const endIndex = endMatch.index;
+        if (endIndex === undefined)
+            break;
+        const templateEndIndex = templateStartIndex + endIndex + endMatch[0].length;
+        const templateContent = result.substring(templateStartIndex, templateEndIndex);
+        const beforeMarker = result.substring(0, lineStart + 1);
+        const afterTemplate = result.substring(templateEndIndex);
+        const pipeIndentEscaped = pipeIndent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const adjustedTemplate = templateContent.replace(new RegExp(`^${pipeIndentEscaped}`, 'gm'), baseIndent);
+        result = beforeMarker + adjustedTemplate + afterTemplate;
+    }
     result = result.replace(/\\"/g, '"');
-    result = result.replace(/\\\\/g, '');
+    result = result.replace(/^(\s+)(\w+):\s+(\{\{-?\s*if\s+[^}]+\}\})\s*\n(\s+)(.+?)\n(\s+)(\{\{-?\s*end\s*-?\}\})/gm, (match, baseIndent, fieldKey, ifTag, contentIndent, content, endIndent, endTag) => {
+        const contentLines = content.split('\n');
+        const firstContentLine = contentLines[0]?.trim() || '';
+        if (firstContentLine.startsWith(`${fieldKey}:`)) {
+            contentLines[0] = contentLines[0].replace(new RegExp(`^\\s*${fieldKey}:\\s*`), '');
+            content = contentLines.join('\n');
+        }
+        const contentFormatted = content
+            ? '\n' +
+                content
+                    .split('\n')
+                    .map((line) => baseIndent + '    ' + line.trimStart())
+                    .join('\n')
+            : '';
+        return `${baseIndent}${ifTag}\n${baseIndent}  ${fieldKey}:${contentFormatted}\n${baseIndent}${endTag}`;
+    });
+    result = postProcessFieldConditionals(result);
+    return result;
+}
+export function postProcessFieldConditionals(yaml) {
+    let result = yaml;
+    while (result.includes('__FIELD_WITH_MARKER__:')) {
+        const markerIndex = result.indexOf('__FIELD_WITH_MARKER__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)(\w+):\s*|[-]?\s*$/);
+        if (!fieldKeyMatch || !fieldKeyMatch[2])
+            break;
+        const baseIndent = fieldKeyMatch[1] || '';
+        const fieldKey = fieldKeyMatch[2];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_WITH_MARKER__:([^:]+):(.+?)$/m);
+        if (!markerMatch || !markerMatch[1] || !markerMatch[2])
+            break;
+        const path = markerMatch[1];
+        const content = markerMatch[2].trim();
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const template = `${baseIndent}{{- with ${path} }}\n${baseIndent}${fieldKey}:\n${baseIndent}  ${content}\n${baseIndent}{{- end }}`;
+        result = result.substring(0, secondLastNewline + 1) + template + result.substring(markerEnd);
+    }
+    while (result.includes('__FIELD_WITH__:')) {
+        const markerIndex = result.indexOf('__FIELD_WITH__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)__fieldWithTemplate_\w+:\s*|[-]?\s*$/);
+        if (!fieldKeyMatch)
+            break;
+        const baseIndent = fieldKeyMatch[1];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_WITH__:\w+:(.+?\{\{-?\s*end\s*-?\}\})/s);
+        if (!markerMatch || !markerMatch[1])
+            break;
+        const template = markerMatch[1];
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const lines = template.split('\n');
+        const processed = lines
+            .map((line) => {
+            if (!line.trim())
+                return '';
+            const trimmed = line.trimStart();
+            return baseIndent + trimmed;
+        })
+            .join('\n');
+        result = result.substring(0, secondLastNewline + 1) + processed + result.substring(markerEnd);
+    }
+    while (result.includes('__FIELD_CONDITIONAL__:')) {
+        const markerIndex = result.indexOf('__FIELD_CONDITIONAL__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)(\w+):\s*|[-]?\s*$/);
+        if (!fieldKeyMatch)
+            break;
+        const baseIndent = fieldKeyMatch[1];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_CONDITIONAL__:\w+:(.+?\{\{-?\s*end\s*-?\}\})/s);
+        if (!markerMatch || !markerMatch[1])
+            break;
+        const template = markerMatch[1];
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const lines = template.split('\n');
+        const processed = lines
+            .map((line) => {
+            if (!line.trim())
+                return '';
+            const trimmed = line.trimStart();
+            return baseIndent + trimmed;
+        })
+            .join('\n');
+        result = result.substring(0, secondLastNewline + 1) + processed + result.substring(markerEnd);
+    }
     result = result.replace(/:\s*\|[-+]?\s*\n(\s*\{\{)/g, ':\n$1');
     result = result.replace(/"(\{\{[\s\S]*?\}\})"/g, '$1');
     return result;

package/dist/lib/utils/valuesRef.d.ts

@@ -0,0 +1,102 @@
+import { type HelmExpression } from './helmControlStructures.js';
+declare const HELM_VALUE_SYMBOL: unique symbol;
+export interface HelmValue<T = unknown> {
+    [HELM_VALUE_SYMBOL]: true;
+    __path: string;
+    __type?: T;
+    eq(value: HelmValue | string | number | boolean): HelmCondition;
+    ne(value: HelmValue | string | number | boolean): HelmCondition;
+    gt(value: HelmValue | number): HelmCondition;
+    ge(value: HelmValue | number): HelmCondition;
+    lt(value: HelmValue | number): HelmCondition;
+    le(value: HelmValue | number): HelmCondition;
+    not(): HelmCondition;
+    and(other: HelmCondition): HelmCondition;
+    or(other: HelmCondition): HelmCondition;
+    default(defaultValue: HelmValue | string | number | boolean): HelmValue<T>;
+    quote(): HelmValue<string>;
+    upper(): HelmValue<string>;
+    lower(): HelmValue<string>;
+    title(): HelmValue<string>;
+    trim(): HelmValue<string>;
+    trimPrefix(prefix: string): HelmValue<string>;
+    trimSuffix(suffix: string): HelmValue<string>;
+    replace(old: string, newStr: string): HelmValue<string>;
+    contains(substr: string): HelmCondition;
+    hasPrefix(prefix: string): HelmCondition;
+    hasSuffix(suffix: string): HelmCondition;
+    trunc(length: number): HelmValue<string>;
+    kindIs(kind: 'string' | 'slice' | 'map' | 'bool' | 'int' | 'float'): HelmCondition;
+    hasKey(key: string): HelmCondition;
+    toYaml(): HelmValue<string>;
+    toJson(): HelmValue<string>;
+    nindent(spaces: number): HelmValue<string>;
+    indent(spaces: number): HelmValue<string>;
+    toExpression(): HelmExpression;
+    if<V>(condition: HelmCondition, thenValue: V): HelmFieldConditional<V>;
+    ifElse<V>(condition: HelmCondition, thenValue: V, elseValue: V): HelmValue<V>;
+    range<V>(callback: (item: HelmValue<T extends (infer U)[] ? U : unknown>, index: HelmValue<number>) => V): HelmRange<V>;
+    with<V>(callback: (ctx: HelmValue<T>) => V): HelmWith<V>;
+}
+export interface HelmCondition {
+    [HELM_VALUE_SYMBOL]: true;
+    __condition: string;
+    not(): HelmCondition;
+    and(other: HelmCondition): HelmCondition;
+    or(other: HelmCondition): HelmCondition;
+    toString(): string;
+}
+export interface HelmFieldConditional<T> {
+    __helmFieldConditional: true;
+    condition: HelmCondition;
+    thenValue: T;
+    elseValue?: T;
+}
+export interface HelmRange<T> {
+    __helmRange: true;
+    source: HelmValue;
+    callback: (item: HelmValue, index: HelmValue<number>) => T;
+}
+export interface HelmWith<T> {
+    __helmWith: true;
+    source: HelmValue;
+    callback: (ctx: HelmValue) => T;
+}
+export interface HelmHelpers {
+    include(templateName: string, context?: '.' | HelmValue): HelmValue<string>;
+    printf(format: string, ...args: (HelmValue | string | number)[]): HelmValue<string>;
+    release: {
+        name: HelmValue<string>;
+        namespace: HelmValue<string>;
+        service: HelmValue<string>;
+        isUpgrade: HelmValue<boolean>;
+        isInstall: HelmValue<boolean>;
+        revision: HelmValue<number>;
+    };
+    chart: {
+        name: HelmValue<string>;
+        version: HelmValue<string>;
+        appVersion: HelmValue<string>;
+        type: HelmValue<string>;
+    };
+    capabilities: {
+        kubeVersion: {
+            version: HelmValue<string>;
+            major: HelmValue<string>;
+            minor: HelmValue<string>;
+        };
+        apiVersions: {
+            has(apiVersion: string): HelmCondition;
+        };
+    };
+    rawCondition(condition: string): HelmCondition;
+}
+export declare function valuesRef<T extends Record<string, unknown>>(): HelmValue<T> & HelmHelpers;
+export declare function isHelmValue(value: unknown): value is HelmValue;
+export declare function isHelmCondition(value: unknown): value is HelmCondition;
+export declare function isHelmFieldConditional(value: unknown): value is HelmFieldConditional<unknown>;
+export declare function isHelmRange(value: unknown): value is HelmRange<unknown>;
+export declare function isHelmWith(value: unknown): value is HelmWith<unknown>;
+export declare function serializeHelmValue(value: HelmValue): string;
+export declare function serializeHelmCondition(condition: HelmCondition): string;
+export {};