@seniorsistemas/angular-components 16.13.1 → 17.0.0

package/components/gantt/components/gantt/arrow.d.ts

@@ -0,0 +1,16 @@
+import { Gantt } from "./gantt";
+import { Bar } from "./bar";
+export declare class Arrow {
+    private _gantt;
+    private _fromTask;
+    private _toTask;
+    private _path;
+    private _element;
+    constructor(gantt: Gantt, fromTask: Bar, toTask: Bar);
+    get fromTask(): Bar;
+    get toTask(): Bar;
+    get element(): any;
+    update(): void;
+    private calculatePath;
+    private draw;
+}

package/components/gantt/components/gantt/bar.d.ts

@@ -0,0 +1,43 @@
+import { EnrichedTask } from "../../models/task";
+import { Arrow } from "./arrow";
+export declare class Bar {
+    private _actionCompleted;
+    private _gantt;
+    private _invalid;
+    private _height;
+    private _x;
+    private _y;
+    private _cornerRadius;
+    private _duration;
+    private _width;
+    private _barGroup;
+    private _arrows;
+    private _group;
+    private _task;
+    private _element;
+    get arrows(): Arrow[];
+    set arrows(arrows: Arrow[]);
+    get task(): EnrichedTask;
+    get element(): any;
+    get group(): any;
+    constructor(gantt: any, task: any);
+    updateBarPosition({ x, width }: any): void;
+    dateChanged(): void;
+    setActionCompleted(): void;
+    private _setDefaults;
+    private _prepare;
+    private _prepareValues;
+    private _prepareHelpers;
+    private _draw;
+    private _drawBar;
+    private _drawLabel;
+    private _bind;
+    private _setupClickEvent;
+    private _showPopup;
+    private _computeStartEndDate;
+    private _computeX;
+    private _computeY;
+    private _updateAttr;
+    private _updateLabelPosition;
+    private _updateArrowPosition;
+}

package/components/gantt/components/gantt/gantt-options.d.ts

@@ -0,0 +1,2 @@
+import { Options } from "../../models/options";
+export declare const defaultOptions: Options;

package/components/gantt/components/gantt/gantt.d.ts

@@ -0,0 +1,66 @@
+import { Bar } from "./bar";
+import { Arrow } from "./arrow";
+import { Options } from "../../models/options";
+import { ViewMode } from "../../models/view-mode";
+import { Task, EnrichedTask } from "../../models";
+export declare class Gantt {
+    options: Options;
+    tasks: EnrichedTask[];
+    dependency_map: any;
+    private _minDate;
+    private _maxDate;
+    private _realMinDate;
+    private _realMaxDate;
+    dates: any;
+    layers: any;
+    bars: Bar[];
+    arrows: Arrow[];
+    bar_being_dragged: any;
+    $svg: any;
+    $container: HTMLDivElement;
+    popup_wrapper: HTMLDivElement;
+    popup: any;
+    get minDate(): Date;
+    get maxDate(): Date;
+    constructor(wrapper: any, tasks: Task[], options?: Options);
+    private setup_wrapper;
+    private setup_options;
+    setup_tasks(tasks: any): void;
+    private setup_dependencies;
+    refresh(tasks: Task[]): void;
+    change_view_mode(mode?: ViewMode): void;
+    private update_view_scale;
+    private setup_dates;
+    private setup_gantt_dates;
+    private setup_date_values;
+    private bind_events;
+    private render;
+    private setup_layers;
+    private make_grid;
+    private make_grid_background;
+    private make_grid_rows;
+    private make_grid_header;
+    private make_grid_ticks;
+    make_grid_highlights(): void;
+    private make_dates;
+    private get_dates_to_draw;
+    private get_date_info;
+    private make_bars;
+    private make_arrows;
+    private map_arrows_on_bars;
+    private set_width;
+    private set_scroll_position;
+    private bind_grid_click;
+    private bind_bar_events;
+    private get_all_dependent_tasks;
+    private get_snap_position;
+    unselect_all(): void;
+    view_is(modes: ViewMode | ViewMode[]): boolean;
+    private get_task;
+    get_bar(id: any): Bar;
+    show_popup(options: any): void;
+    private hide_popup;
+    trigger_event(event: string, args: any): void;
+    private get_oldest_starting_date;
+    private clear;
+}

package/components/gantt/components/gantt/popup.d.ts

@@ -0,0 +1,11 @@
+export declare class Popup {
+    private parent;
+    private customHtml;
+    private title;
+    private subtitle;
+    private pointer;
+    constructor(parent: any, customHtml: any);
+    show(options: any): void;
+    private make;
+    private hide;
+}

package/components/gantt/components/gantt/utils/date-utils.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class DateUtils {
+    static parse(date: Date | string): Date;
+    static toString(date: Date, with_time?: boolean): string;
+    static format(date: any, formatString?: string, lang?: string): string;
+    static diff(fistDate: Date, secondDate: Date, scale: string): number;
+    static today(): Date;
+    static now(): Date;
+    static add(date: Date, quantity: any, scale: any): Date;
+    static startOf(date: Date, scale: string): Date;
+    static clone(date: Date): Date;
+    static getDateValues(date: Date): number[];
+    static getDaysInMonth(date: Date): number;
+}

package/components/gantt/components/gantt/utils/svg-utils.d.ts

@@ -0,0 +1,11 @@
+export declare const $: {
+    (expr: any, con: any): any;
+    on(element: any, event: any, selector: any, callback: any): void;
+    off(element: any, event: any, handler: any): void;
+    bind(element: any, event: any, callback: any): void;
+    delegate(element: any, event: any, selector: any, callback: any): void;
+    closest(selector: any, element: any): any;
+    attr(element: any, attr: any, value: any): any;
+};
+export declare const createSVG: (tag: any, attrs: any) => any;
+export declare const animateSVG: (svgElement: any, attr: any, from: any, to: any) => void;

package/components/gantt/components/side-table/side-table.component.d.ts

@@ -0,0 +1,7 @@
+import { TaskGroup } from '../../models/task';
+export declare class SideTableComponent {
+    ROW_HEIGHT: number;
+    columnTitle: string;
+    tasks: TaskGroup[];
+    multipleTaskPerLine: boolean;
+}

package/components/gantt/gantt.component.d.ts

@@ -0,0 +1,21 @@
+import { AfterViewInit, OnChanges, OnInit, EventEmitter, SimpleChanges } from "@angular/core";
+import { TaskGroup, Task } from "./models/task";
+import { ViewMode } from "./models/view-mode";
+export declare class GanttComponent implements AfterViewInit, OnChanges, OnInit {
+    columnTitle: string;
+    multipleTaskPerLine: boolean;
+    showSideTable: boolean;
+    viewMode: ViewMode;
+    tasks: TaskGroup[];
+    marginBeforeStart?: number;
+    marginAfterEnd?: number;
+    taskClicked: EventEmitter<Task>;
+    taskDateChanged: EventEmitter<any>;
+    viewChanged: EventEmitter<ViewMode>;
+    private _gantt;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _filterTask;
+    private _validateViewMode;
+}

package/components/gantt/gantt.module.d.ts

@@ -0,0 +1,2 @@
+export declare class GanttModule {
+}

package/components/gantt/index.d.ts

@@ -0,0 +1,3 @@
+export { GanttComponent } from "./gantt.component";
+export { GanttModule } from "./gantt.module";
+export { Task, ViewMode, TaskGroup } from "./models/index";

package/components/gantt/models/index.d.ts

@@ -0,0 +1,3 @@
+export { Task, EnrichedTask, TaskGroup } from "./task";
+export { Options } from "./options";
+export { ViewMode } from "./view-mode";

package/components/gantt/models/options.d.ts

@@ -0,0 +1,21 @@
+import { ViewMode } from "./view-mode";
+import { EnrichedTask } from "./task";
+export interface Options {
+    headerHeight?: number;
+    columnWidth?: number;
+    step?: number;
+    barHeight?: number;
+    barCornerRadius?: number;
+    arrowCurve?: number;
+    padding?: number;
+    viewMode?: ViewMode;
+    dateFormat?: string;
+    customPopupHtml?: string | ((task: EnrichedTask) => string);
+    language?: string;
+    popupTrigger?: any;
+    marginBeforeStart?: number;
+    marginAfterEnd?: number;
+    onClick?: ((task: EnrichedTask) => void);
+    onDateChange?: ((task: EnrichedTask, start: Date, end: Date) => void);
+    onViewChange?: ((mode: ViewMode) => void);
+}

package/components/gantt/models/task.d.ts

@@ -0,0 +1,21 @@
+export interface Task {
+    id: string;
+    name: string;
+    start: Date;
+    end: Date;
+    showTaskName?: boolean;
+    dependencies?: string[];
+    color?: string;
+    custom_class?: string;
+}
+export interface EnrichedTask extends Task {
+    _index: number;
+    _row_id: number;
+    invalid?: boolean | undefined;
+}
+export interface TaskGroup {
+    id: string;
+    title: string;
+    subtitle: string;
+    tasks: Task[];
+}

package/components/gantt/models/view-mode.d.ts

@@ -0,0 +1,9 @@
+export declare enum ViewMode {
+    QuarterDay = "quarterDay",
+    HalfDay = "halfDay",
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Year = "year",
+    Hour = "hour"
+}

package/esm2015/components/gantt/components/gantt/arrow.js

@@ -0,0 +1,82 @@
+import { createSVG } from './utils/svg-utils';
+export class Arrow {
+    constructor(gantt, fromTask, toTask) {
+        this._gantt = gantt;
+        this._fromTask = fromTask;
+        this._toTask = toTask;
+        this.calculatePath();
+        this.draw();
+    }
+    get fromTask() {
+        return this._fromTask;
+    }
+    get toTask() {
+        return this._toTask;
+    }
+    get element() {
+        return this._element;
+    }
+    update() {
+        this.calculatePath();
+        this._element.setAttribute("d", this._path);
+    }
+    calculatePath() {
+        let startX = this.fromTask.element.getX() + this.fromTask.element.getWidth() / 2;
+        const condition = () => this.toTask.element.getX() < startX + this._gantt.options.padding &&
+            startX > this.fromTask.element.getX() + this._gantt.options.padding;
+        while (condition()) {
+            startX -= 10;
+        }
+        const 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;
+        const endX = this.toTask.element.getX() - this._gantt.options.padding / 2;
+        const 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;
+        const fromIsBelowTo = this.fromTask.task._index > this.toTask.task._index;
+        const curve = this._gantt.options.arrowCurve;
+        const clockwise = fromIsBelowTo ? 1 : 0;
+        const curveY = fromIsBelowTo ? -curve : curve;
+        const offset = fromIsBelowTo
+            ? endY + this._gantt.options.arrowCurve
+            : endY - this._gantt.options.arrowCurve;
+        this._path = `
+            M ${startX} ${startY}
+            V ${offset}
+            a ${curve} ${curve} 0 0 ${clockwise} ${curve} ${curveY}
+            L ${endX} ${endY}
+            m -5 -5
+            l 5 5
+            l -5 5`;
+        if (this.toTask.element.getX() < this.fromTask.element.getX() + this._gantt.options.padding) {
+            const down1 = this._gantt.options.padding / 2 - curve;
+            const down2 = this.toTask.element.getY() + this.toTask.element.getHeight() / 2 - curveY;
+            const left = this.toTask.element.getX() - this._gantt.options.padding;
+            this._path = `
+                M ${startX} ${startY}
+                v ${down1}
+                a ${curve} ${curve} 0 0 1 -${curve} ${curve}
+                H ${left}
+                a ${curve} ${curve} 0 0 ${clockwise} -${curve} ${curveY}
+                V ${down2}
+                a ${curve} ${curve} 0 0 ${clockwise} ${curve} ${curveY}
+                L ${endX} ${endY}
+                m -5 -5
+                l 5 5
+                l -5 5`;
+        }
+    }
+    draw() {
+        this._element = createSVG("path", {
+            d: this._path,
+            "data-from": this.fromTask.task.id,
+            "data-to": this.toTask.task.id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrow.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/gantt/components/gantt/arrow.ts"],"names":[],"mappings":"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","sourcesContent":["import { createSVG } from './utils/svg-utils';\nimport { Gantt } from \"./gantt\";\nimport { Bar } from \"./bar\";\n\nexport class Arrow {\n    private _gantt: Gantt;\n    private _fromTask: Bar;\n    private _toTask: Bar;\n    private _path: any;\n    private _element: any;\n\n    constructor(gantt: Gantt, fromTask: Bar, toTask: Bar) {\n        this._gantt = gantt;\n        this._fromTask = fromTask;\n        this._toTask = toTask;\n\n        this.calculatePath();\n        this.draw();\n    }\n\n    public get fromTask(): Bar {\n        return this._fromTask;\n    }\n\n    public get toTask(): Bar {\n        return this._toTask;\n    }\n\n    public get element() {\n        return this._element;\n    }\n\n    public update() {\n        this.calculatePath();\n        this._element.setAttribute(\"d\", this._path);\n    }\n\n    private calculatePath() {\n        let startX = this.fromTask.element.getX() + this.fromTask.element.getWidth() / 2;\n\n        const condition = () =>\n            this.toTask.element.getX() < startX + this._gantt.options.padding &&\n            startX > this.fromTask.element.getX() + this._gantt.options.padding;\n\n        while (condition()) {\n            startX -= 10;\n        }\n\n        const startY = this._gantt.options.headerHeight +\n            this._gantt.options.barHeight +\n            (this._gantt.options.padding + this._gantt.options.barHeight) *\n            this.fromTask.task._index +\n            this._gantt.options.padding;\n        const endX = this.toTask.element.getX() - this._gantt.options.padding / 2;\n        const endY = this._gantt.options.headerHeight +\n            this._gantt.options.barHeight / 2 +\n            (this._gantt.options.padding + this._gantt.options.barHeight) *\n            this.toTask.task._index +\n            this._gantt.options.padding;\n        const fromIsBelowTo = this.fromTask.task._index > this.toTask.task._index;\n        const curve = this._gantt.options.arrowCurve;\n        const clockwise = fromIsBelowTo ? 1 : 0;\n        const curveY = fromIsBelowTo ? -curve : curve;\n        const offset = fromIsBelowTo\n            ? endY + this._gantt.options.arrowCurve\n            : endY - this._gantt.options.arrowCurve;\n\n        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`;\n\n        if (this.toTask.element.getX() < this.fromTask.element.getX() + this._gantt.options.padding) {\n            const down1 = this._gantt.options.padding / 2 - curve;\n            const down2 = this.toTask.element.getY() + this.toTask.element.getHeight() / 2 - curveY;\n            const left = this.toTask.element.getX() - this._gantt.options.padding;\n\n            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`;\n        }\n    }\n\n    private draw() {\n        this._element = createSVG(\"path\", {\n            d: this._path,\n            \"data-from\": this.fromTask.task.id,\n            \"data-to\": this.toTask.task.id,\n        });\n    }\n}\n"]}

package/esm2015/components/gantt/components/gantt/bar.js

@@ -0,0 +1,236 @@
+import { DateUtils } from './utils/date-utils';
+import { $, createSVG, animateSVG } from './utils/svg-utils';
+import { ViewMode } from "../../models/view-mode";
+export class Bar {
+    constructor(gantt, task) {
+        this._setDefaults(gantt, task);
+        this._prepare();
+        this._draw();
+        this._bind();
+    }
+    get arrows() {
+        return this._arrows;
+    }
+    set arrows(arrows) {
+        this._arrows = arrows;
+    }
+    get task() {
+        return this._task;
+    }
+    get element() {
+        return this._element;
+    }
+    get group() {
+        return this._group;
+    }
+    updateBarPosition({ x, width }) {
+        const bar = this.element;
+        if (x) {
+            // get all x values of parent task
+            const xs = this.task.dependencies.map((dep) => {
+                return this._gantt.get_bar(dep).element.getX();
+            });
+            // child task must not go before parent
+            const valid_x = xs.reduce((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();
+    }
+    dateChanged() {
+        let changed = false;
+        const { newStartDate, newEndDate } = this._computeStartEndDate();
+        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"),
+            ]);
+        }
+        ;
+    }
+    setActionCompleted() {
+        this._actionCompleted = true;
+        setTimeout(() => {
+            this._actionCompleted = false;
+        }, 1000);
+    }
+    _setDefaults(gantt, task) {
+        this._actionCompleted = false;
+        this._gantt = gantt;
+        this._task = task;
+    }
+    _prepare() {
+        this._prepareValues();
+        this._prepareHelpers();
+    }
+    _prepareValues() {
+        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,
+        });
+    }
+    _prepareHelpers() {
+        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();
+        };
+    }
+    _draw() {
+        this._drawBar();
+        this._drawLabel();
+    }
+    _drawBar() {
+        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");
+        }
+    }
+    _drawLabel() {
+        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(() => this._updateLabelPosition());
+    }
+    _bind() {
+        if (!this._invalid) {
+            this._setupClickEvent();
+        }
+    }
+    _setupClickEvent() {
+        $.on(this.group, "focus " + this._gantt.options.popupTrigger, (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", (e) => {
+            // just finished a move action, wait for a few seconds
+            if (!this._actionCompleted) {
+                this._gantt.trigger_event("onClick", [this.task]);
+            }
+        }, null);
+    }
+    _showPopup() {
+        if (this._gantt.bar_being_dragged) {
+            return;
+        }
+        const formatString = this._gantt.view_is(ViewMode.Hour)
+            ? "HH:ss"
+            : "MMM D";
+        const start_date = DateUtils.format(this.task.start, formatString, this._gantt.options.language);
+        const end_date = DateUtils.format(DateUtils.add(this.task.end, -1, "second"), formatString, this._gantt.options.language);
+        const subtitle = start_date + " - " + end_date;
+        this._gantt.show_popup({
+            target_element: this.element,
+            title: this.task.name,
+            subtitle: subtitle,
+            task: this.task,
+        });
+    }
+    _computeStartEndDate() {
+        const bar = this.element;
+        const xInUnits = bar.getX() / this._gantt.options.columnWidth;
+        const newStartDate = DateUtils.add(this._gantt.minDate, xInUnits * this._gantt.options.step, "hour");
+        const width_in_units = bar.getWidth() / this._gantt.options.columnWidth;
+        const newEndDate = DateUtils.add(newStartDate, width_in_units * this._gantt.options.step, "hour");
+        return { newStartDate, newEndDate };
+    }
+    _computeX() {
+        const { step, columnWidth } = this._gantt.options;
+        const diff = DateUtils.diff(this.task.start, this._gantt.minDate, "hour");
+        let x = (diff / step) * columnWidth;
+        if (this._gantt.view_is(ViewMode.Month)) {
+            const diff = DateUtils.diff(this.task.start, this._gantt.minDate, "day");
+            x = (diff * columnWidth) / 30;
+        }
+        return x;
+    }
+    _computeY() {
+        return (this._gantt.options.headerHeight +
+            this._gantt.options.padding +
+            this.task._index * (this._height + this._gantt.options.padding));
+    }
+    _updateAttr(element, attr, value) {
+        value = +value;
+        if (!isNaN(value)) {
+            element.setAttribute(attr, value);
+        }
+        return element;
+    }
+    _updateLabelPosition() {
+        const 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);
+        }
+    }
+    _updateArrowPosition() {
+        this._arrows = this._arrows || [];
+        for (let arrow of this._arrows) {
+            arrow.update();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bar.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/gantt/components/gantt/bar.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateUtils } from './utils/date-utils';\nimport { $, createSVG, animateSVG } from './utils/svg-utils';\nimport { ViewMode } from \"../../models/view-mode\";\n\nimport { Gantt } from \"./gantt\";\nimport { EnrichedTask } from \"../../models/task\";\nimport { Arrow } from \"./arrow\";\n\nexport class Bar {\n    private _actionCompleted: boolean;\n    private _gantt: Gantt;\n    private _invalid: boolean;\n    private _height: number;\n    private _x: number;\n    private _y: number;\n    private _cornerRadius: number;\n    private _duration: number;\n    private _width: number;\n    private _barGroup: any;\n\n    private _arrows: Arrow[];\n    private _group: any;\n    private _task: EnrichedTask;\n    private _element: any;\n\n    public get arrows(): Arrow[] {\n        return this._arrows;\n    }\n\n    public set arrows(arrows: Arrow[]) {\n        this._arrows = arrows;\n    }\n\n    public get task(): EnrichedTask {\n        return this._task;\n    }\n\n    public get element() {\n        return this._element;\n    }\n\n    public get group() {\n        return this._group;\n    }\n\n    constructor(gantt: any, task: any) {\n        this._setDefaults(gantt, task);\n        this._prepare();\n        this._draw();\n        this._bind();\n    }\n\n    public updateBarPosition({ x, width }: any): void {\n        const bar = this.element;\n        if (x) {\n            // get all x values of parent task\n            const xs = this.task.dependencies.map((dep: any) => {\n                return this._gantt.get_bar(dep).element.getX();\n            });\n            // child task must not go before parent\n            const valid_x = xs.reduce((prev: any, curr: any) => {\n                return x >= curr;\n            }, x);\n            if (!valid_x) {\n                width = null;\n                return;\n            }\n            this._updateAttr(bar, \"x\", x);\n        }\n        if (width && width >= this._gantt.options.columnWidth) {\n            this._updateAttr(bar, \"width\", width);\n        }\n        this._updateLabelPosition();\n        this._updateArrowPosition();\n    }\n\n    public dateChanged(): void {\n        let changed = false;\n        const { newStartDate, newEndDate } = this._computeStartEndDate();\n\n        if (this.task.start !== newStartDate) {\n            changed = true;\n            this.task.start = newStartDate;\n        }\n\n        if (this.task.end !== newEndDate) {\n            changed = true;\n            this.task.end = newEndDate;\n        }\n\n        if (changed) {\n            this._gantt.trigger_event(\"onDateChange\", [\n                this.task,\n                newStartDate,\n                DateUtils.add(newEndDate, -1, \"second\"),\n            ]);\n        };\n    }\n\n    public setActionCompleted(): void {\n        this._actionCompleted = true;\n        setTimeout(() => {\n            this._actionCompleted = false;\n        }, 1000);\n    }\n\n    private _setDefaults(gantt: any, task: any) {\n        this._actionCompleted = false;\n        this._gantt = gantt;\n        this._task = task;\n    }\n\n    private _prepare() {\n        this._prepareValues();\n        this._prepareHelpers();\n    }\n\n    private _prepareValues(): void {\n        this._invalid = this.task.invalid;\n        this._height = this._gantt.options.barHeight;\n        this._x = this._computeX();\n        this._y = this._computeY();\n        this._cornerRadius = this._gantt.options.barCornerRadius;\n        this._duration = DateUtils.diff(this.task.end, this.task.start, \"minute\") / this._gantt.options.step / 60.0;\n        this._width = this._gantt.options.columnWidth * this._duration;\n        this._group = createSVG(\"g\", {\n            class: \"bar-wrapper \" + (this.task.custom_class || \"\"),\n            \"data-id\": this.task.id,\n        });\n        this._barGroup = createSVG(\"g\", {\n            class: \"bar-group\",\n            append_to: this.group,\n        });\n    }\n\n    private _prepareHelpers(): void {\n        (SVGElement.prototype as any).getX = function () {\n            return +this.getAttribute(\"x\");\n        };\n        (SVGElement.prototype as any).getY = function () {\n            return +this.getAttribute(\"y\");\n        };\n        (SVGElement.prototype as any).getWidth = function () {\n            return +this.getAttribute(\"width\");\n        };\n        (SVGElement.prototype as any).getHeight = function () {\n            return +this.getAttribute(\"height\");\n        };\n        (SVGElement.prototype as any).getEndX = function () {\n            return this.getX() + this.getWidth();\n        };\n    }\n\n    private _draw(): void {\n        this._drawBar();\n        this._drawLabel();\n    }\n\n    private _drawBar(): void {\n        this._element = createSVG(\"rect\", {\n            x: this._x,\n            y: this._y,\n            width: this._width,\n            height: this._height,\n            rx: this._cornerRadius,\n            ry: this._cornerRadius,\n            class: \"bar\",\n            append_to: this._barGroup,\n            fill: this.task.color,\n        });\n\n        animateSVG(this.element, \"width\", 0, this._width);\n\n        if (this._invalid) {\n            this.element.classList.add(\"bar-invalid\");\n        }\n    }\n\n    private _drawLabel(): void {\n        createSVG(\"text\", {\n            x: this._x + this._width / 2,\n            y: this._y + this._height / 2,\n            innerHTML: this.task.showTaskName ? this.task.name : \"\",\n            class: \"bar-label\",\n            append_to: this._barGroup,\n        });\n        // labels get BBox in the next tick\n        requestAnimationFrame(() => this._updateLabelPosition());\n    }\n\n    private _bind(): void {\n        if (!this._invalid) {\n            this._setupClickEvent();\n        }\n    }\n\n    private _setupClickEvent(): void {\n        $.on(this.group, \"focus \" + this._gantt.options.popupTrigger, (e: any) => {\n            // just finished a move action, wait for a few seconds\n            if (!this._actionCompleted) {\n                this._showPopup();\n                this._gantt.unselect_all();\n                this.group.classList.add(\"active\");\n            }\n        }, null);\n\n        $.on(this.group, \"dblclick\", (e: any) => {\n            // just finished a move action, wait for a few seconds\n            \n            if (!this._actionCompleted) {\n                this._gantt.trigger_event(\"onClick\", [this.task]);\n            }\n        }, null);\n    }\n\n    private _showPopup() {\n        if (this._gantt.bar_being_dragged) {\n            return;\n        }\n\n        const formatString = this._gantt.view_is(ViewMode.Hour)\n            ? \"HH:ss\"\n            : \"MMM D\";\n\n        const start_date = DateUtils.format(\n            this.task.start,\n            formatString,\n            this._gantt.options.language\n        );\n        const end_date = DateUtils.format(\n            DateUtils.add(this.task.end, -1, \"second\"),\n            formatString,\n            this._gantt.options.language\n        );\n        const subtitle = start_date + \" - \" + end_date;\n\n        this._gantt.show_popup({\n            target_element: this.element,\n            title: this.task.name,\n            subtitle: subtitle,\n            task: this.task,\n        });\n    }\n\n    private _computeStartEndDate(): { newStartDate: Date, newEndDate: Date } {\n        const bar = this.element;\n        const xInUnits = bar.getX() / this._gantt.options.columnWidth;\n        const newStartDate = DateUtils.add(\n            this._gantt.minDate,\n            xInUnits * this._gantt.options.step,\n            \"hour\"\n        );\n        const width_in_units = bar.getWidth() / this._gantt.options.columnWidth;\n        const newEndDate = DateUtils.add(\n            newStartDate,\n            width_in_units * this._gantt.options.step,\n            \"hour\"\n        );\n\n        return { newStartDate, newEndDate };\n    }\n\n    private _computeX() {\n        const { step, columnWidth } = this._gantt.options;\n        const diff = DateUtils.diff(this.task.start, this._gantt.minDate, \"hour\");\n        let x = (diff / step) * columnWidth;\n\n        if (this._gantt.view_is(ViewMode.Month)) {\n            const diff = DateUtils.diff(this.task.start, this._gantt.minDate, \"day\");\n            x = (diff * columnWidth) / 30;\n        }\n        return x;\n    }\n\n    private _computeY() {\n        return (\n            this._gantt.options.headerHeight +\n            this._gantt.options.padding +\n            this.task._index * (this._height + this._gantt.options.padding)\n        );\n    }\n\n    private _updateAttr(element: any, attr: any, value: any) {\n        value = +value;\n        if (!isNaN(value)) {\n            element.setAttribute(attr, value);\n        }\n        return element;\n    }\n\n    private _updateLabelPosition(): void {\n        const bar = this.element,\n            label = this.group.querySelector(\".bar-label\");\n\n        if (label.getBBox().width > bar.getWidth()) {\n            label.classList.add(\"big\");\n            label.setAttribute(\"x\", bar.getX() + bar.getWidth() + 5);\n        } else {\n            label.classList.remove(\"big\");\n            label.setAttribute(\"x\", bar.getX() + bar.getWidth() / 2);\n        }\n    }\n\n    private _updateArrowPosition(): void {\n        this._arrows = this._arrows || [];\n        for (let arrow of this._arrows) {\n            arrow.update();\n        }\n    }\n}\n"]}