add CI config file

ts/Global/domGenerator.js

+"use strict";
+exports.__esModule = true;
+var EStatementAlignement;
+(function (EStatementAlignement) {
+    EStatementAlignement[EStatementAlignement["Top"] = 0] = "Top";
+    EStatementAlignement[EStatementAlignement["Bottom"] = 1] = "Bottom";
+    EStatementAlignement[EStatementAlignement["Middle"] = 2] = "Middle";
+    EStatementAlignement[EStatementAlignement["Left"] = 3] = "Left";
+    EStatementAlignement[EStatementAlignement["Right"] = 4] = "Right";
+})(EStatementAlignement = exports.EStatementAlignement || (exports.EStatementAlignement = {}));
+function getAlignementType(alignement) {
+    switch (alignement) {
+        case "top":
+        case 0:
+            return EStatementAlignement.Top;
+        case "bottom":
+        case 1:
+            return EStatementAlignement.Bottom;
+        case "middle":
+        case 2:
+            return EStatementAlignement.Middle;
+        case "left":
+        case 3:
+            return EStatementAlignement.Left;
+        case "right":
+        case 4:
+            return EStatementAlignement.Right;
+    }
+}
+exports.getAlignementType = getAlignementType;
+function getAlignementTypeText(alignement) {
+    switch (alignement) {
+        case EStatementAlignement.Top:
+            return '"top"';
+        case EStatementAlignement.Bottom:
+            return '"bottom"';
+        case EStatementAlignement.Middle:
+            return '"middle"';
+        case EStatementAlignement.Left:
+            return '"left"';
+        case EStatementAlignement.Right:
+            return '"right"';
+    }
+}
+exports.getAlignementTypeText = getAlignementTypeText;
+/**
+ * DOMGenerator
+ */
+var DOMGenerator = /** @class */ (function () {
+    function DOMGenerator() {
+    }
+    DOMGenerator.prototype.GetMain = function () {
+        var main = document.getElementById("main");
+        if (main !== null)
+            return main;
+        main = document.createElement("div");
+        main.id = "main";
+        document.body.appendChild(main);
+        return main;
+    };
+    DOMGenerator.prototype.CleanMain = function (jokers, stillDisplay) {
+        var main = this.GetMain();
+        if (jokers) {
+            var found = false;
+            for (var iterator = 0; iterator < main.childNodes.length; iterator++) {
+                found = false;
+                var htmlchildNode = main.childNodes[iterator];
+                for (var iterator2 = 0; iterator2 < jokers.length; iterator2++) {
+                    if (jokers[iterator2] === htmlchildNode.id) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    main.removeChild(main.childNodes[iterator]);
+                    iterator--;
+                }
+                else if (!stillDisplay)
+                    htmlchildNode.style.display = "none";
+            }
+        }
+        else {
+            while (main.firstChild)
+                main.removeChild(main.firstChild);
+        }
+    };
+    DOMGenerator.prototype.CleanNodeByName = function (name, jokers) {
+        var main = document.getElementById(name);
+        if (jokers) {
+            var found = false;
+            for (var iterator = 0; iterator < main.childNodes.length; iterator++) {
+                found = false;
+                for (var iterator2 = 0; iterator2 < jokers.length; iterator2++) {
+                    var htmlchildNode = main.childNodes[iterator];
+                    if (jokers[iterator2] === htmlchildNode.id) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    main.removeChild(main.childNodes[iterator]);
+                    iterator--;
+                }
+            }
+        }
+        else {
+            while (main.firstChild)
+                main.removeChild(main.firstChild);
+        }
+    };
+    DOMGenerator.prototype.CleanNode = function (node, jokers) {
+        if (jokers) {
+            var found = false;
+            for (var iterator = 0; iterator < node.childNodes.length; iterator++) {
+                found = false;
+                for (var iterator2 = 0; iterator2 < jokers.length; iterator2++) {
+                    var htmlchildNode = node.childNodes[iterator];
+                    if (jokers[iterator2] === htmlchildNode.id) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    node.removeChild(node.childNodes[iterator]);
+                    iterator--;
+                }
+            }
+        }
+        else {
+            while (node.firstChild)
+                node.removeChild(node.firstChild);
+        }
+    };
+    DOMGenerator.prototype.GetParentWithId = function (node, joker, returnOnFirst) {
+        if (node.id) {
+            if (returnOnFirst)
+                return node;
+            else
+                node = node.parentNode;
+        }
+        while (!node.id || (joker && node.id.includes(joker))) {
+            if (!node.parentNode)
+                return node;
+            node = node.parentNode;
+        }
+        return node;
+    };
+    DOMGenerator.prototype.GetParentWithClassName = function (node, className) {
+        if (node.className.includes(className))
+            return node;
+        while (true) {
+            if (node.className.includes(className))
+                return node;
+            if (!node.parentNode)
+                return null;
+            node = node.parentNode;
+        }
+        return null;
+    };
+    DOMGenerator.prototype.GetParentWithType = function (node, type) {
+        if (node.tagName.includes(type))
+            return node;
+        while (true) {
+            if (node.tagName && node.tagName.includes(type))
+                return node;
+            else if (node.nodeName && node.nodeName.includes(type))
+                return node;
+            if (!node.parentNode)
+                return null;
+            node = node.parentNode;
+        }
+        return null;
+    };
+    DOMGenerator.prototype.GenSubTitle = function (title, content, tooltipContent, isOptional, buttonInnerHTML, buttonFunctor) {
+        var mainContent = document.createElement('div');
+        mainContent.style.marginTop = "50px";
+        var titleObj = mainContent.appendChild(document.createElement('div'));
+        Object.assign(titleObj.style, { color: "#000", marginBottom: "20px", fontVariant: "small-caps", fontWeight: "bold", fontSize: "28px", textShadow: "2px 2px 4px #aaa" });
+        var titleDiv = titleObj.appendChild(document.createElement("div"));
+        titleDiv.appendChild(document.createTextNode(title));
+        if (isOptional) {
+            titleObj.appendChild(document.createElement("br"));
+            var hideButton = titleObj.appendChild(document.createElement("button"));
+            hideButton.innerHTML = buttonInnerHTML; //configuration.optionnalPartDeactivate;
+            //isActive[isOptional]=true;
+            hideButton.id = "active" + isOptional;
+            hideButton.onclick = function (variable) { return function (event) { buttonFunctor(event, variable); /*if(content.style.display==="none"){QAnalysisGenerator.ShowHideContent(content,"",event.target,configuration.optionnalPartDeactivate);AdminHistory.StoreInHistoric(variable,"set",true);isActive[variable]=true;}else{QAnalysisGenerator.ShowHideContent(content,"none",event.target,configuration.optionnalPartActivate);AdminHistory.StoreInHistoric(variable,"set",false);isActive[variable]=false;}/*if(document.getElementById("texts").childNodes.length)QAnalysisGenerator.GenerateWallOfTexts();*/ }; }(isOptional);
+        }
+        mainContent.appendChild(content);
+        if (tooltipContent && tooltipContent.length > 1) {
+            titleDiv.className += "tooltip";
+            var tooltip = titleDiv.appendChild(document.createElement("span"));
+            tooltip.className = "tooltiptext";
+            tooltip.innerHTML = tooltipContent;
+        }
+        return (mainContent);
+    };
+    DOMGenerator.prototype.GetChildsIds = function (container, functor, joker) {
+        if (!container)
+            return null;
+        var data = new Set();
+        for (var iterator = 0; iterator < container.childElementCount; iterator++) {
+            var htmlchildNode = container.childNodes[iterator];
+            if ((!htmlchildNode.id || joker && htmlchildNode.id.includes(joker)) && htmlchildNode.childElementCount > 0) {
+                var dataSecondary = this.GetChildsIds(container.childNodes[iterator], functor);
+                for (var _i = 0, dataSecondary_1 = dataSecondary; _i < dataSecondary_1.length; _i++) {
+                    var currentNumber = dataSecondary_1[_i];
+                    data.add(currentNumber);
+                }
+            }
+            else {
+                if (htmlchildNode.id) {
+                    data.add(htmlchildNode.id);
+                    if (functor)
+                        functor(container.childNodes[iterator]);
+                }
+            }
+        }
+        return data;
+    };
+    DOMGenerator.prototype.Addvalue = function (begin, size, value, tab) {
+        for (var iterator = begin; iterator < size + begin; iterator++)
+            tab[iterator].limit += value;
+    };
+    DOMGenerator.prototype.CheckQState = function (qsort, statementsNumber) {
+        var sum = 0;
+        for (var iterator in qsort) {
+            if (!qsort[iterator].limit)
+                return;
+            sum += qsort[iterator].limit;
+        }
+        var style = "";
+        if (sum !== statementsNumber)
+            style = "red";
+        document.getElementById("qSort").style.backgroundColor = style;
+    };
+    DOMGenerator.prototype.CreateQStatediv = function (isLimitless, isLine) {
+        var qstatediv = document.createElement("div");
+        if (isLimitless) {
+            qstatediv.className = "nestable grey";
+            qstatediv.style.minHeight = "100px";
+            if (isLine)
+                qstatediv.style.minWidth = "100%";
+        }
+        else {
+            qstatediv['childLimit'] = 1;
+            qstatediv.style.minHeight = "30px";
+            if (isLine)
+                qstatediv.className = "grey nestable-line";
+            else
+                qstatediv.className = "grey nestable";
+        }
+        return qstatediv;
+    };
+    DOMGenerator.prototype.QTabPlacement = function (min, max, statementsNumber) {
+        var qsort = new Array();
+        var qtablesize = (max - min) + 1;
+        for (var iterator_1 = min; iterator_1 <= max; iterator_1++) {
+            if (qsort.length !== 0 && qsort[iterator_1])
+                qsort[iterator_1] = { limit: 0, title: qsort[iterator_1].title };
+            else
+                qsort[iterator_1] = { limit: 0, title: "" };
+        }
+        var result = statementsNumber;
+        if (!result)
+            return;
+        var size = qtablesize;
+        var lign = 0;
+        var iterator = min;
+        while (true) {
+            lign = Math.floor(result / size);
+            result -= lign * size;
+            if (result === lign || (result - lign) * size < size - 2)
+                lign--;
+            this.Addvalue(iterator, size, lign, qsort);
+            size -= 2;
+            iterator++;
+            if (size === 1 || lign === 0) {
+                qsort[0].limit += Math.ceil(result);
+                break;
+            }
+            if (isNaN(lign) || isNaN(result)) {
+                var sum = 1;
+                for (var iterator_2 = min; iterator_2 <= max; iterator_2++)
+                    sum += qsort[iterator_2].limit;
+                qsort[0].limit += statementsNumber - sum;
+                break;
+            }
+        }
+        return qsort;
+    };
+    DOMGenerator.prototype.DeleteQSort = function () {
+        if (document.getElementById("qSort") === null)
+            return;
+        document.getElementById("simulator").removeChild(document.getElementById("qSort"));
+    };
+    DOMGenerator.prototype.GenerateQSortByColumns = function (states, sortedTab, qConfig, statAlign, insertToTitleCellFunctor) {
+        var headerRow;
+        var dataDow;
+        var data;
+        switch (statAlign) {
+            case EStatementAlignement.Top:
+            case EStatementAlignement.Middle:
+                headerRow = states.insertRow();
+                dataDow = states.insertRow();
+                break;
+            case EStatementAlignement.Bottom:
+                dataDow = states.insertRow();
+                headerRow = states.insertRow();
+                break;
+        }
+        for (var iterator in sortedTab) {
+            var dataStat = document.createElement("div");
+            data = document.createElement("div");
+            data.className = "tabletitle";
+            insertToTitleCellFunctor(qConfig, data, dataStat, iterator, sortedTab, false);
+            headerRow.insertCell().appendChild(data);
+            dataStat.id = "tab_" + (sortedTab[iterator]).toString();
+            dataStat.className = "nest-container statAlign";
+            if (!qConfig[sortedTab[iterator]].limit)
+                dataStat.appendChild(this.CreateQStatediv(true, false));
+            else
+                for (var iterator2 = 0; iterator2 < qConfig[sortedTab[iterator]].limit; iterator2++)
+                    dataStat.appendChild(this.CreateQStatediv(false, false));
+            var cell = dataDow.insertCell();
+            cell.appendChild(dataStat);
+        }
+    };
+    DOMGenerator.prototype.GenerateQSortByLines = function (states, sortedTab, qConfig, statAlign, insertToTitleCellFunctor) {
+        var dataTitle, dataCell;
+        for (var iterator in sortedTab) {
+            dataTitle = document.createElement("div");
+            dataCell = document.createElement("div");
+            dataTitle.className = "tabletitle";
+            //specific insertion (QAdmin input vs QInterfaceText)
+            insertToTitleCellFunctor(qConfig, dataTitle, dataCell, iterator, sortedTab, true);
+            dataCell.id = "tab_" + (sortedTab[iterator]).toString();
+            dataCell.className = "nest-container statAlign";
+            if (!qConfig[sortedTab[iterator]].limit)
+                dataCell.appendChild(this.CreateQStatediv(true, true));
+            else
+                for (var iterator2 = 0; iterator2 < qConfig[sortedTab[iterator]].limit; iterator2++)
+                    dataCell.appendChild(this.CreateQStatediv(false, true));
+            var row = states.insertRow();
+            var cellTitle = void 0, cellStates = void 0;
+            switch (statAlign) {
+                case EStatementAlignement.Left:
+                    cellTitle = row.insertCell();
+                    cellStates = row.insertCell();
+                    break;
+                case EStatementAlignement.Right:
+                    cellStates = row.insertCell();
+                    cellTitle = row.insertCell();
+                    break;
+            }
+            //cellStates.className="statAlign";
+            cellStates.appendChild(dataCell);
+            cellTitle.appendChild(dataTitle);
+            /*if(dataCell.childNodes.length===1)
+                dataTitle.style.minHeight="100px";
+            else
+                dataTitle.style.minHeight="30px";*/
+            cellTitle.style.minWidth = "12.5%";
+            cellStates.style.minWidth = "50%";
+            cellTitle.style.width = "25%";
+            cellStates.style.width = "75%";
+        }
+    };
+    DOMGenerator.prototype.GenerateQSort = function (isCrescent, statAlign, qConfig, statementsNumber, checkFunctor, insertToTitleCellFunctor, insertFunctor) {
+        //spesific check do before (aka froze 3 states in qInterface)
+        checkFunctor();
+        var states = document.createElement("table");
+        states.id = "qSort";
+        var tab = Array();
+        for (var key in qConfig)
+            tab[tab.length] = Number.parseInt(key);
+        if (isCrescent)
+            tab.sort(function (a, b) { return a - b; });
+        else
+            tab.sort(function (a, b) { return b - a; });
+        switch (statAlign) {
+            case EStatementAlignement.Top:
+            case EStatementAlignement.Bottom:
+            case EStatementAlignement.Middle:
+                this.GenerateQSortByColumns(states, tab, qConfig, statAlign, insertToTitleCellFunctor);
+                break;
+            case EStatementAlignement.Left:
+            case EStatementAlignement.Right:
+                this.GenerateQSortByLines(states, tab, qConfig, statAlign, insertToTitleCellFunctor);
+                break;
+        }
+        insertFunctor(states);
+        this.CheckQState(qConfig, statementsNumber);
+        this.SetStatementsAlignement(statAlign);
+    };
+    DOMGenerator.prototype.SetStatementsAlignement = function (statAlign) {
+        var cells = document.getElementsByClassName("statAlign");
+        if (!cells || !cells.length)
+            return;
+        switch (statAlign) {
+            case EStatementAlignement.Top:
+                for (var iterator = 0; iterator < cells.length; iterator++) {
+                    var htmlNode = cells[iterator];
+                    var parent_1 = htmlNode.parentNode;
+                    parent_1.style.verticalAlign = "top";
+                }
+                break;
+            case EStatementAlignement.Bottom:
+                for (var iterator = 0; iterator < cells.length; iterator++) {
+                    var htmlNode = cells[iterator];
+                    var parent_2 = htmlNode.parentNode;
+                    parent_2.style.verticalAlign = "bottom";
+                }
+                break;
+            case EStatementAlignement.Middle:
+                for (var iterator = 0; iterator < cells.length; iterator++) {
+                    var htmlNode = cells[iterator];
+                    var parent_3 = htmlNode.parentNode;
+                    parent_3.style.verticalAlign = "middle";
+                }
+                break;
+            case EStatementAlignement.Left:
+                for (var iterator = 0; iterator < cells.length; iterator++) {
+                    var htmlNode = cells[iterator];
+                    htmlNode.className += " nested-line-left";
+                }
+                break;
+            case EStatementAlignement.Right:
+                for (var iterator = 0; iterator < cells.length; iterator++) {
+                    var htmlNode = cells[iterator];
+                    htmlNode.className += " nested-line-right";
+                }
+                break;
+        }
+    };
+    DOMGenerator.prototype.GenerateThreeStates = function (threeStateConfig, checkFunctor, insertToTitleCellFunctor, insertThreeStatesFunctor) {
+        if (document.getElementById("threestates") !== null)
+            return;
+        checkFunctor();
+        var states = document.createElement("table");
+        states.id = "threeStates";
+        var rowHead = states.insertRow();
+        var rowBody = states.insertRow();
+        for (var iterator = 0; iterator < 3; iterator++) {
+            var cell = rowHead.insertCell();
+            //cell.style.width="30%";
+            var title = cell.appendChild(document.createElement("div"));
+            insertToTitleCellFunctor(threeStateConfig, title, iterator);
+            cell = rowBody.insertCell();
+            cell.style.verticalAlign = "top";
+            var div = cell.appendChild(document.createElement("div"));
+            div.id = threeStateConfig[iterator].type;
+            div.className = "nestable grey nest-container";
+            // TO DO check replay state
+            /*if(isReplay)
+            {
+                div.style.minWidth=(replayScale*130)+'px';
+                div.style.minHeight=(replayScale*90)+'px';
+            }*/
+        }
+        insertThreeStatesFunctor(states);
+    };
+    DOMGenerator.prototype.GenerateDropZone = function (id, text, className, parent, accept, isMultiple, functor) {
+        var dropZone = parent.appendChild(document.createElement("div"));
+        dropZone.appendChild(document.createTextNode(text + " : "));
+        dropZone.className = className;
+        dropZone.id = id;
+        dropZone.onchange = function (event) { if (event.target)
+            functor(event.target.files); };
+        var form = dropZone.appendChild(document.createElement("form"));
+        var input = form.appendChild(document.createElement("input"));
+        input.type = "file";
+        input.multiple = isMultiple;
+        input.accept = accept;
+    };
+    DOMGenerator.prototype.UpdateDeckView = function (isThreeStatesDeck) {
+        var pickingZone = document.getElementById("pickingZone");
+        if (!pickingZone || !pickingZone.childNodes.length)
+            return;
+        if (isThreeStatesDeck) {
+            var htmlNode = pickingZone.firstChild;
+            htmlNode.style.display = "";
+            for (var iterator = 1; iterator < pickingZone.childNodes.length; iterator++) {
+                htmlNode = pickingZone.childNodes[iterator];
+                htmlNode.style.display = "none";
+            }
+        }
+        else {
+            for (var iterator = 0; iterator < pickingZone.childNodes.length; iterator++) {
+                var htmlNode = pickingZone.childNodes[iterator];
+                htmlNode.style.display = "";
+            }
+        }
+    };
+    return DOMGenerator;
+}());
+exports.DOMGenerator = DOMGenerator;