@progress/kendo-react-gantt 6.1.1 → 7.0.0-develop.10

package/index.mjs

@@ -0,0 +1,2582 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as t from "react";
+import * as i from "prop-types";
+import { mapTree as ya, extendDataItem as va, getter as D, classNames as ce, noop as F, useDraggable as Kt, IconWrap as mt, guid as Jt, canUseDOM as gt, validatePackage as Ta, shouldShowValidationUI as ba, WatermarkOverlay as Ra, setter as ee } from "@progress/kendo-react-common";
+import { MS_PER_MINUTE as Sa, MS_PER_DAY as Oe, getDate as oe, addDays as ht, ZonedDate as S, firstDayInWeek as at, addMonths as Qt, firstDayOfMonth as en, lastDayOfMonth as tn, firstMonthOfYear as xa, lastMonthOfYear as Ia } from "@progress/kendo-date-math";
+import { TABLE_ROW_INDEX_ATTRIBUTE as Na, TABLE_COL_INDEX_ATTRIBUTE as Ma, TABLE_PREVENT_SELECTION_ELEMENT as Fa, orderBy as La, filterBy as Ha, tableKeyboardNavigation as De, getSelectionOptions as Bt, CommonDragLogic as Aa, ColumnResize as Va, tableKeyboardNavigationTools as $t, Header as za, HeaderRow as Ga, tableColumnsVirtualization as Wa, TableKeyboardNavigationContext as nn, tableKeyboardNavigationScopeAttributes as Oa, TableSelection as Pa, tableKeyboardNavigationBodyAttributes as _a, DropClue as Ka, DragClue as Ba, FilterRow as $a, readColumns as Ua, mapColumns as Ya, TextFilterCell as qa, NumericFilterCell as Xa, BooleanFilterCell as ja, DateFilterCell as Za } from "@progress/kendo-react-data-tools";
+import { getSelectedState as Ps, getSelectedStateFromKeyDown as _s, setSelectedState as Ks } from "@progress/kendo-react-data-tools";
+import { createDataTree as Ja, setHeaderRowsTop as Qa, tableRowsVirtualization as eo, TreeListRow as an, TreeListNoRecords as to, TreeListCell as no, flatData as ao } from "@progress/kendo-react-treelist";
+import { useInternationalization as xe, useLocalization as ae } from "@progress/kendo-react-intl";
+import { xIcon as oo, caretAltDownIcon as so, plusIcon as ro } from "@progress/kendo-svg-icons";
+import { Button as ze, ButtonGroup as lo, DropDownButton as on, ToolbarItem as io, Toolbar as co, ToolbarSpacer as uo } from "@progress/kendo-react-buttons";
+import * as sn from "react-dom";
+import { FieldWrapper as ft, FormElement as mo, Field as He, Form as go } from "@progress/kendo-react-form";
+import { Dialog as rn, DialogActionsBar as ln } from "@progress/kendo-react-dialogs";
+import { Label as pt, Hint as Ct, Error as kt } from "@progress/kendo-react-labels";
+import { Input as ho, NumericTextBox as fo } from "@progress/kendo-react-inputs";
+import { DateTimePicker as po } from "@progress/kendo-react-dateinputs";
+const bs = Na, Rs = Ma, Ss = Fa, Ut = (/* @__PURE__ */ new Date()).getTime(), cn = 7, Co = "hh:mm a", ot = { skeleton: "MEd" }, ko = "MMM", Eo = "yyyy", Ie = 100, Do = 6, Ge = "data-dependency-drag-handle", wo = "start", yo = "finish", Yt = { [Ge]: wo }, qt = { [Ge]: yo }, We = "data-task-id", dn = {
+  id: "id",
+  start: "start",
+  end: "end",
+  title: "title",
+  percentComplete: "percentComplete",
+  isRollup: "isRollup",
+  isExpanded: "isExpanded",
+  isInEdit: "isInEdit",
+  children: "children",
+  isSelected: "isSelected"
+}, un = {
+  id: "id",
+  fromId: "fromId",
+  toId: "toId",
+  type: "type"
+}, xs = La, Is = Ha, Et = ya, Ns = va, Ms = Ja, vo = (e) => ({ fields: { ...dn, ...e } }), To = (e) => ({ fields: { ...un, ...e } }), mn = (e) => oe(e), Dt = (e, a) => oe(ht(e, a || 1)), bo = (e, a, n, o) => n < a && e <= o;
+function se(e) {
+  return new Date(Date.UTC(
+    e.getFullYear(),
+    e.getMonth(),
+    e.getDate(),
+    e.getHours(),
+    e.getMinutes(),
+    e.getSeconds(),
+    e.getMilliseconds()
+  ));
+}
+const te = 4, nt = 10, Ro = (e, a, n, o) => {
+  const r = [];
+  let l = 0, s = 0;
+  const c = nt, m = Math.floor(n / 2), g = e.top < a.top, d = () => r.push({ left: s, top: l });
+  if (o === 0 || o === 3) {
+    const u = o === 3 ? "start" : "end";
+    l = e.top, s = e[u], d(), s = Math[u === "start" ? "min" : "max"](e[u], a[u]), s = u === "start" ? s - c : s + c, d(), l = a.top, d(), s = u === "start" ? a[u] - te : a[u] + te, d(), Xt(l, s, r, u !== "start");
+  } else {
+    const u = o === 2 ? "start" : "end", h = o === 2 ? "end" : "start", p = o === 2 ? e[u] - nt * 2 >= a[h] : e[u] + nt * 2 <= a[h];
+    l = e.top, s = e[u], d(), s = u === "start" ? s - c : s + c, d(), p || (l = g ? l + m : l - m, d(), s = u === "start" ? a[h] + c : a[h] - c, d()), l = a.top, d(), s = h === "start" ? a[h] - te : a[h] + te, d(), Xt(l, s, r, h !== "start");
+  }
+  return r;
+}, Xt = (e, a, n, o) => o ? So(e, a, n) : xo(e, a, n), So = (e, a, n) => {
+  n.push({
+    top: e - te / 2,
+    left: a
+  }), n.push({
+    top: e,
+    left: a - te + 1
+  }), n.push({
+    top: e + te / 2,
+    left: a
+  }), n.push({
+    top: e,
+    left: a
+  });
+}, xo = (e, a, n) => {
+  n.push({
+    top: e + te / 2,
+    left: a
+  }), n.push({
+    top: e,
+    left: a + te - 1
+  }), n.push({
+    top: e - te / 2,
+    left: a
+  }), n.push({
+    top: e,
+    left: a
+  });
+}, gn = (e) => {
+  if (e.workWeekStart === void 0 || e.workWeekEnd === void 0)
+    return [];
+  const a = [];
+  let n = e.workWeekStart;
+  for (a.push(n); e.workWeekEnd !== n; )
+    n > 6 ? n -= 7 : n++, a.push(n);
+  return a;
+}, Io = (e, a) => {
+  const n = e.getDay();
+  return a.indexOf(n) > -1;
+}, hn = (e, { step: a, timezone: n }) => {
+  const o = [], r = S.fromLocalDate(e.start, n), l = S.fromLocalDate(e.end, n);
+  let s = r.clone();
+  for (; s.getTime() < l.getTime(); ) {
+    const c = s.clone(), m = c.clone().addTime(a), g = new Date(c.getTime()), u = {
+      end: new Date(m.getTime()),
+      start: g,
+      zonedStart: c,
+      zonedEnd: m
+    };
+    o.push(u), s = s.addTime(a);
+  }
+  return o;
+}, No = (e, { timezone: a }, n) => {
+  const o = [], r = S.fromLocalDate(e.start, a), l = S.fromLocalDate(e.end, a);
+  for (let s = r.clone(), c = 0; s.getTime() < l.getTime(); c++) {
+    const m = s.clone(), g = Dt(at(oe(m), n.firstDay()), cn), d = S.fromUTCDate(se(g), a), u = d.getTime() > l.getTime() ? l.clone() : d;
+    s = u.clone();
+    const h = new Date(m.getTime()), C = {
+      end: new Date(u.getTime()),
+      start: h,
+      zonedStart: m,
+      zonedEnd: u
+    };
+    o.push(C);
+  }
+  return o;
+}, Mo = (e, { timezone: a }) => {
+  const n = [], o = S.fromLocalDate(e.start, a), r = S.fromLocalDate(e.end, a);
+  for (let l = o.clone(), s = 0; l.getTime() < r.getTime(); s++) {
+    const c = l.clone(), m = S.fromLocalDate(Qt(new Date(c.getTime()), 1), a);
+    l = m.clone();
+    const g = new Date(c.getTime()), u = {
+      end: new Date(m.getTime()),
+      start: g,
+      zonedStart: c,
+      zonedEnd: m
+    };
+    n.push(u);
+  }
+  return n;
+}, Fo = (e, { timezone: a }) => {
+  const n = [], o = S.fromLocalDate(e.start, a), r = S.fromLocalDate(e.end, a);
+  for (let l = o.clone(), s = 0; l.getTime() < r.getTime(); s++) {
+    const c = l.clone(), m = S.fromLocalDate(Qt(new Date(c.getTime()), 12), a);
+    l = m.clone();
+    const g = new Date(c.getTime()), u = {
+      end: new Date(m.getTime()),
+      start: g,
+      zonedStart: c,
+      zonedEnd: m
+    };
+    n.push(u);
+  }
+  return n;
+}, Lo = (e, a, n) => {
+  const o = n.parseDate(a.workDayStart).getHours(), r = n.parseDate(a.workDayEnd).getHours();
+  return hn(e, { step: Sa * a.slotDuration, timezone: a.timezone }).map((s) => {
+    const c = s.zonedStart.getHours();
+    return {
+      range: s,
+      isWork: c >= o && c < r,
+      span: 1,
+      text: n.formatDate(s.zonedStart, Co),
+      type: "time"
+    };
+  });
+}, fn = (e, a, n) => hn(e, { step: Oe, timezone: a.timezone }).map((r) => ({
+  range: r,
+  isWork: Io(r.start, a.workDays),
+  span: 1,
+  text: n.formatDate(r.zonedStart, ot),
+  type: "day"
+})), pn = (e, a, n) => No(e, { timezone: a.timezone }, n).map((r) => {
+  const l = Math.round((r.zonedEnd.getTime() - r.zonedStart.getTime()) / Oe);
+  return {
+    range: r,
+    isWork: !1,
+    span: l,
+    text: `${n.formatDate(r.zonedStart, ot)} - ${n.formatDate(r.zonedEnd, ot)}`,
+    type: "week"
+  };
+}), Cn = (e, a, n) => Mo(e, { timezone: a.timezone }).map((r) => {
+  const l = Math.round((r.zonedEnd.getTime() - r.zonedStart.getTime()) / Oe);
+  return {
+    range: r,
+    isWork: !1,
+    span: l,
+    text: n.formatDate(r.zonedStart, ko),
+    type: "month"
+  };
+}), Ho = (e, a, n) => Fo(e, { timezone: a.timezone }).map((r) => {
+  const l = Math.round((r.zonedEnd.getTime() - r.zonedStart.getTime()) / Oe);
+  return {
+    range: r,
+    isWork: !1,
+    span: l,
+    text: n.formatDate(r.zonedStart, Eo),
+    type: "year"
+  };
+}), Ao = (e, a, n) => {
+  const o = n;
+  return /* @__PURE__ */ t.createElement("table", { className: "k-table k-table-md", ref: a, "aria-hidden": !0 }, /* @__PURE__ */ t.createElement("tbody", { className: "k-table-tbody" }, e.map((r, l) => /* @__PURE__ */ t.createElement("tr", { className: "k-table-row", key: l }, r.map((s, c) => /* @__PURE__ */ t.createElement(
+    "td",
+    {
+      key: s.range.start.getTime(),
+      colSpan: s.span,
+      className: ce(
+        "k-table-th",
+        {
+          "k-header": !0,
+          "k-nonwork-hour": !s.isWork
+        }
+      )
+    },
+    o ? /* @__PURE__ */ t.createElement(
+      o,
+      {
+        rowIndex: l,
+        index: c,
+        range: s.range,
+        text: s.text,
+        isWork: s.isWork,
+        type: s.type
+      }
+    ) : s.text
+  ))))));
+}, Vo = (e, a) => {
+  const n = e[e.length - 1];
+  return /* @__PURE__ */ t.createElement("table", { className: "k-table k-table-md k-gantt-columns", ref: a, "aria-hidden": !0 }, /* @__PURE__ */ t.createElement("tbody", { className: "k-table-tbody" }, /* @__PURE__ */ t.createElement("tr", { className: "k-table-row" }, n.map((o) => /* @__PURE__ */ t.createElement(
+    "td",
+    {
+      key: o.range.start.getTime(),
+      colSpan: o.span,
+      className: ce(
+        "k-table-td",
+        {
+          "k-nonwork-hour": !o.isWork
+        }
+      )
+    }
+  )))));
+}, zo = (e, a) => {
+  const n = e[e.length - 1];
+  let o = 0, r = 0;
+  return n.forEach((l) => {
+    const s = l.span;
+    r += s, s > o && (o = s);
+  }), Math.round(r * a / o);
+}, st = (e, a) => !!D(a)(e), kn = (e, a) => !!D(a)(e), Go = (e, a) => (n) => st(n, e) && kn(n, a) ? [...D(a)(n)] : [], wt = t.createContext([]), Wo = () => t.useContext(wt);
+wt.displayName = "KendoReactGanttTaskDataContext";
+const yt = t.createContext([]), Oo = () => t.useContext(yt);
+yt.displayName = "KendoReactGanttDependencyDataContext";
+const vt = t.createContext(dn), Tt = () => t.useContext(vt);
+vt.displayName = "KendoReactGanttTaskModelFieldsContext";
+const bt = t.createContext(un), En = () => t.useContext(bt);
+bt.displayName = "KendoReactGanttDependencyModelFieldsContext";
+const Rt = t.createContext({}), Ne = () => t.useContext(Rt);
+Rt.displayName = "KendoReactGanttPropsContext";
+const St = t.createContext({
+  start: /* @__PURE__ */ new Date(),
+  end: /* @__PURE__ */ new Date(),
+  zonedStart: S.fromLocalDate(/* @__PURE__ */ new Date()),
+  zonedEnd: S.fromLocalDate(/* @__PURE__ */ new Date())
+}), Me = () => t.useContext(St);
+St.displayName = "KendoReactGanttDateRangeContext";
+const xt = t.createContext([]), Po = () => t.useContext(xt);
+xt.displayName = "KendoReactGanttViewsContext";
+const It = t.createContext(["week", F]), Dn = () => t.useContext(It);
+It.displayName = "KendoReactGanttActiveViewContext";
+const Nt = t.createContext(0), wn = () => t.useContext(Nt);
+Nt.displayName = "KendoReactGanttRowHeightContext";
+const Mt = t.createContext(0), _o = () => t.useContext(Mt);
+Mt.displayName = "KendoReactGanttToolbarHeightContext";
+const Ft = t.createContext({
+  onDataStateChange: F,
+  onSortChange: F,
+  onFilterChange: F,
+  onColumnMenuFilterChange: F,
+  onExpandChange: F,
+  onRowClick: F,
+  onRowDoubleClick: F,
+  onRowContextMenu: F,
+  onColumnResize: F,
+  onColumnReorder: F,
+  onDependencyCreate: F,
+  onKeyDown: F,
+  onSelectionChange: F,
+  onHeaderSelectionChange: F
+}), Ko = () => t.useContext(Ft);
+Ft.displayName = "KendoReactGanttEventsContext";
+const Lt = t.createContext({
+  onTaskClick: F,
+  onTaskDoubleClick: F,
+  onTaskContextMenu: F
+}), Bo = () => t.useContext(Lt);
+Lt.displayName = "KendoReactGanttTaskEventsContext";
+const yn = ({
+  children: e,
+  taskData: a,
+  dependencyData: n,
+  taskModelFields: o,
+  dependencyModelFields: r,
+  props: l,
+  dateRange: s,
+  views: c,
+  activeView: m,
+  rowHeight: g,
+  toolbarHeight: d,
+  events: u,
+  taskEvents: h
+}) => /* @__PURE__ */ t.createElement(Rt.Provider, { value: l }, /* @__PURE__ */ t.createElement(wt.Provider, { value: a }, /* @__PURE__ */ t.createElement(yt.Provider, { value: n }, /* @__PURE__ */ t.createElement(vt.Provider, { value: o }, /* @__PURE__ */ t.createElement(bt.Provider, { value: r }, /* @__PURE__ */ t.createElement(St.Provider, { value: s }, /* @__PURE__ */ t.createElement(xt.Provider, { value: c }, /* @__PURE__ */ t.createElement(It.Provider, { value: m }, /* @__PURE__ */ t.createElement(Nt.Provider, { value: g }, /* @__PURE__ */ t.createElement(Mt.Provider, { value: d }, /* @__PURE__ */ t.createElement(Ft.Provider, { value: u }, /* @__PURE__ */ t.createElement(Lt.Provider, { value: h }, e))))))))))));
+yn.displayName = "KendoReactGanttContext";
+const Ht = t.createContext([{ current: {} }, F]), vn = () => t.useContext(Ht);
+Ht.displayName = "KendoReactGanttViewContext";
+const At = t.createContext(0), $o = () => t.useContext(At);
+At.displayName = "KendoReactGanttViewTimelineWidthContext";
+const Vt = t.createContext({
+  onDependencyHandlePress: F,
+  onDependencyHandleDrag: F,
+  onDependencyHandleRelease: F,
+  isEnabled: !1,
+  draggedId: null
+}), Uo = () => t.useContext(Vt);
+Vt.displayName = "KendoReactGanttViewDependencyDragContext";
+const Tn = ({
+  children: e,
+  tasksStore: a,
+  timelineWidth: n,
+  dependencyDrag: o
+}) => /* @__PURE__ */ t.createElement(Ht.Provider, { value: a }, /* @__PURE__ */ t.createElement(At.Provider, { value: n }, /* @__PURE__ */ t.createElement(Vt.Provider, { value: o }, e)));
+Tn.displayName = "KendoReactGanttViewContext";
+var rt = /* @__PURE__ */ ((e) => (e[e.add = 0] = "add", e[e.remove = 1] = "remove", e))(rt || {});
+const Yo = () => {
+  const e = t.useRef({}), a = t.useCallback(
+    (n) => {
+      switch (n.type) {
+        case 0:
+          e.current[n.id] = n.itemRef;
+          break;
+        case 1:
+          delete e.current[n.id];
+          break;
+      }
+    },
+    []
+  );
+  return [e, a];
+}, qo = (e, a, n, o) => {
+  const r = t.useRef(null), [, l] = vn();
+  t.useImperativeHandle(r, () => ({ element: o.current, dataItem: e })), t.useImperativeHandle(n, () => r.current), t.useLayoutEffect(
+    () => {
+      const s = r.current;
+      if (s)
+        return l({
+          type: rt.add,
+          itemRef: s,
+          id: a
+        }), () => {
+          l({
+            type: rt.remove,
+            itemRef: s,
+            id: a
+          });
+        };
+    }
+  );
+}, bn = t.forwardRef((e, a) => {
+  const n = Me(), o = Tt(), r = $o(), l = Uo(), s = Bo(), c = t.useRef(null), m = t.useRef(null);
+  qo(e.dataItem, D(o.id)(e.dataItem), a, c);
+  const g = t.useRef(null), d = D(o.id)(e.dataItem), u = D(o.start)(e.dataItem), h = D(o.end)(e.dataItem), p = D(o.title)(e.dataItem), C = D(o.percentComplete)(e.dataItem), f = D(o.children)(e.dataItem), v = D(o.isSelected)(e.dataItem), L = u && u.getTime(), V = h && h.getTime(), M = f && f.length, x = !M && L === V, z = L && V && bo(n.start, n.end, u, h), [J, R] = t.useState(!1), X = t.useRef(null), A = t.useRef(null);
+  Kt(X, {
+    onPress: l.onDependencyHandlePress,
+    onDrag: l.onDependencyHandleDrag,
+    onRelease: l.onDependencyHandleRelease
+  }), Kt(A, {
+    onPress: l.onDependencyHandlePress,
+    onDrag: l.onDependencyHandleDrag,
+    onRelease: l.onDependencyHandleRelease
+  });
+  const j = t.useCallback(
+    (w) => {
+      s.onTaskClick && s.onTaskClick({
+        dataItem: e.dataItem,
+        level: e.level,
+        nativeEvent: w && w.nativeEvent,
+        syntheticEvent: w,
+        target: null
+      });
+    },
+    [e.dataItem, e.level]
+  ), G = t.useCallback(
+    (w) => {
+      s.onTaskDoubleClick && s.onTaskDoubleClick({
+        dataItem: e.dataItem,
+        level: e.level,
+        nativeEvent: w && w.nativeEvent,
+        syntheticEvent: w,
+        target: null
+      });
+    },
+    [e.dataItem, e.level]
+  ), B = t.useCallback(
+    (w) => {
+      s.onTaskContextMenu && s.onTaskContextMenu({
+        dataItem: e.dataItem,
+        level: e.level,
+        nativeEvent: w && w.nativeEvent,
+        syntheticEvent: w,
+        target: null
+      });
+    },
+    [e.dataItem, e.level]
+  ), E = t.useCallback(
+    (w) => {
+      s.onTaskRemoveClick && s.onTaskRemoveClick({
+        dataItem: e.dataItem,
+        level: e.level,
+        nativeEvent: w && w.nativeEvent,
+        syntheticEvent: w,
+        target: null
+      });
+    },
+    [e.dataItem, e.level]
+  ), H = t.useCallback(
+    () => {
+      const w = n.start, Z = n.end, T = g.current, N = c.current, K = m.current;
+      if (!z || T === null || N === null)
+        return;
+      const Y = T.clientWidth / (Z.getTime() - w.getTime()), W = (u.getTime() - w.getTime()) * Y, O = (h.getTime() - u.getTime()) * Y, ge = (T.offsetHeight - N.offsetHeight) / 2;
+      N.style.left = `${Math.round(x ? W - Do : W)}px`, N.style.top = `${Math.round(ge)}px`, x || (N.style.width = `${Math.round(O)}px`, K !== null && (K.style.width = `${Math.round(O * (C || 0))}px`)), R(!0);
+    },
+    [n.start.getTime(), n.end.getTime(), L, V, z, C, r]
+  );
+  t.useEffect(H, [H]);
+  const Q = {
+    visibility: J ? void 0 : "hidden",
+    display: z ? void 0 : "none"
+  }, _ = {
+    userSelect: "none",
+    display: l.draggedId === String(d) ? "block" : void 0
+  };
+  return /* @__PURE__ */ t.createElement("td", { ref: g, key: d, role: "presentation" }, x ? /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      "aria-hidden": !0,
+      className: ce({
+        "k-task": !0,
+        "k-task-milestone": !0,
+        "k-selected": v && !Array.isArray(v)
+      }),
+      style: Q,
+      ref: c,
+      [We]: d,
+      onClick: j,
+      onDoubleClick: G,
+      onContextMenu: B
+    },
+    /* @__PURE__ */ t.createElement("div", { className: "k-task-milestone-content" }),
+    l.isEnabled && /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-task-dot k-task-start",
+        ref: X,
+        style: _,
+        ...Yt
+      }
+    ),
+    l.isEnabled && /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-task-dot k-task-end",
+        ref: A,
+        style: _,
+        ...qt
+      }
+    )
+  ) : /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      "aria-hidden": !0,
+      className: ce({
+        "k-task": !0,
+        "k-task-summary": M,
+        "k-task-single": !M,
+        "k-selected": v && !Array.isArray(v)
+      }),
+      ref: c,
+      style: Q,
+      [We]: d,
+      onClick: j,
+      onDoubleClick: G,
+      onContextMenu: B
+    },
+    M ? /* @__PURE__ */ t.createElement("div", { className: "k-task-summary-progress", ref: m }, /* @__PURE__ */ t.createElement("div", { className: "k-task-summary-complete" })) : /* @__PURE__ */ t.createElement("div", { className: "k-task-complete", ref: m }),
+    !M && /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement("div", { className: "k-task-content" }, p), s.onTaskRemoveClick ? /* @__PURE__ */ t.createElement("span", { className: "k-task-actions" }, /* @__PURE__ */ t.createElement("span", { onClick: E, className: "k-link k-task-delete", "aria-label": "Delete" }, /* @__PURE__ */ t.createElement(mt, { name: "x", icon: oo }))) : null),
+    l.isEnabled && /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-task-dot k-task-start",
+        ref: X,
+        style: _,
+        ...Yt
+      }
+    ),
+    l.isEnabled && /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-task-dot k-task-end",
+        ref: A,
+        style: _,
+        ...qt
+      }
+    )
+  ));
+});
+bn.displayName = "KendoReactGanttTask";
+const Rn = (e) => {
+  const { dependency: a } = e, [n] = vn(), o = t.useRef(null), r = En(), l = wn(), [s, c] = t.useState(!1), m = () => {
+    if (o.current === null || n.current === null) {
+      c(!1);
+      return;
+    }
+    const g = n.current[D(r.fromId)(a)], d = n.current[D(r.toId)(a)];
+    if (!g || !d) {
+      c(!1);
+      return;
+    }
+    const u = g.element, h = d.element;
+    if (!u || !h) {
+      c(!1);
+      return;
+    }
+    if (s === !1) {
+      c(!0);
+      return;
+    }
+    const p = {
+      top: u.offsetTop + u.offsetHeight / 2,
+      start: u.offsetLeft,
+      end: u.offsetLeft + u.offsetWidth
+    }, C = {
+      top: h.offsetTop + h.offsetHeight / 2,
+      start: h.offsetLeft,
+      end: h.offsetLeft + h.offsetWidth
+    }, f = D(r.type)(a), v = Ro(p, C, l, f);
+    v && v.length && o.current.setAttribute("points", v.map((L) => `${L.left},${L.top}`).join(" "));
+  };
+  return t.useEffect(m), /* @__PURE__ */ t.createElement(
+    "polyline",
+    {
+      ref: o,
+      style: {
+        display: s ? void 0 : "none"
+      }
+    }
+  );
+};
+Rn.displayName = "KendoReactGanttDependency";
+class zt extends t.Component {
+  constructor(a) {
+    super(a), this.state = {
+      activeId: void 0,
+      level: 0
+    }, this.tableElement = null, this.tbodyElement = null, this.wrapperScrollLeft = 0, this.wrapperScrollTop = 0, this.updateOnScroll = !1, this.tbodyOffsetTop = 0, this.prevData = [], this.flattedData = [], this.element = null, this._treeListId = Jt(), this.contextStateRef = { current: void 0 }, this.navigationStateRef = { current: void 0 }, this.scrollIntoView = (n) => {
+      if (!this.element)
+        return;
+      const { rowIndex: o = 0 } = n, { rowHeight: r = 0 } = this.props;
+      this.element.scroll(0, (o - 1) * r);
+    }, this.getColumns = (n) => {
+      const o = n.filter((l) => l.declarationIndex >= 0 && l.parentIndex === -1), r = (l) => (l.sort((s, c) => s.declarationIndex - c.declarationIndex), l.map((s) => {
+        const {
+          declarationIndex: c,
+          parentIndex: m,
+          depth: g,
+          colSpan: d,
+          rowSpan: u,
+          index: h,
+          kFirst: p,
+          groupable: C,
+          children: f,
+          ...v
+        } = s;
+        return f.length ? {
+          children: r(f),
+          ...v
+        } : v;
+      }));
+      return r(o);
+    }, this.onKeyDown = (n) => {
+      if (De.onKeyDown(n, {
+        contextStateRef: this.contextStateRef,
+        navigationStateRef: this.navigationStateRef
+      }), this.props.onKeyDown) {
+        const { mode: o, cell: r } = Bt(this.props.selectable), l = {
+          dataItems: this.getLeafDataItems(),
+          mode: o,
+          cell: r,
+          componentId: this._treeListId,
+          selectedField: this.props.selectedField,
+          ...this.getEventArguments(n)
+        };
+        this.props.onKeyDown.call(void 0, l);
+      }
+    }, this.onFocus = (n) => {
+      De.onFocus(n, {
+        contextStateRef: this.contextStateRef
+      });
+    }, this.onRowDrag = (n) => {
+      if (this.props.onRowDrag) {
+        const o = {
+          ...n,
+          target: this
+        };
+        this.props.onRowDrag.call(void 0, o);
+      }
+    }, this.onRowDrop = (n) => {
+      if (this.props.onRowDrop) {
+        const o = {
+          ...n,
+          target: this
+        };
+        this.props.onRowDrop.call(void 0, o);
+      }
+    }, this.onColumnReorder = (n, o, r) => {
+      const { extendedColumns: l } = this.props, s = l[n].depth, c = (d) => {
+        do
+          d++;
+        while (d < l.length && l[d].depth > s);
+        return d;
+      }, m = [...l], g = m.splice(n, c(n) - n);
+      if (m.splice(n < o ? c(o - g.length) : o, 0, ...g), m.filter((d) => d.declarationIndex >= 0).forEach((d, u) => d.orderIndex = u), this.props.onColumnReorder) {
+        const d = {
+          target: this,
+          columns: this.getColumns(m),
+          nativeEvent: r
+        };
+        this.props.onColumnReorder.call(void 0, d);
+      }
+    }, this.onColumnResize = (n, o, r, l, s) => {
+      if (this.props.onColumnResize) {
+        const c = this.props.extendedColumns.filter((g) => g.children.length === 0).reduce((g, d) => g += parseFloat(String(d.width)), 0);
+        this.tableElement && (this.tableElement.style.width = c + "px");
+        const m = {
+          columns: this.getColumns(this.props.extendedColumns),
+          totalWidth: c,
+          index: n,
+          nativeEvent: l,
+          newWidth: o,
+          oldWidth: r,
+          end: s,
+          target: this
+        };
+        this.props.onColumnResize.call(void 0, m);
+      }
+    }, this.onScroll = (n) => {
+      const o = n.currentTarget.scrollLeft, r = n.currentTarget.scrollTop, { columnVirtualization: l, scrollable: s, rowHeight: c = 0 } = this.props, m = c, g = 0;
+      let d = !1;
+      l && Math.abs(this.wrapperScrollLeft - o) > g && (this.wrapperScrollLeft = o, d = !0), s === "virtual" && Math.abs(this.wrapperScrollTop - r) > m && (this.wrapperScrollTop = r, d = !0), d && (this.updateOnScroll = !0, this.forceUpdate());
+    }, this.calculateSizes = (n) => {
+      if (!n || this.props.scrollable === "none")
+        return;
+      const o = Array.from(n.childNodes), r = o.find((c) => c.nodeName === "TABLE"), l = this.props.toolbar && o.find((c) => c.nodeType === 1 && c.classList.contains("k-grid-toolbar"));
+      let s = 0;
+      if (l) {
+        const c = l.style.boxSizing;
+        l.style.boxSizing = "border-box", s = parseFloat(String(window.getComputedStyle(l).height)) || l.offsetHeight, l.style.boxSizing = c, l.getAttribute("style") || l.removeAttribute("style");
+      }
+      this.tbodyOffsetTop = r.tBodies[0].offsetTop, Qa(r, s);
+    }, this.onItemChange = (n) => {
+      if (n.field === this.props.expandField) {
+        const o = this.props.onExpandChange;
+        if (o) {
+          const r = {
+            ...this.getEventArguments(n.syntheticEvent),
+            dataItem: n.dataItem,
+            level: n.level,
+            value: n.value
+          };
+          o.call(void 0, r);
+        }
+        return;
+      }
+      if (this.props.onItemChange) {
+        const o = {
+          ...this.getEventArguments(n.syntheticEvent),
+          dataItem: n.dataItem,
+          level: n.level,
+          field: n.field,
+          value: n.value
+        };
+        this.props.onItemChange.call(void 0, o);
+      }
+    }, this.onHeaderSelectionChange = (n) => {
+      if (this.props.onHeaderSelectionChange) {
+        const o = {
+          field: n.field,
+          nativeEvent: n.syntheticEvent && n.syntheticEvent.nativeEvent,
+          syntheticEvent: n.syntheticEvent,
+          target: this,
+          dataItems: this.getLeafDataItems()
+        };
+        this.props.onHeaderSelectionChange.call(void 0, o);
+      }
+    }, this.selectionRelease = (n) => {
+      if (this.props.onSelectionChange) {
+        const o = {
+          syntheticEvent: void 0,
+          target: this,
+          selectedField: this.props.selectedField || "",
+          componentId: this._treeListId,
+          dataItems: this.getLeafDataItems(),
+          dataItem: null,
+          level: [],
+          ...n
+        };
+        this.props.onSelectionChange.call(void 0, o);
+      }
+    }, this.onSortChange = (n, o, r) => {
+      this.onDataStateChange(this.props.onSortChange, { sort: o, field: r }, n);
+    }, this.onFilterChange = (n) => {
+      const { filter: o, field: r } = n;
+      this.onDataStateChange(this.props.onFilterChange, { filter: o, field: r }, n.syntheticEvent);
+    }, this.onColumnMenuFilterChange = (n, o, r) => {
+      if (!r)
+        return;
+      const { onColumnMenuFilterChange: l } = this.props;
+      if (!l)
+        return;
+      const s = {
+        syntheticEvent: n,
+        filter: o,
+        field: r,
+        target: this,
+        nativeEvent: n.nativeEvent
+      };
+      l.call(void 0, s);
+    }, this.onExpandChange = (n, o, r) => {
+      const { expandField: l, onExpandChange: s } = this.props;
+      if (l && s) {
+        const c = {
+          ...this.getEventArguments(n),
+          dataItem: o,
+          level: r,
+          value: st(o, this.props.expandField)
+        };
+        s.call(void 0, c);
+      }
+    }, this.onRowClick = (n, o) => {
+      if (this.props.onRowClick && n.target.nodeName === "TD") {
+        const r = {
+          dataItem: o.dataItem,
+          level: o.level,
+          ...this.getEventArguments(n)
+        };
+        this.props.onRowClick.call(void 0, r);
+      }
+    }, this.rowDoubleClick = (n, o) => {
+      if (this.props.onRowDoubleClick && n.target.nodeName === "TD") {
+        const r = {
+          dataItem: o.dataItem,
+          level: o.level,
+          ...this.getEventArguments(n)
+        };
+        this.props.onRowDoubleClick.call(void 0, r);
+      }
+    }, this.rowContextMenu = (n, o) => {
+      if (this.props.onRowContextMenu && n.target.nodeName === "TD") {
+        const r = {
+          dataItem: o.dataItem,
+          level: o.level,
+          ...this.getEventArguments(n)
+        };
+        this.props.onRowContextMenu.call(void 0, r);
+      }
+    }, this.onPageChange = (n) => {
+      if (this.props.onPageChange) {
+        const o = {
+          ...this.getEventArguments(n.syntheticEvent),
+          skip: n.skip,
+          take: n.take
+        };
+        this.props.onPageChange.call(void 0, o);
+      }
+    }, this.onDataStateChange = (n, o, r) => {
+      if (n && n.call(void 0, { ...this.getEventArguments(r), ...o }), this.props.onDataStateChange) {
+        const l = {
+          ...this.getEventArguments(r),
+          dataState: { ...this.getDataState(), ...o }
+        };
+        this.props.onDataStateChange.call(void 0, l);
+      }
+    }, this.getDataState = () => ({
+      filter: this.props.filter,
+      sort: this.props.sort
+    }), this.getEventArguments = (n) => ({
+      nativeEvent: n && n.nativeEvent,
+      syntheticEvent: n,
+      target: this
+    }), this.getLeafDataItems = () => this.flatData.map((n) => n.dataItem), this.dragLogic = new Aa(this.onColumnReorder, F, F), this.columnResize = new Va(this.onColumnResize), De.onConstructor({
+      navigatable: !!a.navigatable,
+      contextStateRef: this.contextStateRef,
+      navigationStateRef: this.navigationStateRef,
+      idPrefix: a.idPrefix
+    });
+  }
+  get document() {
+    if (gt)
+      return this.element && this.element.ownerDocument || document;
+  }
+  /**
+   * @hidden
+   */
+  componentDidMount() {
+    this.calculateSizes(this.element), De.onComponentDidMount({
+      scope: this.element || void 0,
+      contextStateRef: this.contextStateRef,
+      navigationStateRef: this.navigationStateRef
+    });
+  }
+  /**
+   * @hidden
+   */
+  getSnapshotBeforeUpdate() {
+    return De.onGetSnapshotBeforeUpdate({
+      document: this.document,
+      contextStateRef: this.contextStateRef,
+      navigationStateRef: this.navigationStateRef
+    }), null;
+  }
+  /**
+   * @hidden
+   */
+  componentDidUpdate(a) {
+    a.columns !== this.props.columns && this.calculateSizes(this.element), De.onComponentDidUpdate({
+      scope: this.element || void 0,
+      contextStateRef: this.contextStateRef,
+      navigationStateRef: this.navigationStateRef
+    });
+  }
+  /**
+   * @hidden
+   */
+  componentWillUnmount() {
+    this.columnResize.columns = [], this.dragLogic.columns = [], this.prevData = [], this.flattedData = [], this.updateOnScroll = !1;
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const {
+      filterRow: a,
+      scrollable: n = "scrollable",
+      resizable: o = !1,
+      reorderable: r = !1,
+      skip: l,
+      take: s,
+      afterContent: c,
+      extendedColumns: m = [],
+      columnsMap: g
+    } = this.props, d = m.some((E) => !!E.filter) || a !== void 0, u = a || $a, h = $t.getIdPrefix(this.navigationStateRef);
+    this.columnResize.columns = m, this.columnResize.resizable = o, this.dragLogic.columns = m, this.dragLogic.reorderable = r, this.dragLogic.groupable = !1;
+    const p = m.filter((E) => E.children.length === 0), C = /* @__PURE__ */ t.createElement(
+      za,
+      {
+        headerRow: /* @__PURE__ */ t.createElement(
+          Ga,
+          {
+            sort: this.props.sort,
+            sortable: this.props.sortable,
+            sortChange: this.onSortChange,
+            selectionChange: this.onHeaderSelectionChange,
+            columns: m,
+            columnsMap: g,
+            cellRender: this.props.headerCellRender,
+            columnResize: this.columnResize,
+            columnMenu: this.props.columnMenu,
+            columnMenuFilter: this.props.columnMenuFilter,
+            columnMenuFilterChange: this.onColumnMenuFilterChange,
+            pressHandler: this.dragLogic.pressHandler,
+            dragHandler: this.dragLogic.dragHandler,
+            releaseHandler: this.dragLogic.releaseHandler
+          }
+        ),
+        filterRow: d && /* @__PURE__ */ t.createElement(
+          u,
+          {
+            columns: p,
+            filter: this.props.filter,
+            filterChange: this.onFilterChange,
+            sort: this.props.sort,
+            ariaRowIndex: g.length + 1
+          }
+        ) || void 0,
+        columnResize: this.columnResize
+      }
+    ), f = this.props.style || {}, { colSpans: v, hiddenColumns: L } = Wa({
+      enabled: this.props.columnVirtualization,
+      columns: p,
+      scrollLeft: this.wrapperScrollLeft,
+      tableViewPortWidth: parseFloat((f.width || "").toString())
+    }), V = (E, H, Q, _, w, Z) => p.map((T, N) => {
+      if (L[N])
+        return null;
+      const K = T.id ? T.id : N, Y = `k-table-td ${T.className ? T.className + " " : ""}${T.locked ? "k-grid-content-sticky" : ""}`, W = {
+        id: $t.generateNavigatableId(`${Q}-${String(N)}`, h),
+        colSpan: v[N],
+        dataItem: E.dataItem,
+        field: T.field,
+        format: T.format,
+        className: Y || void 0,
+        render: this.props.cellRender,
+        onChange: this.onItemChange,
+        selectionChange: this.props.onSelectionChange ? (O) => {
+          this.onSelectionChange({ event: O, item: E, columnIndex: N, dataIndex: w });
+        } : void 0,
+        level: E.level,
+        expandable: T.expandable,
+        expanded: _,
+        hasChildren: kn(E.dataItem, this.props.subItemsField),
+        colIndex: N,
+        ariaColumnIndex: T.ariaColumnIndex,
+        onExpandChange: this.onExpandChange,
+        style: T.left !== void 0 && {
+          left: T.left,
+          right: T.right,
+          borderRightWidth: T.rightBorder ? "1px" : ""
+        } || {},
+        isSelected: Array.isArray(Z) && Z.indexOf(N) > -1
+      };
+      return H && T.editCell ? /* @__PURE__ */ t.createElement(T.editCell, { ...W, onChange: this.onItemChange, key: K }) : T.cell ? /* @__PURE__ */ t.createElement(T.cell, { key: K, ...W }) : /* @__PURE__ */ t.createElement(no, { key: K, ...W });
+    });
+    let M = this.flatData;
+    const x = M.length;
+    l !== void 0 && s !== void 0 && (M = M.slice(l, l + s)), n === "virtual" && (M = eo({
+      rows: M,
+      tableViewPortHeight: parseFloat((f.height || f.maxHeight || "").toString()),
+      scrollTop: this.wrapperScrollTop
+    }), this.updateOnScroll = !1);
+    const z = M.map((E) => E.level), J = g.length + (d ? 1 : 0) + 1, R = M.length > 0 && M.map((E, H) => {
+      const Q = D(this.props.editField || "")(E.dataItem), _ = D(this.props.dataItemKey)(E.dataItem), w = String(_ || E.level.join(".")), Z = st(E.dataItem, this.props.expandField), T = this.props.selectedField ? D(this.props.selectedField)(E.dataItem) : void 0, N = {
+        key: w,
+        level: E.level,
+        levels: z,
+        dataItem: E.dataItem,
+        selectedField: this.props.selectedField,
+        rowHeight: E.height,
+        render: this.props.rowRender,
+        onDrop: this.onRowDrop,
+        onDrag: this.onRowDrag,
+        onClick: (O) => this.onRowClick(O, E),
+        onDoubleClick: (O) => this.rowDoubleClick(O, E),
+        onContextMenu: (O) => this.rowContextMenu(O, E),
+        isAltRow: H % 2 !== 0,
+        expanded: Z,
+        rowIndex: H,
+        ariaRowIndex: J + H,
+        ariaSetSize: E.levelCount,
+        ariaPosInSet: E.level[E.level.length - 1] + 1,
+        isSelected: typeof T == "boolean" && T
+      }, K = this.props.editRow, Y = this.props.row || an, W = V(E, Q, w, Z, H, T);
+      return Q && K ? /* @__PURE__ */ t.createElement(K, { ...N }, W) : /* @__PURE__ */ t.createElement(Y, { ...N }, W);
+    }) || /* @__PURE__ */ t.createElement("tr", { className: "k-table-row k-grid-norecords" }, /* @__PURE__ */ t.createElement("td", { className: "k-table-td", colSpan: p.length }, this.props.noRecords || /* @__PURE__ */ t.createElement(to, null))), X = (E) => this.props.sort && this.props.sort.some((H) => H.field === E), A = /* @__PURE__ */ t.createElement("colgroup", { ref: (E) => {
+      this.columnResize.colGroupMain = E;
+    } }, p.map(
+      (E, H) => /* @__PURE__ */ t.createElement(
+        "col",
+        {
+          key: H.toString(),
+          className: X(E.field) ? "k-sorted" : void 0,
+          style: E.width !== void 0 ? { width: E.width } : void 0
+        }
+      )
+    )), j = this.props.columnVirtualization || this.props.scrollable === "virtual", G = this.props.selectable && this.props.selectable.drag ? "none" : void 0, B = this.props.tableProps || {};
+    return /* @__PURE__ */ t.createElement(nn.Provider, { value: this.contextStateRef.current }, /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        style: this.props.style,
+        className: ce(
+          "k-grid k-grid-md",
+          this.props.className,
+          { "k-treelist-scrollable": n !== "none" }
+        ),
+        ref: (E) => this.element = E,
+        onScroll: j ? this.onScroll : void 0,
+        onKeyDown: this.onKeyDown,
+        onFocus: this.onFocus,
+        "aria-rowcount": x,
+        "aria-colcount": p.length,
+        role: "treegrid",
+        ...Oa
+      },
+      this.props.toolbar,
+      /* @__PURE__ */ t.createElement(
+        Pa,
+        {
+          selectable: this.props.selectable,
+          onRelease: this.selectionRelease,
+          childRef: (E) => {
+            this.tableElement = E;
+          }
+        },
+        /* @__PURE__ */ t.createElement(
+          "table",
+          {
+            className: "k-table k-table-md",
+            ...this.props.tableProps || {},
+            style: { ...B.style || {}, userSelect: G },
+            role: "presentation"
+          },
+          A,
+          C,
+          /* @__PURE__ */ t.createElement("tbody", { className: "k-table-tbody", ..._a, ref: (E) => this.tbodyElement = E, role: "presentation" }, R)
+        )
+      ),
+      this.props.pager && /* @__PURE__ */ t.createElement(
+        this.props.pager,
+        {
+          className: "k-grid-pager",
+          total: x,
+          skip: l,
+          take: s,
+          onPageChange: this.onPageChange
+        }
+      ),
+      r && /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement(Ka, { ref: this.dragLogic.refDropElementClue }), /* @__PURE__ */ t.createElement(Ba, { ref: this.dragLogic.refDragElementClue })),
+      c
+    ));
+  }
+  get flatData() {
+    const { data: a = [], rowHeight: n = 0 } = this.props;
+    let o = 0;
+    const r = () => {
+      const s = { height: n, offsetTop: o };
+      return o += s.height, s;
+    }, l = this.updateOnScroll && this.prevData === a && this.tbodyOffsetTop > 0 && this.flattedData.length ? this.flattedData : a.map((s) => ({ ...s, ...r() }));
+    return this.prevData = a, this.flattedData = l, l;
+  }
+  onSelectionChange(a) {
+    if (this.props.onSelectionChange) {
+      const { event: n, item: o, dataIndex: r, columnIndex: l } = a, { mode: s, cell: c } = Bt(this.props.selectable), m = {
+        ...this.getEventArguments(n.syntheticEvent),
+        dataItem: o.dataItem,
+        level: o.level,
+        startColIndex: l,
+        endColIndex: l,
+        startRowIndex: r,
+        endRowIndex: r,
+        dataItems: this.getLeafDataItems(),
+        altKey: !1,
+        ctrlKey: !1,
+        shiftKey: !1,
+        metaKey: !1,
+        mode: s,
+        cell: c,
+        isDrag: !1,
+        componentId: this._treeListId,
+        selectedField: this.props.selectedField || ""
+      };
+      this.props.onSelectionChange.call(void 0, m);
+    }
+  }
+}
+zt.propTypes = {
+  data: i.array,
+  resizable: i.bool,
+  reorderable: i.bool,
+  sortable: i.oneOfType([
+    i.bool,
+    i.shape({
+      mode: i.oneOf(["single", "multiple"]),
+      allowUnsort: i.bool
+    })
+  ]),
+  onSortChange: i.func,
+  sort: i.array,
+  columns: i.arrayOf(i.object),
+  columnVirtualization: i.bool,
+  filter: i.array,
+  onFilterChange: i.func,
+  filterRow: i.any,
+  toolbar: i.any,
+  noRecords: i.any,
+  onExpandChange: i.func,
+  expandField: i.string,
+  subItemsField: i.string,
+  selectedField: i.string,
+  onSelectionChange: i.func,
+  onHeaderSelectionChange: i.func,
+  onRowClick: i.func,
+  onItemChange: i.func,
+  editField: i.string,
+  scrollable: i.oneOf(["none", "scrollable", "virtual"]),
+  rowHeight: i.number,
+  style: i.object,
+  tableProps: i.object,
+  pager: i.any,
+  skip: i.number,
+  take: i.number,
+  onPageChange: i.func,
+  onDataStateChange: i.func,
+  onColumnResize: i.func,
+  onColumnReorder: i.func,
+  extendedColumns: i.arrayOf(i.object),
+  columnsMap: i.arrayOf(i.array),
+  dataItemKey: i.string.isRequired,
+  afterContent: i.any,
+  navigatable: i.bool,
+  idPrefix: i.string
+};
+zt.contextType = nn;
+const Fe = t.forwardRef((e, a) => {
+  const { slotLevels: n, slotWidth: o, timelineHeaderCell: r } = e, {
+    columns: l,
+    noRecords: s,
+    resizable: c,
+    reorderable: m,
+    sortable: g,
+    sort: d,
+    filter: u,
+    columnMenuFilter: h,
+    columnMenu: p,
+    navigatable: C,
+    row: f,
+    selectable: v
+  } = Ne(), {
+    onDataStateChange: L,
+    onSortChange: V,
+    onFilterChange: M,
+    onColumnMenuFilterChange: x,
+    onExpandChange: z,
+    onRowClick: J,
+    onRowDoubleClick: R,
+    onRowContextMenu: X,
+    onColumnResize: A,
+    onColumnReorder: j,
+    onDependencyCreate: G,
+    onKeyDown: B,
+    onSelectionChange: E,
+    onHeaderSelectionChange: H
+  } = Ko(), Q = wn(), _ = _o(), w = Tt(), Z = En(), T = Wo(), N = Oo(), K = t.useRef(null), Y = t.useRef(null), W = t.useRef(null), O = t.useRef(null), ge = t.useRef(0), we = t.useRef(Jt()), b = t.useRef(null), Le = t.useRef(null), Ye = t.useCallback(
+    (y) => {
+      W.current && W.current.scrollIntoView(y);
+    },
+    []
+  );
+  t.useImperativeHandle(Le, () => ({ scrollIntoView: Ye })), t.useImperativeHandle(a, () => Le.current);
+  const he = t.useRef(0), fe = t.useRef(0), pe = t.useRef(0), Ce = t.useRef(0), de = t.useRef(null), ye = t.useRef(null), [ue, ve] = t.useState(null), qe = Ao(n, K, r), Xe = Vo(n, Y), ke = zo(n, o), { extendedColumns: je, columnsWidth: Ze, columnsMap: Je } = t.useMemo(
+    () => {
+      const y = Ua(
+        [
+          ...l,
+          {
+            title: "",
+            sortable: !1,
+            resizable: !1,
+            reorderable: !1,
+            width: ke,
+            headerCell: () => qe,
+            cell: bn,
+            orderIndex: Number.MAX_SAFE_INTEGER,
+            navigatable: !1
+          }
+        ],
+        { prevId: 0, idPrefix: we.current }
+      );
+      let P = 0;
+      return y.forEach((I, $, q) => {
+        const U = $ + 1 === q.length, ie = I.children.length === 0;
+        U ? I.isAccessible = !1 : (I.locked = !0, ie && (I.width = I.width || Ie)), ie && (P += parseFloat(String(I.width)));
+      }), {
+        extendedColumns: y,
+        columnsWidth: P,
+        columnsMap: Ya(y)
+      };
+    },
+    [l, ke]
+  ), [Qe, et] = Yo(), Te = t.useCallback(
+    () => K.current && K.current.parentElement,
+    []
+  ), k = () => {
+    const y = Te(), P = Y.current, I = W.current && W.current.tbodyElement;
+    if (!y || !P || !I)
+      return;
+    const $ = I.offsetTop, q = y.offsetLeft, U = ke;
+    P.style.top = $ + "px", P.style.left = q + "px", P.style.width = U + "px", P.style.height = I.offsetHeight + "px";
+  }, re = () => {
+    const y = Te();
+    y && (ge.current = y.offsetLeft);
+  };
+  t.useEffect(k), t.useEffect(re);
+  const le = t.useCallback(
+    (y) => {
+      if (!O.current)
+        return;
+      const P = y.columns.slice(0, y.columns.length - 1);
+      if (y.end)
+        O.current.style.left = "0px";
+      else {
+        const I = Te();
+        if (!I)
+          return;
+        O.current.style.left = I.offsetLeft - ge.current + "px", k();
+      }
+      A({
+        ...y,
+        columns: P
+      });
+    },
+    [A]
+  ), be = t.useCallback(
+    (y) => {
+      const P = y.columns.slice(0, y.columns.length - 1);
+      j({
+        ...y,
+        columns: P
+      });
+    },
+    [A]
+  ), Re = t.useCallback(
+    (y) => {
+      const I = (b.current && b.current.ownerDocument ? b.current.ownerDocument : document).elementFromPoint(y.clientX, y.clientY), $ = b.current;
+      if (!I || !I.parentElement || !$)
+        return;
+      const q = $.parentElement, U = $.firstElementChild;
+      if (!q || !U)
+        return;
+      const ie = I.getAttribute(Ge);
+      if (ie) {
+        const pa = $.offsetTop, Ca = $.offsetLeft, ka = q.offsetTop, Ea = q.offsetLeft, Da = U.scrollTop, wa = U.scrollLeft;
+        pe.current = Ca + Ea, Ce.current = pa + ka, he.current = y.clientX - pe.current + wa, fe.current = y.clientY - Ce.current + Da, de.current = I.parentElement.getAttribute(We), ye.current = ie;
+      }
+    },
+    []
+  ), tt = t.useCallback(
+    (y) => {
+      const P = b.current;
+      if (!P)
+        return;
+      const I = P.firstElementChild;
+      if (!I)
+        return;
+      const $ = I.scrollTop, q = I.scrollLeft, U = y.clientX - pe.current + q, ie = y.clientY - Ce.current + $;
+      Math.abs(he.current - U) < 10 && Math.abs(fe.current - ie) < 10 || ve({
+        startX: he.current,
+        startY: fe.current,
+        endX: U,
+        endY: ie
+      });
+    },
+    []
+  ), Ee = t.useCallback(
+    (y) => {
+      const I = (b.current && b.current.ownerDocument ? b.current.ownerDocument : document).elementFromPoint(y.clientX, y.clientY);
+      if (!I || !I.parentElement)
+        return;
+      const $ = I.parentElement.getAttribute(We), q = I.getAttribute(Ge);
+      if (q && $ !== de.current && G) {
+        let U;
+        ye.current === "start" ? U = q === "start" ? 3 : 2 : U = q === "start" ? 1 : 0, G({
+          fromId: de.current,
+          toId: $,
+          type: U
+        });
+      }
+      he.current = 0, fe.current = 0, pe.current = 0, Ce.current = 0, de.current = null, ye.current = null, ve(null);
+    },
+    [G, ve]
+  );
+  return /* @__PURE__ */ t.createElement(
+    Tn,
+    {
+      tasksStore: [Qe, et],
+      timelineWidth: ke,
+      dependencyDrag: {
+        isEnabled: !!G,
+        draggedId: de.current,
+        onDependencyHandlePress: Re,
+        onDependencyHandleDrag: tt,
+        onDependencyHandleRelease: Ee
+      }
+    },
+    /* @__PURE__ */ t.createElement("div", { className: "k-gantt-content", ref: b, style: { height: `calc(100% - ${_}px)` } }, /* @__PURE__ */ t.createElement(
+      zt,
+      {
+        ref: W,
+        extendedColumns: je,
+        columnsMap: Je,
+        dataItemKey: w.id,
+        data: T,
+        idPrefix: we.current,
+        navigatable: C,
+        expandField: w.isExpanded,
+        subItemsField: w.children,
+        editField: w.isInEdit,
+        selectedField: w.isSelected,
+        onDataStateChange: L,
+        onSortChange: V,
+        onFilterChange: M,
+        onExpandChange: z,
+        onRowClick: J,
+        onRowDoubleClick: R,
+        onRowContextMenu: X,
+        onColumnResize: le,
+        onColumnReorder: be,
+        onColumnMenuFilterChange: x,
+        onKeyDown: B,
+        onSelectionChange: E,
+        onHeaderSelectionChange: H,
+        tableProps: { style: { width: Ze }, className: "k-table k-table-md k-table-layout-fixed" },
+        noRecords: s,
+        rowHeight: Q,
+        resizable: c,
+        reorderable: m,
+        sortable: g,
+        sort: d,
+        filter: u,
+        columnMenuFilter: h,
+        columnMenu: p,
+        row: f,
+        selectable: v,
+        afterContent: /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement("svg", { className: "k-gantt-dependencies-svg", ref: O, style: { left: 0, top: 0 } }, N.map((y) => /* @__PURE__ */ t.createElement(Rn, { key: D(Z.id)(y), dependency: y }))), /* @__PURE__ */ t.createElement("svg", { className: "k-gantt-dependencies-svg", style: { left: 0, top: 0, zIndex: 3 } }, ue && /* @__PURE__ */ t.createElement("polyline", { points: `${ue.startX},${ue.startY} ${ue.endX},${ue.endY}` })), T && T.length ? Xe : null)
+      }
+    ))
+  );
+});
+Fe.displayName = "KendoReactGanttBaseView";
+const lt = "gantt.weekViewTitle", it = "gantt.dayViewTitle", ct = "gantt.monthViewTitle", dt = "gantt.yearViewTitle", ut = "gantt.filterClearButton", Pe = "gantt.filterEqOperator", _e = "gantt.filterNotEqOperator", Ke = "gantt.filterIsNullOperator", Be = "gantt.filterIsNotNullOperator", Sn = "gantt.filterIsEmptyOperator", xn = "gantt.filterIsNotEmptyOperator", In = "gantt.filterStartsWithOperator", Nn = "gantt.filterContainsOperator", Mn = "gantt.filterNotContainsOperator", Fn = "gantt.filterEndsWithOperator", Ln = "gantt.filterGteOperator", Hn = "gantt.filterGtOperator", An = "gantt.filterLteOperator", Vn = "gantt.filterLtOperator", zn = "gantt.filterIsTrue", Gn = "gantt.filterIsFalse", Wn = "gantt.filterBooleanAll", On = "gantt.filterAfterOrEqualOperator", Pn = "gantt.filterAfterOperator", _n = "gantt.filterBeforeOperator", Kn = "gantt.filterBeforeOrEqualOperator", Xo = "gantt.noRecords", Bn = "gantt.editSave", Gt = "gantt.editCancel", $n = "gantt.editorTitle", Un = "gantt.editorTaskTitle", Yn = "gantt.editorTaskStart", qn = "gantt.editorTaskEnd", Xn = "gantt.editorTaskComplete", jn = "gantt.editorValidationRequired", Zn = "gantt.editorValidationStart", Jn = "gantt.editorValidationEnd", Qn = "gantt.addTask", ea = "gantt.addChild", ta = "gantt.addAbove", na = "gantt.addBelow", aa = "gantt.editorDelete", oa = "gantt.deleteConfirmation", sa = "gantt.deleteDialogTitle", ne = {
+  [lt]: "Week",
+  [it]: "Day",
+  [ct]: "Month",
+  [dt]: "Year",
+  [ut]: "Clear",
+  [Pe]: "Is equal to",
+  [_e]: "Is not equal to",
+  [Ke]: "Is null",
+  [Be]: "Is not null",
+  [Sn]: "Is empty",
+  [xn]: "Is not empty",
+  [In]: "Starts with",
+  [Nn]: "Contains",
+  [Mn]: "Does not contain",
+  [Fn]: "Ends with",
+  [Ln]: "Is greater than or equal to",
+  [Hn]: "Is greater than",
+  [An]: "Is less than or equal to",
+  [Vn]: "Is less than",
+  [zn]: "Is true",
+  [Gn]: "Is false",
+  [Wn]: "(All)",
+  [On]: "Is after or equal to",
+  [Pn]: "Is after",
+  [_n]: "Is before",
+  [Kn]: "Is before or equal to",
+  [Xo]: "No records available",
+  [Bn]: "Save",
+  [Gt]: "Cancel",
+  [$n]: "Task",
+  [Un]: "Title",
+  [Yn]: "Start",
+  [qn]: "End",
+  [Xn]: "Complete",
+  [jn]: "Field is required.",
+  [Zn]: "Start time must be be before End time.",
+  [Jn]: "End time must be after Start time.",
+  [Qn]: "Add Task",
+  [ea]: "Add Child",
+  [ta]: "Add Above",
+  [na]: "Add Below",
+  [aa]: "Delete",
+  [oa]: "Are you sure you want to delete this event?",
+  [sa]: "Delete Event"
+}, $e = t.forwardRef((e, a) => {
+  const { slotWidth: n = Ae.slotWidth, firstSlotRangeRef: o, timelineHeaderCell: r } = e, { timezone: l } = Ne(), s = xe(), c = t.useRef(null), m = t.useRef(null), g = t.useCallback(
+    (C) => {
+      m.current && m.current.scrollIntoView(C);
+    },
+    []
+  );
+  t.useImperativeHandle(c, () => ({ scrollIntoView: g })), t.useImperativeHandle(a, () => c.current);
+  const d = Me(), u = e.workWeekStart || Ae.workWeekStart, h = e.workWeekEnd || Ae.workWeekEnd, p = t.useMemo(
+    () => {
+      const C = gn({
+        workWeekStart: u,
+        workWeekEnd: h
+      }), f = [], v = pn(d, { timezone: l }, s);
+      return v.forEach((L) => {
+        const V = fn(L.range, { workDays: C, timezone: l }, s);
+        f.push.apply(f, V);
+      }), o && f[0] && (o.current = f[0].range), [v, f];
+    },
+    [l, d.start.getTime(), d.end.getTime(), s, u, h]
+  );
+  return /* @__PURE__ */ t.createElement(
+    Fe,
+    {
+      ref: m,
+      slotWidth: n,
+      slotLevels: p,
+      timelineHeaderCell: r
+    }
+  );
+}), jo = ({ intl: e, tasksStart: a, tasksEnd: n, timezone: o }) => {
+  const r = S.fromLocalDate(a, o), l = S.fromLocalDate(n, o), s = mn(at(oe(r), e.firstDay())), c = Dt(at(oe(l), e.firstDay()), cn), m = S.fromUTCDate(se(s), o), g = S.fromUTCDate(se(c), o);
+  return {
+    start: new Date(m.getTime()),
+    end: new Date(g.getTime()),
+    zonedStart: m,
+    zonedEnd: g
+  };
+}, Ae = {
+  name: "week",
+  dateRange: jo,
+  title: (e) => e.toLanguageString(lt, ne[lt]),
+  slotWidth: Ie,
+  workWeekStart: 1,
+  workWeekEnd: 5,
+  workDayStart: "08:00",
+  workDayEnd: "17:00"
+};
+$e.defaultProps = Ae;
+$e.propTypes = {
+  name: i.string,
+  dateRange: i.oneOfType([i.func, i.object]),
+  title: i.oneOfType([i.string, i.func]),
+  slotWidth: i.number,
+  workWeekStart: i.number,
+  workWeekEnd: i.number,
+  workDayStart: i.string,
+  workDayEnd: i.string
+};
+$e.displayName = "KendoReactGanttWeekView";
+const Zo = (e, a, n) => {
+  const [o, r] = t.useState(a || e), l = t.useCallback(
+    (s, c) => {
+      r(s), n && n.call(void 0, { ...c, value: s });
+    },
+    [n, r]
+  );
+  return [a !== void 0 ? a : o, l];
+}, ra = (e) => {
+  const [a, n] = Dn(), o = ae(), r = t.useMemo(
+    () => typeof e.view.title == "function" ? e.view.title.call(void 0, o) : e.view.title,
+    [e.view.title, o]
+  ), l = t.useCallback(
+    () => {
+      e.view.name && n(e.view.name);
+    },
+    [n, e.view.name]
+  );
+  return /* @__PURE__ */ t.createElement(
+    ze,
+    {
+      role: "button",
+      type: "button",
+      tabIndex: -1,
+      togglable: !0,
+      selected: e.view.name === a,
+      onClick: l
+    },
+    r
+  );
+};
+ra.displayName = "KendoReactGanttViewSelectorItem";
+const la = t.forwardRef(() => {
+  const e = Po(), [a, n] = Dn(), o = e.find((s) => s.props.name === a), r = ae(), l = t.useCallback(
+    (s) => {
+      n && (s.syntheticEvent.preventDefault(), n(s.item.name));
+    },
+    [n]
+  );
+  return /* @__PURE__ */ t.createElement("div", { className: "k-gantt-views-wrapper" }, /* @__PURE__ */ t.createElement(lo, { className: "k-gantt-views" }, e.map((s) => /* @__PURE__ */ t.createElement(ra, { key: s.props.name, view: s.props }))), o && /* @__PURE__ */ t.createElement(
+    on,
+    {
+      className: "k-views-dropdown",
+      onItemClick: l,
+      popupSettings: { popupClass: "k-gantt-toolbar" },
+      textField: "title",
+      items: e.map((s) => ({
+        ...s.props,
+        selected: s.props.name === a,
+        title: typeof s.props.title == "function" ? s.props.title.call(void 0, r) : s.props.title
+      })),
+      text: /* @__PURE__ */ t.createElement(t.Fragment, null, typeof o.props.title == "function" ? o.props.title.call(void 0, r) : o.props.title, /* @__PURE__ */ t.createElement(mt, { name: "caret-alt-down", icon: so }))
+    }
+  ));
+});
+la.displayName = "KendoReactGanttViewSelectorList";
+const ia = t.forwardRef((e, a) => {
+  const {
+    className: n,
+    ...o
+  } = e, r = t.useRef(null);
+  return t.useImperativeHandle(a, () => ({ element: r.current, props: e })), /* @__PURE__ */ t.createElement(
+    io,
+    {
+      ref: (l) => {
+        l && (r.current = l.element);
+      },
+      className: ce("k-gantt-views", n),
+      ...o
+    },
+    e.children
+  );
+});
+ia.displayName = "KendoReactGanttViewSelector";
+const ca = t.forwardRef((e, a) => {
+  const {
+    className: n,
+    ...o
+  } = e, r = t.useRef(null), l = t.useRef(null);
+  t.useImperativeHandle(l, () => ({ element: r.current, props: e })), t.useImperativeHandle(a, () => l.current);
+  const s = t.useMemo(() => ce("k-gantt-toolbar k-gantt-header", n), [n]);
+  return /* @__PURE__ */ t.createElement(
+    co,
+    {
+      ref: (c) => {
+        c && (r.current = c.element);
+      },
+      className: s,
+      ...o
+    },
+    e.children
+  );
+});
+ca.displayName = "KendoReactGanttToolbar";
+const jt = {
+  name: "@progress/kendo-react-gantt",
+  productName: "KendoReact",
+  productCodes: ["KENDOUIREACT", "KENDOUICOMPLETE"],
+  publishDate: 1701439813,
+  version: "",
+  licensingDocsUrl: "https://www.telerik.com/kendo-react-ui/components/my-license/"
+}, da = t.forwardRef((e, a) => {
+  const n = ae(), o = (u) => n.toLanguageString(u, ne[u]), r = o(Qn), l = o(ea), s = o(ta), c = o(na), m = t.useCallback(
+    (u) => {
+      u.syntheticEvent.preventDefault();
+      const h = u.item && u.item.direction ? u.item.direction : "none";
+      e.onClick && e.onClick({
+        nativeEvent: u.nativeEvent,
+        syntheticEvent: u.syntheticEvent,
+        direction: h
+      });
+    },
+    [e.onClick]
+  ), g = t.useCallback(
+    (u) => {
+      u.preventDefault(), e.onClick && e.onClick({
+        nativeEvent: u && u.nativeEvent,
+        syntheticEvent: u,
+        direction: "none"
+      });
+    },
+    [e.onClick]
+  ), d = /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement(mt, { name: "plus", icon: ro }), r);
+  return e.selectedTask ? /* @__PURE__ */ t.createElement(
+    on,
+    {
+      className: "k-views-dropdown",
+      onItemClick: m,
+      popupSettings: { popupClass: "k-gantt-toolbar" },
+      textField: "title",
+      items: [
+        { title: l, direction: "child" },
+        { title: s, direction: "above" },
+        { title: c, direction: "below" }
+      ],
+      text: d
+    }
+  ) : /* @__PURE__ */ t.createElement(ze, { onClick: g }, d);
+});
+da.displayName = "KendoReactGanttAddButton";
+const Wt = t.forwardRef((e, a) => {
+  Ta(jt);
+  const n = ba(jt), {
+    columns: o = Se.columns,
+    taskData: r = Se.taskData,
+    dependencyData: l = Se.dependencyData,
+    style: s,
+    className: c,
+    noRecords: m,
+    timezone: g,
+    rowHeight: d = Se.rowHeight,
+    resizable: u,
+    reorderable: h,
+    sortable: p,
+    sort: C,
+    filter: f,
+    columnMenuFilter: v,
+    columnMenu: L,
+    navigatable: V,
+    toolbar: M,
+    row: x,
+    selectable: z
+  } = e, J = xe(), { fields: R } = t.useMemo(() => vo(e.taskModelFields), [e.taskModelFields]), { fields: X } = t.useMemo(() => To(e.dependencyModelFields), [e.dependencyModelFields]), A = t.useCallback(
+    Go(R.isExpanded, R.children),
+    [R.isExpanded, R.children]
+  ), j = t.useRef(null), G = t.useRef(null), B = t.useRef(null), E = t.useRef(null), H = t.useRef(null), Q = t.useCallback(
+    (k) => {
+      const re = D(R.start)(k), le = D(R.end)(k), be = D(R.isSelected)(k);
+      (!G.current || re < G.current) && (G.current = re), (!B.current || le > B.current) && (B.current = le), be && (E.current = k);
+    },
+    [R.start, R.end]
+  ), _ = t.useMemo(
+    () => (G.current = null, B.current = null, E.current = null, ao(r, A, Q)),
+    [r, A]
+  );
+  (!G.current || !B.current) && (G.current = new Date(Ut), B.current = new Date(Ut));
+  const w = t.Children.toArray(
+    e.children || [/* @__PURE__ */ t.createElement($e, { key: "week", firstSlotRangeRef: H })]
+  ), [
+    Z,
+    T
+  ] = Zo(
+    e.defaultView || w[0].props.name,
+    e.view,
+    e.onViewChange
+  ), N = w.find((k) => k.props.name === Z) || w[0], K = typeof N.props.dateRange == "function" ? N.props.dateRange.call(void 0, {
+    intl: J,
+    tasksStart: G.current,
+    tasksEnd: B.current,
+    timezone: g
+  }) : N.props.dateRange, Y = t.useRef(null), [W, O] = t.useState(0);
+  t.useLayoutEffect(
+    () => {
+      Y.current && O(Y.current.element.offsetHeight);
+    },
+    []
+  );
+  const ge = t.useCallback(
+    (k) => {
+      j.current && j.current.scrollIntoView(k);
+    },
+    []
+  ), we = t.useRef(null), b = t.useRef(null);
+  t.useImperativeHandle(b, () => ({ props: e, element: we.current, scrollIntoView: ge })), t.useImperativeHandle(a, () => b.current);
+  const Le = t.useCallback(
+    (k) => {
+      e.onDataStateChange && e.onDataStateChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onDataStateChange]
+  ), Ye = t.useCallback(
+    (k) => {
+      e.onSortChange && e.onSortChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onSortChange]
+  ), he = t.useCallback(
+    (k) => {
+      e.onKeyDown && e.onKeyDown.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onKeyDown]
+  ), fe = t.useCallback(
+    (k) => {
+      e.onSelectionChange && e.onSelectionChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onSelectionChange]
+  ), pe = t.useCallback(
+    (k) => {
+      e.onHeaderSelectionChange && e.onHeaderSelectionChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onHeaderSelectionChange]
+  ), Ce = t.useCallback(
+    (k) => {
+      e.onFilterChange && e.onFilterChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onFilterChange]
+  ), de = t.useCallback(
+    (k) => {
+      e.onColumnMenuFilterChange && e.onColumnMenuFilterChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onColumnMenuFilterChange]
+  ), ye = t.useCallback(
+    (k) => {
+      e.onExpandChange && e.onExpandChange.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onExpandChange]
+  ), ue = t.useCallback(
+    (k) => {
+      e.onAddClick && e.onAddClick.call(
+        void 0,
+        {
+          ...k,
+          target: b.current,
+          selectedDataItem: E.current,
+          slotStart: H.current && new Date(H.current.start.getTime()),
+          slotEnd: H.current && new Date(H.current.end.getTime())
+        }
+      );
+    },
+    [e.onAddClick]
+  ), ve = t.useCallback(
+    (k) => {
+      e.onColumnResize && e.onColumnResize.call(
+        void 0,
+        {
+          ...k,
+          target: b.current
+        }
+      );
+    },
+    [e.onColumnResize]
+  ), qe = t.useCallback(
+    (k) => {
+      e.onColumnReorder && e.onColumnReorder.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onColumnReorder]
+  ), Xe = t.useCallback(
+    (k) => {
+      e.onRowClick && e.onRowClick.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onRowClick]
+  ), ke = t.useCallback(
+    (k) => {
+      e.onRowDoubleClick && e.onRowDoubleClick.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onRowClick]
+  ), je = t.useCallback(
+    (k) => {
+      e.onRowContextMenu && e.onRowContextMenu.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onRowClick]
+  ), Ze = t.useCallback(
+    (k) => {
+      e.onTaskClick && e.onTaskClick.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onTaskClick]
+  ), Je = t.useCallback(
+    (k) => {
+      e.onTaskDoubleClick && e.onTaskDoubleClick.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onTaskDoubleClick]
+  ), Qe = t.useCallback(
+    (k) => {
+      e.onTaskContextMenu && e.onTaskContextMenu.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onTaskContextMenu]
+  ), et = t.useCallback(
+    (k) => {
+      e.onTaskRemoveClick && e.onTaskRemoveClick.call(
+        void 0,
+        { ...k, target: b.current }
+      );
+    },
+    [e.onTaskRemoveClick]
+  ), Te = t.useCallback(
+    (k) => {
+      if (e.onDependencyCreate) {
+        let re, le;
+        const be = D(R.id);
+        for (let Re = 0; Re < _.length; Re++) {
+          const tt = _[Re], Ee = be(tt.dataItem);
+          if (String(Ee) === k.fromId && (re = Ee), String(Ee) === k.toId && (le = Ee), re && le)
+            break;
+        }
+        e.onDependencyCreate.call(
+          void 0,
+          {
+            fromId: re,
+            toId: le,
+            target: b.current,
+            type: k.type
+          }
+        );
+      }
+    },
+    [e.onDependencyCreate, R, _]
+  );
+  return /* @__PURE__ */ t.createElement(
+    yn,
+    {
+      dateRange: K,
+      taskData: _,
+      dependencyData: l,
+      taskModelFields: R,
+      dependencyModelFields: X,
+      views: w,
+      activeView: [Z, T],
+      rowHeight: d,
+      toolbarHeight: W,
+      props: {
+        columns: o,
+        noRecords: m,
+        timezone: g,
+        resizable: u,
+        reorderable: h,
+        sortable: p,
+        sort: C,
+        filter: f,
+        columnMenuFilter: v,
+        columnMenu: L,
+        navigatable: V,
+        row: x,
+        selectable: z
+      },
+      events: {
+        onDataStateChange: Le,
+        onSortChange: Ye,
+        onFilterChange: Ce,
+        onColumnMenuFilterChange: de,
+        onExpandChange: ye,
+        onRowClick: Xe,
+        onRowDoubleClick: ke,
+        onRowContextMenu: je,
+        onColumnResize: ve,
+        onColumnReorder: qe,
+        onDependencyCreate: e.onDependencyCreate && Te,
+        onKeyDown: he,
+        onSelectionChange: fe,
+        onHeaderSelectionChange: pe
+      },
+      taskEvents: {
+        onTaskClick: Ze,
+        onTaskDoubleClick: Je,
+        onTaskContextMenu: Qe,
+        onTaskRemoveClick: e.onTaskRemoveClick && et
+      }
+    },
+    /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        ref: we,
+        role: "application",
+        style: s,
+        className: ce("k-gantt", c)
+      },
+      /* @__PURE__ */ t.createElement(ca, { ref: Y }, M && M.addTaskButton ? /* @__PURE__ */ t.createElement(da, { selectedTask: E.current, onClick: ue }) : null, /* @__PURE__ */ t.createElement(uo, null), /* @__PURE__ */ t.createElement(ia, null, /* @__PURE__ */ t.createElement(la, null))),
+      N && /* @__PURE__ */ t.createElement(
+        N.type,
+        {
+          key: N.props.name,
+          ref: j,
+          ...N.props,
+          firstSlotRangeRef: H
+        }
+      ),
+      n && /* @__PURE__ */ t.createElement(Ra, null)
+    )
+  );
+}), Se = {
+  taskData: [],
+  dependencyData: [],
+  columns: [],
+  rowHeight: 40
+};
+Wt.propTypes = {
+  taskData: i.array,
+  taskModelFields: i.shape({
+    id: i.string,
+    start: i.string,
+    end: i.string,
+    title: i.string,
+    percentComplete: i.string,
+    isRollup: i.string,
+    isExpanded: i.string,
+    children: i.string,
+    isInEdit: i.string
+  }),
+  dependencyData: i.array,
+  dependencyModelFields: i.shape({
+    id: i.string,
+    fromId: i.string,
+    toId: i.string,
+    type: i.string
+  }),
+  columns: i.arrayOf(
+    i.shape({
+      width: i.number,
+      cell: i.any,
+      editCell: i.any,
+      headerCell: i.any,
+      filter: i.any,
+      children: i.any,
+      field: i.string,
+      title: i.string,
+      sortable: i.any,
+      expandable: i.bool,
+      headerSelectionValue: i.bool,
+      format: i.string,
+      headerClassName: i.string,
+      className: i.string,
+      resizable: i.bool,
+      reorderable: i.bool,
+      minResizableWidth: i.number,
+      orderIndex: i.number,
+      columnMenu: i.any
+    })
+  ),
+  sort: i.array,
+  filter: i.array,
+  columnMenuFilter: i.array,
+  columnMenu: i.any,
+  style: i.object,
+  className: i.string,
+  children: i.any,
+  timezone: i.string,
+  defaultView: i.string,
+  view: i.string,
+  rowHeight: i.number,
+  navigatable: i.bool,
+  onViewChange: i.func,
+  onDataStateChange: i.func,
+  onSortChange: i.func,
+  onFilterChange: i.func,
+  onExpandChange: i.func,
+  onRowClick: i.func,
+  onColumnResize: i.func,
+  onColumnReorder: i.func
+};
+Wt.defaultProps = Se;
+Wt.displayName = "KendoReactGantt";
+const Ot = t.forwardRef((e, a) => {
+  const { slotWidth: n = me.slotWidth, slotDuration: o = me.slotDuration, firstSlotRangeRef: r, timelineHeaderCell: l } = e, { timezone: s } = Ne(), c = xe(), m = t.useRef(null), g = t.useRef(null), d = t.useCallback(
+    (L) => {
+      g.current && g.current.scrollIntoView(L);
+    },
+    []
+  );
+  t.useImperativeHandle(m, () => ({ scrollIntoView: d })), t.useImperativeHandle(a, () => m.current);
+  const u = Me(), h = e.workWeekStart || me.workWeekStart, p = e.workWeekEnd || me.workWeekEnd, C = e.workDayStart || me.workDayStart, f = e.workDayEnd || me.workDayEnd, v = t.useMemo(
+    () => {
+      const L = gn({
+        workWeekStart: h,
+        workWeekEnd: p
+      }), V = [], M = fn(u, { workDays: L, timezone: s }, c);
+      return M.forEach((x) => {
+        const z = Lo(
+          x.range,
+          {
+            workDayStart: C,
+            workDayEnd: f,
+            timezone: s,
+            slotDuration: o
+          },
+          c
+        );
+        x.span = z.length, V.push.apply(V, z);
+      }), r && V[0] && (r.current = V[0].range), [M, V];
+    },
+    [s, u.start.getTime(), u.end.getTime(), c, h, p, C, f]
+  );
+  return /* @__PURE__ */ t.createElement(
+    Fe,
+    {
+      ref: g,
+      slotWidth: n,
+      slotLevels: v,
+      timelineHeaderCell: l
+    }
+  );
+}), Jo = ({ tasksStart: e, tasksEnd: a, timezone: n }) => {
+  const o = S.fromLocalDate(e, n), r = S.fromLocalDate(a, n), l = mn(o), s = Dt(r), c = S.fromUTCDate(se(l), n), m = S.fromUTCDate(se(s), n);
+  return {
+    // Sat May 31 2014 07:00:00 GMT+0300 (Eastern European Summer Time)
+    start: new Date(c.getTime()),
+    end: new Date(m.getTime()),
+    // Sat May 31 2014 00:00:00 GMT-0400 (EDT)
+    zonedStart: c,
+    zonedEnd: m
+  };
+}, me = {
+  name: "day",
+  dateRange: Jo,
+  title: (e) => e.toLanguageString(it, ne[it]),
+  slotWidth: Ie,
+  slotDuration: 60,
+  workWeekStart: 1,
+  workWeekEnd: 5,
+  workDayStart: "08:00",
+  workDayEnd: "17:00"
+};
+Ot.defaultProps = me;
+Ot.propTypes = {
+  name: i.string,
+  dateRange: i.oneOfType([i.func, i.object]),
+  title: i.oneOfType([i.string, i.func]),
+  slotWidth: i.number,
+  slotDuration: i.number,
+  workWeekStart: i.number,
+  workWeekEnd: i.number,
+  workDayStart: i.string,
+  workDayEnd: i.string
+};
+Ot.displayName = "KendoReactGanttDayView";
+const Pt = t.forwardRef((e, a) => {
+  const { slotWidth: n = ua.slotWidth, firstSlotRangeRef: o, timelineHeaderCell: r } = e, { timezone: l } = Ne(), s = xe(), c = t.useRef(null), m = t.useRef(null), g = t.useCallback(
+    (h) => {
+      m.current && m.current.scrollIntoView(h);
+    },
+    []
+  );
+  t.useImperativeHandle(c, () => ({ scrollIntoView: g })), t.useImperativeHandle(a, () => c.current);
+  const d = Me(), u = t.useMemo(
+    () => {
+      const h = [], p = Cn(d, { timezone: l }, s);
+      return p.forEach((C) => {
+        const f = pn(
+          C.range,
+          { timezone: l },
+          s
+        );
+        h.push.apply(h, f);
+      }), o && h[0] && (o.current = h[0].range), [p, h];
+    },
+    [l, d.start.getTime(), d.end.getTime(), s]
+  );
+  return /* @__PURE__ */ t.createElement(
+    Fe,
+    {
+      ref: m,
+      slotWidth: n,
+      slotLevels: u,
+      timelineHeaderCell: r
+    }
+  );
+}), Qo = ({ tasksStart: e, tasksEnd: a, timezone: n }) => {
+  const o = S.fromLocalDate(e, n), r = S.fromLocalDate(a, n), l = en(oe(o)), s = ht(tn(oe(r)), 1), c = S.fromUTCDate(se(l), n), m = S.fromUTCDate(se(s), n);
+  return {
+    start: new Date(c.getTime()),
+    end: new Date(m.getTime()),
+    zonedStart: c,
+    zonedEnd: m
+  };
+}, ua = {
+  name: "month",
+  dateRange: Qo,
+  title: (e) => e.toLanguageString(ct, ne[ct]),
+  slotWidth: Ie,
+  workWeekStart: 1,
+  workWeekEnd: 5,
+  workDayStart: "08:00",
+  workDayEnd: "17:00"
+};
+Pt.defaultProps = ua;
+Pt.propTypes = {
+  name: i.string,
+  dateRange: i.oneOfType([i.func, i.object]),
+  title: i.oneOfType([i.string, i.func]),
+  slotWidth: i.number,
+  workWeekStart: i.number,
+  workWeekEnd: i.number,
+  workDayStart: i.string,
+  workDayEnd: i.string
+};
+Pt.displayName = "GanttMonthView";
+const _t = t.forwardRef((e, a) => {
+  const { slotWidth: n = ma.slotWidth, firstSlotRangeRef: o, timelineHeaderCell: r } = e, { timezone: l } = Ne(), s = xe(), c = t.useRef(null), m = t.useRef(null), g = t.useCallback(
+    (h) => {
+      m.current && m.current.scrollIntoView(h);
+    },
+    []
+  );
+  t.useImperativeHandle(c, () => ({ scrollIntoView: g })), t.useImperativeHandle(a, () => c.current);
+  const d = Me(), u = t.useMemo(
+    () => {
+      const h = Ho(d, { timezone: l }, s), p = [];
+      return h.forEach((C) => {
+        const f = Cn(
+          C.range,
+          { timezone: l },
+          s
+        );
+        p.push.apply(p, f);
+      }), o && p[0] && (o.current = p[0].range), [h, p];
+    },
+    [l, d.start.getTime(), d.end.getTime(), s]
+  );
+  return /* @__PURE__ */ t.createElement(
+    Fe,
+    {
+      slotWidth: n,
+      slotLevels: u,
+      timelineHeaderCell: r
+    }
+  );
+}), es = ({ tasksStart: e, tasksEnd: a, timezone: n }) => {
+  const o = S.fromLocalDate(e, n), r = S.fromLocalDate(a, n), l = en(xa(oe(o))), s = ht(tn(Ia(oe(r))), 1), c = S.fromUTCDate(se(l), n), m = S.fromUTCDate(se(s), n);
+  return {
+    start: new Date(c.getTime()),
+    end: new Date(m.getTime()),
+    zonedStart: c,
+    zonedEnd: m
+  };
+}, ma = {
+  name: "year",
+  dateRange: es,
+  title: (e) => e.toLanguageString(dt, ne[dt]),
+  slotWidth: Ie
+};
+_t.defaultProps = ma;
+_t.propTypes = {
+  name: i.string,
+  dateRange: i.oneOfType([i.func, i.object]),
+  title: i.oneOfType([i.string, i.func]),
+  slotWidth: i.number
+};
+_t.displayName = "GanttYearView";
+const ts = [
+  { text: Nn, operator: "contains" },
+  { text: Mn, operator: "doesnotcontain" },
+  { text: Pe, operator: "eq" },
+  { text: _e, operator: "neq" },
+  { text: In, operator: "startswith" },
+  { text: Fn, operator: "endswith" },
+  { text: Ke, operator: "isnull" },
+  { text: Be, operator: "isnotnull" },
+  { text: Sn, operator: "isempty" },
+  { text: xn, operator: "isnotempty" }
+], ns = [
+  { text: Pe, operator: "eq" },
+  { text: _e, operator: "neq" },
+  { text: Ln, operator: "gte" },
+  { text: Hn, operator: "gt" },
+  { text: An, operator: "lte" },
+  { text: Vn, operator: "lt" },
+  { text: Ke, operator: "isnull" },
+  { text: Be, operator: "isnotnull" }
+], as = [
+  { text: Pe, operator: "eq" },
+  { text: _e, operator: "neq" },
+  { text: On, operator: "gte" },
+  { text: Pn, operator: "gt" },
+  { text: _n, operator: "lt" },
+  { text: Kn, operator: "lte" },
+  { text: Ke, operator: "isnull" },
+  { text: Be, operator: "isnotnull" }
+], os = [
+  { text: Wn, operator: "" },
+  { text: zn, operator: !0 },
+  { text: Gn, operator: !1 }
+];
+function Ue(e, a) {
+  return {
+    clearButtonTitle: e.toLanguageString(ut, ne[ut]),
+    operators: a.map((n) => ({
+      text: e.toLanguageString(n.text, ne[n.text]),
+      operator: n.operator
+    }))
+  };
+}
+const ss = (e) => {
+  const { operators: a, ...n } = e;
+  return /* @__PURE__ */ t.createElement(
+    qa,
+    {
+      ariaLabel: "text filter",
+      ...Ue(ae(), a || ts),
+      ...n
+    }
+  );
+};
+ss.displayName = "KendoReactGanttTextFilter";
+const rs = (e) => {
+  const { operators: a, ...n } = e;
+  return /* @__PURE__ */ t.createElement(
+    Xa,
+    {
+      ariaLabel: "numeric filter",
+      ...Ue(ae(), a || ns),
+      ...n
+    }
+  );
+};
+rs.displayName = "KendoReactGanttNumericFilter";
+const ls = (e) => {
+  const { operators: a, ...n } = e;
+  return /* @__PURE__ */ t.createElement(
+    ja,
+    {
+      ariaLabel: "boolean filter",
+      ...Ue(ae(), a || os),
+      ...n
+    }
+  );
+};
+ls.displayName = "KendoReactGanttBooleanFilter";
+const is = (e) => {
+  const { operators: a, ...n } = e;
+  return /* @__PURE__ */ t.createElement(
+    Za,
+    {
+      ariaLabel: "date filter",
+      ...Ue(ae(), a || as),
+      ...n
+    }
+  );
+};
+is.displayName = "KendoReactGanttDateFilter";
+const Fs = (e) => {
+  const { dependencyData: a, dependencyModelFields: n, defaultDataItem: o, fromId: r, toId: l, type: s } = e, c = a.map((h) => ({ ...h })), m = ee(n.fromId), g = ee(n.toId), d = ee(n.type), u = o ? { ...o } : {};
+  return m(u, r), g(u, l), d(u, s), c.push(u), c;
+}, Ls = (e) => {
+  const { defaultDataItem: a, selectedDataItem: n, direction: o, taskModelFields: r, dataTree: l, slotStart: s, slotEnd: c } = e, m = Et(l, r.children, (f) => ({ ...f })), g = ee(r.start), d = ee(r.end), u = D(r.start), h = D(r.end), p = a ? { ...a } : {}, C = u(p) && h(p);
+  if (!n || o === "none")
+    C || (g(p, s), d(p, c)), m.unshift(p);
+  else {
+    const f = [{
+      task: { [r.children]: m },
+      childrenIndex: 0
+    }], v = D(r.id), L = D(r.children), V = ee(r.children), M = v(n);
+    for (; f.length > 0; ) {
+      const x = f[f.length - 1], z = x.task, J = v(z), R = L(z);
+      if (J && J === M)
+        break;
+      R && R.length && R.length > x.childrenIndex ? (f.push({
+        task: R[x.childrenIndex],
+        childrenIndex: 0
+      }), x.childrenIndex++) : f.pop();
+    }
+    if (f.length > 1) {
+      const x = f[f.length - 1].task, z = f[f.length - 2].childrenIndex, R = f[f.length - 2].task, X = L(R);
+      switch (o) {
+        case "child": {
+          let A = L(x);
+          A || (A = [], V(x, A)), C || (g(p, new Date(u(x).getTime())), d(p, new Date(h(x).getTime()))), A.push(p), Ve(f.splice(1, f.length - 1).map((j) => j.task), r);
+          break;
+        }
+        case "above": {
+          u(R) && h(R) && !C ? (g(p, new Date(u(x).getTime())), d(p, new Date(h(x).getTime()))) : (g(p, s), d(p, c)), X.splice(z - 1, 0, p), Ve(f.splice(1, f.length - 2).map((A) => A.task), r);
+          break;
+        }
+        case "below": {
+          u(R) && h(R) && !C ? (g(p, new Date(u(x).getTime())), d(p, new Date(h(x).getTime()))) : (g(p, s), d(p, c)), X.splice(z, 0, p), Ve(f.splice(1, f.length - 2).map((A) => A.task), r);
+          break;
+        }
+      }
+    }
+  }
+  return m;
+}, Hs = (e) => {
+  const { updatedDataItem: a, taskModelFields: n, dataTree: o } = e, r = D(n.id), l = D(n.children), s = r(a);
+  let c;
+  const m = Et(o, n.children, (d) => r(d) === s ? (c = d, { ...a }) : { ...d });
+  let g = [{
+    task: { [n.children]: m },
+    childrenIndex: 0
+  }];
+  for (; g.length > 0; ) {
+    const d = g[g.length - 1], u = d.task, h = r(u), p = l(u);
+    if (h && h === s)
+      break;
+    p && p.length && p.length > d.childrenIndex ? (g.push({
+      task: p[d.childrenIndex],
+      childrenIndex: 0
+    }), d.childrenIndex++) : g.pop();
+  }
+  if (g.length > 1) {
+    g = g.splice(1, g.length - 2);
+    const d = D(n.start), u = D(n.end), h = D(n.percentComplete);
+    if (d(c).getTime() !== d(a).getTime()) {
+      ga(g.map((C) => C.task), n);
+      const p = d(a).getTime() - d(c).getTime();
+      cs(l(a), n, p);
+    }
+    u(c).getTime() !== u(a).getTime() && ha(g.map((p) => p.task), n), h(c) !== h(a) && fa(g.map((p) => p.task), n);
+  }
+  return m;
+}, As = (e) => {
+  const { removedDataItem: a, taskModelFields: n, dataTree: o } = e, r = Et(o, n.children, (g) => ({ ...g }));
+  let l = [{
+    task: { [n.children]: r },
+    childrenIndex: 0
+  }];
+  const s = D(n.id), c = D(n.children), m = s(a);
+  for (; l.length > 0; ) {
+    const g = l[l.length - 1], d = g.task, u = s(d), h = c(d);
+    if (u && u === m)
+      break;
+    h && h.length && h.length > g.childrenIndex ? (l.push({
+      task: h[g.childrenIndex],
+      childrenIndex: 0
+    }), g.childrenIndex++) : l.pop();
+  }
+  if (l.length > 1) {
+    const g = l[l.length - 2], d = g.task;
+    c(d).splice(g.childrenIndex - 1, 1), l = l.splice(1, l.length - 2), Ve(l.map((h) => h.task), n);
+  }
+  return r;
+}, Ve = (e, a) => {
+  ga(e, a), ha(e, a), fa(e, a);
+}, ga = (e, a) => {
+  if (!e.length)
+    return;
+  const n = D(a.children), o = D(a.start), r = ee(a.start);
+  for (let l = e.length - 1; l >= 0; l--) {
+    const s = e[l], c = n(s);
+    if (c && c.length) {
+      const m = c.reduce(
+        (g, d) => Math.min(g, o(d).getTime()),
+        o(c[0]).getTime()
+      );
+      r(s, new Date(m));
+    }
+  }
+}, ha = (e, a) => {
+  if (!e.length)
+    return;
+  const n = D(a.children), o = D(a.end), r = ee(a.end);
+  for (let l = e.length - 1; l >= 0; l--) {
+    const s = e[l], c = n(s);
+    if (c && c.length) {
+      const m = c.reduce(
+        (g, d) => Math.max(g, o(d).getTime()),
+        o(c[0]).getTime()
+      );
+      r(s, new Date(m));
+    }
+  }
+}, fa = (e, a) => {
+  if (!e.length)
+    return;
+  const n = D(a.children), o = D(a.percentComplete), r = ee(a.percentComplete), l = ({ avg: s, n: c }, m) => ({
+    avg: ((o(m) || 0) + c * s) / (c + 1),
+    n: c + 1
+  });
+  for (let s = e.length - 1; s >= 0; s--) {
+    const c = e[s], m = n(c);
+    if (m && m.length) {
+      const g = m.reduce(l, { avg: 0, n: 0 }).avg;
+      r(c, g);
+    }
+  }
+}, cs = (e, a, n) => {
+  if (!e)
+    return;
+  const o = D(a.children), r = D(a.start), l = ee(a.start), s = D(a.end), c = ee(a.end), m = e.map((g) => ({ task: g, childrenIndex: 0 }));
+  for (; m.length > 0; ) {
+    const g = m[m.length - 1], d = g.task, u = o(d);
+    u && u.length && u.length > g.childrenIndex ? (m.push({
+      task: u[g.childrenIndex],
+      childrenIndex: 0
+    }), g.childrenIndex++) : (m.pop(), l(d, new Date(r(d).getTime() + n)), c(d, new Date(s(d).getTime() + n)));
+  }
+}, ds = (e) => {
+  const { validationMessage: a, touched: n, label: o, id: r, valid: l, disabled: s, hint: c, type: m, optional: g, ...d } = e, u = n && a, h = !u && c, p = h ? `${r}_hint` : "", C = u ? `${r}_error` : "";
+  return /* @__PURE__ */ t.createElement(ft, null, /* @__PURE__ */ t.createElement(pt, { editorId: r, editorValid: l, editorDisabled: s, optional: g }, o), /* @__PURE__ */ t.createElement("div", { className: "k-form-field-wrap" }, /* @__PURE__ */ t.createElement(
+    ho,
+    {
+      valid: l,
+      type: m,
+      id: r,
+      disabled: s,
+      ariaDescribedBy: `${p} ${C}`,
+      ...d
+    }
+  ), h && /* @__PURE__ */ t.createElement(Ct, { id: p }, c), u && /* @__PURE__ */ t.createElement(kt, { id: C }, a)));
+}, Zt = (e) => {
+  const { validationMessage: a, touched: n, label: o, id: r, valid: l, disabled: s, hint: c, wrapperStyle: m, ...g } = e, d = n && a, u = !d && c, h = u ? `${r}_hint` : "", p = d ? `${r}_error` : "", C = o ? `${r}_label` : "";
+  return /* @__PURE__ */ t.createElement(ft, { style: m }, /* @__PURE__ */ t.createElement(pt, { id: C, editorId: r, editorValid: l, editorDisabled: s }, o), /* @__PURE__ */ t.createElement("div", { className: "k-form-field-wrap" }, /* @__PURE__ */ t.createElement(
+    po,
+    {
+      ariaLabelledBy: C,
+      ariaDescribedBy: `${h} ${p}`,
+      valid: l,
+      id: r,
+      disabled: s,
+      ...g
+    }
+  ), u && /* @__PURE__ */ t.createElement(Ct, { id: h }, c), d && /* @__PURE__ */ t.createElement(kt, { id: p }, a)));
+}, us = (e) => {
+  const { validationMessage: a, touched: n, label: o, id: r, valid: l, disabled: s, hint: c, ...m } = e, g = n && a, d = !g && c, u = d ? `${r}_hint` : "", h = g ? `${r}_error` : "";
+  return /* @__PURE__ */ t.createElement(ft, null, /* @__PURE__ */ t.createElement(pt, { editorId: r, editorValid: l, editorDisabled: s }, o), /* @__PURE__ */ t.createElement("div", { className: "k-form-field-wrap" }, /* @__PURE__ */ t.createElement(
+    fo,
+    {
+      ariaDescribedBy: `${u} ${h}`,
+      valid: l,
+      id: r,
+      disabled: s,
+      ...m
+    }
+  ), d && /* @__PURE__ */ t.createElement(Ct, { id: u }, c), g && /* @__PURE__ */ t.createElement(kt, { id: h }, a)));
+}, ms = () => {
+  const e = Tt(), a = ae(), n = (f) => a.toLanguageString(f, ne[f]), o = n(Un), r = n(Yn), l = n(qn), s = n(Xn), c = n(jn), m = n(Zn), g = n(Jn), d = t.useCallback(
+    (f) => f || f === 0 ? void 0 : c,
+    [c]
+  ), u = t.useCallback(
+    (f, v) => f && v(e.end) && f.getTime() > v(e.end).getTime() ? m : void 0,
+    [e, m]
+  ), h = t.useCallback(
+    (f, v) => f && v(e.start) && f.getTime() < v(e.start).getTime() ? g : void 0,
+    [e, g]
+  ), p = t.useMemo(
+    () => [d, u],
+    [d, u]
+  ), C = t.useMemo(
+    () => [d, h],
+    [d, h]
+  );
+  return /* @__PURE__ */ t.createElement(mo, { style: { width: 400 }, horizontal: !0 }, /* @__PURE__ */ t.createElement(
+    He,
+    {
+      id: `${e.title}_gantteditor`,
+      name: e.title,
+      label: o,
+      component: ds,
+      validator: d
+    }
+  ), /* @__PURE__ */ t.createElement(
+    He,
+    {
+      id: `${e.start}_gantteditor`,
+      name: e.start,
+      label: r,
+      component: Zt,
+      validator: p
+    }
+  ), /* @__PURE__ */ t.createElement(
+    He,
+    {
+      id: `${e.end}_gantteditor`,
+      name: e.end,
+      label: l,
+      component: Zt,
+      validator: C
+    }
+  ), /* @__PURE__ */ t.createElement(
+    He,
+    {
+      id: `${e.percentComplete}_gantteditor`,
+      name: e.percentComplete,
+      format: "p",
+      label: s,
+      component: us,
+      step: 0.01,
+      validator: d
+    }
+  ));
+}, Vs = (e) => {
+  const { onCancel: a, onClose: n, onSubmit: o, ...r } = e, l = ae(), s = (C) => l.toLanguageString(C, ne[C]), c = s(Bn), m = s(Gt), g = s($n), d = t.useCallback(
+    (C) => {
+      if (a) {
+        const f = { syntheticEvent: C, nativeEvent: C.nativeEvent, dataItem: e.dataItem };
+        a.call(void 0, f);
+      }
+    },
+    [a, e.dataItem]
+  ), u = t.useCallback(
+    ({ syntheticEvent: C }) => {
+      if (n) {
+        const f = { syntheticEvent: C, nativeEvent: C.nativeEvent, dataItem: e.dataItem };
+        n.call(void 0, f);
+      }
+    },
+    [n, e.dataItem]
+  ), h = t.useCallback(
+    (C, f) => {
+      if (o) {
+        const v = { dataItem: C, syntheticEvent: f, nativeEvent: f && f.nativeEvent };
+        o.call(void 0, v);
+      }
+    },
+    [o]
+  ), p = /* @__PURE__ */ t.createElement(
+    go,
+    {
+      initialValues: e.dataItem,
+      onSubmit: h,
+      render: (C) => /* @__PURE__ */ t.createElement(
+        rn,
+        {
+          title: g,
+          minWidth: 600,
+          onClose: u,
+          style: { zIndex: 90 }
+        },
+        /* @__PURE__ */ t.createElement(ms, null),
+        /* @__PURE__ */ t.createElement(ln, null, /* @__PURE__ */ t.createElement(
+          ze,
+          {
+            disabled: !C.allowSubmit,
+            onClick: C.onSubmit
+          },
+          c
+        ), /* @__PURE__ */ t.createElement(ze, { onClick: d }, m))
+      ),
+      ...r
+    }
+  );
+  return gt ? sn.createPortal(p, document && document.body) : null;
+}, zs = (e) => {
+  const { onClose: a, onCancel: n, onConfirm: o, dataItem: r } = e, l = ae(), s = (f) => l.toLanguageString(f, ne[f]), c = s(aa), m = s(Gt), g = s(oa), d = s(sa), u = t.useCallback(
+    ({ syntheticEvent: f }) => {
+      a && a.call(void 0, {
+        syntheticEvent: f,
+        nativeEvent: f && f.nativeEvent,
+        dataItem: null
+      });
+    },
+    [a]
+  ), h = t.useCallback(
+    (f) => {
+      n && n.call(void 0, {
+        syntheticEvent: f,
+        nativeEvent: f && f.nativeEvent,
+        dataItem: null
+      });
+    },
+    [n]
+  ), p = t.useCallback(
+    (f) => {
+      o && o.call(void 0, {
+        syntheticEvent: f,
+        nativeEvent: f && f.nativeEvent,
+        dataItem: r
+      });
+    },
+    [o, r]
+  ), C = /* @__PURE__ */ t.createElement(rn, { title: d, onClose: u }, g, /* @__PURE__ */ t.createElement(ln, null, /* @__PURE__ */ t.createElement("button", { className: "k-button", onClick: h }, m), /* @__PURE__ */ t.createElement("button", { className: "k-button", onClick: p }, c)));
+  return gt ? sn.createPortal(C, document && document.body) : null;
+}, Gs = an;
+export {
+  Rs as GANTT_COL_INDEX_ATTRIBUTE,
+  Ss as GANTT_PREVENT_SELECTION_ELEMENT,
+  bs as GANTT_ROW_INDEX_ATTRIBUTE,
+  Wt as Gantt,
+  ls as GanttBooleanFilter,
+  is as GanttDateFilter,
+  Ot as GanttDayView,
+  Vs as GanttForm,
+  Pt as GanttMonthView,
+  rs as GanttNumericFilter,
+  zs as GanttRemoveDialog,
+  Gs as GanttRow,
+  ss as GanttTextFilter,
+  $e as GanttWeekView,
+  _t as GanttYearView,
+  Fs as addDependency,
+  Ls as addTask,
+  Ms as createDataTree,
+  Ns as extendDataItem,
+  Is as filterBy,
+  Ps as getSelectedState,
+  _s as getSelectedStateFromKeyDown,
+  Et as mapTree,
+  xs as orderBy,
+  As as removeTask,
+  Ks as setSelectedState,
+  Hs as updateTask
+};