@seniorsistemas/angular-components 17.31.2 → 18.0.0-develop-ae6477c0

package/esm2022/gantt/lib/gantt/components/gantt/popup.mjs

@@ -0,0 +1,110 @@
+export class Popup {
+    _parent;
+    _customHtml;
+    _title;
+    _startDate;
+    _startHour;
+    _endDate;
+    _endHour;
+    _pointer;
+    constructor(parent, customHtml) {
+        this._parent = parent;
+        this._customHtml = customHtml;
+        this._make();
+    }
+    show(options) {
+        if (!options.target_element) {
+            throw new Error('target_element is required to show popup');
+        }
+        if (!options.position) {
+            options.position = 'left';
+        }
+        const targetElement = options.target_element;
+        this._parent.style.display = 'block';
+        if (this._customHtml) {
+            let 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._startDate.innerHTML = options.subtitle.startDate ?? '';
+            this._startHour.innerHTML = options.subtitle.startHour ?? '';
+            this._endDate.innerHTML = options.subtitle.endDate ?? '';
+            this._endHour.innerHTML = options.subtitle.endHour ?? '';
+            this._parent.style.width = this._parent.clientWidth + 'px';
+        }
+        // set position
+        let positionMeta;
+        if (targetElement instanceof HTMLElement) {
+            positionMeta = targetElement.getBoundingClientRect();
+        }
+        else if (targetElement instanceof SVGElement) {
+            positionMeta = options.target_element.getBBox();
+        }
+        if (options.position === 'middle') {
+            this._parent.style.position = 'fixed';
+            this._parent.style.top = options.y + 'px';
+            this._pointer.style.transform = 'rotateZ(180deg)';
+            this._pointer.style.top = '-10px';
+            if ((options.x - 17) + this._parent.offsetWidth > window.innerWidth) {
+                this._parent.style.left = (options.x - this._parent.offsetWidth + 17) + 'px';
+                this._pointer.style.right = '16px';
+                this._pointer.style.left = 'auto';
+            }
+            else {
+                this._parent.style.left = (options.x - 17) + 'px';
+                this._pointer.style.left = '16px';
+                this._pointer.style.right = 'auto';
+            }
+        }
+        else 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;
+    }
+    _make() {
+        this._parent.innerHTML = `
+        <div class="popup">
+            <div class="wrp-title">
+                <span class="title"></span>
+            </div>
+            <div class="wrp-subtitle">
+                <span class="icon fas fa-calendar-alt"></span>
+                <div style="margin-right: 15px">
+                    <p class="startDate"></p>
+                    <p class="startHour"></p>
+                </div>
+                <div>
+                    <p class="endDate"></p>
+                    <p class="endHour"></p>
+                </div>
+            </div>
+            <div class="pointer"></div>
+        </div>
+        `;
+        this._hide();
+        this._title = this._parent.querySelector('.title');
+        this._startDate = this._parent.querySelector('.startDate');
+        this._startHour = this._parent.querySelector('.startHour');
+        this._endDate = this._parent.querySelector('.endDate');
+        this._endHour = this._parent.querySelector('.endHour');
+        this._pointer = this._parent.querySelector('.pointer');
+    }
+    _hide() {
+        this._parent.style.opacity = 0;
+        this._parent.style.display = 'none';
+        this._parent.style.left = 0;
+    }
+    hide() {
+        this._hide();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popup.js","sourceRoot":"","sources":["../../../../../../../projects/angular-components/gantt/src/lib/gantt/components/gantt/popup.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,KAAK;IACN,OAAO,CAAM;IACb,WAAW,CAAM;IACjB,MAAM,CAAM;IACZ,UAAU,CAAM;IAChB,UAAU,CAAM;IAChB,QAAQ,CAAM;IACd,QAAQ,CAAM;IACd,QAAQ,CAAM;IAEtB,YAAY,MAAW,EAAE,UAAe;QACpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEM,IAAI,CAAC,OAAY;QACpB,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YACpB,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC;QAC9B,CAAC;QACD,MAAM,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;QAErC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC1C,IAAI,IAAI,6BAA6B,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC;aAAM,CAAC;YACJ,WAAW;YACX,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC;YACtC,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAC;YAC7D,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAC;YAC7D,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC;YACzD,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC;YAEzD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QAC/D,CAAC;QAED,eAAe;QACf,IAAI,YAAY,CAAC;QACjB,IAAI,aAAa,YAAY,WAAW,EAAE,CAAC;YACvC,YAAY,GAAG,aAAa,CAAC,qBAAqB,EAAE,CAAC;QACzD,CAAC;aAAM,IAAI,aAAa,YAAY,UAAU,EAAE,CAAC;YAC7C,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QACpD,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAChC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;YAE1C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,GAAG,iBAAiB,CAAC;YAClD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC;YAElC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;gBAClE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;gBAC7E,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;gBACnC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;YAEtC,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;gBAClD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;gBAClC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;YACvC,CAAC;QAEL,CAAC;aAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;YACrC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;YAC5E,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC;YAE/C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,GAAG,gBAAgB,CAAC;YACjD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;YAClC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC;QACpC,CAAC;QAED,OAAO;QACP,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;IACnC,CAAC;IAEO,KAAK;QACT,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG;;;;;;;;;;;;;;;;;;SAkBxB,CAAC;QAEF,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAC3D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAC3D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAEvD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAC3D,CAAC;IAEO,KAAK;QACT,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC;IAChC,CAAC;IAEM,IAAI;QACP,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;CACJ","sourcesContent":["export class Popup {\n    private _parent: any;\n    private _customHtml: any;\n    private _title: any;\n    private _startDate: any;\n    private _startHour: any;\n    private _endDate: any;\n    private _endHour: any;\n    private _pointer: any;\n\n    constructor(parent: any, customHtml: any) {\n        this._parent = parent;\n        this._customHtml = customHtml;\n        this._make();\n    }\n\n    public show(options: any) {\n        if (!options.target_element) {\n            throw new Error('target_element is required to show popup');\n        }\n        if (!options.position) {\n            options.position = 'left';\n        }\n        const targetElement = options.target_element;\n        this._parent.style.display = 'block';\n\n        if (this._customHtml) {\n            let html = this._customHtml(options.task);\n            html += '<div class=\"pointer\"></div>';\n            this._parent.innerHTML = html;\n            this._pointer = this._parent.querySelector('.pointer');\n        } else {\n            // set data\n            this._title.innerHTML = options.title;\n            this._startDate.innerHTML = options.subtitle.startDate ?? '';\n            this._startHour.innerHTML = options.subtitle.startHour ?? '';\n            this._endDate.innerHTML = options.subtitle.endDate ?? '';\n            this._endHour.innerHTML = options.subtitle.endHour ?? '';\n\n            this._parent.style.width = this._parent.clientWidth + 'px';\n        }\n\n        // set position\n        let positionMeta;\n        if (targetElement instanceof HTMLElement) {\n            positionMeta = targetElement.getBoundingClientRect();\n        } else if (targetElement instanceof SVGElement) {\n            positionMeta = options.target_element.getBBox();\n        }\n\n        if (options.position === 'middle') {\n            this._parent.style.position = 'fixed';\n            this._parent.style.top = options.y + 'px';\n\n            this._pointer.style.transform = 'rotateZ(180deg)';\n            this._pointer.style.top = '-10px';\n\n            if ((options.x - 17) + this._parent.offsetWidth > window.innerWidth) {\n                this._parent.style.left = (options.x - this._parent.offsetWidth + 17) + 'px';\n                this._pointer.style.right = '16px';\n                this._pointer.style.left = 'auto';\n\n            } else {\n                this._parent.style.left = (options.x - 17) + 'px';\n                this._pointer.style.left = '16px';\n                this._pointer.style.right = 'auto';\n            }\n\n        } else if (options.position === 'left') {\n            this._parent.style.left = positionMeta.x + (positionMeta.width + 10) + 'px';\n            this._parent.style.top = positionMeta.y + 'px';\n\n            this._pointer.style.transform = 'rotateZ(90deg)';\n            this._pointer.style.left = '-7px';\n            this._pointer.style.top = '2px';\n        }\n\n        // show\n        this._parent.style.opacity = 1;\n    }\n\n    private _make() {\n        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                <div style=\"margin-right: 15px\">\n                    <p class=\"startDate\"></p>\n                    <p class=\"startHour\"></p>\n                </div>\n                <div>\n                    <p class=\"endDate\"></p>\n                    <p class=\"endHour\"></p>\n                </div>\n            </div>\n            <div class=\"pointer\"></div>\n        </div>\n        `;\n\n        this._hide();\n\n        this._title = this._parent.querySelector('.title');\n        this._startDate = this._parent.querySelector('.startDate');\n        this._startHour = this._parent.querySelector('.startHour');\n        this._endDate = this._parent.querySelector('.endDate');\n        this._endHour = this._parent.querySelector('.endHour');\n\n        this._pointer = this._parent.querySelector('.pointer');\n    }\n\n    private _hide() {\n        this._parent.style.opacity = 0;\n        this._parent.style.display = 'none';\n        this._parent.style.left = 0;\n    }\n\n    public hide() {\n        this._hide();\n    }\n}\n"]}

package/esm2022/gantt/lib/gantt/components/gantt/utils/date-utils.mjs

@@ -0,0 +1,116 @@
+import moment from 'moment';
+const YEAR = 'year';
+const MONTH = 'month';
+const DAY = 'day';
+const HOUR = 'hour';
+const MINUTE = 'minute';
+const SECOND = 'second';
+const MILLISECOND = 'millisecond';
+export class DateUtils {
+    static parse(date) {
+        return moment(date).toDate();
+    }
+    static toString(date, with_time = false) {
+        const result = with_time ? moment(date, 'YYYY-MM-DD hh:mm:ss.SSS') : moment(date, 'YYYY-MM-DD');
+        return result.toString();
+    }
+    static format(date, formatString = 'YYYY-MM-DD HH:mm:ss.SSS', lang = 'en') {
+        const monthName = moment(date).locale(lang).startOf('month').format('MMMM');
+        const monthNameCapitalized = monthName.charAt(0).toUpperCase() + monthName.slice(1);
+        const dateToFormat = moment(date).locale(lang);
+        const formatMap = {
+            YYYY: dateToFormat.format('YYYY'),
+            MM: dateToFormat.format('MM'),
+            DD: dateToFormat.format('DD'),
+            // Removendo alterações nas traduções que acontecem nos diferentes idiomas
+            ddd: dateToFormat.format('ddd').toUpperCase().replace('.', ''),
+            HH: dateToFormat.format('HH'),
+            mm: dateToFormat.format('mm'),
+            ss: dateToFormat.format('ss'),
+            SSS: dateToFormat.format('SSS'),
+            D: dateToFormat.format('D'),
+            MMMM: monthNameCapitalized,
+            MMM: monthNameCapitalized,
+        };
+        let str = formatString;
+        const formattedValues = [];
+        Object.keys(formatMap)
+            .sort((a, b) => b.length - a.length)
+            .forEach((key) => {
+            if (str.includes(key)) {
+                str = str.replace(key, `$${formattedValues.length}`);
+                formattedValues.push(formatMap[key]);
+            }
+        });
+        formattedValues.forEach((value, i) => {
+            str = str.replace(`$${i}`, value);
+        });
+        return str;
+    }
+    static diff(fistDate, secondDate, scale) {
+        const milliseconds = moment(fistDate).diff(secondDate, MILLISECOND);
+        const seconds = moment(fistDate).diff(secondDate, SECOND);
+        const minutes = moment(fistDate).diff(secondDate, MINUTE);
+        const hours = moment(fistDate).diff(secondDate, HOUR);
+        const days = moment(fistDate).diff(secondDate, DAY);
+        const months = moment(fistDate).diff(secondDate, MONTH);
+        const years = moment(fistDate).diff(secondDate, YEAR);
+        if (!scale.endsWith('s')) {
+            scale += 's';
+        }
+        return Math.floor({ milliseconds, seconds, minutes, hours, days, months, years }[scale]);
+    }
+    static today() {
+        const dateStr = moment().format('YYY-MM-DD');
+        return new Date(dateStr);
+    }
+    static now() {
+        return moment().toDate();
+    }
+    static add(date, quantity, scale) {
+        return moment(date).add(quantity, scale).toDate();
+    }
+    static startOf(date, scale) {
+        const scores = {
+            [YEAR]: 6,
+            [MONTH]: 5,
+            [DAY]: 4,
+            [HOUR]: 3,
+            [MINUTE]: 2,
+            [SECOND]: 1,
+            [MILLISECOND]: 0,
+        };
+        function shouldReset(_scale) {
+            const maxScore = scores[scale];
+            return scores[_scale] <= maxScore;
+        }
+        const 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]);
+    }
+    static clone(date) {
+        return moment(date).toDate();
+    }
+    static getDateValues(date) {
+        return [
+            date.getFullYear(),
+            date.getMonth(),
+            date.getDate(),
+            date.getHours(),
+            date.getMinutes(),
+            date.getSeconds(),
+            date.getMilliseconds(),
+        ];
+    }
+    static getDaysInMonth(date) {
+        return moment(date, 'YYYY-MM').daysInMonth();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-utils.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-components/gantt/src/lib/gantt/components/gantt/utils/date-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from 'moment';\n\n\n\nconst YEAR = 'year';\nconst MONTH = 'month';\nconst DAY = 'day';\nconst HOUR = 'hour';\nconst MINUTE = 'minute';\nconst SECOND = 'second';\nconst MILLISECOND = 'millisecond';\n\nexport abstract class DateUtils {\n\tpublic static parse(date: Date | string): Date {\n\t\treturn moment(date).toDate();\n\t}\n\n\tpublic static toString(date: Date, with_time = false) {\n\t\tconst result = with_time ? moment(date, 'YYYY-MM-DD hh:mm:ss.SSS') : moment(date, 'YYYY-MM-DD');\n\n\t\treturn result.toString();\n\t}\n\n\tpublic static format(date: any, formatString: string = 'YYYY-MM-DD HH:mm:ss.SSS', lang: string = 'en'): string {\n\t\tconst monthName = moment(date).locale(lang).startOf('month').format('MMMM');\n\n\t\tconst monthNameCapitalized = monthName.charAt(0).toUpperCase() + monthName.slice(1);\n\t\tconst dateToFormat = moment(date).locale(lang);\n\t\tconst formatMap = {\n\t\t\tYYYY: dateToFormat.format('YYYY'),\n\t\t\tMM: dateToFormat.format('MM'),\n\t\t\tDD: dateToFormat.format('DD'),\n\t\t\t// Removendo alterações nas traduções que acontecem nos diferentes idiomas\n\t\t\tddd: dateToFormat.format('ddd').toUpperCase().replace('.', ''),\n\t\t\tHH: dateToFormat.format('HH'),\n\t\t\tmm: dateToFormat.format('mm'),\n\t\t\tss: dateToFormat.format('ss'),\n\t\t\tSSS: dateToFormat.format('SSS'),\n\t\t\tD: dateToFormat.format('D'),\n\t\t\tMMMM: monthNameCapitalized,\n\t\t\tMMM: monthNameCapitalized,\n\t\t};\n\n\t\tlet str = formatString;\n\t\tconst formattedValues: any[] = [];\n\n\t\tObject.keys(formatMap)\n\t\t\t.sort((a, b) => b.length - a.length)\n\t\t\t.forEach((key) => {\n\t\t\t\tif (str.includes(key)) {\n\t\t\t\t\tstr = str.replace(key, `$${formattedValues.length}`);\n\t\t\t\t\tformattedValues.push((formatMap as any)[key]);\n\t\t\t\t}\n\t\t\t});\n\n\t\tformattedValues.forEach((value, i) => {\n\t\t\tstr = str.replace(`$${i}`, value);\n\t\t});\n\n\t\treturn str;\n\t}\n\n\tpublic static diff(fistDate: Date, secondDate: Date, scale: string) {\n\t\tconst milliseconds = moment(fistDate).diff(secondDate, MILLISECOND);\n\t\tconst seconds = moment(fistDate).diff(secondDate, SECOND);\n\t\tconst minutes = moment(fistDate).diff(secondDate, MINUTE);\n\t\tconst hours = moment(fistDate).diff(secondDate, HOUR);\n\t\tconst days = moment(fistDate).diff(secondDate, DAY);\n\t\tconst months = moment(fistDate).diff(secondDate, MONTH);\n\t\tconst years = moment(fistDate).diff(secondDate, YEAR);\n\n\t\tif (!scale.endsWith('s')) {\n\t\t\tscale += 's';\n\t\t}\n\n\t\treturn Math.floor({ milliseconds, seconds, minutes, hours, days, months, years }[scale] as number);\n\t}\n\n\tpublic static today(): Date {\n\t\tconst dateStr = moment().format('YYY-MM-DD');\n\t\treturn new Date(dateStr);\n\t}\n\n\tpublic static now(): Date {\n\t\treturn moment().toDate();\n\t}\n\n\tpublic static add(date: Date, quantity: any, scale: any): Date {\n\t\treturn moment(date).add(quantity, scale).toDate();\n\t}\n\n\tpublic static startOf(date: Date, scale: string): Date {\n\t\tconst scores = {\n\t\t\t[YEAR]: 6,\n\t\t\t[MONTH]: 5,\n\t\t\t[DAY]: 4,\n\t\t\t[HOUR]: 3,\n\t\t\t[MINUTE]: 2,\n\t\t\t[SECOND]: 1,\n\t\t\t[MILLISECOND]: 0,\n\t\t};\n\n\t\tfunction shouldReset(_scale: any) {\n\t\t\tconst maxScore = (scores as any)[scale];\n\t\t\treturn (scores as any)[_scale] <= maxScore;\n\t\t}\n\n\t\tconst vals: any = [\n\t\t\tdate.getFullYear(),\n\t\t\tshouldReset(YEAR) ? 0 : date.getMonth(),\n\t\t\tshouldReset(MONTH) ? 1 : date.getDate(),\n\t\t\tshouldReset(DAY) ? 0 : date.getHours(),\n\t\t\tshouldReset(HOUR) ? 0 : date.getMinutes(),\n\t\t\tshouldReset(MINUTE) ? 0 : date.getSeconds(),\n\t\t\tshouldReset(SECOND) ? 0 : date.getMilliseconds(),\n\t\t];\n\n\t\treturn new Date(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5], vals[6]);\n\t}\n\n\tpublic static clone(date: Date): Date {\n\t\treturn moment(date).toDate();\n\t}\n\n\tpublic static getDateValues(date: Date) {\n\t\treturn [\n\t\t\tdate.getFullYear(),\n\t\t\tdate.getMonth(),\n\t\t\tdate.getDate(),\n\t\t\tdate.getHours(),\n\t\t\tdate.getMinutes(),\n\t\t\tdate.getSeconds(),\n\t\t\tdate.getMilliseconds(),\n\t\t];\n\t}\n\n\tpublic static getDaysInMonth(date: Date) {\n\t\treturn moment(date, 'YYYY-MM').daysInMonth();\n\t}\n}\n"]}

package/esm2022/gantt/lib/gantt/components/gantt/utils/svg-utils.mjs

@@ -0,0 +1,111 @@
+export const $ = (expr, con) => typeof expr === 'string'
+    ? (con || document).querySelector(expr)
+    : expr || null;
+export const createSVG = (tag, attrs) => {
+    const elem = document.createElementNS('http://www.w3.org/2000/svg', tag);
+    for (const attr in attrs) {
+        if (attr === 'append_to') {
+            const parent = attrs.append_to;
+            parent.appendChild(elem);
+        }
+        else if (attr === 'innerHTML') {
+            elem.innerHTML = attrs.innerHTML;
+        }
+        else {
+            elem.setAttribute(attr, attrs[attr]);
+        }
+    }
+    return elem;
+};
+export const animateSVG = (svgElement, attr, from, to) => {
+    const animatedSvgElement = getAnimationElement(svgElement, attr, from, to);
+    if (animatedSvgElement === svgElement) {
+        // triggered 2nd time programmatically
+        // trigger artificial click event
+        const event = new Event('click', { bubbles: true, cancelable: true });
+        animatedSvgElement.dispatchEvent(event);
+    }
+};
+const getAnimationElement = (svgElement, attr, from, to, dur = '0.4s', begin = '0.1s') => {
+    const animEl = svgElement.querySelector('animate');
+    if (animEl) {
+        $.attr(animEl, {
+            attributeName: attr,
+            from,
+            to,
+            dur,
+            begin: 'click + ' + begin, // artificial click
+        }, null);
+        return svgElement;
+    }
+    const animateElement = createSVG('animate', {
+        attributeName: attr,
+        from,
+        to,
+        dur,
+        begin,
+        calcMode: 'spline',
+        values: from + ';' + to,
+        keyTimes: '0; 1',
+        keySplines: cubicBezier('ease-out'),
+    });
+    svgElement.appendChild(animateElement);
+    return svgElement;
+};
+const cubicBezier = (name) => ({
+    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]);
+$.on = (element, event, selector, callback) => {
+    if (!callback) {
+        callback = selector;
+        $.bind(element, event, callback);
+    }
+    else {
+        $.delegate(element, event, selector, callback);
+    }
+};
+$.off = (element, event, handler) => {
+    element.removeEventListener(event, handler);
+};
+$.bind = (element, event, callback) => {
+    event.split(/\s+/).forEach(function (currentEvent) {
+        element.addEventListener(currentEvent, callback);
+    });
+};
+$.delegate = (element, event, selector, callback) => {
+    element.addEventListener(event, function (e) {
+        const delegatedTarget = e.target.closest(selector);
+        if (delegatedTarget) {
+            e.delegatedTarget = delegatedTarget;
+            callback.call(this, e, delegatedTarget);
+        }
+    });
+};
+$.closest = (selector, element) => {
+    if (!element) {
+        return null;
+    }
+    if (element.matches(selector)) {
+        return element;
+    }
+    return $.closest(selector, element.parentNode);
+};
+$.attr = (element, attr, value) => {
+    if (!value && typeof attr === 'string') {
+        return element.getAttribute(attr);
+    }
+    if (typeof attr === 'object') {
+        for (const key in attr) {
+            if (attr.hasOwnProperty(key)) {
+                $.attr(element, key, attr[key]);
+            }
+        }
+        return;
+    }
+    element.setAttribute(attr, value);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"svg-utils.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-components/gantt/src/lib/gantt/components/gantt/utils/svg-utils.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nexport const $ = (expr: any, con: any) => typeof expr === 'string'\n    ? (con || document).querySelector(expr)\n    : expr || null;\n\nexport const createSVG = (tag: any, attrs: any) => {\n    const elem = document.createElementNS('http://www.w3.org/2000/svg', tag);\n    for (const attr in attrs) {\n        if (attr === 'append_to') {\n            const parent = attrs.append_to;\n            parent.appendChild(elem);\n        } else if (attr === 'innerHTML') {\n            elem.innerHTML = attrs.innerHTML;\n        } else {\n            elem.setAttribute(attr, attrs[attr]);\n        }\n    }\n    return elem;\n};\n\nexport const animateSVG = (svgElement: any, attr: any, from: any, to: any) => {\n    const animatedSvgElement = getAnimationElement(svgElement, attr, from, to);\n\n    if (animatedSvgElement === svgElement) {\n        // triggered 2nd time programmatically\n        // trigger artificial click event\n        const event = new Event('click', { bubbles: true, cancelable: true });\n        animatedSvgElement.dispatchEvent(event);\n    }\n};\n\nconst getAnimationElement = (svgElement: any, attr: any, from: any, to: any, dur = '0.4s', begin = '0.1s') => {\n    const animEl = svgElement.querySelector('animate');\n    if (animEl) {\n        $.attr(animEl, {\n            attributeName: attr,\n            from,\n            to,\n            dur,\n            begin: 'click + ' + begin, // artificial click\n        }, null);\n        return svgElement;\n    }\n\n    const animateElement = createSVG('animate', {\n        attributeName: attr,\n        from,\n        to,\n        dur,\n        begin,\n        calcMode: 'spline',\n        values: from + ';' + to,\n        keyTimes: '0; 1',\n        keySplines: cubicBezier('ease-out'),\n    });\n    svgElement.appendChild(animateElement);\n\n    return svgElement;\n};\n\nconst cubicBezier = (name: 'ease' | 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out') => ({\n    ease: '.25 .1 .25 1',\n    linear: '0 0 1 1',\n    'ease-in': '.42 0 1 1',\n    'ease-out': '0 0 .58 1',\n    'ease-in-out': '.42 0 .58 1',\n}[name]);\n\n$.on = (element: any, event: any, selector: any, callback: any) => {\n    if (!callback) {\n        callback = selector;\n        $.bind(element, event, callback);\n    } else {\n        $.delegate(element, event, selector, callback);\n    }\n};\n\n$.off = (element: any, event: any, handler: any) => {\n    element.removeEventListener(event, handler);\n};\n\n$.bind = (element: any, event: any, callback: any) => {\n    event.split(/\\s+/).forEach(function (currentEvent: any) {\n        element.addEventListener(currentEvent, callback);\n    });\n};\n\n$.delegate = (element: any, event: any, selector: any, callback: any) => {\n    element.addEventListener(event, function (this: HTMLElement, e: any) {\n        const delegatedTarget = e.target.closest(selector);\n        if (delegatedTarget) {\n            e.delegatedTarget = delegatedTarget;\n            callback.call(this, e, delegatedTarget);\n        }\n    });\n};\n\n$.closest = (selector: any, element: any): HTMLElement | null => {\n    if (!element) {\n        return null;\n    }\n\n    if (element.matches(selector)) {\n        return element;\n    }\n\n    return $.closest(selector, element.parentNode);\n};\n\n$.attr = (element: any, attr: any, value: any) => {\n    if (!value && typeof attr === 'string') {\n        return element.getAttribute(attr);\n    }\n\n    if (typeof attr === 'object') {\n        for (const key in attr) {\n            if (attr.hasOwnProperty(key)) {\n                $.attr(element, key, attr[key]);\n            }\n        }\n        return;\n    }\n\n    element.setAttribute(attr, value);\n};\n"]}

package/esm2022/gantt/lib/gantt/components/side-table/side-table.component.mjs

@@ -0,0 +1,32 @@
+/* eslint-disable @angular-eslint/component-selector */
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@seniorsistemas/angular-components/tooltip";
+export class SideTableComponent {
+    columnTitle;
+    tasks;
+    multipleTaskPerLine = false;
+    ROW_HEIGHT = 44;
+    ngOnInit() {
+        this._removeEmptyTasks();
+    }
+    _removeEmptyTasks() {
+        this.tasks = this.tasks.filter((task) => task.tasks.length);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SideTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SideTableComponent, selector: "gantt-side-table", inputs: { columnTitle: "columnTitle", tasks: "tasks", multipleTaskPerLine: "multipleTaskPerLine" }, ngImport: i0, template: "<div class=\"side-table\">\n    <div class=\"column-title\">\n        <span>{{ columnTitle }}</span>\n    </div>\n    <div class=\"tasks\" >\n        @for(task of tasks; track task.id; let i = $index) {\n            <div\n                class=\"task\"\n                [ngStyle]=\"{'height.px': multipleTaskPerLine\n                        ? ROW_HEIGHT\n                        : ROW_HEIGHT * task.tasks.length}\"\n                [sTooltip]=\"task.title.length > 20 || task.subtitle.length > 20 ? '<span><strong>' + task.title + ' </strong></br><span> ' + task.subtitle + ' </span></span>' : '' \"\n                [escape]=\"false\">\n                    <div class=\"title\">\n                        {{ task.title }}\n                    </div>\n                    <div class=\"subtitle\">\n                        {{ task.subtitle }}\n                    </div>\n            </div>\n        }\n    </div>\n</div>\n", styles: [".side-table{background:#fff;height:100%;min-width:175px}.side-table .column-title{height:106px;border:solid 1px #e0e0e0;box-sizing:border-box;display:flex;align-items:flex-end;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{align-items:center;background-color:#fff;border:solid 1px #e0e0e0;display:flex;flex-direction:column;font-family:Open Sans,sans-serif;font-weight:400;justify-content:center;line-height:150%;padding:0 5px}.side-table .task .title{color:#333;font-size:14px;max-width:300px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.side-table .task .subtitle{color:#999;font-size:12px;max-width:300px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"], dependencies: [{ kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.TooltipDirective, selector: "[sTooltip]", inputs: ["sTooltip", "tooltipPosition", "showDelay", "displayTime", "tooltipEvent", "escape", "visible", "mobileBehavior", "focusedInputRef", "checkTruncatedText"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SideTableComponent, decorators: [{
+            type: Component,
+            args: [{ 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        @for(task of tasks; track task.id; let i = $index) {\n            <div\n                class=\"task\"\n                [ngStyle]=\"{'height.px': multipleTaskPerLine\n                        ? ROW_HEIGHT\n                        : ROW_HEIGHT * task.tasks.length}\"\n                [sTooltip]=\"task.title.length > 20 || task.subtitle.length > 20 ? '<span><strong>' + task.title + ' </strong></br><span> ' + task.subtitle + ' </span></span>' : '' \"\n                [escape]=\"false\">\n                    <div class=\"title\">\n                        {{ task.title }}\n                    </div>\n                    <div class=\"subtitle\">\n                        {{ task.subtitle }}\n                    </div>\n            </div>\n        }\n    </div>\n</div>\n", styles: [".side-table{background:#fff;height:100%;min-width:175px}.side-table .column-title{height:106px;border:solid 1px #e0e0e0;box-sizing:border-box;display:flex;align-items:flex-end;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{align-items:center;background-color:#fff;border:solid 1px #e0e0e0;display:flex;flex-direction:column;font-family:Open Sans,sans-serif;font-weight:400;justify-content:center;line-height:150%;padding:0 5px}.side-table .task .title{color:#333;font-size:14px;max-width:300px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.side-table .task .subtitle{color:#999;font-size:12px;max-width:300px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], propDecorators: { columnTitle: [{
+                type: Input,
+                args: [{ required: true }]
+            }], tasks: [{
+                type: Input,
+                args: [{ required: true }]
+            }], multipleTaskPerLine: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/gantt/lib/gantt/gantt.component.mjs

@@ -0,0 +1,146 @@
+import { Component, Input, Output, ViewEncapsulation, EventEmitter, ViewChild, } from '@angular/core';
+import { Gantt } from './components/gantt/gantt';
+import { ViewMode } from './models/view-mode';
+import { isNullOrUndefined } from '@seniorsistemas/angular-components/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./components/side-table/side-table.component";
+export class GanttComponent {
+    columnTitle;
+    multipleTaskPerLine = false;
+    showSideTable = true;
+    viewMode = ViewMode.Day;
+    tasks;
+    marginBeforeStart;
+    marginAfterEnd;
+    allowMovement = true;
+    hasPopup = true;
+    containerWidth;
+    fullWidth = false;
+    showOnlyHours = false;
+    showOnlyDays = false;
+    taskClicked = new EventEmitter();
+    taskDateChanged = new EventEmitter();
+    viewChanged = new EventEmitter();
+    outer = null;
+    side = null;
+    _gantt;
+    ngOnInit() {
+        this._validateViewMode();
+        this._validateTasks();
+    }
+    ngAfterViewInit() {
+        if (this.fullWidth) {
+            this.containerWidth = this.outer?.nativeElement.offsetWidth - this.side?.nativeElement.offsetWidth;
+        }
+        this._gantt = new Gantt('#gantt', this._filterTask(this.tasks), {
+            viewMode: this.viewMode,
+            marginBeforeStart: this.marginBeforeStart,
+            marginAfterEnd: this.marginAfterEnd,
+            language: 'pt-br',
+            allowMovement: this.allowMovement,
+            hasPopup: this.hasPopup,
+            containerWidth: this.containerWidth,
+            showOnlyHours: this.showOnlyHours,
+            showOnlyDays: this.showOnlyDays,
+            onClick: (task) => this.taskClicked.emit(task),
+            onDateChange: (task, start, end) => this.taskDateChanged.emit({ task, start, end }),
+            onViewChange: (viewMode) => this.viewChanged.emit(viewMode),
+        });
+    }
+    ngOnChanges(changes) {
+        if (!this._gantt) {
+            return;
+        }
+        if (changes['viewMode'] && !isNullOrUndefined(this._gantt.options?.viewMode)) {
+            this._gantt.options.viewMode = changes['viewMode'].currentValue;
+            this._gantt.change_view_mode();
+        }
+        if (changes['tasks']) {
+            this._gantt.refresh(this._filterTask(changes['tasks'].currentValue));
+        }
+    }
+    _filterTask(tasksGroups) {
+        const tasks = [];
+        if (this.multipleTaskPerLine) {
+            tasksGroups.forEach((group, index) => {
+                tasks.push(...group.tasks.map((task) => ({ ...task, _row_id: index })));
+            }, []);
+        }
+        else {
+            let i = 0;
+            tasksGroups.forEach((group) => {
+                tasks.push(...group.tasks.map((task) => ({ ...task, _row_id: i++ })));
+            }, []);
+        }
+        return tasks;
+    }
+    _validateViewMode() {
+        if (![
+            ViewMode.QuarterHour,
+            ViewMode.Hour,
+            ViewMode.QuarterDay,
+            ViewMode.HalfDay,
+            ViewMode.Day,
+            ViewMode.Week,
+            ViewMode.Month,
+            ViewMode.Year,
+        ].includes(this.viewMode)) {
+            throw new Error('Invalid gantt view mode');
+        }
+    }
+    _validateTasks() {
+        this.tasks.forEach((group) => {
+            group.tasks.forEach((task) => {
+                if (task.start > task.end) {
+                    throw new Error('invalid task. The start date must be less than the end date.');
+                }
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GanttComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: GanttComponent, selector: "s-gantt", inputs: { columnTitle: "columnTitle", multipleTaskPerLine: "multipleTaskPerLine", showSideTable: "showSideTable", viewMode: "viewMode", tasks: "tasks", marginBeforeStart: "marginBeforeStart", marginAfterEnd: "marginAfterEnd", allowMovement: "allowMovement", hasPopup: "hasPopup", containerWidth: "containerWidth", fullWidth: "fullWidth", showOnlyHours: "showOnlyHours", showOnlyDays: "showOnlyDays" }, outputs: { taskClicked: "taskClicked", taskDateChanged: "taskDateChanged", viewChanged: "viewChanged" }, viewQueries: [{ propertyName: "outer", first: true, predicate: ["outer"], descendants: true }, { propertyName: "side", first: true, predicate: ["side"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"outer\" #outer>\n    <div #side>\n        @if(showSideTable) {\n            <gantt-side-table\n                [tasks]=\"tasks\"\n                [columnTitle]=\"columnTitle ?? ''\"\n                [multipleTaskPerLine]=\"multipleTaskPerLine\">\n            </gantt-side-table>\n        }\n    </div>\n    <svg id=\"gantt\"></svg>\n</div>\n", styles: [".outer{display:flex;justify-content:center;align-items:flex-start;align-content:center;flex-wrap:nowrap;flex-direction:row}\n", ".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(2n){fill:#f5f5f5}.gantt .row-line{stroke:#ebeff2}.gantt .tick{stroke:#e0e0e0;stroke-width:.4}.gantt .tick.thick{stroke:#428bca;stroke-width:2}.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 ease;-webkit-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:none}.gantt .bar-wrapper:hover .bar,.gantt .bar-wrapper.active .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;display:flex;align-items:center}.gantt-container .popup-wrapper .popup .wrp-subtitle .icon{margin-right:10px}.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}\n"], dependencies: [{ kind: "component", type: i1.SideTableComponent, selector: "gantt-side-table", inputs: ["columnTitle", "tasks", "multipleTaskPerLine"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GanttComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-gantt', encapsulation: ViewEncapsulation.None, template: "<div class=\"outer\" #outer>\n    <div #side>\n        @if(showSideTable) {\n            <gantt-side-table\n                [tasks]=\"tasks\"\n                [columnTitle]=\"columnTitle ?? ''\"\n                [multipleTaskPerLine]=\"multipleTaskPerLine\">\n            </gantt-side-table>\n        }\n    </div>\n    <svg id=\"gantt\"></svg>\n</div>\n", styles: [".outer{display:flex;justify-content:center;align-items:flex-start;align-content:center;flex-wrap:nowrap;flex-direction:row}\n", ".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(2n){fill:#f5f5f5}.gantt .row-line{stroke:#ebeff2}.gantt .tick{stroke:#e0e0e0;stroke-width:.4}.gantt .tick.thick{stroke:#428bca;stroke-width:2}.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 ease;-webkit-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:none}.gantt .bar-wrapper:hover .bar,.gantt .bar-wrapper.active .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;display:flex;align-items:center}.gantt-container .popup-wrapper .popup .wrp-subtitle .icon{margin-right:10px}.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}\n"] }]
+        }], propDecorators: { columnTitle: [{
+                type: Input
+            }], multipleTaskPerLine: [{
+                type: Input
+            }], showSideTable: [{
+                type: Input
+            }], viewMode: [{
+                type: Input
+            }], tasks: [{
+                type: Input,
+                args: [{ required: true }]
+            }], marginBeforeStart: [{
+                type: Input
+            }], marginAfterEnd: [{
+                type: Input
+            }], allowMovement: [{
+                type: Input
+            }], hasPopup: [{
+                type: Input
+            }], containerWidth: [{
+                type: Input
+            }], fullWidth: [{
+                type: Input
+            }], showOnlyHours: [{
+                type: Input
+            }], showOnlyDays: [{
+                type: Input
+            }], taskClicked: [{
+                type: Output
+            }], taskDateChanged: [{
+                type: Output
+            }], viewChanged: [{
+                type: Output
+            }], outer: [{
+                type: ViewChild,
+                args: ['outer']
+            }], side: [{
+                type: ViewChild,
+                args: ['side']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gantt.component.js","sourceRoot":"","sources":["../../../../../projects/angular-components/gantt/src/lib/gantt/gantt.component.ts","../../../../../projects/angular-components/gantt/src/lib/gantt/gantt.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n\tAfterViewInit,\n\tComponent,\n\tInput,\n\tOnChanges,\n\tOnInit,\n\tOutput,\n\tViewEncapsulation,\n\tEventEmitter,\n\tSimpleChanges,\n\tElementRef,\n\tViewChild,\n} from '@angular/core';\n\nimport { Gantt } from './components/gantt/gantt';\nimport { TaskGroup, Task, EnrichedTask } from './models/task';\nimport { ViewMode } from './models/view-mode';\nimport { isNullOrUndefined } from '@seniorsistemas/angular-components/utils';\n\n@Component({\n\tselector: 's-gantt',\n\ttemplateUrl: './gantt.component.html',\n\tstyleUrls: ['./gantt.component.scss', './components/gantt/gantt.scss'],\n\tencapsulation: ViewEncapsulation.None,\n})\nexport class GanttComponent implements AfterViewInit, OnChanges, OnInit {\n\t@Input()\n\tpublic columnTitle?: string;\n\n\t@Input()\n\tpublic multipleTaskPerLine = false;\n\n\t@Input()\n\tpublic showSideTable = true;\n\n\t@Input()\n\tpublic viewMode = ViewMode.Day;\n\n\t@Input({ required: true })\n\tpublic tasks!: TaskGroup[];\n\n\t@Input()\n\tpublic marginBeforeStart?: number;\n\n\t@Input()\n\tpublic marginAfterEnd?: number;\n\n\t@Input()\n\tpublic allowMovement = true;\n\n\t@Input()\n\tpublic hasPopup = true;\n\n\t@Input()\n\tpublic containerWidth?: number;\n\n\t@Input()\n\tpublic fullWidth = false;\n\n\t@Input()\n\tpublic showOnlyHours = false;\n\n\t@Input()\n\tpublic showOnlyDays = false;\n\n\t@Output()\n\tpublic taskClicked: EventEmitter<Task> = new EventEmitter();\n\n\t@Output()\n\tpublic taskDateChanged: EventEmitter<any> = new EventEmitter();\n\n\t@Output()\n\tpublic viewChanged: EventEmitter<ViewMode> = new EventEmitter();\n\n\t@ViewChild('outer')\n\tpublic outer: ElementRef | null = null;\n\n\t@ViewChild('side')\n\tpublic side: ElementRef | null = null;\n\n\tprivate _gantt?: Gantt;\n\n\tpublic ngOnInit(): void {\n\t\tthis._validateViewMode();\n\t\tthis._validateTasks();\n\t}\n\n\tpublic ngAfterViewInit(): void {\n\t\tif (this.fullWidth) {\n\t\t\tthis.containerWidth = this.outer?.nativeElement.offsetWidth - this.side?.nativeElement.offsetWidth;\n\t\t}\n\n\t\tthis._gantt = new Gantt('#gantt', this._filterTask(this.tasks), {\n\t\t\tviewMode: this.viewMode,\n\t\t\tmarginBeforeStart: this.marginBeforeStart,\n\t\t\tmarginAfterEnd: this.marginAfterEnd,\n\t\t\tlanguage: 'pt-br',\n\t\t\tallowMovement: this.allowMovement,\n\t\t\thasPopup: this.hasPopup,\n\t\t\tcontainerWidth: this.containerWidth,\n\t\t\tshowOnlyHours: this.showOnlyHours,\n\t\t\tshowOnlyDays: this.showOnlyDays,\n\t\t\tonClick: (task: Task) => this.taskClicked.emit(task),\n\t\t\tonDateChange: (task: Task, start: any, end: any) => this.taskDateChanged.emit({ task, start, end }),\n\t\t\tonViewChange: (viewMode: ViewMode) => this.viewChanged.emit(viewMode),\n\t\t});\n\t}\n\n\tpublic ngOnChanges(changes: SimpleChanges): void {\n\t\tif (!this._gantt) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (changes['viewMode'] && !isNullOrUndefined(this._gantt.options?.viewMode)) {\n\t\t\tthis._gantt.options.viewMode = changes['viewMode'].currentValue;\n\t\t\tthis._gantt.change_view_mode();\n\t\t}\n\n\t\tif (changes['tasks']) {\n\t\t\tthis._gantt.refresh(this._filterTask(changes['tasks'].currentValue));\n\t\t}\n\t}\n\n\tprivate _filterTask(tasksGroups: TaskGroup[]): Task[] {\n\t\tconst tasks: Task[] = [];\n\n\t\tif (this.multipleTaskPerLine) {\n\t\t\ttasksGroups.forEach((group: any, index: number) => {\n\t\t\t\ttasks.push(...group.tasks.map((task: EnrichedTask) => ({ ...task, _row_id: index })));\n\t\t\t}, []);\n\t\t} else {\n\t\t\tlet i = 0;\n\t\t\ttasksGroups.forEach((group: any) => {\n\t\t\t\ttasks.push(...group.tasks.map((task: EnrichedTask) => ({ ...task, _row_id: i++ })));\n\t\t\t}, []);\n\t\t}\n\n\t\treturn tasks;\n\t}\n\n\tprivate _validateViewMode(): void {\n\t\tif (\n\t\t\t![\n\t\t\t\tViewMode.QuarterHour,\n\t\t\t\tViewMode.Hour,\n\t\t\t\tViewMode.QuarterDay,\n\t\t\t\tViewMode.HalfDay,\n\t\t\t\tViewMode.Day,\n\t\t\t\tViewMode.Week,\n\t\t\t\tViewMode.Month,\n\t\t\t\tViewMode.Year,\n\t\t\t].includes(this.viewMode)\n\t\t) {\n\t\t\tthrow new Error('Invalid gantt view mode');\n\t\t}\n\t}\n\n\tprivate _validateTasks(): void {\n\t\tthis.tasks.forEach((group) => {\n\t\t\tgroup.tasks.forEach((task) => {\n\t\t\t\tif (task.start > task.end) {\n\t\t\t\t\tthrow new Error('invalid task. The start date must be less than the end date.');\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n","<div class=\"outer\" #outer>\n    <div #side>\n        @if(showSideTable) {\n            <gantt-side-table\n                [tasks]=\"tasks\"\n                [columnTitle]=\"columnTitle ?? ''\"\n                [multipleTaskPerLine]=\"multipleTaskPerLine\">\n            </gantt-side-table>\n        }\n    </div>\n    <svg id=\"gantt\"></svg>\n</div>\n"]}