@microtronics/studio-cli 0.61.0 → 0.62.0

package/out/dde/fileGenerators/dloLocalData.js

@@ -1,387 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDloLocalDataIncFromMap = generateDloLocalDataIncFromMap;
-const coreDefinitions_1 = require("../coreDefinitions");
-var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
-const dlo_1 = require("./dlo");
-const helper_1 = require("../../helper");
-const PAWN_SZTEMP_DECL = '\tnew szTemp{64};';
-const PAWN_STRCAT_RETURN = '\treturn strcat(aData, szTemp, sizeof(szTemp));';
-/**
- * Determines if a field type can use a format helper function, and which one.
- * Returns null if the field type needs inline code (packed types, wstring, etc.)
- */
-function getHelperFormatType(tdefPwn) {
-    // Binary (memtostr) fields - check before printf since printf is null for binary
-    if (!tdefPwn.printf && tdefPwn.printfFormat === 'memtostr') {
-        return 'bin';
-    }
-    if (!tdefPwn.printf) {
-        return null;
-    }
-    const rwp = tdefPwn.rwp || '%n';
-    const hasCellArray = rwp.includes('[');
-    const hasPackedArray = rwp.includes('{');
-    const isComplex = hasPackedArray || hasCellArray;
-    if (tdefPwn.printfFormat === 'stampToISOString') {
-        return isComplex ? null : 'stamp';
-    }
-    switch (tdefPwn.printf) {
-        case '%d':
-            return isComplex ? null : 'd';
-        case '%f':
-            return isComplex ? null : 'f';
-        case '%s':
-            return hasCellArray ? null : 's';
-        default:
-            return null;
-    }
-}
-/**
- * Gets the format type for a field, handling shadow/skip filtering.
- * Returns null if the field should be skipped or needs inline code.
- */
-function getFieldFormatType(field) {
-    if (field.type === 'shadow' || field.shadowRef) {
-        return null;
-    }
-    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
-    if (!tdefPwn || tdefPwn === 'skip') {
-        return null;
-    }
-    return getHelperFormatType(tdefPwn);
-}
-/**
- * Checks if a container is device-side (hx or cx) and not backend-only.
- */
-function isDeviceContainer(containerDefinition) {
-    return ([coreDefinitions_1.DDE_Core.ContainerType.hx, coreDefinitions_1.DDE_Core.ContainerType.cx].includes(containerDefinition.containerType) &&
-        containerDefinition.transferDirection !== TransferDirection.backendOnly);
-}
-/**
- * Checks if a field is valid for code generation (not shadow, not skipped).
- */
-function isValidField(field) {
-    if (field.type === 'shadow' || field.shadowRef) {
-        return false;
-    }
-    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
-    return !!tdefPwn && tdefPwn !== 'skip';
-}
-/**
- * Adds an array field to the appropriate group in the group map.
- */
-function addFieldToGroup(field, formatType, groupMap) {
-    const bracketEnd = field.name.indexOf(']');
-    const subField = bracketEnd >= 0 ? field.name.substring(bracketEnd + 1) : '';
-    const groupKey = `${field.arrayRef.name}|${subField}|${formatType}`;
-    if (!groupMap.has(groupKey)) {
-        groupMap.set(groupKey, { fields: [], formatType });
-    }
-    groupMap.get(groupKey).fields.push(field);
-}
-/**
- * Classifies fields into array-groupable and standalone categories.
- */
-function classifyFields(fields) {
-    const standaloneFields = [];
-    const groupMap = new Map();
-    const usedFormats = new Set();
-    let hasInlineFields = false;
-    for (const field of fields) {
-        if (!isValidField(field)) {
-            continue;
-        }
-        const formatType = getFieldFormatType(field);
-        if (field.arrayRef && formatType) {
-            addFieldToGroup(field, formatType, groupMap);
-        }
-        else {
-            standaloneFields.push(field);
-            if (formatType) {
-                usedFormats.add(formatType);
-            }
-            else {
-                hasInlineFields = true;
-            }
-        }
-    }
-    return { standaloneFields, groupMap, usedFormats, hasInlineFields };
-}
-/**
- * Converts a group map entry into an ArrayFieldGroup if it has consistent stepping.
- * Returns null if the group should be treated as standalone fields.
- */
-function tryBuildArrayGroup(containerTitle, groupKey, groupFields) {
-    groupFields.sort((a, b) => a.arrayRef.index - b.arrayRef.index);
-    const offsets = groupFields.map(f => f.byteOffset);
-    const step = offsets[1] - offsets[0];
-    const isConsistent = step > 0 && offsets.every((o, i) => i === 0 || o - offsets[i - 1] === step);
-    if (!isConsistent) {
-        return null;
-    }
-    const [arrayName, subField] = groupKey.split('|');
-    const fieldNamePrefix = groupFields[0].library
-        ? `_${helper_1.Helper.generateHashForLibraryName(groupFields[0].library)}`
-        : 'DDE_';
-    return {
-        arrayName,
-        subField,
-        fields: groupFields,
-        startOffset: offsets[0],
-        endOffset: offsets[offsets.length - 1],
-        step,
-        formatType: getFieldFormatType(groupFields[0]),
-        pawnVarBase: `${fieldNamePrefix}${containerTitle}_${arrayName}`
-    };
-}
-/**
- * Analyzes container fields and groups array elements that can be collapsed
- * into arithmetic if-blocks for reduced AMX binary size.
- */
-function analyzeContainerFields(containerTitle, fields) {
-    const { standaloneFields, groupMap, usedFormats, hasInlineFields } = classifyFields(fields);
-    const arrayGroups = [];
-    for (const [groupKey, groupData] of groupMap) {
-        const { fields: groupFields, formatType } = groupData;
-        if (groupFields.length < 2) {
-            standaloneFields.push(...groupFields);
-            usedFormats.add(formatType);
-            continue;
-        }
-        const group = tryBuildArrayGroup(containerTitle, groupKey, groupFields);
-        if (group) {
-            usedFormats.add(formatType);
-            arrayGroups.push(group);
-        }
-        else {
-            standaloneFields.push(...groupFields);
-            usedFormats.add(formatType);
-        }
-    }
-    standaloneFields.sort((a, b) => a.byteOffset - b.byteOffset);
-    return { arrayGroups, standaloneFields, usedFormats, hasInlineFields };
-}
-/**
- * Scans all eligible container fields to determine which helper format types are needed.
- */
-function collectUsedFormats(ddeMap) {
-    const usedFormats = new Set();
-    for (const [, containerDefinition] of Object.entries(ddeMap.containers)) {
-        if (!isDeviceContainer(containerDefinition)) {
-            continue;
-        }
-        for (const field of containerDefinition.fields) {
-            const formatType = getFieldFormatType(field);
-            if (formatType) {
-                usedFormats.add(formatType);
-            }
-        }
-    }
-    return usedFormats;
-}
-/**
- * Generates Pawn helper functions that encapsulate the sprintf+strcat pattern.
- * Only generates the helpers that are actually used, reducing dead code.
- * Each helper replaces 3 lines of repeated code per field with a single call.
- */
-function buildHelperFunctions(pawnSource, usedFormats) {
-    if (usedFormats.has('d')) {
-        pawnSource('stock _DDE_fmt_d(aData{}, value) {');
-        pawnSource(PAWN_SZTEMP_DECL);
-        pawnSource('\tsprintf(szTemp, _, "%d", value);');
-        pawnSource(PAWN_STRCAT_RETURN);
-        pawnSource('}');
-    }
-    if (usedFormats.has('f')) {
-        pawnSource('');
-        pawnSource('stock _DDE_fmt_f(aData{}, Float:value) {');
-        pawnSource(PAWN_SZTEMP_DECL);
-        pawnSource('\tsprintf(szTemp, _, "%.3f", value);');
-        pawnSource(PAWN_STRCAT_RETURN);
-        pawnSource('}');
-    }
-    if (usedFormats.has('s')) {
-        pawnSource('');
-        pawnSource('stock _DDE_fmt_s(aData{}, value{}) {');
-        pawnSource(PAWN_SZTEMP_DECL);
-        pawnSource('\tsprintf(szTemp, _, "%s", value);');
-        pawnSource(PAWN_STRCAT_RETURN);
-        pawnSource('}');
-    }
-    if (usedFormats.has('stamp')) {
-        pawnSource('');
-        pawnSource('stock _DDE_fmt_stamp(aData{}, value) {');
-        pawnSource(PAWN_SZTEMP_DECL);
-        pawnSource('\tsprintf(szTemp, _, "%s", (stampToISOString(value)));');
-        pawnSource(PAWN_STRCAT_RETURN);
-        pawnSource('}');
-    }
-    if (usedFormats.has('bin')) {
-        pawnSource('');
-        pawnSource('stock _DDE_fmt_bin(aData{}, mem{}, dim) {');
-        pawnSource('\t#pragma warning disable 224');
-        pawnSource('\tmemtostr(aData, mem, 0, dim);');
-        pawnSource('\t#pragma warning disable 224');
-        pawnSource('\treturn dim;');
-        pawnSource('}');
-    }
-}
-/**
- * Builds the Pawn index expression for accessing an array element by byte offset.
- */
-function buildIndexExpression(startOffset, step) {
-    if (step === 1) {
-        return startOffset === 0 ? 'idx' : `idx - ${startOffset}`;
-    }
-    return startOffset === 0 ? `idx / ${step}` : `(idx - ${startOffset}) / ${step}`;
-}
-/**
- * Builds the Pawn condition for matching a byte offset to an array group.
- */
-function buildConditionExpression(startOffset, endOffset, step) {
-    const rangeCheck = `idx >= ${startOffset} && idx <= ${endOffset}`;
-    if (step === 1) {
-        return rangeCheck;
-    }
-    const modCheck = startOffset === 0 ? `idx % ${step} == 0` : `(idx - ${startOffset}) % ${step} == 0`;
-    return `${rangeCheck} && ${modCheck}`;
-}
-/**
- * Generates an if-block that collapses an array group into arithmetic index calculation.
- */
-function buildArrayGroupBlock(pawnSource, group) {
-    const { startOffset, endOffset, step, formatType, pawnVarBase, subField } = group;
-    const indexExpr = buildIndexExpression(startOffset, step);
-    const condition = buildConditionExpression(startOffset, endOffset, step);
-    pawnSource(`\tif (${condition}) {`);
-    if (formatType === 'bin') {
-        const fieldAccess = `${pawnVarBase}[${indexExpr}]${subField}`;
-        const subFieldName = subField ? subField.substring(1) : '';
-        const dimDefine = subFieldName ? `${pawnVarBase}_${subFieldName}_dim` : `${pawnVarBase}_dim`;
-        pawnSource(`\t\treturn _DDE_fmt_bin(aData, ${fieldAccess}, ${dimDefine});`);
-    }
-    else {
-        pawnSource(`\t\treturn _DDE_fmt_${formatType}(aData, ${pawnVarBase}[${indexExpr}]${subField});`);
-    }
-    pawnSource(`\t}`);
-}
-/**
- * Builds a case statement for a standalone field.
- * Uses compact helper function calls when available, falls back to inline code
- * for packed types (s64, f64, stamp40) and memtostr (binary).
- */
-function buildOptimizedCaseForField(pawnSource, containerTitle, field) {
-    if (field.type === 'shadow' || field.shadowRef) {
-        return;
-    }
-    const tdefPwn = (0, dlo_1.getPawnTypeDefinition)(field);
-    if (!tdefPwn || tdefPwn === 'skip') {
-        return;
-    }
-    const fieldNamePrefix = field.library ? `_${helper_1.Helper.generateHashForLibraryName(field.library)}` : 'DDE_';
-    const ddeFieldName = `${fieldNamePrefix}${containerTitle}_${field.name}`;
-    const formatType = getHelperFormatType(tdefPwn);
-    if (formatType === 'bin') {
-        // Compact single-line case using binary helper function
-        pawnSource(`\t\tcase ${field.byteOffset}: return _DDE_fmt_bin(aData, ${ddeFieldName}, ${ddeFieldName}_dim);`);
-    }
-    else if (formatType) {
-        // Compact single-line case using helper function
-        pawnSource(`\t\tcase ${field.byteOffset}: return _DDE_fmt_${formatType}(aData, ${ddeFieldName});`);
-    }
-    else {
-        // Fall back to inline code (packed types, wstring, etc.)
-        pawnSource(`\t\tcase ${field.byteOffset}: {`);
-        if (tdefPwn.printf) {
-            let printfInsert = ddeFieldName;
-            if (tdefPwn.printfFormat) {
-                printfInsert = `(${tdefPwn.printfFormat}(${printfInsert}))`;
-            }
-            pawnSource(`\t\t\tsprintf(szTemp, _, "${tdefPwn.printf}", ${printfInsert});`);
-            pawnSource(`\t\t\treturn (strcat(aData, szTemp, sizeof(szTemp)));`);
-        }
-        pawnSource(`\t\t}`);
-    }
-}
-function buildCaseForContainerName(pawnSource, containerName, containerDefinition) {
-    pawnSource(`\t\t\tcase '${containerName.at(-1)}': {`);
-    pawnSource(`\t\t\t\treturn _DDE_local_${containerDefinition.title}(aData, idx);`);
-    pawnSource(`\t\t\t}`);
-}
-function buildIfWithSwitchForContainerType(pawnSource, ddeMap, type) {
-    const cname0 = type === coreDefinitions_1.DDE_Core.ContainerType.cx ? 'c' : 'h';
-    const nameFilter = type === coreDefinitions_1.DDE_Core.ContainerType.cx ? 'config' : 'histdata';
-    pawnSource(`\tif(cname{0} == '${cname0}'){`);
-    pawnSource(`\t\tswitch(cname{1}) {`);
-    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
-        if (type === containerDefinition.containerType &&
-            containerName.startsWith(nameFilter) &&
-            containerDefinition.transferDirection !== TransferDirection.backendOnly) {
-            buildCaseForContainerName(pawnSource, containerName, containerDefinition);
-        }
-    }
-    pawnSource(`\t\t\tdefault:`);
-    pawnSource(`\t\t\t\treturn OK;`);
-    pawnSource(`\t\t}`);
-    pawnSource(`\t\treturn OK;`);
-    pawnSource(`\t}`);
-}
-/**
- * Generates an optimized per-container local data return function.
- * Uses if-blocks for collapsed array groups and a switch for standalone fields.
- * Only declares szTemp when inline (non-helper) fields are present.
- */
-function buildOptimizedLocalDataReturnFunction(pawnSource, containerDefinition) {
-    const analysis = analyzeContainerFields(containerDefinition.title, containerDefinition.fields);
-    pawnSource('');
-    pawnSource(`stock _DDE_local_${containerDefinition.title}(aData{}, idx) {`);
-    // Declare szTemp only if there are inline fields that need it
-    if (analysis.hasInlineFields) {
-        pawnSource(`\tnew szTemp{64};`);
-    }
-    // Generate if-blocks for array groups (before the switch)
-    for (const group of analysis.arrayGroups) {
-        buildArrayGroupBlock(pawnSource, group);
-    }
-    // Generate switch for standalone fields
-    if (analysis.standaloneFields.length > 0) {
-        pawnSource(`\tswitch(idx) {`);
-        for (const field of analysis.standaloneFields) {
-            buildOptimizedCaseForField(pawnSource, containerDefinition.title, field);
-        }
-        pawnSource(`\t\tdefault:`);
-        pawnSource(`\t\t\treturn OK;`);
-        pawnSource(`\t}`);
-    }
-    pawnSource(`\treturn OK;`);
-    pawnSource(`}`);
-}
-function buildOptimizedLocalDataReturnFunctions(pawnSource, ddeMap) {
-    for (const [, containerDefinition] of Object.entries(ddeMap.containers)) {
-        if (!isDeviceContainer(containerDefinition)) {
-            continue;
-        }
-        buildOptimizedLocalDataReturnFunction(pawnSource, containerDefinition);
-    }
-}
-function generateDloLocalDataIncFromMap(ddeMap) {
-    const _pwn = [];
-    const pwn = _pwn.push.bind(_pwn);
-    // Generate helper functions based on which format types are actually used
-    const usedFormats = collectUsedFormats(ddeMap);
-    buildHelperFunctions(pwn, usedFormats);
-    // Generate main dispatch function
-    if (usedFormats.size > 0) {
-        pwn('');
-    }
-    pwn(`stock DDE_get_local_data(cname{}, aData{}, idx) {`);
-    buildIfWithSwitchForContainerType(pwn, ddeMap, coreDefinitions_1.DDE_Core.ContainerType.cx);
-    buildIfWithSwitchForContainerType(pwn, ddeMap, coreDefinitions_1.DDE_Core.ContainerType.hx);
-    pwn(`\treturn OK;`);
-    pwn(`}`);
-    // Generate optimized per-container functions
-    buildOptimizedLocalDataReturnFunctions(pwn, ddeMap);
-    return _pwn.join('\n');
-}
-//# sourceMappingURL=dloLocalData.js.map

package/out/dde/fileGenerators/xml.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateXMLFromMap = generateXMLFromMap;
-const coreDefinitions_1 = require("../coreDefinitions");
-var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
-var parseXMLValueWithRelation = coreDefinitions_1.DDE_Core.parseXMLValueWithRelation;
-var parseXMLBitmask = coreDefinitions_1.DDE_Core.parseXMLBitmask;
-var parseXMLDefaultValue = coreDefinitions_1.DDE_Core.parseXMLDefaultValue;
-var fieldTypeDefinitions = coreDefinitions_1.DDE_Core.fieldTypeDefinitions;
-const helper_1 = require("../../helper");
-const manifest_1 = require("../../manifest");
-// eslint-disable-next-line sonarjs/cognitive-complexity
-function generateXMLFromMap(manifest, ddeMap) {
-    const indent = '';
-    const xml_ = [];
-    function xml(s, condition = true) {
-        if (!condition) {
-            return;
-        }
-        if (Array.isArray(s)) {
-            xml_.push.apply(xml_, s);
-            return;
-        }
-        xml_.push(indent + s);
-    }
-    function xmlAttr(attribute, val) {
-        if (attribute === 'mergeofs') {
-            return;
-        }
-        xml(`${attribute}=${val}`);
-    }
-    xml('// DDE STRUCTURE created by Microtronics Studio');
-    const rm2mraw = 'source=rm2mraw';
-    for (const [containerName, containerDefinition] of Object.entries(ddeMap.containers)) {
-        if (containerName.startsWith('histdata') &&
-            containerDefinition.transferDirection !== TransferDirection.deviceOnly) {
-            xml('<split>');
-            xml(rm2mraw);
-            xml('target=' + containerName);
-            xml('key=0' + containerName.substr(-1, 1));
-            xml('</split>');
-        }
-        xml('<table>');
-        xmlAttr('name', containerName); // output container-name as very first line (mandatory!)
-        xmlAttr('alias', containerDefinition.title);
-        xmlAttr('title', containerDefinition.title.replace('_', ' '));
-        const containerAttributes = {};
-        // enforce container's direction - 'up','up+','down','down+','both','both+'
-        // .upload/.download are reserved container attributes (already claimed during parsing)
-        if ([
-            TransferDirection.none,
-            TransferDirection.backendOnly,
-            TransferDirection.deviceOnly,
-            TransferDirection.down,
-            TransferDirection.downPlus
-        ].includes(containerDefinition.transferDirection)) {
-            // containerAttributes['upload'] = '0';
-            xmlAttr('upload', '0');
-        }
-        if ([
-            TransferDirection.none,
-            TransferDirection.backendOnly,
-            TransferDirection.deviceOnly,
-            TransferDirection.up,
-            TransferDirection.upPlus
-        ].includes(containerDefinition.transferDirection)) {
-            // containerAttributes['download'] = '0';
-            xmlAttr('download', '0');
-        }
-        // set edit=99 on upward containers to reject write access via API
-        // only for IoT apps and libraries. For addons or analytics this is not needed.
-        if ((manifest_1.Manifest.isIotApp(manifest) || manifest_1.Manifest.isLibrary(manifest)) &&
-            [TransferDirection.up, TransferDirection.upPlus].includes(containerDefinition.transferDirection)) {
-            xmlAttr('edit', '99');
-        }
-        //insert fields:
-        for (const field of containerDefinition.fields) {
-            if (field.type === 'shadow') {
-                continue;
-            }
-            const patchedField = patchFieldWithArrayInfo(field);
-            const typeDefinition = fieldTypeDefinitions[patchedField.type];
-            // build the field title:
-            let fieldTitle = parseXMLValueWithRelation('title', patchedField, ddeMap) || patchedField.name;
-            // only add the library prefix if the attribute is not referenced
-            if (!fieldTitle.startsWith('%') && patchedField.library) {
-                fieldTitle = `${patchedField.library}: ${fieldTitle}`;
-            }
-            const xmlField = {
-                title: fieldTitle,
-                alias: patchedField.name,
-                index: field.index,
-                ...containerAttributes
-            };
-            xmlField.byteofs = `${patchedField.byteOffset}`;
-            // add xml attributes based on field type
-            for (const [attribute, value] of Object.entries(typeDefinition.xml)) {
-                //@ts-ignore
-                xmlField[attribute] = value;
-            }
-            if (Object.hasOwn(typeDefinition, 'xmlOut')) {
-                typeDefinition.xmlOut(xmlField, patchedField, ddeMap);
-            }
-            // additional attributes from the dde
-            xmlField.units = parseXMLValueWithRelation('unit', patchedField, ddeMap);
-            xmlField.chmode = parseXMLValueWithRelation('channelMode', patchedField, ddeMap);
-            // warn and alarm thresholds
-            xmlField.ialarm_high = parseXMLValueWithRelation('chartAlarmHigh', patchedField, ddeMap);
-            xmlField.ialarm_low = parseXMLValueWithRelation('chartAlarmLow', patchedField, ddeMap);
-            xmlField.iwarn_high = parseXMLValueWithRelation('chartWarningHigh', patchedField, ddeMap);
-            xmlField.iwarn_low = parseXMLValueWithRelation('chartWarningLow', patchedField, ddeMap);
-            xmlField.hysterese = parseXMLValueWithRelation('chartHysteresis', patchedField, ddeMap);
-            xmlField.itrigger = parseXMLValueWithRelation('chartTriggerThreshold', patchedField, ddeMap);
-            xmlField.itriggerus = parseXMLValueWithRelation('chartTriggerRelation', patchedField, ddeMap);
-            xmlField.setpoint = parseXMLValueWithRelation('chartSetPoint', patchedField, ddeMap);
-            xmlField.bitmask = parseXMLBitmask(patchedField);
-            // process field as hex
-            if (patchedField.hex) {
-                xmlField.editmask = '%HEX%';
-            }
-            if (patchedField.readPermission) {
-                xmlField.view = patchedField.readPermission;
-            }
-            if (patchedField.writePermission) {
-                xmlField.edit = patchedField.writePermission;
-            }
-            if (patchedField.defaultValue !== undefined) {
-                xmlField.default = parseXMLDefaultValue(patchedField);
-            }
-            if (patchedField.utilsTransferInterval === true) {
-                xmlField.param0 = '%FFFF0005%transfer_interval';
-            }
-            xml('<field>');
-            if (patchedField.library) {
-                xml(`// declared by ${patchedField.library} library`, true);
-            }
-            for (const [attribute, value] of Object.entries(xmlField)) {
-                // if (attribute === 'byteofs') {
-                // 	xml(`// patching byte offset due to removed field`);
-                // }
-                if (value !== undefined) {
-                    xmlAttr(attribute, `${value}`);
-                }
-            }
-            xml('</field>');
-        }
-        // end of container
-        if (!['alerts', 'applog'].includes(containerName)) {
-            xml('</table>');
-            xml('// ' + containerDefinition.size + ' bytes total size');
-        }
-    }
-    // insert alerts stream
-    xml('<split>');
-    xml(rm2mraw);
-    xml('target=alarm0');
-    xml('key=20'); // implicit hex!
-    xml('</split>');
-    // insert applog stream
-    xml('<split>');
-    xml(rm2mraw);
-    xml('target=applog0');
-    xml('key=28'); // implicit hex!
-    xml('</split>');
-    return xml_.join('\n');
-}
-function patchFieldWithArrayInfo(ddeField) {
-    const clonedField = structuredClone(ddeField);
-    const arrayIndex = ddeField.arrayRef?.index;
-    if (arrayIndex === undefined) {
-        return clonedField;
-    }
-    // eslint-disable-next-line prefer-const
-    for (let [attribute, value] of Object.entries(clonedField)) {
-        // @ts-ignore
-        clonedField[attribute] = helper_1.Helper.patchValueWithArrayInfo(value, arrayIndex);
-    }
-    return clonedField;
-}
-//# sourceMappingURL=xml.js.map