@microtronics/studio-cli 0.60.0 → 0.62.0

package/out/dde/yamlDdePreCompiler.js

@@ -1,889 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.YamlPreCompiler = void 0;
-const yaml_1 = require("yaml");
-const diagnostics_1 = require("../diagnostics");
-const coreDefinitions_1 = require("./coreDefinitions");
-const helper_1 = require("../helper");
-var DDEContainerName = coreDefinitions_1.DDE_Core.DDEContainerName;
-var allowedRelationTypes = coreDefinitions_1.DDE_Core.allowedRelationTypes;
-var regexRelation = coreDefinitions_1.DDE_Core.regexRelation;
-var ContainerType = coreDefinitions_1.DDE_Core.ContainerType;
-var checkForReservedFieldName = coreDefinitions_1.DDE_Core.checkForReservedFieldName;
-var ContainerName = coreDefinitions_1.DDE_Core.ContainerName;
-var CONTAINER_DEFS = coreDefinitions_1.DDE_Core.CONTAINER_DEFS;
-var SERVER_CONTAINER = coreDefinitions_1.DDE_Core.SERVER_CONTAINER;
-var HISTDATA_CONTAINER = coreDefinitions_1.DDE_Core.HISTDATA_CONTAINER;
-var CONFIG_CONTAINER = coreDefinitions_1.DDE_Core.CONFIG_CONTAINER;
-var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
-var fieldTypeDefinitions = coreDefinitions_1.DDE_Core.fieldTypeDefinitions;
-var yamlRangeToLineInformation = helper_1.Helper.yamlRangeToLineInformation;
-const api_1 = require("../api");
-var YamlPreCompiler;
-(function (YamlPreCompiler) {
-    class PreCompiler {
-        manifest;
-        libraryFiles;
-        ddeHistory;
-        fieldNamesPerContainer = {};
-        usedContainerNames = {};
-        fileDiagnostics = [];
-        libraryDDE = [];
-        libraryYaml = {};
-        constructor(manifest, libraryFiles, ddeHistory) {
-            this.manifest = manifest;
-            this.libraryFiles = libraryFiles;
-            this.ddeHistory = ddeHistory;
-        }
-        /**
-         * Parse the given library files and return the diagnostics
-         */
-        parseLibraries() {
-            this.libraryDDE.length = 0;
-            const libDiagnostics = [];
-            this.libraryFiles.forEach(file => {
-                const { parsedDDE, diagnostics, parsedYaml } = this.parseYamlFile(file.path, file.yaml, file.libraryName);
-                libDiagnostics.push(...diagnostics);
-                this.libraryDDE.push(parsedDDE);
-                this.libraryYaml[file.libraryName] = parsedYaml;
-            });
-            return libDiagnostics;
-        }
-        get previousVersion() {
-            return { setPointList: { ...this.ddeHistory?.setPointList }, containers: { ...this.ddeHistory?.containers } };
-        }
-        getContainerOfPreviousVersion(containerName) {
-            const previousDDE = this.previousVersion;
-            const cleanContainerName = containerName.startsWith('timeseries_') ? containerName.substring(11) : containerName;
-            return (Object.values(previousDDE.containers).find(containerDefinition => containerDefinition.title === cleanContainerName) || null);
-        }
-        parseMainDDE(filePath, yaml) {
-            const { parsedDDE, diagnostics } = this.parseYamlFile(filePath, yaml);
-            const hasError = diagnostics.find(diagnostic => diagnostic.level === 'error');
-            //early abort if any file has an error
-            if (hasError) {
-                return { ddeJSON: null, diagnostics };
-            }
-            const mergedDDE = this.mergeAndFormat(parsedDDE);
-            return { ddeJSON: mergedDDE, diagnostics };
-        }
-        /**
-         * Parses a YAML file and validates its content to produce a structured JSON object along with diagnostic information.
-         *
-         * @param filePath The URI of the YAML file being parsed.
-         * @param yaml The raw YAML content to parse.
-         * @param libraryName An optional parameter specifying the library name for additional validation.
-         * @return An object containing the parsed DDE JSON and an array of diagnostic messages related to the file.
-         */
-        parseYamlFile(filePath, yaml, libraryName) {
-            this.fileDiagnostics.length = 0;
-            const lineCounter = new yaml_1.LineCounter();
-            const yamlDoc = (0, yaml_1.parseDocument)(yaml, { lineCounter });
-            // dde is empty - skip parsing
-            if (!yamlDoc.contents) {
-                return {
-                    parsedDDE: {
-                        containers: {},
-                        setPointList: {}
-                    },
-                    diagnostics: [],
-                    parsedYaml: null
-                };
-            }
-            const docContent = yamlDoc.contents || new yaml_1.YAMLMap();
-            const containerList = this.validateContainerDefinition(docContent.items);
-            containerList.forEach(container => {
-                this.validateAllowedContainer(filePath, container, lineCounter, libraryName);
-                this.validateContainerFields(yamlDoc, filePath, container, lineCounter);
-            });
-            // mapAsMap is used to keep order of fields:
-            return {
-                parsedDDE: this.yamlDocToDdeJson(yamlDoc.toJS({ mapAsMap: true }), libraryName),
-                diagnostics: [...this.fileDiagnostics],
-                parsedYaml: yamlDoc
-            };
-        }
-        // eslint-disable-next-line sonarjs/cognitive-complexity
-        yamlDocToDdeJson(ddeMap, libraryName) {
-            const ddeJson = {
-                containers: {},
-                setPointList: {}
-            };
-            const allContainer = new Map();
-            const allowedContainer = [...Object.values(DDEContainerName)];
-            if (ddeMap.get('cloudProject')) {
-                const knownContainer = Object.values(this.previousVersion.containers).map(containerDefinition => {
-                    return containerDefinition.title;
-                });
-                const allContainer = [...new Set([...allowedContainer, ...knownContainer])];
-                allowedContainer.length = 0;
-                allowedContainer.push(...allContainer);
-            }
-            for (const containerName of allowedContainer) {
-                if (ddeMap.has(containerName)) {
-                    allContainer.set(containerName, ddeMap.get(containerName));
-                }
-            }
-            const timeseries = ddeMap.get('timeseries');
-            if (timeseries) {
-                for (const [timeseriesName, timeseriesContent] of timeseries) {
-                    allContainer.set(timeseriesName, timeseriesContent);
-                }
-            }
-            for (const [containerName, containerContent] of allContainer) {
-                const { realContainer, transferDirection, legacyTitle } = this.getRealContainerInformation(containerName);
-                if (!realContainer) {
-                    continue;
-                }
-                const containerDefinition = CONTAINER_DEFS[realContainer];
-                const containerTitle = containerName.includes('timeseries_')
-                    ? containerName.replace('timeseries_', '')
-                    : containerName;
-                const containerInfo = {
-                    name: realContainer,
-                    title: containerTitle,
-                    previousTitle: legacyTitle,
-                    containerType: containerDefinition.ctype,
-                    volatile: containerName === DDEContainerName.volatile,
-                    transferDirection,
-                    fieldCount: containerContent.size,
-                    knownNames: [],
-                    libraries: [],
-                    arrays: {},
-                    shadows: {},
-                    fields: [],
-                    size: 0,
-                    fieldIndex: 0
-                };
-                if (libraryName) {
-                    containerInfo.libraries.push(libraryName);
-                }
-                for (const [fieldName, fieldContent] of containerContent) {
-                    const containerFields = [];
-                    const currentFieldType = fieldContent.get('type');
-                    const typeDefinition = fieldTypeDefinitions[currentFieldType];
-                    if (!typeDefinition && currentFieldType !== 'array') {
-                        continue;
-                    }
-                    // handle arrays with subfields
-                    if (currentFieldType === 'array') {
-                        // generate dde fields for the current array...
-                        const allArrayFields = [];
-                        const length = fieldContent.get('length');
-                        const arrayFields = fieldContent.get('fields');
-                        const arrayInformation = {
-                            name: fieldName,
-                            length: length,
-                            library: libraryName || null,
-                            fields: []
-                        };
-                        // store the information about the array within the container info
-                        containerInfo.arrays[fieldName] = arrayInformation;
-                        for (let arrayIdx = 0; arrayIdx < length; arrayIdx++) {
-                            const arrayRef = {
-                                name: fieldName,
-                                index: arrayIdx
-                            };
-                            // iterate through the subfields and create them
-                            for (const [subFieldName, subFieldContent] of arrayFields) {
-                                const subTypeDefinition = fieldTypeDefinitions[subFieldContent.get('type')];
-                                if (!subTypeDefinition) {
-                                    continue;
-                                }
-                                // only add the field if it's unknown
-                                if (!arrayInformation.fields?.find(field => field.name === subFieldName)) {
-                                    // @ts-ignore
-                                    arrayInformation.fields.push({
-                                        name: subFieldName,
-                                        type: subFieldContent.get('type'),
-                                        byteSize: subTypeDefinition.len || subFieldContent.get('bytes') || subFieldContent.get('length')
-                                    });
-                                }
-                                const fullName = `${fieldName}[${arrayIdx}].${subFieldName}`;
-                                const { /*arrayInfo,*/ fields, shadowInfo } = this.createDDEJsonFields(fullName, libraryName, subTypeDefinition, subFieldContent);
-                                // the subfield is an array, add the array info
-                                // todo are subarrays even possible?
-                                /*if (arrayInfo) {
-                                    containerInfo.arrays[arrayInfo.name] = arrayInfo;
-                                }*/
-                                fields.forEach(field => {
-                                    field.arrayRef = arrayRef;
-                                });
-                                if (shadowInfo) {
-                                    containerInfo.shadows[shadowInfo.name] = shadowInfo;
-                                }
-                                allArrayFields.push(...fields);
-                            }
-                        }
-                        containerFields.push(...allArrayFields);
-                    }
-                    else {
-                        // standard container field with possible flat array or shadow fields
-                        const { arrayInfo, fields, shadowInfo } = this.createDDEJsonFields(fieldName, libraryName, typeDefinition, fieldContent);
-                        if (arrayInfo) {
-                            containerInfo.arrays[arrayInfo.name] = arrayInfo;
-                        }
-                        if (shadowInfo) {
-                            containerInfo.shadows[shadowInfo.name] = shadowInfo;
-                        }
-                        containerFields.push(...fields);
-                    }
-                    // calculate the container size
-                    containerFields.forEach(field => {
-                        field.index = ++containerInfo.fieldIndex;
-                        containerInfo.fields.push(field);
-                        containerInfo.size += field.byteSize;
-                    });
-                }
-                ddeJson.containers[realContainer] = containerInfo;
-            }
-            return ddeJson;
-        }
-        getRealContainerInformation(ddeContainerName) {
-            let realContainer = undefined;
-            let transferDirection = undefined;
-            // keep track of the previous container name of an imported legacy project
-            let legacyTitle = undefined;
-            if (this.previousVersion) {
-                const currentName = ddeContainerName.startsWith('timeseries_')
-                    ? ddeContainerName.substring(11)
-                    : ddeContainerName;
-                const { name, direction, previousTitle } = this.findPreviousUsedContainer(currentName);
-                realContainer = name;
-                transferDirection = direction;
-                legacyTitle = previousTitle;
-            }
-            if (!realContainer) {
-                // reuse known container
-                const isKnown = Object.entries(this.usedContainerNames).find(([, ddeName]) => ddeName === ddeContainerName);
-                if (isKnown) {
-                    realContainer = isKnown[0];
-                }
-            }
-            if (!realContainer) {
-                realContainer = this.findNextFreeContainer(ddeContainerName);
-            }
-            this.usedContainerNames[realContainer] = ddeContainerName;
-            if (!transferDirection) {
-                transferDirection = [DDEContainerName.setting, DDEContainerName.command].includes(ddeContainerName)
-                    ? TransferDirection.down
-                    : TransferDirection.up;
-            }
-            if (realContainer && [ContainerName.configA, ContainerName.configB].includes(realContainer)) {
-                transferDirection = TransferDirection.backendOnly;
-            }
-            return { realContainer, transferDirection, legacyTitle };
-        }
-        findNextFreeContainer(ddeContainerName) {
-            // aloha is a predefined container
-            if (ddeContainerName === ContainerName.aloha) {
-                return ContainerName.aloha;
-            }
-            let containerList = CONFIG_CONTAINER;
-            // timeseries container:
-            if (ddeContainerName.startsWith('timeseries_')) {
-                //get the next available histdata container.
-                containerList = HISTDATA_CONTAINER;
-            }
-            else if (
-            // server container
-            [DDEContainerName.relations, DDEContainerName.storage].includes(ddeContainerName)) {
-                containerList = SERVER_CONTAINER;
-            }
-            const previousContainerList = this.previousVersion?.containers;
-            // filter out all containers that are already used
-            if (previousContainerList) {
-                containerList = containerList.filter(containerName => {
-                    return !Object.hasOwn(previousContainerList, containerName);
-                });
-            }
-            return containerList.find(containerName => {
-                return !Object.hasOwn(this.usedContainerNames, containerName);
-            });
-        }
-        findPreviousUsedContainer(ddeContainerName) {
-            const previousContainerList = this.previousVersion.containers;
-            const previousContainer = Object.values(previousContainerList).find(containerDefinition => {
-                return containerDefinition.title === ddeContainerName;
-            });
-            return {
-                name: previousContainer?.name,
-                direction: previousContainer?.transferDirection,
-                previousTitle: previousContainer?.previousTitle
-            };
-        }
-        createDDEJsonFields(fieldName, libraryName, typeDefinition, fieldContent) {
-            const arrayLength = fieldContent.get('array');
-            const fields = [];
-            let arrayInfo = undefined;
-            let shadowInfo = undefined;
-            if (arrayLength) {
-                arrayInfo = {
-                    name: fieldName,
-                    library: libraryName || null,
-                    length: arrayLength
-                };
-                // add array info to container info
-                for (let fieldArrayIdx = 0; fieldArrayIdx < arrayLength; fieldArrayIdx++) {
-                    const arrayFieldName = `${fieldName.toLowerCase()}[${fieldArrayIdx}]`;
-                    fields.push(this.buildDDEJsonField(arrayFieldName, fieldContent, { name: fieldName, index: fieldArrayIdx }, typeDefinition, libraryName, null));
-                }
-            }
-            else {
-                const newField = this.buildDDEJsonField(fieldName, fieldContent, null, typeDefinition, libraryName, null);
-                fields.push(newField);
-                const shadowFieldContent = fieldContent.get('shadowFields');
-                // validate if the given field has shadow fields:
-                if (shadowFieldContent) {
-                    shadowInfo = {
-                        name: newField.name,
-                        byteSize: newField.byteSize,
-                        byteOffset: newField.byteOffset //init with null, will be filled afterwards!
-                    };
-                    for (const [subFieldName, subFieldContent] of shadowFieldContent) {
-                        let shadowFieldName = subFieldName;
-                        if (fieldName.includes('.')) {
-                            shadowFieldName = fieldName.split('.')[0] + `.${subFieldName}`;
-                        }
-                        fields.push(this.buildDDEJsonField(shadowFieldName, subFieldContent, null, typeDefinition, libraryName, newField.name));
-                    }
-                }
-            }
-            return {
-                arrayInfo,
-                shadowInfo,
-                fields: fields
-            };
-        }
-        // eslint-disable-next-line sonarjs/cognitive-complexity
-        buildDDEJsonField(name, fieldContent, arrayRef, typeDefinition, libraryName, shadowRef) {
-            return {
-                id: name.toLowerCase(),
-                name: name,
-                index: 0,
-                library: libraryName || null,
-                byteOffset: 0,
-                // either length of type || if binary bytes || if string length
-                byteSize: typeDefinition.len || fieldContent.get('bytes') || fieldContent.get('length'),
-                type: fieldContent.get('type'),
-                title: fieldContent.get('title') || null,
-                arrayRef,
-                shadowRef,
-                unit: fieldContent.get('unit'),
-                hex: fieldContent.get('hex'),
-                decimalPlaces: fieldContent.get('decimalPlaces'),
-                writePermission: this.parseUserLevel(fieldContent.get('writePermission')),
-                readPermission: this.parseUserLevel(fieldContent.get('readPermission')),
-                channelMode: this.parseChannelMode(fieldContent.get('channelMode')),
-                defaultValue: fieldContent.get('defaultValue'),
-                scale: fieldContent.get('scale'),
-                offset: fieldContent.get('offset'),
-                chartMinimum: fieldContent.get('chartMinimum'),
-                description: fieldContent.get('description'),
-                chartMaximum: fieldContent.get('chartMaximum'),
-                chartAlarmLow: fieldContent.get('chartAlarmLow'),
-                chartAlarmHigh: fieldContent.get('chartAlarmHigh'),
-                chartWarningLow: fieldContent.get('chartWarningLow'),
-                chartWarningHigh: fieldContent.get('chartWarningHigh'),
-                chartHysteresis: fieldContent.get('chartHysteresis'),
-                chartTriggerThreshold: fieldContent.get('chartTriggerThreshold'),
-                chartTriggerRelation: this.parseTriggerUndershoot(fieldContent.get('chartTriggerRelation')),
-                chartSetPoint: fieldContent.get('chartSetPoint'),
-                utilsTransferInterval: Boolean(fieldContent.get('utilsTransferInterval')),
-                bitmask: fieldContent.get('bitmask')
-            };
-        }
-        resolvePossibleAlias(yamlDoc, value) {
-            return (0, yaml_1.isAlias)(value) ? value.resolve(yamlDoc).value : value?.value;
-        }
-        validateContainerDefinition(yamlItems) {
-            const definedContainer = [];
-            yamlItems.forEach(yamlItem => {
-                const itemKey = yamlItem.key;
-                const containerName = itemKey.value;
-                if (containerName === 'timeseries') {
-                    yamlItem.value.items.forEach(timeSeriesContainer => {
-                        timeSeriesContainer.key.value = `timeseries_${timeSeriesContainer.key}`;
-                        //@ts-ignore
-                        definedContainer.push(timeSeriesContainer);
-                    });
-                }
-                else if (!['dde', 'cloudProject', 'constants'].includes(containerName)) {
-                    //@ts-ignore
-                    definedContainer.push(yamlItem);
-                }
-            });
-            return definedContainer;
-        }
-        parseUserLevel(userLevelString) {
-            if (userLevelString === 'read-only') {
-                return 99;
-            }
-            if (userLevelString?.startsWith('UL')) {
-                return Number(userLevelString.substring(2));
-            }
-            return undefined;
-        }
-        parseChannelMode(channelModeString) {
-            if (!channelModeString) {
-                return undefined;
-            }
-            return ({
-                digital: 1,
-                'day-counter': 2,
-                'interval-counter': 3,
-                analog: 6,
-                'infinite-counter': 12
-            }[channelModeString] ?? channelModeString);
-        }
-        parseTriggerUndershoot(triggerUndershoot) {
-            if (!triggerUndershoot) {
-                return undefined;
-            }
-            return ({
-                'greater-or-equal': 0,
-                'less-or-equal': 1
-            }[triggerUndershoot] ?? triggerUndershoot);
-        }
-        validateAllowedContainer(sourceUri, container, lineCounter, libraryName) {
-            const containerFields = container.value; //(container.value as YAMLMap).get('fields', true);
-            if (!containerFields) {
-                return;
-            }
-            const containerName = container.key.value;
-            if (libraryName && (containerName.startsWith('aloha') || containerName.startsWith('timeseries'))) {
-                const invalidName = containerName.includes('_') ? containerName.split('_')[1] : containerName;
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `"${invalidName}" not allowed within a library`,
-                    ...yamlRangeToLineInformation(lineCounter, container.key.range)
-                });
-            }
-            if (api_1.Manifest.isAnalytics(this.manifest) &&
-                ![DDEContainerName.relations, DDEContainerName.storage].includes(containerName)) {
-                const invalidName = containerName.includes('_') ? containerName.split('_')[1] : containerName;
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `"${invalidName}" not allowed within an analytics app. Only "relations" and "storage" are allowed.`,
-                    ...yamlRangeToLineInformation(lineCounter, container.key.range)
-                });
-            }
-        }
-        validateContainerFields(yamlDoc, sourceUri, container, lineCounter) {
-            const containerFields = container.value; //(container.value as YAMLMap).get('fields', true);
-            if (!containerFields) {
-                return;
-            }
-            const containerName = container.key.value;
-            // todo validate fields across all container?
-            if (!Object.hasOwn(this.fieldNamesPerContainer, containerName)) {
-                this.fieldNamesPerContainer[containerName] = [];
-            }
-            const previousContainerDefinition = this.getContainerOfPreviousVersion(containerName);
-            //@ts-ignore
-            containerFields.items.forEach(containerFieldPair => {
-                const containerFieldKey = containerFieldPair.key;
-                const fieldName = containerFieldKey.value;
-                this.checkForContainerRelation(containerFieldPair, yamlDoc, sourceUri, lineCounter);
-                this.validateFieldName(containerFieldPair, containerName, sourceUri, lineCounter);
-                this.checkFieldNameLength(containerFieldPair, containerName, sourceUri, lineCounter);
-                const previousDefinition = previousContainerDefinition?.fields.find(field => field.id === fieldName.toLowerCase());
-                const fieldItemValues = containerFieldPair.value;
-                const typeField = fieldItemValues.get('type', true);
-                const type = this.resolvePossibleAlias(yamlDoc, typeField);
-                const bytesField = fieldItemValues.get('bytes', true);
-                const bytes = this.resolvePossibleAlias(yamlDoc, bytesField);
-                // validate if the type of this field has changed
-                if (previousDefinition) {
-                    if (typeField && type && previousDefinition.type !== type) {
-                        this.fileDiagnostics.push({
-                            file: sourceUri,
-                            level: 'warning',
-                            message: `Field type changed from "${previousDefinition.type}" to "${type}".\nChanging the type of an existing field can result in data loss or unexpected behaviour.`,
-                            ...yamlRangeToLineInformation(lineCounter, typeField.range)
-                        });
-                    }
-                    if (bytesField && bytes && previousDefinition.byteSize !== bytes) {
-                        this.fileDiagnostics.push({
-                            file: sourceUri,
-                            level: 'warning',
-                            message: `Byte size changed from '${previousDefinition.byteSize}' to '${bytes}'.\nChanging the size of an existing field can result in data loss or unexpected behaviour.`,
-                            ...yamlRangeToLineInformation(lineCounter, bytesField.range)
-                        });
-                    }
-                }
-            });
-        }
-        checkForContainerRelation(containerFieldPair, yamlDoc, sourceUri, lineCounter) {
-            // if it is a structured array, validate the subfields for any relation
-            const isStructArray = containerFieldPair.value.get('fields');
-            if (isStructArray) {
-                isStructArray.items.forEach((arrayItem) => {
-                    this.checkForContainerRelation(arrayItem, yamlDoc, sourceUri, lineCounter);
-                });
-            }
-            const allFieldItems = containerFieldPair.value.items;
-            allFieldItems.forEach(fieldItem => {
-                const itemValue = fieldItem.value;
-                // check if the field value is a relation
-                if (itemValue?.value && regexRelation.exec(`${itemValue.value}`)) {
-                    const itemType = fieldItem.key.value;
-                    // relations for the given property are not allowed.
-                    if (itemType) {
-                        if (!Object.hasOwn(allowedRelationTypes, itemType)) {
-                            return this.fileDiagnostics.push({
-                                file: sourceUri,
-                                level: 'error',
-                                message: `Property "${itemType}" does not allow relations.`,
-                                ...yamlRangeToLineInformation(lineCounter, itemValue.range)
-                            });
-                        }
-                        if (['scale', 'offset'].includes(itemType)) {
-                            return this.fileDiagnostics.push({
-                                file: sourceUri,
-                                level: 'warning',
-                                message: `Container relations for "${itemType}" are not available within the dlo source.`,
-                                ...yamlRangeToLineInformation(lineCounter, itemValue.range)
-                            });
-                        }
-                    }
-                    return this.validateContainerRelation(itemType, itemValue, yamlDoc, sourceUri, lineCounter);
-                }
-            });
-        }
-        validateFieldName(containerFieldPair, containerName, sourceUri, lineCounter) {
-            const knownFieldNames = this.fieldNamesPerContainer[containerName];
-            const containerFieldKey = containerFieldPair.key;
-            const fieldName = containerFieldKey.value;
-            if (checkForReservedFieldName(fieldName)) {
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `Reserved property "${fieldName}" is not allowed.`,
-                    ...yamlRangeToLineInformation(lineCounter, containerFieldKey.range)
-                });
-            }
-            const shadowFields = containerFieldPair.value.get('shadowFields');
-            if (shadowFields) {
-                // validate if all shadowFields are unique
-                shadowFields.items.forEach((shadowField) => {
-                    this.validateFieldName(shadowField, containerName, sourceUri, lineCounter);
-                });
-            }
-            // check if this fieldname is already in use
-            if (knownFieldNames.includes(fieldName.toLowerCase())) {
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `Field name "${fieldName}" is already occupied`,
-                    ...yamlRangeToLineInformation(lineCounter, containerFieldKey.range)
-                });
-            }
-            else {
-                knownFieldNames.push(fieldName.toLowerCase());
-            }
-        }
-        checkFieldNameLength(containerFieldPair, containerName, sourceUri, lineCounter) {
-            const containerFieldKey = containerFieldPair.key;
-            const fieldName = containerFieldKey.value;
-            const plainContainerName = containerName.startsWith('timeseries') ? containerName.substring(10) : containerName;
-            const dloBaseName = `DDE_${plainContainerName}_`;
-            const maxChars = 31 - dloBaseName.length;
-            if (dloBaseName.length + fieldName.length > 31) {
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    code: diagnostics_1.Diagnostics.CODE.ddeFieldLength,
-                    message: `Field name "${fieldName}" to long. ${maxChars} characters allowed for this field/container.`,
-                    ...yamlRangeToLineInformation(lineCounter, containerFieldKey.range)
-                });
-            }
-        }
-        // eslint-disable-next-line sonarjs/cognitive-complexity
-        validateContainerRelation(itemType, itemValue, yamlDoc, sourceUri, lineCounter) {
-            //validate if the relation exist
-            const [root, fieldRef, arrayField] = itemValue.value.split('.', 3);
-            const [libraryRelation, containerName] = root.split('@');
-            const libraryName = libraryRelation ? libraryRelation.split(':')[1] : null;
-            const yamlContentToSearch = libraryName && this.libraryYaml[libraryName] ? this.libraryYaml[libraryName] : yamlDoc;
-            const containerExist = yamlContentToSearch.contents?.get(containerName);
-            const referencedField = fieldRef.split('[')[0];
-            let relatedField = null;
-            if (containerExist) {
-                const fieldExist = containerExist.get(referencedField);
-                if (fieldExist) {
-                    // check if an array field is referenced...
-                    if (arrayField) {
-                        const arrayItems = fieldExist.get('fields');
-                        if (arrayItems && arrayItems.get(arrayField)) {
-                            relatedField = arrayItems.get(arrayField);
-                        }
-                    }
-                    else {
-                        relatedField = fieldExist;
-                    }
-                }
-                else {
-                    // search for related field within the shadowfields
-                    relatedField = this.findRelatedShadowField(containerExist, referencedField);
-                }
-            }
-            // validate if the target field type matches
-            if (relatedField) {
-                // @ts-ignore
-                const allowedTypes = allowedRelationTypes[itemType];
-                const relatedType = relatedField.get('type');
-                if (!allowedTypes.includes(relatedType)) {
-                    this.fileDiagnostics.push({
-                        file: sourceUri,
-                        level: 'error',
-                        message: `Related field type "${relatedType}" is not allowed for attribute "${itemType}".`,
-                        ...yamlRangeToLineInformation(lineCounter, itemValue.range)
-                    });
-                }
-            }
-            else if (libraryName && !this.libraryYaml[libraryName]) {
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `Related library "${libraryName}" does not exist.`,
-                    ...yamlRangeToLineInformation(lineCounter, itemValue.range)
-                });
-            }
-            else {
-                this.fileDiagnostics.push({
-                    file: sourceUri,
-                    level: 'error',
-                    message: `Related field "${itemValue.value}" does not exist.`,
-                    ...yamlRangeToLineInformation(lineCounter, itemValue.range)
-                });
-            }
-        }
-        findRelatedShadowField(relatedContainer, referencedField) {
-            for (const field of relatedContainer.items) {
-                const fieldValue = field.value;
-                const shadowFields = fieldValue.get('shadowFields');
-                if (!shadowFields) {
-                    continue;
-                }
-                const refField = shadowFields.get(referencedField);
-                if (refField) {
-                    return refField;
-                }
-            }
-            return undefined;
-        }
-        mergeAndFormat(mainDDE) {
-            const mergedDDE = {
-                containers: {},
-                setPointList: {}
-            };
-            for (const library of this.libraryDDE) {
-                this.combineDDE(mergedDDE, library);
-            }
-            this.combineDDE(mergedDDE, mainDDE);
-            this.sortContainerFields(mergedDDE);
-            this.generateSetPointList(mergedDDE);
-            return mergedDDE;
-        }
-        combineDDE(destination, source) {
-            for (const [container, containerValues] of Object.entries(source.containers)) {
-                let currentContainer = destination.containers[container];
-                if (!currentContainer) {
-                    currentContainer = destination.containers[container] = structuredClone(containerValues);
-                    currentContainer.knownNames.unshift(containerValues.title);
-                    currentContainer.fieldCount = currentContainer.fields.length;
-                    currentContainer.fieldIndex = 0;
-                }
-                else {
-                    // the last title wins!
-                    currentContainer.title = containerValues.title;
-                    // keep all known names...
-                    currentContainer.knownNames.unshift(containerValues.title);
-                    currentContainer.libraries.push(...containerValues.libraries);
-                    currentContainer.fields.push(...containerValues.fields);
-                    currentContainer.arrays = { ...currentContainer.arrays, ...containerValues.arrays };
-                    currentContainer.shadows = { ...currentContainer.shadows, ...containerValues.shadows };
-                }
-                // first byte of a histdata container is the split tag.
-                let byteOffset = this.initialContainerByteOffset(currentContainer);
-                //calculate the byteOffset for each field:
-                for (const [index, field] of currentContainer.fields.entries()) {
-                    // get the actual byteoffset of the parent shadow root
-                    if (field.shadowRef) {
-                        const shadowRef = currentContainer.shadows[field.shadowRef];
-                        field.byteOffset = shadowRef.byteOffset;
-                    }
-                    else {
-                        field.byteOffset = byteOffset;
-                        this.updateShadowFieldInformation(destination.containers[container], field);
-                        byteOffset += field.byteSize || 0;
-                    }
-                    if (index > currentContainer.fieldCount - 1) {
-                        field.index += currentContainer.fieldIndex;
-                    }
-                }
-                // update fieldIndex
-                currentContainer.fieldIndex += containerValues.fieldIndex;
-                // remove duplicates from
-                currentContainer.knownNames = [...new Set(currentContainer.knownNames)];
-                currentContainer.libraries = [...new Set(currentContainer.libraries)];
-                currentContainer.fieldCount = currentContainer.fields.length;
-            }
-        }
-        initialContainerByteOffset(container) {
-            return container.containerType === ContainerType.hx ? 1 : 0;
-        }
-        updateShadowFieldInformation(container, field) {
-            if (field && Object.hasOwn(container.shadows, field.name)) {
-                container.shadows[field.name].byteOffset = field.byteOffset;
-            }
-        }
-        sortContainerFields(mergedDDE) {
-            for (const containerDefinition of Object.values(mergedDDE.containers)) {
-                const { sortedFields, containerSize } = this.sortFields(containerDefinition);
-                containerDefinition.fields = sortedFields;
-                containerDefinition.size = containerSize;
-                containerDefinition.fieldCount = containerDefinition.fields.length;
-            }
-        }
-        sortFields(containerDefinition) {
-            const containerFields = containerDefinition.fields.filter(field => !field.shadowRef);
-            const shadowFields = containerDefinition.fields.filter(field => field.shadowRef);
-            const sortedFields = [];
-            const containerName = containerDefinition.name;
-            const previousContainer = this.previousVersion.containers[containerName];
-            if (previousContainer) {
-                const previousFields = this.sortPreviousContainerFields(containerDefinition, containerFields);
-                sortedFields.push(...previousFields);
-            }
-            else {
-                sortedFields.push(...containerFields);
-            }
-            // update shadow field information
-            sortedFields.forEach(field => {
-                this.updateShadowFieldInformation(containerDefinition, field);
-            });
-            // get the last field of the container for calculating the container size
-            const lastField = sortedFields[sortedFields.length - 1];
-            const containerSize = lastField.byteSize + lastField.byteOffset;
-            // insert all shadowfields at the end with the correct offset information
-            shadowFields.forEach(field => {
-                field.byteOffset = containerDefinition.shadows[field.shadowRef].byteOffset;
-                sortedFields.push(field);
-            });
-            return { sortedFields, containerSize };
-        }
-        // eslint-disable-next-line sonarjs/cognitive-complexity
-        sortPreviousContainerFields(containerDefinition, containerFields) {
-            const containerName = containerDefinition.name;
-            const previousContainer = this.previousVersion.containers[containerName];
-            const sortedFields = [];
-            let byteOffset = this.initialContainerByteOffset(containerDefinition);
-            // iterate over the existing container
-            for (const previousVersionField of previousContainer.fields) {
-                if (previousVersionField.shadowRef) {
-                    continue;
-                }
-                const existingLineIndex = containerFields.findIndex(field => {
-                    return previousVersionField.id === field.name?.toLowerCase();
-                });
-                // if the previous existing line doesn't exist anymore
-                // get the byte offset and pass it to the next line
-                if (existingLineIndex === -1) {
-                    byteOffset = previousVersionField.byteOffset + previousVersionField.byteSize;
-                    continue;
-                }
-                const existingField = containerFields[existingLineIndex];
-                // validate if the field type and length has changed
-                if (previousVersionField.type !== existingField.type &&
-                    previousVersionField.byteSize !== existingField.byteSize) {
-                    // if the length changed, handle the field as a "new" field
-                    byteOffset = previousVersionField.byteOffset + previousVersionField.byteSize;
-                    continue;
-                }
-                // set the previous byte offset to prevent any field movement
-                existingField.byteOffset = previousVersionField.byteOffset;
-                //remove existing line from available list
-                containerFields.splice(existingLineIndex, 1);
-                sortedFields.push(existingField);
-                byteOffset = this.initialContainerByteOffset(containerDefinition);
-            }
-            // only add a possible shadow field if the previous byteoffset is different than the initial one
-            // histdata starts with 1 cfg with 0
-            if (byteOffset > this.initialContainerByteOffset(containerDefinition)) {
-                const nextField = containerFields.shift();
-                sortedFields.push(...this.generatePlaceholderFieldIfNeeded(byteOffset, nextField));
-                this.updateShadowFieldInformation(containerDefinition, nextField);
-            }
-            //insert new fields and adjust their byte offset:
-            for (const newField of containerFields) {
-                // only calculate the byteOffset for none shadow fields!
-                if (newField.shadowRef) {
-                    newField.byteOffset = containerDefinition.shadows[newField.shadowRef].byteOffset;
-                }
-                else {
-                    this.updateShadowFieldInformation(containerDefinition, newField);
-                    let prevField = sortedFields[sortedFields.length - 1];
-                    // get the reference if it is a shadow field
-                    if (prevField.shadowRef) {
-                        prevField = containerDefinition.shadows[prevField.shadowRef];
-                    }
-                    newField.byteOffset = prevField.byteOffset + prevField.byteSize;
-                }
-                sortedFields.push(newField);
-            }
-            return sortedFields;
-        }
-        generatePlaceholderFieldIfNeeded(byteOffset, nextField) {
-            const fieldList = [];
-            // crate a shadow field if there isn't any known field left
-            if (!nextField) {
-                const shadowField = {
-                    byteOffset: byteOffset,
-                    byteSize: 0,
-                    id: '_shadow',
-                    library: null,
-                    name: '_shadow',
-                    type: 'shadow',
-                    arrayRef: null,
-                    shadowRef: null,
-                    title: null,
-                    index: 0
-                };
-                fieldList.push(shadowField);
-            }
-            else {
-                // add the byteoffset to the next known field
-                nextField.byteOffset = byteOffset;
-                fieldList.push(nextField);
-            }
-            return fieldList;
-        }
-        generateSetPointList(mergedDDE) {
-            // copy previous versions setpointlist
-            mergedDDE.setPointList = { ...(this.previousVersion.setPointList || {}) };
-            //find fields with SetPointAttribute:
-            for (const containerDefinition of Object.values(mergedDDE.containers)) {
-                for (const field of containerDefinition.fields) {
-                    if (!field.chartSetPoint) {
-                        continue;
-                    }
-                    //setpoint is already known -> skip
-                    if (Object.hasOwn(mergedDDE.setPointList, field.name)) {
-                        continue;
-                    }
-                    mergedDDE.setPointList[field.name] = this.getNextSetpointValue(mergedDDE.setPointList);
-                }
-            }
-        }
-        getNextSetpointValue(setPointList) {
-            const knownValues = [...Object.values(setPointList), 0];
-            return Math.max(...knownValues) + 1;
-        }
-    }
-    YamlPreCompiler.PreCompiler = PreCompiler;
-})(YamlPreCompiler || (exports.YamlPreCompiler = YamlPreCompiler = {}));
-//# sourceMappingURL=yamlDdePreCompiler.js.map