xml-from-object/dist/xml-from-object.js

Easy, highly typed and customizable way to build your xml using JS/TS plain objects.

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.xmlFromObject = exports.XmlFromObject = void 0;
var helpers_1 = require("./helpers");
/**
 * Class way to transform a Javascript plain object into XML
 */
var XmlFromObject = /** @class */ (function () {
    function XmlFromObject() {
        /**
         * Transform a Javascript plain object into XML
         * @param {object} schemaConfig.schema - The typed schema with fields and configs to create the XML.
         * @param {object} [schemaConfig.header] - (Optional) The xml header (typically "<?xml version...>").
         *
         */
        this.fromObject = xmlFromObject;
    }
    return XmlFromObject;
}());
exports.XmlFromObject = XmlFromObject;
/**
 * Functional way to transform a Javascript plain object into XML
 * @param {object} schemaConfig.schema - The typed schema with fields and configs to create the XML.
 * @param {object} [schemaConfig.header] - (Optional) The xml header (typically "<?xml version...>").
 */
function xmlFromObject(schemaConfig) {
    if (!schemaConfig.header)
        return parseSchemaToXml(schemaConfig.schema);
    var parsedHeader = parseXmlHeader(schemaConfig.header);
    var parsedSchema = parseSchemaToXml(schemaConfig.schema);
    return parsedHeader + parsedSchema;
}
exports.xmlFromObject = xmlFromObject;
function parseXmlHeader(header) {
    if (header.custom !== undefined)
        return header.custom;
    return "<?xml version=\"".concat(header.version, "\" encoding=\"").concat(header.encoding, "\"?>");
}
function parseSchemaToXml(schema) {
    var resultInArray = Object.entries(schema).map(function (_a) {
        var _b = _a, _c = __read(_b, 2), key = _c[0], _d = _c[1], untypedValue = _d.value, fieldConfig = __rest(_d, ["value"]);
        var _e = getValueType(untypedValue), value = _e.value, type = _e.type;
        switch (type) {
            case "array-of-object":
                return parseTagForArrayOfObjects(key, value, fieldConfig);
            case "array-of-string":
                return parseTagForArrayOfString(key, value, fieldConfig);
            case "object":
                return parseTagForObject(key, value, fieldConfig);
            case "string":
                return parseTagForString(key, value, fieldConfig);
            case "self-closing":
                return parseSelfClosingTag(key);
        }
    });
    return resultInArray.join("");
}
function getValueType(value) {
    if (value === undefined || value === null)
        return { type: "self-closing", value: undefined };
    if ((0, helpers_1.isArrayOfObject)(value))
        return { type: "array-of-object", value: value };
    if ((0, helpers_1.isArrayOfString)(value))
        return { type: "array-of-string", value: value };
    if (typeof value === "object")
        return { type: "object", value: value };
    return { type: "string", value: String(value) };
}
function parseTagForArrayOfObjects(key, values, config) {
    var nestedTagsAsArrayOfString = values.map(parseSchemaToXml);
    var nestedTags = nestedTagsAsArrayOfString.join("");
    return keyValueToXmlTag(key, nestedTags, config);
}
function parseTagForArrayOfString(key, value, config) {
    return keyValueToXmlTag(key, value.join(), config);
}
function parseTagForObject(key, value, config) {
    var nestedValue = parseSchemaToXml(value);
    return keyValueToXmlTag(key, nestedValue, config);
}
function parseTagForString(key, value, config) {
    return keyValueToXmlTag(key, value, config);
}
function parseSelfClosingTag(key) {
    return "<".concat(key, "/>");
}
function keyValueToXmlTag(key, value, config) {
    var parsedKey = parseKey(key, config);
    var parsedValue = parseValue(value, config);
    return parsedKey.start + parsedValue + parsedKey.end;
}
function parseValue(value, config) {
    var _a;
    if ((_a = config.options) === null || _a === void 0 ? void 0 : _a.cdata)
        return wrapWithCdata(value);
    return value;
}
function wrapWithCdata(value) {
    return "<![CDATA[".concat(value, "]]>");
}
function parseKey(key, config) {
    var start = parseStartOfKey(key, config);
    var end = "</".concat(key, ">");
    return { start: start, end: end };
}
function parseStartOfKey(key, config) {
    if (!config.attributes)
        return "<".concat(key, ">");
    return "<".concat(key, " ").concat(parseKeyAttributes(config.attributes), ">");
}
function parseKeyAttributes(attributes) {
    var attributesInArray = Object.entries(attributes).map(function (_a) {
        var _b = __read(_a, 2), key = _b[0], value = _b[1];
        return parseAttribute(key, value);
    });
    return attributesInArray.join(" ");
}
function parseAttribute(key, value) {
    return "".concat(key, "=\"").concat(value, "\"");
}
//# sourceMappingURL=xml-from-object.js.map