@seniorsistemas/angular-components 16.13.2 → 17.1.0

package/fesm5/seniorsistemas-angular-components.js

@@ -8605,6 +8605,1710 @@ var EditableOverlayModule = /** @class */ (function () {
     return EditableOverlayModule;
 }());
 
+var moment$7 = moment_;
+var YEAR = "year";
+var MONTH = "month";
+var DAY = "day";
+var HOUR = "hour";
+var MINUTE = "minute";
+var SECOND = "second";
+var MILLISECOND = "millisecond";
+var DateUtils = /** @class */ (function () {
+    function DateUtils() {
+    }
+    DateUtils.parse = function (date) {
+        return moment$7(date).toDate();
+    };
+    DateUtils.toString = function (date, with_time) {
+        if (with_time === void 0) { with_time = false; }
+        var result = with_time ? moment$7(date, "YYYY-MM-DD hh:mm:ss.SSS") : moment$7(date, "YYYY-MM-DD");
+        return result.toString();
+    };
+    DateUtils.format = function (date, formatString, lang) {
+        if (formatString === void 0) { formatString = "YYYY-MM-DD HH:mm:ss.SSS"; }
+        if (lang === void 0) { lang = "en"; }
+        var monthName = moment$7(date)
+            .locale(lang)
+            .startOf("month")
+            .format("MMMM");
+        var monthNameCapitalized = monthName.charAt(0).toUpperCase() + monthName.slice(1);
+        var dateToFormat = moment$7(date);
+        var format_map = {
+            YYYY: dateToFormat.format("YYYY"),
+            MM: dateToFormat.format("MM"),
+            DD: dateToFormat.format("DD"),
+            HH: dateToFormat.format("HH"),
+            mm: dateToFormat.format("mm"),
+            ss: dateToFormat.format("ss"),
+            SSS: dateToFormat.format("SSS"),
+            D: dateToFormat.format("D"),
+            MMMM: monthNameCapitalized,
+            MMM: monthNameCapitalized,
+        };
+        var str = formatString;
+        var formattedValues = [];
+        Object.keys(format_map)
+            .sort(function (a, b) { return b.length - a.length; })
+            .forEach(function (key) {
+            if (str.includes(key)) {
+                str = str.replace(key, "$" + formattedValues.length);
+                formattedValues.push(format_map[key]);
+            }
+        });
+        formattedValues.forEach(function (value, i) {
+            str = str.replace("$" + i, value);
+        });
+        return str;
+    };
+    DateUtils.diff = function (fistDate, secondDate, scale) {
+        var milliseconds = moment$7(fistDate).diff(secondDate, MILLISECOND);
+        var seconds = moment$7(fistDate).diff(secondDate, SECOND);
+        var minutes = moment$7(fistDate).diff(secondDate, MINUTE);
+        var hours = moment$7(fistDate).diff(secondDate, HOUR);
+        var days = moment$7(fistDate).diff(secondDate, DAY);
+        var months = moment$7(fistDate).diff(secondDate, MONTH);
+        var years = moment$7(fistDate).diff(secondDate, YEAR);
+        if (!scale.endsWith("s")) {
+            scale += "s";
+        }
+        return Math.floor({
+            milliseconds: milliseconds,
+            seconds: seconds,
+            minutes: minutes,
+            hours: hours,
+            days: days,
+            months: months,
+            years: years,
+        }[scale]);
+    };
+    DateUtils.today = function () {
+        var dateStr = moment$7().format("YYY-MM-DD");
+        return new Date(dateStr);
+    };
+    DateUtils.now = function () {
+        return moment$7().toDate();
+    };
+    DateUtils.add = function (date, quantity, scale) {
+        return moment$7(date).add(quantity, scale).toDate();
+    };
+    DateUtils.startOf = function (date, scale) {
+        var _a;
+        var scores = (_a = {},
+            _a[YEAR] = 6,
+            _a[MONTH] = 5,
+            _a[DAY] = 4,
+            _a[HOUR] = 3,
+            _a[MINUTE] = 2,
+            _a[SECOND] = 1,
+            _a[MILLISECOND] = 0,
+            _a);
+        function shouldReset(_scale) {
+            var max_score = scores[scale];
+            return scores[_scale] <= max_score;
+        }
+        var vals = [
+            date.getFullYear(),
+            shouldReset(YEAR) ? 0 : date.getMonth(),
+            shouldReset(MONTH) ? 1 : date.getDate(),
+            shouldReset(DAY) ? 0 : date.getHours(),
+            shouldReset(HOUR) ? 0 : date.getMinutes(),
+            shouldReset(MINUTE) ? 0 : date.getSeconds(),
+            shouldReset(SECOND) ? 0 : date.getMilliseconds(),
+        ];
+        return new Date(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5], vals[6]);
+    };
+    DateUtils.clone = function (date) {
+        return moment$7(date).toDate();
+    };
+    DateUtils.getDateValues = function (date) {
+        return [
+            date.getFullYear(),
+            date.getMonth(),
+            date.getDate(),
+            date.getHours(),
+            date.getMinutes(),
+            date.getSeconds(),
+            date.getMilliseconds(),
+        ];
+    };
+    DateUtils.getDaysInMonth = function (date) {
+        return moment$7(date, "YYYY-MM").daysInMonth();
+    };
+    return DateUtils;
+}());
+
+var $ = function (expr, con) {
+    return typeof expr === 'string'
+        ? (con || document).querySelector(expr)
+        : expr || null;
+};
+var createSVG = function (tag, attrs) {
+    var elem = document.createElementNS("http://www.w3.org/2000/svg", tag);
+    for (var attr in attrs) {
+        if (attr === "append_to") {
+            var parent_1 = attrs.append_to;
+            parent_1.appendChild(elem);
+        }
+        else if (attr === "innerHTML") {
+            elem.innerHTML = attrs.innerHTML;
+        }
+        else {
+            elem.setAttribute(attr, attrs[attr]);
+        }
+    }
+    return elem;
+};
+var animateSVG = function (svgElement, attr, from, to) {
+    var animatedSvgElement = getAnimationElement(svgElement, attr, from, to);
+    if (animatedSvgElement === svgElement) {
+        // triggered 2nd time programmatically
+        // trigger artificial click event
+        var event_1 = document.createEvent("HTMLEvents");
+        event_1.initEvent("click", true, true);
+        // event.eventName = 'click'; TODO: Ver porque esta propriedade não existe
+        animatedSvgElement.dispatchEvent(event_1);
+    }
+};
+var getAnimationElement = function (svgElement, attr, from, to, dur, begin) {
+    if (dur === void 0) { dur = "0.4s"; }
+    if (begin === void 0) { begin = "0.1s"; }
+    var animEl = svgElement.querySelector("animate");
+    if (animEl) {
+        $.attr(animEl, {
+            attributeName: attr,
+            from: from,
+            to: to,
+            dur: dur,
+            begin: "click + " + begin,
+        }, null);
+        return svgElement;
+    }
+    var animateElement = createSVG("animate", {
+        attributeName: attr,
+        from: from,
+        to: to,
+        dur: dur,
+        begin: begin,
+        calcMode: "spline",
+        values: from + ";" + to,
+        keyTimes: "0; 1",
+        keySplines: cubic_bezier("ease-out"),
+    });
+    svgElement.appendChild(animateElement);
+    return svgElement;
+};
+var ɵ0 = getAnimationElement;
+var cubic_bezier = function (name) {
+    return {
+        ease: ".25 .1 .25 1",
+        linear: "0 0 1 1",
+        "ease-in": ".42 0 1 1",
+        "ease-out": "0 0 .58 1",
+        "ease-in-out": ".42 0 .58 1",
+    }[name];
+};
+var ɵ1 = cubic_bezier;
+$.on = function (element, event, selector, callback) {
+    if (!callback) {
+        callback = selector;
+        $.bind(element, event, callback);
+    }
+    else {
+        $.delegate(element, event, selector, callback);
+    }
+};
+$.off = function (element, event, handler) {
+    element.removeEventListener(event, handler);
+};
+$.bind = function (element, event, callback) {
+    event.split(/\s+/).forEach(function (event) {
+        element.addEventListener(event, callback);
+    });
+};
+$.delegate = function (element, event, selector, callback) {
+    element.addEventListener(event, function (e) {
+        var delegatedTarget = e.target.closest(selector);
+        if (delegatedTarget) {
+            e.delegatedTarget = delegatedTarget;
+            callback.call(this, e, delegatedTarget);
+        }
+    });
+};
+$.closest = function (selector, element) {
+    if (!element) {
+        return null;
+    }
+    if (element.matches(selector)) {
+        return element;
+    }
+    // TODO: Corrigir este problema
+    // return $.closest(selector, element.parentNode);
+};
+$.attr = function (element, attr, value) {
+    if (!value && typeof attr === "string") {
+        return element.getAttribute(attr);
+    }
+    if (typeof attr === "object") {
+        for (var key in attr) {
+            $.attr(element, key, attr[key]);
+        }
+        return;
+    }
+    element.setAttribute(attr, value);
+};
+
+var ViewMode;
+(function (ViewMode) {
+    ViewMode["QuarterDay"] = "quarterDay";
+    ViewMode["HalfDay"] = "halfDay";
+    ViewMode["Day"] = "day";
+    ViewMode["Week"] = "week";
+    ViewMode["Month"] = "month";
+    ViewMode["Year"] = "year";
+    ViewMode["Hour"] = "hour";
+})(ViewMode || (ViewMode = {}));
+
+var Bar = /** @class */ (function () {
+    function Bar(gantt, task) {
+        this._setDefaults(gantt, task);
+        this._prepare();
+        this._draw();
+        this._bind();
+    }
+    Object.defineProperty(Bar.prototype, "arrows", {
+        get: function () {
+            return this._arrows;
+        },
+        set: function (arrows) {
+            this._arrows = arrows;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bar.prototype, "task", {
+        get: function () {
+            return this._task;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bar.prototype, "element", {
+        get: function () {
+            return this._element;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bar.prototype, "group", {
+        get: function () {
+            return this._group;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Bar.prototype.updateBarPosition = function (_a) {
+        var _this = this;
+        var x = _a.x, width = _a.width;
+        var bar = this.element;
+        if (x) {
+            // get all x values of parent task
+            var xs = this.task.dependencies.map(function (dep) {
+                return _this._gantt.get_bar(dep).element.getX();
+            });
+            // child task must not go before parent
+            var valid_x = xs.reduce(function (prev, curr) {
+                return x >= curr;
+            }, x);
+            if (!valid_x) {
+                width = null;
+                return;
+            }
+            this._updateAttr(bar, "x", x);
+        }
+        if (width && width >= this._gantt.options.columnWidth) {
+            this._updateAttr(bar, "width", width);
+        }
+        this._updateLabelPosition();
+        this._updateArrowPosition();
+    };
+    Bar.prototype.dateChanged = function () {
+        var changed = false;
+        var _a = this._computeStartEndDate(), newStartDate = _a.newStartDate, newEndDate = _a.newEndDate;
+        if (this.task.start !== newStartDate) {
+            changed = true;
+            this.task.start = newStartDate;
+        }
+        if (this.task.end !== newEndDate) {
+            changed = true;
+            this.task.end = newEndDate;
+        }
+        if (changed) {
+            this._gantt.trigger_event("onDateChange", [
+                this.task,
+                newStartDate,
+                DateUtils.add(newEndDate, -1, "second"),
+            ]);
+        }
+        ;
+    };
+    Bar.prototype.setActionCompleted = function () {
+        var _this = this;
+        this._actionCompleted = true;
+        setTimeout(function () {
+            _this._actionCompleted = false;
+        }, 1000);
+    };
+    Bar.prototype._setDefaults = function (gantt, task) {
+        this._actionCompleted = false;
+        this._gantt = gantt;
+        this._task = task;
+    };
+    Bar.prototype._prepare = function () {
+        this._prepareValues();
+        this._prepareHelpers();
+    };
+    Bar.prototype._prepareValues = function () {
+        this._invalid = this.task.invalid;
+        this._height = this._gantt.options.barHeight;
+        this._x = this._computeX();
+        this._y = this._computeY();
+        this._cornerRadius = this._gantt.options.barCornerRadius;
+        this._duration = DateUtils.diff(this.task.end, this.task.start, "minute") / this._gantt.options.step / 60.0;
+        this._width = this._gantt.options.columnWidth * this._duration;
+        this._group = createSVG("g", {
+            class: "bar-wrapper " + (this.task.custom_class || ""),
+            "data-id": this.task.id,
+        });
+        this._barGroup = createSVG("g", {
+            class: "bar-group",
+            append_to: this.group,
+        });
+    };
+    Bar.prototype._prepareHelpers = function () {
+        SVGElement.prototype.getX = function () {
+            return +this.getAttribute("x");
+        };
+        SVGElement.prototype.getY = function () {
+            return +this.getAttribute("y");
+        };
+        SVGElement.prototype.getWidth = function () {
+            return +this.getAttribute("width");
+        };
+        SVGElement.prototype.getHeight = function () {
+            return +this.getAttribute("height");
+        };
+        SVGElement.prototype.getEndX = function () {
+            return this.getX() + this.getWidth();
+        };
+    };
+    Bar.prototype._draw = function () {
+        this._drawBar();
+        this._drawLabel();
+    };
+    Bar.prototype._drawBar = function () {
+        this._element = createSVG("rect", {
+            x: this._x,
+            y: this._y,
+            width: this._width,
+            height: this._height,
+            rx: this._cornerRadius,
+            ry: this._cornerRadius,
+            class: "bar",
+            append_to: this._barGroup,
+            fill: this.task.color,
+        });
+        animateSVG(this.element, "width", 0, this._width);
+        if (this._invalid) {
+            this.element.classList.add("bar-invalid");
+        }
+    };
+    Bar.prototype._drawLabel = function () {
+        var _this = this;
+        createSVG("text", {
+            x: this._x + this._width / 2,
+            y: this._y + this._height / 2,
+            innerHTML: this.task.showTaskName ? this.task.name : "",
+            class: "bar-label",
+            append_to: this._barGroup,
+        });
+        // labels get BBox in the next tick
+        requestAnimationFrame(function () { return _this._updateLabelPosition(); });
+    };
+    Bar.prototype._bind = function () {
+        if (!this._invalid) {
+            this._setupClickEvent();
+        }
+    };
+    Bar.prototype._setupClickEvent = function () {
+        var _this = this;
+        $.on(this.group, "focus " + this._gantt.options.popupTrigger, function (e) {
+            // just finished a move action, wait for a few seconds
+            if (!_this._actionCompleted) {
+                _this._showPopup();
+                _this._gantt.unselect_all();
+                _this.group.classList.add("active");
+            }
+        }, null);
+        $.on(this.group, "dblclick", function (e) {
+            // just finished a move action, wait for a few seconds
+            if (!_this._actionCompleted) {
+                _this._gantt.trigger_event("onClick", [_this.task]);
+            }
+        }, null);
+    };
+    Bar.prototype._showPopup = function () {
+        if (this._gantt.bar_being_dragged) {
+            return;
+        }
+        var formatString = this._gantt.view_is(ViewMode.Hour)
+            ? "HH:ss"
+            : "MMM D";
+        var start_date = DateUtils.format(this.task.start, formatString, this._gantt.options.language);
+        var end_date = DateUtils.format(DateUtils.add(this.task.end, -1, "second"), formatString, this._gantt.options.language);
+        var subtitle = start_date + " - " + end_date;
+        this._gantt.show_popup({
+            target_element: this.element,
+            title: this.task.name,
+            subtitle: subtitle,
+            task: this.task,
+        });
+    };
+    Bar.prototype._computeStartEndDate = function () {
+        var bar = this.element;
+        var xInUnits = bar.getX() / this._gantt.options.columnWidth;
+        var newStartDate = DateUtils.add(this._gantt.minDate, xInUnits * this._gantt.options.step, "hour");
+        var width_in_units = bar.getWidth() / this._gantt.options.columnWidth;
+        var newEndDate = DateUtils.add(newStartDate, width_in_units * this._gantt.options.step, "hour");
+        return { newStartDate: newStartDate, newEndDate: newEndDate };
+    };
+    Bar.prototype._computeX = function () {
+        var _a = this._gantt.options, step = _a.step, columnWidth = _a.columnWidth;
+        var diff = DateUtils.diff(this.task.start, this._gantt.minDate, "hour");
+        var x = (diff / step) * columnWidth;
+        if (this._gantt.view_is(ViewMode.Month)) {
+            var diff_1 = DateUtils.diff(this.task.start, this._gantt.minDate, "day");
+            x = (diff_1 * columnWidth) / 30;
+        }
+        return x;
+    };
+    Bar.prototype._computeY = function () {
+        return (this._gantt.options.headerHeight +
+            this._gantt.options.padding +
+            this.task._index * (this._height + this._gantt.options.padding));
+    };
+    Bar.prototype._updateAttr = function (element, attr, value) {
+        value = +value;
+        if (!isNaN(value)) {
+            element.setAttribute(attr, value);
+        }
+        return element;
+    };
+    Bar.prototype._updateLabelPosition = function () {
+        var bar = this.element, label = this.group.querySelector(".bar-label");
+        if (label.getBBox().width > bar.getWidth()) {
+            label.classList.add("big");
+            label.setAttribute("x", bar.getX() + bar.getWidth() + 5);
+        }
+        else {
+            label.classList.remove("big");
+            label.setAttribute("x", bar.getX() + bar.getWidth() / 2);
+        }
+    };
+    Bar.prototype._updateArrowPosition = function () {
+        var e_1, _a;
+        this._arrows = this._arrows || [];
+        try {
+            for (var _b = __values(this._arrows), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var arrow = _c.value;
+                arrow.update();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    return Bar;
+}());
+
+var Popup = /** @class */ (function () {
+    function Popup(parent, customHtml) {
+        this.parent = parent;
+        this.customHtml = customHtml;
+        this.make();
+    }
+    Popup.prototype.show = function (options) {
+        if (!options.target_element) {
+            throw new Error("target_element is required to show popup");
+        }
+        if (!options.position) {
+            options.position = "left";
+        }
+        var target_element = options.target_element;
+        if (this.customHtml) {
+            var html = this.customHtml(options.task);
+            html += '<div class="pointer"></div>';
+            this.parent.innerHTML = html;
+            this.pointer = this.parent.querySelector(".pointer");
+        }
+        else {
+            // set data
+            this.title.innerHTML = options.title;
+            this.subtitle.innerHTML = options.subtitle;
+            this.parent.style.width = this.parent.clientWidth + "px";
+        }
+        // set position
+        var positionMeta;
+        if (target_element instanceof HTMLElement) {
+            positionMeta = target_element.getBoundingClientRect();
+        }
+        else if (target_element instanceof SVGElement) {
+            positionMeta = options.target_element.getBBox();
+        }
+        if (options.position === 'left') {
+            this.parent.style.left = positionMeta.x + (positionMeta.width + 10) + "px";
+            this.parent.style.top = positionMeta.y + "px";
+            this.pointer.style.transform = "rotateZ(90deg)";
+            this.pointer.style.left = "-7px";
+            this.pointer.style.top = "2px";
+        }
+        // show
+        this.parent.style.opacity = 1;
+    };
+    Popup.prototype.make = function () {
+        this.parent.innerHTML = "\n        <div class=\"popup\">\n            <div class=\"wrp-title\">\n                <span class=\"title\"></span>\n            </div>\n            <div class=\"wrp-subtitle\">\n                <span class=\"icon fas fa-calendar-alt\"></span>\n                <span class=\"subtitle\"></span>\n            </div>\n            <div class=\"pointer\"></div>\n        </div>\n        ";
+        this.hide();
+        this.title = this.parent.querySelector(".title");
+        this.subtitle = this.parent.querySelector(".subtitle");
+        this.pointer = this.parent.querySelector(".pointer");
+    };
+    Popup.prototype.hide = function () {
+        this.parent.style.opacity = 0;
+        this.parent.style.left = 0;
+    };
+    return Popup;
+}());
+
+var Arrow = /** @class */ (function () {
+    function Arrow(gantt, fromTask, toTask) {
+        this._gantt = gantt;
+        this._fromTask = fromTask;
+        this._toTask = toTask;
+        this.calculatePath();
+        this.draw();
+    }
+    Object.defineProperty(Arrow.prototype, "fromTask", {
+        get: function () {
+            return this._fromTask;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Arrow.prototype, "toTask", {
+        get: function () {
+            return this._toTask;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Arrow.prototype, "element", {
+        get: function () {
+            return this._element;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Arrow.prototype.update = function () {
+        this.calculatePath();
+        this._element.setAttribute("d", this._path);
+    };
+    Arrow.prototype.calculatePath = function () {
+        var _this = this;
+        var startX = this.fromTask.element.getX() + this.fromTask.element.getWidth() / 2;
+        var condition = function () {
+            return _this.toTask.element.getX() < startX + _this._gantt.options.padding &&
+                startX > _this.fromTask.element.getX() + _this._gantt.options.padding;
+        };
+        while (condition()) {
+            startX -= 10;
+        }
+        var startY = this._gantt.options.headerHeight +
+            this._gantt.options.barHeight +
+            (this._gantt.options.padding + this._gantt.options.barHeight) *
+                this.fromTask.task._index +
+            this._gantt.options.padding;
+        var endX = this.toTask.element.getX() - this._gantt.options.padding / 2;
+        var endY = this._gantt.options.headerHeight +
+            this._gantt.options.barHeight / 2 +
+            (this._gantt.options.padding + this._gantt.options.barHeight) *
+                this.toTask.task._index +
+            this._gantt.options.padding;
+        var fromIsBelowTo = this.fromTask.task._index > this.toTask.task._index;
+        var curve = this._gantt.options.arrowCurve;
+        var clockwise = fromIsBelowTo ? 1 : 0;
+        var curveY = fromIsBelowTo ? -curve : curve;
+        var offset = fromIsBelowTo
+            ? endY + this._gantt.options.arrowCurve
+            : endY - this._gantt.options.arrowCurve;
+        this._path = "\n            M " + startX + " " + startY + "\n            V " + offset + "\n            a " + curve + " " + curve + " 0 0 " + clockwise + " " + curve + " " + curveY + "\n            L " + endX + " " + endY + "\n            m -5 -5\n            l 5 5\n            l -5 5";
+        if (this.toTask.element.getX() < this.fromTask.element.getX() + this._gantt.options.padding) {
+            var down1 = this._gantt.options.padding / 2 - curve;
+            var down2 = this.toTask.element.getY() + this.toTask.element.getHeight() / 2 - curveY;
+            var left = this.toTask.element.getX() - this._gantt.options.padding;
+            this._path = "\n                M " + startX + " " + startY + "\n                v " + down1 + "\n                a " + curve + " " + curve + " 0 0 1 -" + curve + " " + curve + "\n                H " + left + "\n                a " + curve + " " + curve + " 0 0 " + clockwise + " -" + curve + " " + curveY + "\n                V " + down2 + "\n                a " + curve + " " + curve + " 0 0 " + clockwise + " " + curve + " " + curveY + "\n                L " + endX + " " + endY + "\n                m -5 -5\n                l 5 5\n                l -5 5";
+        }
+    };
+    Arrow.prototype.draw = function () {
+        this._element = createSVG("path", {
+            d: this._path,
+            "data-from": this.fromTask.task.id,
+            "data-to": this.toTask.task.id,
+        });
+    };
+    return Arrow;
+}());
+
+var defaultOptions = {
+    headerHeight: 94,
+    columnWidth: 30,
+    step: 24,
+    barHeight: 20,
+    barCornerRadius: 0,
+    arrowCurve: 4,
+    padding: 24,
+    viewMode: ViewMode.Day,
+    dateFormat: "YYYY-MM-DD",
+    popupTrigger: "click",
+    customPopupHtml: null,
+    language: "en",
+};
+
+var Gantt = /** @class */ (function () {
+    function Gantt(wrapper, tasks, options) {
+        this.setup_wrapper(wrapper);
+        this.setup_options(options);
+        this.setup_tasks(tasks);
+        // initialize with default view mode
+        this.change_view_mode();
+        this.bind_events();
+    }
+    Object.defineProperty(Gantt.prototype, "minDate", {
+        get: function () {
+            return this._minDate;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Gantt.prototype, "maxDate", {
+        get: function () {
+            return this._maxDate;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Gantt.prototype.setup_wrapper = function (element) {
+        var svg_element, wrapper_element;
+        // CSS Selector is passed
+        if (typeof element === "string") {
+            element = document.querySelector(element);
+        }
+        // get the SVGElement
+        if (element instanceof HTMLElement) {
+            wrapper_element = element;
+            svg_element = element.querySelector("svg");
+        }
+        else if (element instanceof SVGElement) {
+            svg_element = element;
+        }
+        else {
+            throw new TypeError("Frappé Gantt only supports usage of a string CSS selector, HTML DOM element or SVG DOM element for the \'element\' parameter");
+        }
+        // svg element
+        if (!svg_element) {
+            // create it
+            this.$svg = createSVG("svg", {
+                append_to: wrapper_element,
+                class: "gantt",
+            });
+        }
+        else {
+            this.$svg = svg_element;
+            this.$svg.classList.add("gantt");
+        }
+        // wrapper element
+        this.$container = document.createElement("div");
+        this.$container.classList.add("gantt-container");
+        var parent_element = this.$svg.parentElement;
+        parent_element.appendChild(this.$container);
+        this.$container.appendChild(this.$svg);
+        // popup wrapper
+        this.popup_wrapper = document.createElement("div");
+        this.popup_wrapper.classList.add("popup-wrapper");
+        this.$container.appendChild(this.popup_wrapper);
+    };
+    Gantt.prototype.setup_options = function (options) {
+        this.options = Object.assign({}, defaultOptions, options);
+    };
+    Gantt.prototype.setup_tasks = function (tasks) {
+        // prepare tasks
+        this.tasks = tasks.map(function (task, i) {
+            //standard colors if needed
+            task.color = task.color || '#7892A1';
+            // convert to Date objects
+            task._start = DateUtils.parse(task.start);
+            task._end = DateUtils.parse(task.end);
+            // make task invalid if duration too large
+            if (DateUtils.diff(task._end, task._start, "year") > 10) {
+                task.end = null;
+            }
+            // cache index
+            task._index = i;
+            if (typeof task._row_id === "number") {
+                task._index = task._row_id;
+            }
+            // invalid dates
+            if (!task.start && !task.end) {
+                var today = DateUtils.today();
+                task._start = today;
+                task._end = DateUtils.add(today, 2, "day");
+            }
+            if (!task.start && task.end) {
+                task._start = DateUtils.add(task._end, -2, 'day');
+            }
+            if (task.start && !task.end) {
+                task._end = DateUtils.add(task._start, 2, "day");
+            }
+            // if hours is not set, assume the last day is full day
+            // e.g: 2018-09-09 becomes 2018-09-09 23:59:59
+            var task_end_values = DateUtils.getDateValues(task._end);
+            if (task_end_values.slice(3).every(function (d) { return d === 0; })) {
+                task._end = DateUtils.add(task._end, 24, "hour");
+            }
+            // invalid flag
+            if (!task.start || !task.end) {
+                task.invalid = true;
+            }
+            // dependencies
+            if (typeof task.dependencies === "string" || !task.dependencies) {
+                var deps = [];
+                if (task.dependencies) {
+                    deps = task.dependencies
+                        .split(',')
+                        .map(function (d) { return d.trim(); })
+                        .filter(function (d) { return d; });
+                }
+                task.dependencies = deps;
+            }
+            // uids
+            if (!task.id) {
+                task.id = generate_id(task);
+            }
+            return task;
+        });
+        this.setup_dependencies();
+    };
+    Gantt.prototype.setup_dependencies = function () {
+        var e_1, _a, e_2, _b;
+        this.dependency_map = {};
+        try {
+            for (var _c = __values(this.tasks), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var t = _d.value;
+                try {
+                    for (var _e = (e_2 = void 0, __values(t.dependencies)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var d = _f.value;
+                        this.dependency_map[d] = this.dependency_map[d] || [];
+                        this.dependency_map[d].push(t.id);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    Gantt.prototype.refresh = function (tasks) {
+        this.setup_tasks(tasks);
+        this.change_view_mode();
+    };
+    Gantt.prototype.change_view_mode = function (mode) {
+        if (mode === void 0) { mode = this.options.viewMode; }
+        this.update_view_scale(mode);
+        this.setup_dates();
+        this.render();
+        // fire viewmode_change event
+        this.trigger_event("onViewChange", [mode]);
+    };
+    Gantt.prototype.update_view_scale = function (view_mode) {
+        this.options.viewMode = view_mode;
+        // this.isHourView = false;
+        if (view_mode === ViewMode.Hour) {
+            this.options.step = 24 / 24;
+            this.options.columnWidth = 50;
+            // this.isHourView = true;
+        }
+        else if (view_mode === ViewMode.Day) {
+            this.options.step = 24;
+            this.options.columnWidth = 50;
+        }
+        else if (view_mode === ViewMode.HalfDay) {
+            this.options.step = 24 / 2;
+            this.options.columnWidth = 50;
+        }
+        else if (view_mode === ViewMode.QuarterDay) {
+            this.options.step = 24 / 4;
+            this.options.columnWidth = 50;
+        }
+        else if (view_mode === ViewMode.Week) {
+            this.options.step = 24 * 7;
+            this.options.columnWidth = 140;
+        }
+        else if (view_mode === ViewMode.Month) {
+            this.options.step = 24 * 30;
+            this.options.columnWidth = 120;
+        }
+        else if (view_mode === ViewMode.Year) {
+            this.options.step = 24 * 365;
+            this.options.columnWidth = 120;
+        }
+    };
+    Gantt.prototype.setup_dates = function () {
+        this.setup_gantt_dates();
+        this.setup_date_values();
+    };
+    Gantt.prototype.setup_gantt_dates = function () {
+        var e_3, _a;
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        this._minDate = null;
+        this._maxDate = null;
+        try {
+            for (var _r = __values(this.tasks), _s = _r.next(); !_s.done; _s = _r.next()) {
+                var task = _s.value;
+                // set global start and end date
+                if (!this.minDate || task.start < this.minDate) {
+                    this._minDate = task.start;
+                }
+                if (!this.maxDate || task.end > this.maxDate) {
+                    this._maxDate = task.end;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_s && !_s.done && (_a = _r.return)) _a.call(_r);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this._realMinDate = this.minDate;
+        this._realMaxDate = this.maxDate;
+        switch (this.options.viewMode) {
+            case ViewMode.Hour:
+                this._minDate = DateUtils.add(this.minDate, -((_b = this.options.marginBeforeStart) !== null && _b !== void 0 ? _b : 1), "hour");
+                this._maxDate = DateUtils.add(this.maxDate, (_c = this.options.marginAfterEnd) !== null && _c !== void 0 ? _c : 1, "hour");
+                break;
+            case ViewMode.QuarterDay:
+                this._minDate = DateUtils.add(this.minDate, -((_d = this.options.marginBeforeStart) !== null && _d !== void 0 ? _d : 12), "hour");
+                this._maxDate = DateUtils.add(this.maxDate, (_e = this.options.marginAfterEnd) !== null && _e !== void 0 ? _e : 12, "hour");
+                break;
+            case ViewMode.HalfDay:
+                this._minDate = DateUtils.add(this.minDate, -((_f = this.options.marginBeforeStart) !== null && _f !== void 0 ? _f : 1), "day");
+                this._maxDate = DateUtils.add(this.maxDate, (_g = this.options.marginAfterEnd) !== null && _g !== void 0 ? _g : 1, "day");
+                break;
+            case ViewMode.Day:
+                this._minDate = DateUtils.add(this.minDate, -((_h = this.options.marginBeforeStart) !== null && _h !== void 0 ? _h : 3), "day");
+                this._maxDate = DateUtils.add(this.maxDate, (_j = this.options.marginAfterEnd) !== null && _j !== void 0 ? _j : 3, "day");
+                break;
+            case ViewMode.Week:
+                this._minDate = DateUtils.add(this.minDate, -((_k = this.options.marginBeforeStart) !== null && _k !== void 0 ? _k : 1), "month");
+                this._maxDate = DateUtils.add(this.maxDate, (_l = this.options.marginAfterEnd) !== null && _l !== void 0 ? _l : 1, "month");
+                break;
+            case ViewMode.Month:
+                this._minDate = DateUtils.add(this.minDate, -((_m = this.options.marginBeforeStart) !== null && _m !== void 0 ? _m : 1), "year");
+                this._maxDate = DateUtils.add(this.maxDate, (_o = this.options.marginAfterEnd) !== null && _o !== void 0 ? _o : 1, "year");
+                break;
+            case ViewMode.Year:
+                this._minDate = DateUtils.add(this.minDate, -((_p = this.options.marginBeforeStart) !== null && _p !== void 0 ? _p : 2), "year");
+                this._maxDate = DateUtils.add(this.maxDate, (_q = this.options.marginAfterEnd) !== null && _q !== void 0 ? _q : 2, "year");
+                break;
+        }
+    };
+    Gantt.prototype.setup_date_values = function () {
+        this.dates = [];
+        var cur_date = null;
+        while (cur_date === null || cur_date < this.maxDate) {
+            if (!cur_date) {
+                cur_date = DateUtils.clone(this.minDate);
+            }
+            else {
+                if (this.view_is(ViewMode.Year)) {
+                    cur_date = DateUtils.add(cur_date, 1, "year");
+                }
+                else if (this.view_is(ViewMode.Month)) {
+                    cur_date = DateUtils.add(cur_date, 1, "month");
+                }
+                else {
+                    cur_date = DateUtils.add(cur_date, this.options.step, 'hour');
+                }
+            }
+            this.dates.push(cur_date);
+        }
+        console.log("cur_date", cur_date);
+        console.log("dates", this.dates);
+    };
+    Gantt.prototype.bind_events = function () {
+        this.bind_grid_click();
+        this.bind_bar_events();
+    };
+    Gantt.prototype.render = function () {
+        this.clear();
+        this.setup_layers();
+        this.make_grid();
+        this.make_dates();
+        this.make_bars();
+        this.make_arrows();
+        this.map_arrows_on_bars();
+        this.set_width();
+        this.set_scroll_position();
+    };
+    Gantt.prototype.setup_layers = function () {
+        var e_4, _a;
+        this.layers = {};
+        var layers = ["grid", "date", "arrow", "progress", "bar", "details"];
+        try {
+            // make group layers
+            for (var layers_1 = __values(layers), layers_1_1 = layers_1.next(); !layers_1_1.done; layers_1_1 = layers_1.next()) {
+                var layer = layers_1_1.value;
+                this.layers[layer] = createSVG('g', {
+                    class: layer,
+                    append_to: this.$svg,
+                });
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (layers_1_1 && !layers_1_1.done && (_a = layers_1.return)) _a.call(layers_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    Gantt.prototype.make_grid = function () {
+        this.make_grid_background();
+        this.make_grid_rows();
+        this.make_grid_header();
+        this.make_grid_highlights();
+        this.make_grid_ticks();
+    };
+    Gantt.prototype.make_grid_background = function () {
+        var grid_width = this.dates.length * this.options.columnWidth;
+        var distinct_rows = __spread(new Set(this.tasks.map(function (x) { return x._row_id; })));
+        var grid_height = this.options.headerHeight +
+            this.options.padding / 2 +
+            (this.options.barHeight + this.options.padding) *
+                distinct_rows.length;
+        createSVG("rect", {
+            x: 0,
+            y: 0,
+            width: grid_width,
+            height: grid_height,
+            class: "grid-background",
+            append_to: this.layers.grid,
+        });
+        $.attr(this.$svg, {
+            height: grid_height,
+            width: "100%",
+        }, null);
+    };
+    Gantt.prototype.make_grid_rows = function () {
+        var _this = this;
+        var rows_layer = createSVG("g", { append_to: this.layers.grid });
+        var lines_layer = createSVG("g", { append_to: this.layers.grid });
+        var row_width = this.dates.length * this.options.columnWidth;
+        var row_height = this.options.barHeight + this.options.padding;
+        //TODO:  ajustar o posicionamento das linhas
+        var row_y = this.options.headerHeight + this.options.padding / 2;
+        this.tasks.forEach(function (_) {
+            createSVG("rect", {
+                x: 0,
+                y: row_y,
+                width: row_width,
+                height: row_height,
+                class: "grid-row",
+                append_to: rows_layer,
+            });
+            createSVG("line", {
+                x1: 0,
+                y1: row_y + row_height,
+                x2: row_width,
+                y2: row_y + row_height,
+                class: "row-line",
+                append_to: lines_layer,
+            });
+            row_y += _this.options.barHeight + _this.options.padding;
+        });
+    };
+    Gantt.prototype.make_grid_header = function () {
+        // const addIsHourView = this.isHourView ? 25 : 10
+        var header_width = this.dates.length * this.options.columnWidth;
+        var header_height = this.options.headerHeight + 10;
+        createSVG("rect", {
+            x: 0,
+            y: 0,
+            width: header_width,
+            height: header_height,
+            class: "grid-header",
+            append_to: this.layers.grid,
+        });
+    };
+    Gantt.prototype.make_grid_ticks = function () {
+        var e_5, _a;
+        var tick_x = 0;
+        var tick_y = this.options.headerHeight + this.options.padding / 2;
+        var tick_height = (this.options.barHeight + this.options.padding) *
+            this.tasks.length;
+        try {
+            for (var _b = __values(this.dates), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var date = _c.value;
+                var tick_class = "tick";
+                // thick tick for monday
+                if (this.view_is(ViewMode.Day) && date.getDate() === 1) {
+                    tick_class += " thick";
+                }
+                // thick tick for first week
+                if (this.view_is(ViewMode.Week) &&
+                    date.getDate() >= 1 &&
+                    date.getDate() < 8) {
+                    tick_class += " thick";
+                }
+                // thick ticks for quarters
+                if (this.view_is(ViewMode.Month) && date.getMonth() % 3 === 0) {
+                    tick_class += " thick";
+                }
+                createSVG("path", {
+                    d: "M " + tick_x + " " + tick_y + " v " + tick_height,
+                    class: tick_class,
+                    append_to: this.layers.grid,
+                });
+                if (this.view_is(ViewMode.Month)) {
+                    tick_x +=
+                        (DateUtils.getDaysInMonth(date) *
+                            this.options.columnWidth) /
+                            30;
+                }
+                else {
+                    tick_x += this.options.columnWidth;
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    Gantt.prototype.make_grid_highlights = function () {
+        var e_6, _a;
+        if (this.view_is(ViewMode.Day)) {
+            var width = this.options.columnWidth;
+            var height = (this.options.barHeight + this.options.padding) *
+                this.tasks.length +
+                this.options.headerHeight +
+                this.options.padding / 2;
+            var x = 0;
+            try {
+                for (var _b = __values(this.dates), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var date = _c.value;
+                    var y = (this.options.headerHeight + this.options.padding) / 2;
+                    var isToday = date.toString() == DateUtils.today();
+                    var isWeekend = (date.getDay() == 0 || date.getDay() == 6);
+                    var className = void 0;
+                    if (isToday) {
+                        className = "today-highlight";
+                        y = (this.options.headerHeight + this.options.padding) / 2;
+                    }
+                    else if (isWeekend) {
+                        className = "weekend-highlight";
+                    }
+                    var rx = 3;
+                    var ry = 3;
+                    if (isToday || isWeekend) {
+                        createSVG("rect", {
+                            x: x,
+                            y: y,
+                            rx: rx,
+                            ry: ry,
+                            width: width,
+                            height: height,
+                            class: className,
+                            append_to: this.layers.grid
+                        });
+                    }
+                    x += this.options.columnWidth;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+    };
+    Gantt.prototype.make_dates = function () {
+        var dates = this.get_dates_to_draw();
+        var isHourView = this.view_is([ViewMode.Hour, ViewMode.QuarterDay, ViewMode.HalfDay]);
+        var counter = 0;
+        for (var i = 0; i < dates.length; i++) {
+            var date = dates[i];
+            if (isHourView && date.date >= this._realMinDate && date.date <= this._realMaxDate) {
+                createSVG("text", {
+                    x: date.lower_x,
+                    y: date.lower_y,
+                    innerHTML: "H" + counter++ * this.options.step,
+                    class: "title-1",
+                    append_to: this.layers.date,
+                });
+            }
+            createSVG("text", {
+                x: date.lower_x,
+                y: date.lower_y + 20,
+                innerHTML: date.lower_text,
+                class: "title-2",
+                append_to: this.layers.date,
+            });
+            if (date.upper_text) {
+                var $upper_text = createSVG("text", {
+                    x: date.upper_x,
+                    y: date.upper_y,
+                    innerHTML: date.upper_text,
+                    class: "upper-text",
+                    append_to: this.layers.date,
+                });
+                // remove out-of-bound dates
+                if ($upper_text.getBBox().x2 > this.layers.grid.getBBox().width) {
+                    $upper_text.remove();
+                }
+            }
+        }
+    };
+    Gantt.prototype.get_dates_to_draw = function () {
+        var _this = this;
+        var last_date = null;
+        var dates = this.dates.map(function (date, i) {
+            var d = _this.get_date_info(date, last_date, i);
+            last_date = date;
+            return d;
+        });
+        return dates;
+    };
+    Gantt.prototype.get_date_info = function (date, last_date, i) {
+        if (!last_date) {
+            last_date = DateUtils.add(date, 1, "year");
+        }
+        var date_text = {
+            hourLower: DateUtils.format(date, "HH:mm", this.options.language),
+            quarterDayLower: DateUtils.format(date, "HH:mm", this.options.language),
+            halfDayLower: DateUtils.format(date, "HH:mm", this.options.language),
+            dayLower: date.getDate() !== last_date.getDate()
+                ? DateUtils.format(date, "D", this.options.language)
+                : "",
+            weekLower: date.getMonth() !== last_date.getMonth()
+                ? DateUtils.format(date, "D MMM", this.options.language)
+                : DateUtils.format(date, "D", this.options.language),
+            monthLower: DateUtils.format(date, "MMMM", this.options.language),
+            yearLower: DateUtils.format(date, "YYYY", this.options.language),
+            quarterDayUpper: date.getDate() !== last_date.getDate()
+                ? DateUtils.format(date, "D MMM", this.options.language)
+                : "",
+            halfDayUpper: date.getDate() !== last_date.getDate()
+                ? date.getMonth() !== last_date.getMonth()
+                    ? DateUtils.format(date, "D MMM", this.options.language)
+                    : DateUtils.format(date, "D", this.options.language)
+                : "",
+            dayUpper: date.getMonth() !== last_date.getMonth()
+                ? DateUtils.format(date, "MMMM", this.options.language)
+                : "",
+            weekUpper: date.getMonth() !== last_date.getMonth()
+                ? DateUtils.format(date, "MMMM", this.options.language)
+                : "",
+            monthUpper: date.getFullYear() !== last_date.getFullYear()
+                ? DateUtils.format(date, "YYYY", this.options.language)
+                : "",
+            yearUpper: date.getFullYear() !== last_date.getFullYear()
+                ? DateUtils.format(date, "YYYY", this.options.language)
+                : "",
+            hour: date.getHours() !== last_date.getHours()
+                ? DateUtils.format(date, "HH:mm", this.options.language)
+                : "",
+        };
+        // Descontando 20 para adcionar uma segunda linha de informação no cabeçalho
+        var base_pos = {
+            x: i * this.options.columnWidth,
+            lower_y: this.options.headerHeight - 20,
+            upper_y: this.options.headerHeight - 20 - 25,
+        };
+        var x_pos = {
+            hourLower: this.options.columnWidth / 2,
+            hourUpper: this.options.columnWidth * 24 / 2,
+            quarterDayLower: this.options.columnWidth / 2,
+            quarterDayUpper: this.options.columnWidth * 4 / 2,
+            halfDayLower: this.options.columnWidth / 2,
+            halfDayUpper: this.options.columnWidth * 2 / 2,
+            dayLower: this.options.columnWidth / 2,
+            dayUpper: (this.options.columnWidth * 30) / 2,
+            weekLower: 0,
+            weekUpper: (this.options.columnWidth * 4) / 2,
+            monthLower: this.options.columnWidth / 2,
+            monthUpper: (this.options.columnWidth * 12) / 2,
+            yearLower: this.options.columnWidth / 2,
+            yearUpper: (this.options.columnWidth * 30) / 2,
+        };
+        return {
+            upper_text: date_text[this.options.viewMode + "Upper"],
+            lower_text: date_text[this.options.viewMode + "Lower"],
+            upper_x: base_pos.x + x_pos[this.options.viewMode + "Upper"],
+            upper_y: base_pos.upper_y,
+            lower_x: base_pos.x + x_pos[this.options.viewMode + "Lower"],
+            lower_y: base_pos.lower_y,
+            date: date,
+        };
+    };
+    Gantt.prototype.make_bars = function () {
+        var _this = this;
+        this.bars = this.tasks.map(function (task) {
+            var bar = new Bar(_this, task);
+            _this.layers.bar.appendChild(bar.group);
+            return bar;
+        });
+    };
+    Gantt.prototype.make_arrows = function () {
+        var e_7, _a;
+        var _this = this;
+        this.arrows = [];
+        var _loop_1 = function (task) {
+            var arrows = [];
+            arrows = task.dependencies
+                .map(function (task_id) {
+                var dependency = _this.get_task(task_id);
+                if (!dependency)
+                    return;
+                var arrow = new Arrow(_this, _this.bars[dependency._index], // from_task
+                _this.bars[task._index] // to_task
+                );
+                _this.layers.arrow.appendChild(arrow.element);
+                return arrow;
+            })
+                .filter(Boolean); // filter falsy values
+            this_1.arrows = this_1.arrows.concat(arrows);
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(this.tasks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var task = _c.value;
+                _loop_1(task);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    Gantt.prototype.map_arrows_on_bars = function () {
+        var e_8, _a;
+        var _loop_2 = function (bar) {
+            bar.arrows = this_2.arrows.filter(function (arrow) {
+                return (arrow.fromTask.task.id === bar.task.id ||
+                    arrow.toTask.task.id === bar.task.id);
+            });
+        };
+        var this_2 = this;
+        try {
+            for (var _b = __values(this.bars), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var bar = _c.value;
+                _loop_2(bar);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    };
+    Gantt.prototype.set_width = function () {
+        var cur_width = this.$svg.getBoundingClientRect().width;
+        var actual_width = this.$svg
+            .querySelector(".grid .grid-row")
+            .getAttribute("width");
+        if (cur_width < actual_width) {
+            this.$svg.setAttribute("width", actual_width);
+        }
+    };
+    Gantt.prototype.set_scroll_position = function () {
+        var parent_element = this.$svg.parentElement;
+        if (!parent_element)
+            return;
+        var hours_before_first_task = DateUtils.diff(this.get_oldest_starting_date(), this.minDate, "hour");
+        var scroll_pos = (hours_before_first_task / this.options.step) *
+            this.options.columnWidth -
+            this.options.columnWidth;
+        parent_element.scrollLeft = scroll_pos;
+    };
+    Gantt.prototype.bind_grid_click = function () {
+        var _this = this;
+        $.on(this.$svg, this.options.popupTrigger, ".grid-row, .grid-header", function () {
+            _this.unselect_all();
+            _this.hide_popup();
+        });
+    };
+    Gantt.prototype.bind_bar_events = function () {
+        var _this = this;
+        var is_dragging = false;
+        var x_on_start = 0;
+        var is_resizing_left = false;
+        var is_resizing_right = false;
+        var parent_bar_id = null;
+        var bars = [];
+        this.bar_being_dragged = null;
+        function action_in_progress() {
+            return is_dragging || is_resizing_left || is_resizing_right;
+        }
+        $.on(this.$svg, "mousedown", ".bar-wrapper, .handle", function (e, element) {
+            var bar_wrapper = $.closest(".bar-wrapper", element);
+            if (element.classList.contains("left")) {
+                is_resizing_left = true;
+            }
+            else if (element.classList.contains("right")) {
+                is_resizing_right = true;
+            }
+            else if (element.classList.contains("bar-wrapper")) {
+                is_dragging = true;
+            }
+            bar_wrapper.classList.add("active");
+            x_on_start = e.offsetX;
+            parent_bar_id = bar_wrapper.getAttribute("data-id");
+            var ids = __spread([
+                parent_bar_id
+            ], _this.get_all_dependent_tasks(parent_bar_id));
+            bars = ids.map(function (id) { return _this.get_bar(id); });
+            _this.bar_being_dragged = parent_bar_id;
+            bars.forEach(function (bar) {
+                var $bar = bar.element;
+                $bar.ox = $bar.getX();
+                $bar.oy = $bar.getY();
+                $bar.owidth = $bar.getWidth();
+                $bar.finaldx = 0;
+            });
+        });
+        $.on(this.$svg, "mousemove", function (e) {
+            if (!action_in_progress()) {
+                return;
+            }
+            var dx = e.offsetX - x_on_start;
+            bars.forEach(function (bar) {
+                var $bar = bar.element;
+                $bar.finaldx = _this.get_snap_position(dx);
+                _this.hide_popup();
+                if (is_resizing_left) {
+                    if (parent_bar_id === bar.task.id) {
+                        bar.updateBarPosition({
+                            x: $bar.ox + $bar.finaldx,
+                            width: $bar.owidth - $bar.finaldx,
+                        });
+                    }
+                    else {
+                        bar.updateBarPosition({
+                            x: $bar.ox + $bar.finaldx,
+                        });
+                    }
+                }
+                else if (is_resizing_right) {
+                    if (parent_bar_id === bar.task.id) {
+                        bar.updateBarPosition({
+                            width: $bar.owidth + $bar.finaldx,
+                        });
+                    }
+                }
+                else if (is_dragging) {
+                    bar.updateBarPosition({ x: $bar.ox + $bar.finaldx });
+                }
+            });
+        }, null);
+        document.addEventListener("mouseup", function (e) {
+            if (is_dragging || is_resizing_left || is_resizing_right) {
+                bars.forEach(function (bar) { return bar.group.classList.remove("active"); });
+            }
+            is_dragging = false;
+            is_resizing_left = false;
+            is_resizing_right = false;
+        });
+        $.on(this.$svg, "mouseup", function (e) {
+            _this.bar_being_dragged = null;
+            bars.forEach(function (bar) {
+                var $bar = bar.element;
+                if (!$bar.finaldx)
+                    return;
+                bar.dateChanged();
+                bar.setActionCompleted();
+            });
+        }, null);
+    };
+    Gantt.prototype.get_all_dependent_tasks = function (task_id) {
+        var _this = this;
+        var out = [];
+        var to_process = [task_id];
+        while (to_process.length) {
+            var deps = to_process.reduce(function (acc, curr) {
+                acc = acc.concat(_this.dependency_map[curr]);
+                return acc;
+            }, []);
+            out = out.concat(deps);
+            to_process = deps.filter(function (d) { return !to_process.includes(d); });
+        }
+        return out.filter(Boolean);
+    };
+    Gantt.prototype.get_snap_position = function (dx) {
+        var odx = dx, rem, position;
+        if (this.view_is(ViewMode.Hour)) {
+            rem = dx % (this.options.columnWidth / 6);
+            position = odx - rem + (rem < this.options.columnWidth / 12 ? 0 : this.options.columnWidth / 6);
+        }
+        else if (this.view_is(ViewMode.Week)) {
+            rem = dx % (this.options.columnWidth / 7);
+            position = odx - rem + (rem < this.options.columnWidth / 14 ? 0 : this.options.columnWidth / 7);
+        }
+        else if (this.view_is(ViewMode.Month)) {
+            rem = dx % (this.options.columnWidth / 30);
+            position = odx - rem + (rem < this.options.columnWidth / 60 ? 0 : this.options.columnWidth / 30);
+        }
+        else {
+            rem = dx % this.options.columnWidth;
+            position = odx - rem + (rem < this.options.columnWidth / 2 ? 0 : this.options.columnWidth);
+        }
+        return position;
+    };
+    Gantt.prototype.unselect_all = function () {
+        __spread(this.$svg.querySelectorAll(".bar-wrapper")).forEach(function (el) {
+            el.classList.remove("active");
+        });
+    };
+    Gantt.prototype.view_is = function (modes) {
+        var _this = this;
+        if (Array.isArray(modes)) {
+            return modes.some(function (mode) { return _this.options.viewMode === mode; });
+        }
+        return this.options.viewMode === modes;
+    };
+    Gantt.prototype.get_task = function (id) {
+        return this.tasks.find(function (task) {
+            return task.id === id;
+        });
+    };
+    Gantt.prototype.get_bar = function (id) {
+        return this.bars.find(function (bar) {
+            return bar.task.id === id;
+        });
+    };
+    Gantt.prototype.show_popup = function (options) {
+        if (!this.popup) {
+            this.popup = new Popup(this.popup_wrapper, this.options.customPopupHtml);
+        }
+        this.popup.show(options);
+    };
+    Gantt.prototype.hide_popup = function () {
+        this.popup && this.popup.hide();
+    };
+    Gantt.prototype.trigger_event = function (event, args) {
+        if (this.options[event]) {
+            this.options[event].apply(null, args);
+        }
+    };
+    Gantt.prototype.get_oldest_starting_date = function () {
+        return this.tasks
+            .map(function (task) { return task._start; })
+            .reduce(function (prev_date, cur_date) {
+            return cur_date <= prev_date ? cur_date : prev_date;
+        });
+    };
+    Gantt.prototype.clear = function () {
+        this.$svg.innerHTML = '';
+    };
+    return Gantt;
+}());
+function generate_id(task) {
+    return task.name + "_" + Math.random().toString(36).slice(2, 12);
+}
+
+var GanttComponent = /** @class */ (function () {
+    function GanttComponent() {
+        this.multipleTaskPerLine = false;
+        this.showSideTable = true;
+        this.viewMode = ViewMode.Day;
+        this.taskClicked = new EventEmitter();
+        this.taskDateChanged = new EventEmitter();
+        this.viewChanged = new EventEmitter();
+    }
+    GanttComponent.prototype.ngOnInit = function () {
+        this._validateViewMode();
+    };
+    GanttComponent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        this._gantt = new Gantt("#gantt", this._filterTask(this.tasks), {
+            viewMode: this.viewMode,
+            marginBeforeStart: this.marginBeforeStart,
+            marginAfterEnd: this.marginAfterEnd,
+            language: "pt-BR",
+            onClick: function (task) { return _this.taskClicked.emit(task); },
+            onDateChange: function (task, start, end) { return _this.taskDateChanged.emit({ task: task, start: start, end: end }); },
+            onViewChange: function (viewMode) { return _this.viewChanged.emit(viewMode); },
+        });
+    };
+    GanttComponent.prototype.ngOnChanges = function (changes) {
+        if (!this._gantt) {
+            return;
+        }
+        if (changes.viewMode) {
+            this._gantt.options.viewMode = changes.viewMode.currentValue;
+            this._gantt.change_view_mode();
+        }
+        if (changes.tasks) {
+            this._gantt.refresh(this._filterTask(changes.tasks.currentValue));
+        }
+    };
+    GanttComponent.prototype._filterTask = function (tasksGroups) {
+        var tasks = [];
+        if (this.multipleTaskPerLine) {
+            tasksGroups.forEach(function (group, index) {
+                tasks.push.apply(tasks, __spread(group.tasks.map(function (task) {
+                    return __assign(__assign({}, task), { _row_id: index });
+                })));
+            }, []);
+        }
+        else {
+            var i_1 = 0;
+            tasksGroups.forEach(function (group) {
+                tasks.push.apply(tasks, __spread(group.tasks.map(function (task) {
+                    return __assign(__assign({}, task), { _row_id: i_1++ });
+                })));
+            }, []);
+        }
+        return tasks;
+    };
+    GanttComponent.prototype._validateViewMode = function () {
+        if (![
+            ViewMode.Hour,
+            ViewMode.QuarterDay,
+            ViewMode.HalfDay,
+            ViewMode.Day,
+            ViewMode.Week,
+            ViewMode.Month,
+            ViewMode.Year,
+        ].includes(this.viewMode)) {
+            throw new Error("Invalid gantt view mode");
+        }
+    };
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "columnTitle", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "multipleTaskPerLine", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "showSideTable", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "viewMode", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "tasks", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "marginBeforeStart", void 0);
+    __decorate([
+        Input()
+    ], GanttComponent.prototype, "marginAfterEnd", void 0);
+    __decorate([
+        Output()
+    ], GanttComponent.prototype, "taskClicked", void 0);
+    __decorate([
+        Output()
+    ], GanttComponent.prototype, "taskDateChanged", void 0);
+    __decorate([
+        Output()
+    ], GanttComponent.prototype, "viewChanged", void 0);
+    GanttComponent = __decorate([
+        Component({
+            selector: "s-gantt",
+            template: "<div class=\"outer\">\n    <gantt-side-table\n        *ngIf=\"showSideTable\"\n        [tasks]=\"tasks\"\n        [columnTitle]=\"columnTitle\"\n        [multipleTaskPerLine]=\"multipleTaskPerLine\">\n    </gantt-side-table>\n    <svg id=\"gantt\"></svg>\n</div>",
+            encapsulation: ViewEncapsulation.None,
+            styles: [".outer{display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:start;align-items:flex-start;-ms-flex-line-pack:center;align-content:center;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row}", ".gantt{border:1px solid #e0e0e0}.gantt .weekend-highlight{fill:#b8c2cc;opacity:.5;stroke:#ebeff2;stroke-width:1}.gantt .grid-background{fill:none}.gantt .grid-header,.gantt .grid-row{fill:#fff}.gantt .grid-row:nth-child(even){fill:#f5f5f5}.gantt .row-line{stroke:#ebeff2}.gantt .tick{stroke:#e0e0e0;stroke-width:.2}.gantt .tick.thick{stroke-width:.4}.gantt .today-highlight{fill:#ffe979;opacity:.5}.gantt .arrow{fill:none;stroke:#666;stroke-width:1.4}.gantt .bar{opacity:.8;stroke:#8d99a6;stroke-width:0;transition:stroke-width .3s;-webkit-user-select:none;-ms-user-select:none;user-select:none}.gantt .bar-invalid{fill:transparent;stroke:#8d99a6;stroke-dasharray:5;stroke-width:1}.gantt .bar-invalid~.bar-label{fill:#555}.gantt .bar-label{fill:#fff;text-anchor:middle;font-size:12px;font-weight:lighter}.gantt .bar-label.big{fill:#555;text-anchor:start}.gantt .bar-wrapper{cursor:pointer;outline:0}.gantt .bar-wrapper.active .bar,.gantt .bar-wrapper:hover .bar{opacity:1}.gantt .bar-wrapper.active .bar{stroke:#212533;stroke-width:2}.gantt .lower-text,.gantt .upper-text{font-size:12px;text-anchor:middle}.gantt .upper-text{fill:#555}.gantt .lower-text{fill:#333}.gantt .hide{display:none}.gantt-container{border-left:1px solid #e0e0e0;font-size:12px;overflow:auto;position:relative}.gantt-container .title-1{fill:#999;font-size:12px;font-weight:400;line-height:150%;text-anchor:middle}.gantt-container .title-2{fill:#333;font-size:14px;font-weight:400;line-height:150%;text-anchor:middle}.gantt-container .popup-wrapper{left:0;position:absolute;top:0}.gantt-container .popup-wrapper .popup{background:#0e1119;border-radius:2px;color:#fff;padding:8px;font-family:\"Open Sans\" sans-serif;line-height:150%;font-weight:400}.gantt-container .popup-wrapper .popup .wrp-title{border-bottom:1px solid #525966;padding-bottom:10px}.gantt-container .popup-wrapper .popup .wrp-title .title{font-size:14px}.gantt-container .popup-wrapper .popup .wrp-subtitle{color:#dfe2e5;padding-top:10px}.gantt-container .popup-wrapper .popup .wrp-subtitle .icon{margin-right:8px}.gantt-container .popup-wrapper .popup .wrp-subtitle .subtitle{font-size:12px}.gantt-container .popup-wrapper .popup .pointer{border:6px solid transparent;border-top-color:#0e1119;height:6px;margin-left:-4px;position:absolute}"]
+        })
+    ], GanttComponent);
+    return GanttComponent;
+}());
+
+var SideTableComponent = /** @class */ (function () {
+    function SideTableComponent() {
+        this.ROW_HEIGHT = 44;
+        this.multipleTaskPerLine = false;
+    }
+    __decorate([
+        Input()
+    ], SideTableComponent.prototype, "columnTitle", void 0);
+    __decorate([
+        Input()
+    ], SideTableComponent.prototype, "tasks", void 0);
+    __decorate([
+        Input()
+    ], SideTableComponent.prototype, "multipleTaskPerLine", void 0);
+    SideTableComponent = __decorate([
+        Component({
+            selector: 'gantt-side-table',
+            template: "<div class=\"side-table\">\n    <div class=\"column-title\">\n        <span>{{ columnTitle }}</span>\n    </div>\n    <div class=\"tasks\">\n        <div *ngFor=\"let task of tasks; let i = index\" class=\"task\" [ngStyle]=\"{'height.px': multipleTaskPerLine\n                ? ROW_HEIGHT\n                : ROW_HEIGHT * task.tasks.length}\">\n            <div class=\"title\">\n                {{ task.title }}\n            </div>\n            <div class=\"subtitle\">\n                {{ task.subtitle }}\n            </div>\n        </div>\n    </div>\n</div>",
+            styles: [".side-table{background:#fff;height:100%;min-width:175px}.side-table .column-title{height:106px;border:1px solid #e0e0e0;box-sizing:border-box;display:-ms-flexbox;display:flex;-ms-flex-align:end;align-items:flex-end;-ms-flex-pack:center;justify-content:center;padding:8px}.side-table .column-title span{font-family:\"Open Sans\" sans-serif;font-size:14px;font-weight:700;line-height:150%}.side-table .task{-ms-flex-align:center;align-items:center;background-color:#fff;border:1px solid #e0e0e0;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;font-family:\"Open Sans\" sans-serif;font-weight:400;-ms-flex-pack:center;justify-content:center;line-height:150%;padding:5px}.side-table .task .title{color:#333;font-size:14px}.side-table .task .subtitle{color:#999;font-size:12px}"]
+        })
+    ], SideTableComponent);
+    return SideTableComponent;
+}());
+
+var GanttModule = /** @class */ (function () {
+    function GanttModule() {
+    }
+    GanttModule = __decorate([
+        NgModule({
+            imports: [CommonModule],
+            declarations: [
+                GanttComponent,
+                SideTableComponent,
+            ],
+            exports: [GanttComponent],
+        })
+    ], GanttModule);
+    return GanttModule;
+}());
+
 var HeaderComponent = /** @class */ (function () {
     function HeaderComponent() {
     }
@@ -11582,7 +13286,7 @@ function getCompletionResults(context) {
     startCompletionResultsSearch(context);
 }
 var cancelLastCompletionSearch = function () { };
-var ɵ0 = cancelLastCompletionSearch;
+var ɵ0$1 = cancelLastCompletionSearch;
 var codeMirrorViewElement;
 /*
  * Starts a new completionResults's async search.
@@ -12552,6 +14256,102 @@ var SplitButtonModule = /** @class */ (function () {
     return SplitButtonModule;
 }());
 
+var SwitchComponent = /** @class */ (function () {
+    function SwitchComponent() {
+        this.readonly = false;
+        this.disabled = false;
+        this.valueChanged = new EventEmitter();
+        this.value = false;
+    }
+    SwitchComponent_1 = SwitchComponent;
+    SwitchComponent.prototype.onFocusIn = function () {
+        var switchElement = this.switchRef.nativeElement;
+        switchElement.classList.add("switch--focus");
+    };
+    SwitchComponent.prototype.onFocusOut = function () {
+        var switchElement = this.switchRef.nativeElement;
+        switchElement.classList.remove("switch--focus");
+    };
+    SwitchComponent.prototype.writeValue = function (value) {
+        if (!this.disabled) {
+            this.value = value;
+        }
+    };
+    SwitchComponent.prototype.registerOnChange = function (onChange) {
+        this._onChange = onChange;
+    };
+    SwitchComponent.prototype.registerOnTouched = function (onTouched) {
+        this._onTouched = onTouched;
+    };
+    SwitchComponent.prototype.setDisabledState = function (disabled) {
+        this.disabled = disabled;
+    };
+    SwitchComponent.prototype.toggleCheck = function () {
+        this.value = !this.value;
+        this.valueChanged.emit(this.value);
+        if (this._onChange) {
+            this._onChange(this.value);
+        }
+    };
+    var SwitchComponent_1;
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "readonly", void 0);
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "trueLabel", void 0);
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "falseLabel", void 0);
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "inputId", void 0);
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "disabled", void 0);
+    __decorate([
+        Output()
+    ], SwitchComponent.prototype, "valueChanged", void 0);
+    __decorate([
+        Input()
+    ], SwitchComponent.prototype, "value", void 0);
+    __decorate([
+        ViewChild("switch", { static: true })
+    ], SwitchComponent.prototype, "switchRef", void 0);
+    __decorate([
+        HostListener('focusin')
+    ], SwitchComponent.prototype, "onFocusIn", null);
+    __decorate([
+        HostListener('focusout')
+    ], SwitchComponent.prototype, "onFocusOut", null);
+    SwitchComponent = SwitchComponent_1 = __decorate([
+        Component({
+            selector: 's-switch',
+            template: "<div #switch class=\"switch\" [ngClass]=\"{ 'switch--disabled': disabled }\">\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            type=\"checkbox\"\n            [checked]=\"value\"\n            [disabled]=\"readonly || disabled\"\n            (change)=\"toggleCheck()\">\n        <span class=\"slider\"></span>\n    </label>\n    <span class=\"label\">\n        {{ value ? trueLabel : falseLabel }}\n    </span>\n</div>",
+            providers: [{
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return SwitchComponent_1; }),
+                    multi: true,
+                }],
+            styles: [".switch{display:-ms-inline-flexbox;display:inline-flex}.switch .switch-toggle{display:inline-block;height:24px;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translateX(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;bottom:0;cursor:pointer;left:0;position:absolute;right:0;top:0;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428BCA80}"]
+        })
+    ], SwitchComponent);
+    return SwitchComponent;
+}());
+
+var SwitchModule = /** @class */ (function () {
+    function SwitchModule() {
+    }
+    SwitchModule = __decorate([
+        NgModule({
+            imports: [CommonModule],
+            declarations: [SwitchComponent],
+            exports: [SwitchComponent],
+        })
+    ], SwitchModule);
+    return SwitchModule;
+}());
+
 var PanelComponent = /** @class */ (function () {
     function PanelComponent() {
         this.toggleable = true;
@@ -12849,5 +14649,5 @@ var fallback = {
  * Generated bundle index. Do not edit.
  */
 
-export { AccordionComponent, AccordionModule, AccordionPanelComponent, AngularComponentsModule, AutocompleteField, BadgeColors, BadgeComponent, BadgeModule, BaseFieldComponent, BignumberField, BignumberInputDirective, BignumberInputModule, BooleanField, BooleanOptionsLabel, BreadcrumbComponent, BreadcrumbModule, Breakpoints, ButtonComponent, ButtonModule, ButtonPriority, ButtonSize, CalendarField, CalendarLocaleOptions, CalendarMaskDirective, CalendarMaskModule, ChipsField, CodeEditorModule, CollapseLinkComponent, CollapseLinkModule, ControlErrorsComponent, ControlErrorsModule, CountryPhonePickerComponent, CountryPhonePickerModule, CurrencyField, CustomFieldsComponent, CustomFieldsModule, CustomFieldsService, DEFAULT_CALENDAR_LOCALE_OPTIONS, DEFAULT_LOCALE_OPTIONS, DEFAULT_NUMBER_LOCALE_OPTIONS, DebounceUtils, DoubleClickDirective, DynamicConfig, DynamicFormComponent, DynamicFormModule, DynamicType, EditableOverlayDirective, EditableOverlayModule, EmptyStateComponent, EmptyStateModule, EnumBadgeColors, EnumColumnFieldType, EnumSeverity, ExportUtils, Field, FieldType, Fieldset, FileUploadComponent, FileUploadModule, FileValidation, FormField, GlobalSearchComponent, GlobalSearchDropdownItemComponent, GlobalSearchModule, GlobalSearchSizeEnum, HostProjectConfigsInjectionToken, ImageCropperComponent, ImageCropperModule, ImageCropperService, InfoSignDirective, InfoSignModule, Languages, LoadingStateComponent, LoadingStateDirective, LoadingStateModule, LocaleModule, LocaleOptions, LocaleService, LocalizedCurrencyPipe, LocalizedCurrencyPipeOptions, LocalizedDateImpurePipe, LocalizedDatePipe, LocalizedNumberInputDirective, LocalizedNumberInputModule, LocalizedNumberPipe, LocalizedTimeImpurePipe, LocalizedTimePipe, LongPressDirective, LookupComponent, LookupField, MaskFormatterModule, MaskFormatterPipe, MouseEventsModule, NavigationDirective, NumberAlignmentOption, NumberField, NumberInputDirective, NumberInputModule, NumberLocaleOptions, ObjectCardComponent, ObjectCardFieldComponent, ObjectCardMainComponent, ObjectCardModule, Option, Ordination, PanelComponent, PanelModule, PasswordField, PasswordStrengthComponent, PasswordStrengthDirective, PasswordStrengthModule, PasswordStrengthPositions, PasswordStrengths, ProductHeaderComponent, ProductHeaderModule, ProfilePicturePickerComponent, ProfilePicturePickerModule, ProgressBarColors, ProgressBarComponent, ProgressBarModule, RadioButtonField, RatingScaleComponent, RatingScaleModule, RationButtonOption, RowTogllerDirective, Section, SelectField, SelectOption, SidebarComponent, SidebarModule, SlidePanelComponent, SlidePanelModule, SplitButtonComponent, SplitButtonModule, SplitButtonType, StatsCardComponent, StatsCardModule, StepState, StepsComponent, StepsModule, Structure, TableFrozenPositionDirective, TableHeaderCheckboxComponent, TableHeaderCheckboxModule, TableModule, TaxCalculationLanguageConfigs, TextAreaField, TextField, Themes, ThumbnailComponent, ThumbnailModule, ThumbnailSize, TileComponent, TileModule, TimelineComponent, TimelineItem, TimelineItemSeverity, TimelineItemSize, TimelineModule, TokenListComponent, TokenListModule, TooltipModule, TooltipPosition, ValidateErrors, WorkspaceSwitchComponent, WorkspaceSwitchModule, countries, fallback, TooltipComponent as ɵa, TooltipDirective as ɵb, SelectFieldComponent as ɵba, TextAreaFieldComponent as ɵbb, TextFieldComponent as ɵbc, BooleanSwitchFieldComponent as ɵbd, PasswordFieldComponent as ɵbe, SliderFieldComponent as ɵbf, DecimalField as ɵbh, StructureModule as ɵbi, HeaderComponent as ɵbj, FooterComponent as ɵbk, NumberLocaleOptions as ɵbl, ThumbnailService as ɵbm, BorderButtonModule as ɵbn, BorderButtonComponent as ɵbo, TimelineItemModule as ɵbp, TimelineIconItemComponent as ɵbq, HorizontalTimelineModule as ɵbr, HorizontalTimelineComponent as ɵbs, VerticalTimelineModule as ɵbt, VerticalTimelineComponent as ɵbu, RangeLineComponent as ɵbv, CollapseOptionComponent as ɵbw, CollapsedItemsComponent as ɵbx, VerticalItemsComponent as ɵby, InfiniteScrollModule as ɵbz, CountryPhonePickerService as ɵc, InfiniteScrollDirective as ɵca, CustomTranslationsModule as ɵcb, CodeEditorComponent as ɵcc, CoreFacade as ɵcd, CodeMirror6Core as ɵce, LocalizedCurrencyImpurePipe as ɵd, LocalizedBignumberPipe as ɵe, LocalizedBignumberImpurePipe as ɵf, EmptyStateGoBackComponent as ɵg, FileUploadService as ɵh, InfoSignComponent as ɵi, TableColumnsComponent as ɵj, TablePagingComponent as ɵk, AutocompleteFieldComponent as ɵl, BooleanFieldComponent as ɵm, CalendarFieldComponent as ɵn, ChipsFieldComponent as ɵo, CurrencyFieldComponent as ɵp, DynamicFieldComponent as ɵq, DynamicFormDirective as ɵr, FieldsetComponent as ɵs, FileUploadComponent$1 as ɵt, LookupFieldComponent as ɵu, NumberFieldComponent as ɵv, BignumberFieldComponent as ɵw, RadioButtonComponent as ɵx, RowComponent as ɵy, SectionComponent as ɵz };
+export { AccordionComponent, AccordionModule, AccordionPanelComponent, AngularComponentsModule, AutocompleteField, BadgeColors, BadgeComponent, BadgeModule, BaseFieldComponent, BignumberField, BignumberInputDirective, BignumberInputModule, BooleanField, BooleanOptionsLabel, BreadcrumbComponent, BreadcrumbModule, Breakpoints, ButtonComponent, ButtonModule, ButtonPriority, ButtonSize, CalendarField, CalendarLocaleOptions, CalendarMaskDirective, CalendarMaskModule, ChipsField, CodeEditorModule, CollapseLinkComponent, CollapseLinkModule, ControlErrorsComponent, ControlErrorsModule, CountryPhonePickerComponent, CountryPhonePickerModule, CurrencyField, CustomFieldsComponent, CustomFieldsModule, CustomFieldsService, DEFAULT_CALENDAR_LOCALE_OPTIONS, DEFAULT_LOCALE_OPTIONS, DEFAULT_NUMBER_LOCALE_OPTIONS, DebounceUtils, DoubleClickDirective, DynamicConfig, DynamicFormComponent, DynamicFormModule, DynamicType, EditableOverlayDirective, EditableOverlayModule, EmptyStateComponent, EmptyStateModule, EnumBadgeColors, EnumColumnFieldType, EnumSeverity, ExportUtils, Field, FieldType, Fieldset, FileUploadComponent, FileUploadModule, FileValidation, FormField, GanttComponent, GanttModule, GlobalSearchComponent, GlobalSearchDropdownItemComponent, GlobalSearchModule, GlobalSearchSizeEnum, HostProjectConfigsInjectionToken, ImageCropperComponent, ImageCropperModule, ImageCropperService, InfoSignDirective, InfoSignModule, Languages, LoadingStateComponent, LoadingStateDirective, LoadingStateModule, LocaleModule, LocaleOptions, LocaleService, LocalizedCurrencyPipe, LocalizedCurrencyPipeOptions, LocalizedDateImpurePipe, LocalizedDatePipe, LocalizedNumberInputDirective, LocalizedNumberInputModule, LocalizedNumberPipe, LocalizedTimeImpurePipe, LocalizedTimePipe, LongPressDirective, LookupComponent, LookupField, MaskFormatterModule, MaskFormatterPipe, MouseEventsModule, NavigationDirective, NumberAlignmentOption, NumberField, NumberInputDirective, NumberInputModule, NumberLocaleOptions, ObjectCardComponent, ObjectCardFieldComponent, ObjectCardMainComponent, ObjectCardModule, Option, Ordination, PanelComponent, PanelModule, PasswordField, PasswordStrengthComponent, PasswordStrengthDirective, PasswordStrengthModule, PasswordStrengthPositions, PasswordStrengths, ProductHeaderComponent, ProductHeaderModule, ProfilePicturePickerComponent, ProfilePicturePickerModule, ProgressBarColors, ProgressBarComponent, ProgressBarModule, RadioButtonField, RatingScaleComponent, RatingScaleModule, RationButtonOption, RowTogllerDirective, Section, SelectField, SelectOption, SidebarComponent, SidebarModule, SlidePanelComponent, SlidePanelModule, SplitButtonComponent, SplitButtonModule, SplitButtonType, StatsCardComponent, StatsCardModule, StepState, StepsComponent, StepsModule, Structure, SwitchComponent, SwitchModule, TableFrozenPositionDirective, TableHeaderCheckboxComponent, TableHeaderCheckboxModule, TableModule, TaxCalculationLanguageConfigs, TextAreaField, TextField, Themes, ThumbnailComponent, ThumbnailModule, ThumbnailSize, TileComponent, TileModule, TimelineComponent, TimelineItem, TimelineItemSeverity, TimelineItemSize, TimelineModule, TokenListComponent, TokenListModule, TooltipModule, TooltipPosition, ValidateErrors, ViewMode, WorkspaceSwitchComponent, WorkspaceSwitchModule, countries, fallback, TooltipComponent as ɵa, TooltipDirective as ɵb, SelectFieldComponent as ɵba, TextAreaFieldComponent as ɵbb, TextFieldComponent as ɵbc, BooleanSwitchFieldComponent as ɵbd, PasswordFieldComponent as ɵbe, SliderFieldComponent as ɵbf, DecimalField as ɵbh, SideTableComponent as ɵbi, StructureModule as ɵbj, HeaderComponent as ɵbk, FooterComponent as ɵbl, NumberLocaleOptions as ɵbm, ThumbnailService as ɵbn, BorderButtonModule as ɵbo, BorderButtonComponent as ɵbp, TimelineItemModule as ɵbq, TimelineIconItemComponent as ɵbr, HorizontalTimelineModule as ɵbs, HorizontalTimelineComponent as ɵbt, VerticalTimelineModule as ɵbu, VerticalTimelineComponent as ɵbv, RangeLineComponent as ɵbw, CollapseOptionComponent as ɵbx, CollapsedItemsComponent as ɵby, VerticalItemsComponent as ɵbz, CountryPhonePickerService as ɵc, InfiniteScrollModule as ɵca, InfiniteScrollDirective as ɵcb, CustomTranslationsModule as ɵcc, CodeEditorComponent as ɵcd, CoreFacade as ɵce, CodeMirror6Core as ɵcf, LocalizedCurrencyImpurePipe as ɵd, LocalizedBignumberPipe as ɵe, LocalizedBignumberImpurePipe as ɵf, EmptyStateGoBackComponent as ɵg, FileUploadService as ɵh, InfoSignComponent as ɵi, TableColumnsComponent as ɵj, TablePagingComponent as ɵk, AutocompleteFieldComponent as ɵl, BooleanFieldComponent as ɵm, CalendarFieldComponent as ɵn, ChipsFieldComponent as ɵo, CurrencyFieldComponent as ɵp, DynamicFieldComponent as ɵq, DynamicFormDirective as ɵr, FieldsetComponent as ɵs, FileUploadComponent$1 as ɵt, LookupFieldComponent as ɵu, NumberFieldComponent as ɵv, BignumberFieldComponent as ɵw, RadioButtonComponent as ɵx, RowComponent as ɵy, SectionComponent as ɵz };
 //# sourceMappingURL=seniorsistemas-angular-components.js.map