n8n-nodes-data-mapper 0.2.0 → 0.4.1

package/dist/nodes/DataMapper/visual.js

@@ -0,0 +1,755 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_PREFIX = exports.visualProperties = void 0;
+exports.encodeFieldId = encodeFieldId;
+exports.decodeFieldId = decodeFieldId;
+exports.fieldDisplayName = fieldDisplayName;
+exports.parseDragReference = parseDragReference;
+exports.getProfileFields = getProfileFields;
+exports.buildDropRules = buildDropRules;
+exports.orderByProfile = orderByProfile;
+exports.executeVisual = executeVisual;
+const n8n_workflow_1 = require("n8n-workflow");
+const csv_1 = require("./csv");
+const mapping_1 = require("./mapping");
+const profile_1 = require("./profile");
+const xml_1 = require("./xml");
+exports.visualProperties = [
+    {
+        displayName: 'Paste your target profile, then fill each target field: drag a field from the INPUT panel, pick one from the Source Profile dropdown, or write an expression. Or switch to "Map Automatically" to match them by name.',
+        name: 'howTo',
+        type: 'notice',
+        default: '',
+    },
+    {
+        displayName: 'Output Format',
+        name: 'targetFormat',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            { name: 'JSON', value: 'json', description: 'Output the mapped data as JSON' },
+            { name: 'XML', value: 'xml', description: 'Output the mapped data as an XML document' },
+            { name: 'CSV', value: 'csv', description: 'Output the mapped data as CSV rows' },
+        ],
+        default: 'json',
+    },
+    {
+        displayName: 'Source Data',
+        name: 'sourceData',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'Incoming Item',
+                value: 'item',
+                description: 'Map the fields of the incoming item; you can drag them from the Input panel',
+            },
+            {
+                name: 'XML or JSON Text in a Field',
+                value: 'field',
+                description: 'Parse XML or JSON text held in a field first, e.g. a raw order in "data"',
+            },
+            { name: 'XML or JSON File', value: 'binary', description: 'Parse an XML or JSON file first' },
+        ],
+        default: 'item',
+    },
+    {
+        displayName: 'Source Field',
+        name: 'sourceDataField',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: { show: { sourceData: ['field'] } },
+    },
+    {
+        displayName: 'Source File Field',
+        name: 'sourceDataBinary',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: { show: { sourceData: ['binary'] } },
+    },
+    {
+        displayName: 'Source Profile',
+        name: 'sourceProfile',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        default: '',
+        placeholder: 'Optional: paste the structure of the incoming data, e.g. a sample order',
+        description: 'Optional. Describes the incoming data. When set, every target field gets a dropdown of source fields to pick from (you can still switch a field to an expression).',
+    },
+    {
+        displayName: 'Target Profile',
+        name: 'targetProfile',
+        type: 'string',
+        typeOptions: { rows: 8 },
+        default: '',
+        required: true,
+        placeholder: 'Paste an XML/JSON/Flat File profile component, JSON Schema, sample JSON or XML, XSD, or a CSV header row',
+        description: 'The structure to map into. Its fields appear below as the targets.',
+    },
+    {
+        displayName: 'Target Fields',
+        name: 'mapping',
+        type: 'resourceMapper',
+        noDataExpression: true,
+        default: { mappingMode: 'defineBelow', value: null },
+        required: true,
+        typeOptions: {
+            loadOptionsDependsOn: ['targetProfile', 'options.profileFormat', 'sourceProfile', 'options.sourceProfileFormat'],
+            resourceMapper: {
+                resourceMapperMethod: 'getProfileFields',
+                mode: 'add',
+                valuesLabel: 'Target Fields',
+                fieldWords: { singular: 'target field', plural: 'target fields' },
+                addAllFields: true,
+                multiKeyMatch: false,
+                supportAutoMap: true,
+                noFieldsError: 'No target fields found. Paste a target profile above.',
+            },
+        },
+    },
+    {
+        displayName: 'Output To',
+        name: 'outputAs',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'Item',
+                value: 'item',
+                description: 'JSON becomes the output item; XML and CSV go into a text field',
+            },
+            { name: 'File', value: 'file', description: 'Output a binary file' },
+        ],
+        default: 'item',
+    },
+    {
+        displayName: 'Put Output in Field',
+        name: 'outputField',
+        type: 'string',
+        default: '',
+        placeholder: 'xml',
+        description: 'Field for the XML or CSV text. Leave empty to use "xml" or "csv".',
+        displayOptions: { show: { outputAs: ['item'], targetFormat: ['xml', 'csv'] } },
+    },
+    {
+        displayName: 'Put Output File in Field',
+        name: 'binaryField',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: { show: { outputAs: ['file'] } },
+    },
+    {
+        displayName: 'File Name',
+        name: 'fileName',
+        type: 'string',
+        default: '',
+        placeholder: 'output.xml',
+        description: 'Leave empty to name the file "output" with the matching extension',
+        displayOptions: { show: { outputAs: ['file'] } },
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add option',
+        default: {},
+        options: [
+            {
+                displayName: 'Add Auto-Map Report',
+                name: 'autoMapReport',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to add an _autoMap field listing matched and unmatched fields (Map Automatically with JSON output)',
+            },
+            {
+                displayName: 'Auto-Map Minimum Confidence',
+                name: 'threshold',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
+                default: 0.6,
+                description: 'How close names must be for Map Automatically, from 0 (anything) to 1 (identical)',
+            },
+            {
+                displayName: 'Convert Types From Profile',
+                name: 'convertTypes',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to turn values into numbers or booleans where the profile says so. Values that cannot be converted are kept as they are.',
+            },
+            {
+                displayName: 'CSV Delimiter',
+                name: 'csvDelimiter',
+                type: 'string',
+                default: ',',
+            },
+            {
+                displayName: 'CSV Header Row',
+                name: 'csvHeader',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to start the CSV with a row of column names',
+            },
+            {
+                displayName: 'CSV Line Ending',
+                name: 'csvLineEnding',
+                type: 'options',
+                options: [
+                    { name: 'LF', value: 'lf' },
+                    { name: 'CRLF', value: 'crlf' },
+                ],
+                default: 'lf',
+            },
+            {
+                displayName: 'Custom Synonyms',
+                name: 'synonyms',
+                type: 'string',
+                typeOptions: { rows: 3 },
+                default: '',
+                placeholder: 'menge=quantity\nartikel=article',
+                description: 'Extra name matches for Map Automatically, one source=target per line (or a JSON object). Common abbreviations such as Qty=quantity are already built in.',
+            },
+            {
+                displayName: 'Escape CSV Formulas',
+                name: 'csvEscapeFormulas',
+                type: 'boolean',
+                default: false,
+                description: "Whether to put ' in front of CSV values that start with =, +, -, @, a tab or a carriage return, so spreadsheet apps don't run them as formulas (CSV injection). Negative numbers then start with ' too.",
+            },
+            {
+                displayName: 'Include XML Declaration',
+                name: 'xmlDeclaration',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to start the XML with <?xml version="1.0" encoding="UTF-8"?>',
+            },
+            {
+                displayName: 'Keep Empty Values',
+                name: 'keepEmpty',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to write target fields whose value is empty, instead of leaving them out',
+            },
+            {
+                displayName: 'One CSV for All Items',
+                name: 'csvCombine',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to put every item into one CSV document, instead of one CSV per item',
+            },
+            {
+                displayName: 'Profile Format',
+                name: 'profileFormat',
+                type: 'options',
+                options: [
+                    { name: 'Detect Automatically', value: 'auto' },
+                    { name: 'Profile Component (XML/JSON/Flat File)', value: 'component' },
+                    { name: 'JSON Schema', value: 'jsonSchema' },
+                    { name: 'Sample JSON', value: 'sampleJson' },
+                    { name: 'Sample XML', value: 'sampleXml' },
+                    { name: 'XSD', value: 'xsd' },
+                    { name: 'CSV Header', value: 'csv' },
+                ],
+                default: 'auto',
+            },
+            {
+                displayName: 'Read Profile From Binary Field',
+                name: 'profileBinaryField',
+                type: 'string',
+                default: '',
+                placeholder: 'data',
+                description: 'Read the target profile from an uploaded file in this binary field instead of the Target Profile box. Works with Map Automatically; to drag and drop, paste the profile.',
+            },
+            {
+                displayName: 'Root Element',
+                name: 'rootElement',
+                type: 'string',
+                default: '',
+                placeholder: 'order',
+                description: 'XML root element name. Leave empty to use the profile\'s root (sample XML profiles), the single top-level field, or "root".',
+            },
+            {
+                displayName: 'Source Profile Format',
+                name: 'sourceProfileFormat',
+                type: 'options',
+                options: [
+                    { name: 'Detect Automatically', value: 'auto' },
+                    { name: 'Profile Component (XML/JSON/Flat File)', value: 'component' },
+                    { name: 'JSON Schema', value: 'jsonSchema' },
+                    { name: 'Sample JSON', value: 'sampleJson' },
+                    { name: 'Sample XML', value: 'sampleXml' },
+                    { name: 'XSD', value: 'xsd' },
+                    { name: 'CSV Header', value: 'csv' },
+                ],
+                default: 'auto',
+            },
+        ],
+    },
+];
+const ID_ESCAPES = {
+    '%': '%25',
+    '/': '%2F',
+    '*': '%2A',
+    '#': '%23',
+    '.': '%2E',
+    '[': '%5B',
+    ']': '%5D',
+};
+const escapeSegment = (s) => s.replace(/[%/*#.[\]]/g, (c) => ID_ESCAPES[c]);
+const unescapeSegment = (s) => s.replace(/%(25|2F|2A|23|2E|5B|5D)/gi, (m) => decodeURIComponent(m));
+function encodeFieldId(path) {
+    const tokens = (0, mapping_1.parsePath)(path);
+    if (tokens.length === 0)
+        return '.';
+    return tokens.map((t) => (t === '*' ? '*' : typeof t === 'number' ? `#${t}` : escapeSegment(t))).join('/');
+}
+function formatKey(key, first) {
+    if (/^[^.[\]\s"']+$/.test(key))
+        return first ? key : `.${key}`;
+    return key.includes('"') ? `['${key}']` : `["${key}"]`;
+}
+function decodeFieldId(id) {
+    if (id === '.' || id === '')
+        return '';
+    let path = '';
+    for (const segment of id.split('/')) {
+        if (segment === '*')
+            path += '[*]';
+        else if (/^#\d+$/.test(segment))
+            path += `[${segment.slice(1)}]`;
+        else
+            path += formatKey(unescapeSegment(segment), path === '');
+    }
+    return path;
+}
+function fieldDisplayName(field) {
+    const tokens = (0, mapping_1.parsePath)(field.path);
+    const parts = [];
+    for (let k = 0; k < tokens.length; k++) {
+        const token = tokens[k];
+        if (token === '*') {
+            if (parts.length > 0)
+                parts[parts.length - 1] += '[]';
+            else
+                parts.push('[]');
+            continue;
+        }
+        const next = tokens[k + 1];
+        if (token === '$' && typeof next === 'string' && next !== '*') {
+            parts.push(`@${next}`);
+            k++;
+            continue;
+        }
+        parts.push(token === '_' ? '(text)' : String(token));
+    }
+    let label = parts.join(' › ') || '(whole document)';
+    if (field.type !== 'string')
+        label += ` (${field.type})`;
+    if (field.required)
+        label += ' *';
+    return label;
+}
+const DRAG_REFERENCE = /^=\s*\{\{\s*\$json((?:\??\.[A-Za-z_$][\w$]*|\??\.?\[\s*(?:\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*\])*)\s*\}\}\s*$/;
+const DRAG_SEGMENT = /\??\.([A-Za-z_$][\w$]*)|\??\.?\[\s*(\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*\]/g;
+function parseDragReference(raw, targetStars) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const match = DRAG_REFERENCE.exec(raw);
+    if (!match)
+        return undefined;
+    const tokens = [];
+    for (const m of match[1].matchAll(DRAG_SEGMENT)) {
+        if (m[1] !== undefined)
+            tokens.push({ kind: 'key', key: m[1] });
+        else if (/^\d+$/.test(m[2]))
+            tokens.push({ kind: 'index', index: Number(m[2]) });
+        else
+            tokens.push({ kind: 'key', key: m[2].slice(1, -1).replace(/\\(.)/g, '$1') });
+    }
+    const indexPositions = tokens.flatMap((t, i) => (t.kind === 'index' ? [i] : []));
+    if (indexPositions.length < targetStars)
+        return undefined;
+    for (const position of indexPositions.slice(indexPositions.length - targetStars)) {
+        tokens[position] = { kind: 'star' };
+    }
+    let path = '';
+    for (const token of tokens) {
+        if (token.kind === 'key')
+            path += formatKey(token.key, path === '');
+        else if (token.kind === 'index')
+            path += `[${token.index}]`;
+        else
+            path += '[*]';
+    }
+    return path;
+}
+async function getProfileFields() {
+    var _a;
+    let text = '';
+    try {
+        text = String((_a = this.getCurrentNodeParameter('targetProfile')) !== null && _a !== void 0 ? _a : '').trim();
+    }
+    catch {
+        text = '';
+    }
+    if (text === '')
+        return { fields: [], emptyFieldsNotice: 'Paste a target profile above to load its fields.' };
+    if (text.startsWith('=') || text.includes('{{')) {
+        return {
+            fields: [],
+            emptyFieldsNotice: 'The target profile comes from an expression, so its fields cannot be listed here. Paste the profile instead, or use Map Automatically.',
+        };
+    }
+    let format = 'auto';
+    try {
+        format = this.getCurrentNodeParameter('options.profileFormat') || 'auto';
+    }
+    catch {
+        format = 'auto';
+    }
+    let profile;
+    try {
+        profile = (0, profile_1.parseProfile)(text, format);
+    }
+    catch (error) {
+        return { fields: [], emptyFieldsNotice: `Could not read the target profile: ${error.message}` };
+    }
+    const sourceOptions = loadSourceOptions(this);
+    const fields = profile.fields.map((field) => ({
+        id: encodeFieldId(field.path),
+        displayName: fieldDisplayName(field),
+        required: false,
+        defaultMatch: false,
+        canBeUsedToMatch: false,
+        display: true,
+        ...(sourceOptions ? { type: 'options', options: sourceOptions } : {}),
+    }));
+    return { fields };
+}
+exports.SOURCE_PREFIX = 'src::';
+function loadSourceOptions(ctx) {
+    var _a;
+    let text = '';
+    let format = 'auto';
+    try {
+        text = String((_a = ctx.getCurrentNodeParameter('sourceProfile')) !== null && _a !== void 0 ? _a : '').trim();
+        format = ctx.getCurrentNodeParameter('options.sourceProfileFormat') || 'auto';
+    }
+    catch {
+        return undefined;
+    }
+    if (text === '' || text.startsWith('=') || text.includes('{{'))
+        return undefined;
+    let fields;
+    try {
+        fields = (0, profile_1.sourceFields)((0, profile_1.parseProfile)(text, format));
+    }
+    catch {
+        return undefined;
+    }
+    if (fields.length === 0)
+        return undefined;
+    return [
+        { name: '(Not Mapped)', value: '' },
+        ...fields.map((field) => ({ name: fieldDisplayName(field), value: `${exports.SOURCE_PREFIX}${field.path}` })),
+    ];
+}
+const typeTransform = (type) => type === 'number' ? 'number' : type === 'boolean' ? 'boolean' : 'none';
+const isEmpty = (v) => v === undefined || v === null || v === '' || v === '=';
+function starCount(path) {
+    return (0, mapping_1.parsePath)(path).filter((t) => t === '*').length;
+}
+function parseSourceText(ctx, text, itemIndex) {
+    const trimmed = text.replace(/^\uFEFF/, '').trim();
+    if (trimmed.startsWith('<')) {
+        return (0, xml_1.xmlToJson)((0, xml_1.parseXml)(trimmed), {
+            attributes: 'group',
+            attributeKey: '$',
+            textKey: '_',
+            includeRoot: true,
+            alwaysArray: false,
+            trim: true,
+        });
+    }
+    const parsed = tryJson(trimmed);
+    if (parsed.ok)
+        return parsed.value;
+    throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'The source text is neither valid JSON nor XML', {
+        itemIndex,
+        description: parsed.error,
+    });
+}
+function tryJson(text) {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+}
+async function readSource(ctx, item, itemIndex, options) {
+    var _a, _b;
+    const sourceData = ctx.getNodeParameter('sourceData', itemIndex, 'item');
+    const binaryField = (sourceData === 'binary'
+        ? ctx.getNodeParameter('sourceDataBinary', itemIndex, 'data')
+        : String((_a = options.sourceBinaryField) !== null && _a !== void 0 ? _a : '')).trim();
+    if (binaryField) {
+        ctx.helpers.assertBinaryData(itemIndex, binaryField);
+        const text = (await ctx.helpers.getBinaryDataBuffer(itemIndex, binaryField)).toString('utf8');
+        return parseSourceText(ctx, text, itemIndex);
+    }
+    const field = (sourceData === 'field'
+        ? ctx.getNodeParameter('sourceDataField', itemIndex, 'data')
+        : String((_b = options.sourceField) !== null && _b !== void 0 ? _b : '')).trim();
+    if (field) {
+        const value = item.json[field];
+        if (value === undefined) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Source field "${field}" does not exist`, { itemIndex });
+        }
+        return typeof value === 'object' ? value : parseSourceText(ctx, String(value), itemIndex);
+    }
+    return item.json;
+}
+async function readProfile(ctx, itemIndex, options, cache) {
+    var _a, _b;
+    const binaryField = String((_a = options.profileBinaryField) !== null && _a !== void 0 ? _a : '').trim();
+    let text;
+    if (binaryField) {
+        ctx.helpers.assertBinaryData(itemIndex, binaryField);
+        text = (await ctx.helpers.getBinaryDataBuffer(itemIndex, binaryField)).toString('utf8').trim();
+    }
+    else {
+        text = String((_b = ctx.getNodeParameter('targetProfile', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim();
+    }
+    if (text === '')
+        return undefined;
+    const format = options.profileFormat || 'auto';
+    const key = `${format}\u0000${text}`;
+    if (!cache.has(key))
+        cache.set(key, (0, profile_1.parseProfile)(text, format));
+    return cache.get(key);
+}
+function buildDropRules(raw, resolved, profile, options) {
+    var _a, _b;
+    const fieldsById = new Map(((_a = profile === null || profile === void 0 ? void 0 : profile.fields) !== null && _a !== void 0 ? _a : []).map((f) => [encodeFieldId(f.path), f]));
+    const sourceRules = [];
+    const spreadRules = [];
+    const broadcastRules = [];
+    const valueRules = [];
+    const ids = [...new Set([...Object.keys(raw), ...Object.keys(resolved)])];
+    for (const id of ids) {
+        const target = decodeFieldId(id);
+        const rawValue = raw[id];
+        const value = resolved[id];
+        if (isEmpty(rawValue) && isEmpty(value)) {
+            if (options.keepEmpty)
+                valueRules.push({ value: '', target });
+            continue;
+        }
+        const transform = options.convertTypes ? typeTransform((_b = fieldsById.get(id)) === null || _b === void 0 ? void 0 : _b.type) : 'none';
+        const stars = starCount(target);
+        const picked = typeof rawValue === 'string' && rawValue.startsWith(exports.SOURCE_PREFIX) ? rawValue.slice(exports.SOURCE_PREFIX.length) : undefined;
+        const source = picked === undefined ? parseDragReference(rawValue, stars) : undefined;
+        const loose = picked !== null && picked !== void 0 ? picked : (source === undefined && stars > 0 ? parseDragReference(rawValue, 0) : undefined);
+        if (source !== undefined) {
+            sourceRules.push({ source, target, transform, lenient: true });
+        }
+        else if (loose !== undefined) {
+            (starCount(loose) >= stars ? sourceRules : broadcastRules).push({
+                source: loose,
+                target,
+                transform,
+                lenient: true,
+                broadcast: true,
+            });
+        }
+        else if (stars > 0 && Array.isArray(value)) {
+            spreadRules.push({ value, target, transform, lenient: true, spread: true });
+        }
+        else {
+            valueRules.push({ value: value !== null && value !== void 0 ? value : '', target, transform, lenient: true });
+        }
+    }
+    return [...sourceRules, ...spreadRules, ...broadcastRules, ...valueRules];
+}
+function buildRules(ctx, itemIndex, source, profile, options) {
+    var _a, _b;
+    const mapping = ctx.getNodeParameter('mapping', itemIndex, undefined, { skipValidation: true });
+    const convertTypes = options.convertTypes !== false;
+    if ((mapping === null || mapping === void 0 ? void 0 : mapping.mappingMode) === 'autoMapInputData') {
+        if (!profile) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Map Automatically needs a target profile. Paste one into the Target Profile box.', { itemIndex });
+        }
+        const result = (0, profile_1.autoMap)((0, profile_1.flattenSource)(source), profile, {
+            threshold: typeof options.threshold === 'number' ? options.threshold : 0.6,
+            strategy: 'fuzzy',
+            caseSensitive: false,
+            reuseSources: false,
+            unmatched: options.keepEmpty ? 'null' : 'skip',
+            synonyms: (0, profile_1.parseSynonyms)(options.synonyms),
+        });
+        const rules = result.rules.map((rule) => ({
+            ...rule,
+            transform: convertTypes && rule.transform !== 'date' ? rule.transform : 'none',
+            lenient: true,
+        }));
+        const built = { rules };
+        if (options.autoMapReport === true) {
+            built.report = { matched: result.matched, unmatched: result.unmatched };
+        }
+        return built;
+    }
+    const raw = ((_a = ctx.getNodeParameter('mapping.value', itemIndex, {}, { rawExpressions: true, skipValidation: true })) !== null && _a !== void 0 ? _a : {});
+    const resolved = ((_b = mapping === null || mapping === void 0 ? void 0 : mapping.value) !== null && _b !== void 0 ? _b : {});
+    return {
+        rules: buildDropRules(raw, resolved, profile, { convertTypes, keepEmpty: options.keepEmpty === true }),
+    };
+}
+function profileOrder(profile) {
+    const root = { children: new Map() };
+    for (const field of profile.fields) {
+        let node = root;
+        for (const token of (0, mapping_1.parsePath)(field.path)) {
+            if (!node.children.has(token))
+                node.children.set(token, { children: new Map() });
+            node = node.children.get(token);
+        }
+    }
+    return root;
+}
+function reorder(value, node) {
+    var _a;
+    if (Array.isArray(value)) {
+        const element = node === null || node === void 0 ? void 0 : node.children.get('*');
+        return value.map((entry) => reorder(entry, element));
+    }
+    if (value === null || typeof value !== 'object' || value instanceof Date)
+        return value;
+    const input = value;
+    const output = {};
+    for (const key of (_a = node === null || node === void 0 ? void 0 : node.children.keys()) !== null && _a !== void 0 ? _a : []) {
+        if (typeof key === 'string' && key !== '*' && Object.prototype.hasOwnProperty.call(input, key)) {
+            (0, mapping_1.setOwn)(output, key, reorder(input[key], node.children.get(key)));
+        }
+    }
+    for (const key of Object.keys(input)) {
+        if (!Object.prototype.hasOwnProperty.call(output, key))
+            (0, mapping_1.setOwn)(output, key, reorder(input[key], node === null || node === void 0 ? void 0 : node.children.get(key)));
+    }
+    return output;
+}
+function orderByProfile(mapped, profile) {
+    if (!profile || profile.fields.length === 0)
+        return mapped;
+    return reorder(mapped, profileOrder(profile));
+}
+function csvColumns(profile, records) {
+    if (profile && profile.fields.length > 0) {
+        return profile.fields.map((field) => ({
+            path: field.path,
+            header: profile.kind === 'csv' ? field.name : field.path.replace(/\[\*\]/g, '').replace(/\$\./g, '@'),
+        }));
+    }
+    const seen = new Set();
+    const columns = [];
+    for (const record of records) {
+        for (const { path } of (0, profile_1.flattenSource)(record)) {
+            if (seen.has(path))
+                continue;
+            seen.add(path);
+            columns.push({ path, header: path.replace(/\[\*\]/g, '') });
+        }
+    }
+    return columns;
+}
+function csvText(records, profile, options) {
+    var _a;
+    return (0, csv_1.toCsv)(records, csvColumns(profile, records), {
+        delimiter: String((_a = options.csvDelimiter) !== null && _a !== void 0 ? _a : ',') || ',',
+        header: options.csvHeader !== false,
+        lineEnding: options.csvLineEnding === 'crlf' ? '\r\n' : '\n',
+        escapeFormulas: options.csvEscapeFormulas === true,
+    });
+}
+const MIME = { json: 'application/json', xml: 'application/xml', csv: 'text/csv' };
+async function textOutput(ctx, format, text, itemIndex) {
+    const outputAs = ctx.getNodeParameter('outputAs', itemIndex, 'item');
+    if (outputAs === 'file') {
+        const field = ctx.getNodeParameter('binaryField', itemIndex, 'data');
+        const fileName = ctx.getNodeParameter('fileName', itemIndex, '') || `output.${format}`;
+        const binary = await ctx.helpers.prepareBinaryData(Buffer.from(text, 'utf8'), fileName, MIME[format]);
+        return { json: {}, binary: { [field]: binary } };
+    }
+    const field = ctx.getNodeParameter('outputField', itemIndex, '') || format;
+    return { json: { [field]: text } };
+}
+async function writeOne(ctx, format, mapped, itemIndex, profile, options, report) {
+    var _a;
+    if (format === 'json') {
+        const outputAs = ctx.getNodeParameter('outputAs', itemIndex, 'item');
+        if (outputAs === 'item')
+            return { json: (report ? { ...mapped, _autoMap: report } : mapped) };
+        return textOutput(ctx, 'json', JSON.stringify(mapped, null, 2), itemIndex);
+    }
+    if (format === 'xml') {
+        const xml = (0, xml_1.jsonToXml)(mapped, {
+            rootName: String((_a = options.rootElement) !== null && _a !== void 0 ? _a : '').trim() || ((profile === null || profile === void 0 ? void 0 : profile.kind) === 'sampleXml' ? profile.rootName : undefined),
+            declaration: options.xmlDeclaration !== false,
+            attributeKey: '$',
+            textKey: '_',
+        });
+        return textOutput(ctx, 'xml', xml, itemIndex);
+    }
+    return textOutput(ctx, 'csv', csvText([mapped], profile, options), itemIndex);
+}
+function toNodeError(ctx, error, itemIndex) {
+    if (error instanceof n8n_workflow_1.NodeOperationError)
+        return error;
+    const known = error instanceof mapping_1.MappingError || error instanceof xml_1.XmlParseError || error instanceof profile_1.ProfileError;
+    return new n8n_workflow_1.NodeOperationError(ctx.getNode(), error.message, {
+        itemIndex,
+        description: known ? undefined : 'Unexpected error while mapping this item',
+    });
+}
+async function executeVisual() {
+    const items = this.getInputData();
+    const format = this.getNodeParameter('targetFormat', 0, 'json');
+    const firstOptions = this.getNodeParameter('options', 0, {});
+    const combineCsv = format === 'csv' && firstOptions.csvCombine !== false;
+    const cache = new Map();
+    const returnData = [];
+    const csvRecords = [];
+    let csvProfile;
+    for (let i = 0; i < items.length; i++) {
+        try {
+            const options = this.getNodeParameter('options', i, {});
+            const source = await readSource(this, items[i], i, options);
+            const profile = await readProfile(this, i, options, cache);
+            const { rules, report } = buildRules(this, i, source, profile, options);
+            const mapped = orderByProfile((0, mapping_1.applyMappings)(source, rules, {}), profile);
+            if (combineCsv) {
+                csvRecords.push({ mapped, index: i });
+                csvProfile !== null && csvProfile !== void 0 ? csvProfile : (csvProfile = profile);
+                continue;
+            }
+            const output = await writeOne(this, format, mapped, i, profile, options, report);
+            returnData.push({ ...output, pairedItem: { item: i } });
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                continue;
+            }
+            throw toNodeError(this, error, i);
+        }
+    }
+    if (combineCsv && csvRecords.length > 0) {
+        const text = csvText(csvRecords.map((r) => r.mapped), csvProfile, firstOptions);
+        const output = await textOutput(this, 'csv', text, 0);
+        returnData.push({ ...output, pairedItem: csvRecords.map((r) => ({ item: r.index })) });
+    }
+    return [returnData];
+}
+//# sourceMappingURL=visual.js.map