"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.XmlProcessor = exports.DomParserProvider = exports.Utils = void 0;
const osfmos_1 = require("../lib/osfmos");
const xmldom_1 = require("@xmldom/xmldom");
var Utils;
(function (Utils) {
    function validateParams(params, expectedParams, ParameterCount) {
        var e, expectedLength = expectedParams.length;
        ParameterCount = ParameterCount || (typeof (ParameterCount) === "undefined");
        e = validateParameterCount(params, expectedParams, ParameterCount);
        if (e) {
            return e;
        }
        for (var i = 0, l = params.length; i < l; i++) {
            var expectedParam = expectedParams[Math.min(i, expectedLength - 1)], paramName = expectedParam.name;
            if (expectedParam.parameterArray) {
                paramName += "[" + (i - expectedLength + 1) + "]";
            }
            else if (!ParameterCount && (i >= expectedLength)) {
                break;
            }
            e = validateParameter(params[i], expectedParam, paramName);
            if (e) {
                e.popStackFrame();
                return e;
            }
        }
        return null;
    }
    Utils.validateParams = validateParams;
    function validateParameter(param, expectedParam, paramName) {
        var e, expectedType = expectedParam.type, expectedInteger = !!expectedParam.integer, expectedDomElement = !!expectedParam.domElement, mayBeNull = !!expectedParam.mayBeNull;
        e = validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName);
        if (e) {
            e.popStackFrame();
            return e;
        }
        var expectedElementType = expectedParam.elementType, elementMayBeNull = !!expectedParam.elementMayBeNull;
        if (expectedType === Array && typeof (param) !== "undefined" && param !== null &&
            (expectedElementType || !elementMayBeNull)) {
            var expectedElementInteger = !!expectedParam.elementInteger, expectedElementDomElement = !!expectedParam.elementDomElement;
            for (var i = 0; i < param.length; i++) {
                var elem = param[i];
                e = validateParameterType(elem, expectedElementType, expectedElementInteger, expectedElementDomElement, elementMayBeNull, paramName + "[" + i + "]");
                if (e) {
                    e.popStackFrame();
                    return e;
                }
            }
        }
        return null;
    }
    Utils.validateParameter = validateParameter;
    ;
    function validateParameterCount(params, expectedParams, validateParameterCount) {
        var i, error, expectedLen = expectedParams.length, actualLen = params.length;
        if (actualLen < expectedLen) {
            var minParams = expectedLen;
            for (i = 0; i < expectedLen; i++) {
                var param = expectedParams[i];
                if (param.optional || param.parameterArray) {
                    minParams--;
                }
            }
            if (actualLen < minParams) {
                error = true;
            }
        }
        else if (validateParameterCount && (actualLen > expectedLen)) {
            error = true;
            for (i = 0; i < expectedLen; i++) {
                if (expectedParams[i].parameterArray) {
                    error = false;
                    break;
                }
            }
        }
        if (error) {
            var e = osfmos_1.OfficeExt.MsAjaxError.parameterCount();
            return e;
        }
        return null;
    }
    Utils.validateParameterCount = validateParameterCount;
    function validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName) {
        var e, i;
        if (typeof (param) === "undefined") {
            if (mayBeNull) {
                return null;
            }
            else {
                e = osfmos_1.OfficeExt.MsAjaxError.argumentUndefined(paramName);
                e.popStackFrame();
                return e;
            }
        }
        if (param === null) {
            if (mayBeNull) {
                return null;
            }
            else {
                e = osfmos_1.OfficeExt.MsAjaxError.argumentNull(paramName);
                e.popStackFrame();
                return e;
            }
        }
        if (expectedType && !osfmos_1.OfficeExt.MsAjaxTypeHelper.isInstanceOfType(expectedType, param)) {
            e = osfmos_1.OfficeExt.MsAjaxError.argumentType(paramName, typeof (param), expectedType);
            e.popStackFrame();
            return e;
        }
        return null;
    }
    Utils.validateParameterType = validateParameterType;
    function getDomainForUrl(url) {
        if (!url) {
            return null;
        }
        var urlObject = osfmos_1.OSF.OUtil.parseUrl(url, true);
        return urlObject.protocol + "//" + urlObject.host;
    }
    Utils.getDomainForUrl = getDomainForUrl;
    function OverrideMethods() {
        osfmos_1.OSF.XmlProcessor = XmlProcessor;
        osfmos_1.OfficeExt.WACUtils.getDomainForUrl = Utils.getDomainForUrl;
    }
    Utils.OverrideMethods = OverrideMethods;
})(Utils || (exports.Utils = Utils = {}));
class DomParserProvider {
    constructor(xml, xmlNamespaces) {
        try {
            this._xmldoc = new xmldom_1.DOMParser({}).parseFromString(xml, "text/xml");
        }
        catch (ex) {
            console.trace("xml doc creating error:" + ex);
        }
        this._namespaceMapping = {};
        this._defaultNamespace = null;
        var namespaces = xmlNamespaces.split(' ');
        var matches;
        for (var i = 0; i < namespaces.length; ++i) {
            matches = /xmlns="([^"]*)"/g.exec(namespaces[i]);
            if (matches) {
                this._defaultNamespace = matches[1];
                continue;
            }
            matches = /xmlns:([^=]*)="([^"]*)"/g.exec(namespaces[i]);
            if (matches) {
                this._namespaceMapping[matches[1]] = matches[2];
                continue;
            }
        }
    }
    addNamespaceMapping(namespacePrefix, namespaceUri) {
        var ns = this._namespaceMapping[namespacePrefix];
        if (ns) {
            return false;
        }
        else {
            this._namespaceMapping[namespacePrefix] = namespaceUri;
            return true;
        }
    }
    getNamespaceMapping() {
        return this._namespaceMapping;
    }
    selectSingleNode(name, contextNode) {
        var selectedNode = contextNode || this._xmldoc;
        var nodes = this._selectNodes(name, selectedNode);
        if (nodes.length === 0)
            return null;
        return nodes[0];
    }
    selectNodes(name, contextNode) {
        var selectedNode = contextNode || this._xmldoc;
        return this._selectNodes(name, selectedNode);
    }
    selectNodesByXPath(xpath, contextNode) {
        return null;
    }
    _selectNodes(name, contextNode) {
        var nodes = [];
        if (!name)
            return nodes;
        var nameInfo = name.split(":");
        var ns, nodeName;
        if (nameInfo.length === 1) {
            ns = null;
            nodeName = nameInfo[0];
        }
        else if (nameInfo.length === 2) {
            ns = this._namespaceMapping[nameInfo[0]];
            nodeName = nameInfo[1];
        }
        else {
            throw osfmos_1.OfficeExt.MsAjaxError.argument("name");
        }
        if (!contextNode.hasChildNodes)
            return nodes;
        var childs = contextNode.childNodes;
        for (var i = 0; i < childs.length; i++) {
            if (nodeName === this._removeNodePrefix(childs[i].nodeName) && (ns === childs[i].namespaceURI)) {
                nodes.push(childs[i]);
            }
        }
        return nodes;
    }
    _removeNodePrefix(nodeName) {
        if (!nodeName)
            return null;
        var nodeInfo = nodeName.split(':');
        if (nodeInfo.length === 1) {
            return nodeName;
        }
        else {
            return nodeInfo[1];
        }
    }
    getDocumentElement() {
        return this._xmldoc.documentElement;
    }
}
exports.DomParserProvider = DomParserProvider;
class XmlProcessor {
    constructor(xml, xmlNamespaces) {
        var e = Utils.validateParams(arguments, [
            { name: "xml", type: String, mayBeNull: false },
            { name: "xmlNamespaces", type: String, mayBeNull: false }
        ]);
        if (e)
            throw e;
        this._provider = new DomParserProvider(xml, xmlNamespaces);
    }
    addNamespaceMapping(namespacePrefix, namespaceUri) {
        var e = Utils.validateParams(arguments, [
            { name: "namespacePrefix", type: String, mayBeNull: false },
            { name: "namespaceUri", type: String, mayBeNull: false }
        ]);
        if (e)
            throw e;
        return this._provider.addNamespaceMapping(namespacePrefix, namespaceUri);
    }
    getNamespaceMapping() {
        var _a;
        return (_a = this._provider) === null || _a === void 0 ? void 0 : _a.getNamespaceMapping();
    }
    selectSingleNode(name, contextNode) {
        var e = Utils.validateParams(arguments, [
            { name: "name", type: String, mayBeNull: false },
            { name: "contextNode", mayBeNull: true, optional: true }
        ]);
        if (e)
            throw e;
        return this._provider.selectSingleNode(name, contextNode);
    }
    selectNodes(name, contextNode) {
        var e = Utils.validateParams(arguments, [
            { name: "name", type: String, mayBeNull: false },
            { name: "contextNode", mayBeNull: true, optional: true }
        ]);
        if (e)
            throw e;
        return this._provider.selectNodes(name, contextNode);
    }
    selectNodesByXPath(xpath, contextNode) {
        var e = Utils.validateParams(arguments, [
            { name: "xpath", type: String, mayBeNull: false },
            { name: "contextNode", mayBeNull: true, optional: true }
        ]);
        if (e)
            throw e;
        contextNode = contextNode || this._provider.getDocumentElement();
        return this._provider.selectNodesByXPath(xpath, contextNode);
    }
    getDocumentElement() {
        return this._provider.getDocumentElement();
    }
    getNodeValue(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var nodeValue;
        if (node.text) {
            nodeValue = node.text;
        }
        else {
            nodeValue = node.textContent;
        }
        return nodeValue;
    }
    getNodeText(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        if (this.getNodeType(node) == 9) {
            return this.getNodeText(this.getDocumentElement());
        }
        var nodeText;
        if (node.text) {
            nodeText = node.text;
        }
        else {
            nodeText = node.textContent;
        }
        return nodeText;
    }
    setNodeText(node, text) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false },
            { name: "text", type: String, mayBeNull: false }
        ]);
        if (e)
            throw e;
        if (this.getNodeType(node) == 9) {
            return false;
        }
        try {
            if (node.text) {
                node.text = text;
            }
            else {
                node.textContent = text;
            }
        }
        catch (ex) {
            return false;
        }
        return true;
    }
    getNodeXml(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var nodeXml;
        if (node.xml) {
            nodeXml = node.xml;
        }
        else {
            nodeXml = new XMLSerializer().serializeToString(node);
            if (this.getNodeType(node) == 2) {
                nodeXml = this.getNodeBaseName(node) + "=\"" + nodeXml + "\"";
            }
        }
        return nodeXml;
    }
    setNodeXml(node, xml) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false },
            { name: "xml", type: String, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var processor = new osfmos_1.OSF.XmlProcessor(xml, "");
        if (!processor.isValidXml()) {
            return null;
        }
        var newNode = processor.getDocumentElement();
        try {
            node.parentNode.replaceChild(newNode, node);
        }
        catch (ex) {
            return null;
        }
        return newNode;
    }
    getNodeNamespaceURI(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        return node.namespaceURI;
    }
    getNodePrefix(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        return node.prefix;
    }
    getNodeBaseName(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var nodeBaseName;
        if (node.nodeType && (node.nodeType == 1 || node.nodeType == 2)) {
            if (node.baseName) {
                nodeBaseName = node.baseName;
            }
            else {
                nodeBaseName = node.localName;
            }
        }
        else {
            nodeBaseName = node.nodeName;
        }
        return nodeBaseName;
    }
    getNodeType(node) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        return node.nodeType;
    }
    appendChild(node, childXml) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false },
            { name: "childXml", type: String, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var processor = new osfmos_1.OSF.XmlProcessor(childXml, "");
        if (!processor.isValidXml()) {
            return null;
        }
        var childNode = processor.getDocumentElement();
        node.appendChild(childNode);
        return childNode;
    }
    _getAttributeLocalName(attribute) {
        var localName;
        if (attribute.localName) {
            localName = attribute.localName;
        }
        else {
            localName = attribute.baseName;
        }
        return localName;
    }
    readAttributes(node, attributesToRead, objectToFill) {
        var e = Utils.validateParams(arguments, [
            { name: "node", type: Object, mayBeNull: false },
            { name: "attributesToRead", type: Object, mayBeNull: false },
            { name: "objectToFill", type: Object, mayBeNull: false }
        ]);
        if (e)
            throw e;
        var attribute;
        var localName;
        for (var i = 0; i < node.attributes.length; i++) {
            attribute = node.attributes[i];
            localName = this._getAttributeLocalName(attribute);
            for (var p in attributesToRead) {
                if (localName === p) {
                    objectToFill[attributesToRead[p]] = attribute.value;
                }
            }
        }
    }
    isValidXml() {
        var documentElement = this.getDocumentElement();
        if (documentElement == null) {
            return false;
        }
        else if (this._provider._xmldoc.getElementsByTagName("parsererror").length > 0) {
            var parser = new xmldom_1.DOMParser();
            var errorParse = parser.parseFromString('<', 'text/xml');
            var parseErrorNS = errorParse.getElementsByTagName("parsererror")[0].namespaceURI;
            return this._provider._xmldoc.getElementsByTagNameNS(parseErrorNS, 'parsererror').length <= 0;
        }
        return true;
    }
}
exports.XmlProcessor = XmlProcessor;
//# sourceMappingURL=osfUtils.js.map