laif-ds 0.1.6 → 0.1.8

package/dist/components/ui/gantt/components/Chart/Scale/Scale.js

@@ -0,0 +1,88 @@
+"use client";
+import { j as a } from "../../../../../../_virtual/jsx-runtime.js";
+import { forwardRef as T, useContext as A, useRef as M, useCallback as u, useEffect as C } from "react";
+import c from "../../../../../../_virtual/dayjs.min.js";
+import { VariableSizeList as O } from "../../../../../../node_modules/react-window/dist/index.esm.js";
+import { GanttContext as R } from "../../Gantt/GanttContext.js";
+/* empty css          */
+import { useForwardRef as _ } from "../../../hooks/useForwardRef.js";
+import { getScaleItems as v } from "../../../utils/getScaleItems.js";
+import { GanttDimensions as p } from "../../../enums/GanttDimensions.js";
+import { GanttDimensionsSettings as w } from "../../../constants/DimensionsSettings.js";
+import { GanttConsts as m } from "../../../constants/GanttConsts.js";
+const F = T(({ width: W, wrapRef: f }, y) => {
+  const { scaleDates: n, setScaleDates: d, setScaleRenderState: h, settings: t } = A(R), e = _(y), l = M(null), j = M(null), E = u(
+    (s) => {
+      const i = c.unix(n[s]);
+      return t.dimension === p.DAY ? i.daysInMonth() * t.stepWidth : t.scaleStepItems * t.stepWidth;
+    },
+    [n, t.dimension, t.scaleStepItems, t.stepWidth]
+  ), N = u(
+    ({ scrollOffset: s }) => {
+      var r, o, S, x, I;
+      const i = w[t.dimension].unitOfTime;
+      if (s < m.MIN_SCROLL_OFFSET) {
+        const g = c.unix(n[0]).subtract(1, i);
+        let D = t.scaleStepItems * t.stepWidth;
+        t.dimension === p.DAY && (D = g.daysInMonth() * t.stepWidth), d([g.unix(), ...n]), (r = f.current) == null || r.scrollTo({ left: s + D }), (o = e == null ? void 0 : e.current) == null || o.resetAfterIndex(0);
+      }
+      (((S = l.current) == null ? void 0 : S.scrollWidth) || 0) - (((x = l.current) == null ? void 0 : x.clientWidth) || 0) - s - m.TREE_WIDTH < m.MIN_SCROLL_OFFSET && (d([
+        ...n,
+        c.unix(n[n.length - 1]).add(1, i).unix()
+      ]), (I = e == null ? void 0 : e.current) == null || I.resetAfterIndex(0));
+    },
+    [
+      e,
+      n,
+      d,
+      t.dimension,
+      t.scaleStepItems,
+      t.stepWidth,
+      f
+    ]
+  ), Y = u(
+    (s) => {
+      h(s);
+    },
+    [h]
+  );
+  return C(() => {
+    var s;
+    (s = e == null ? void 0 : e.current) == null || s.resetAfterIndex(0);
+  }, [e, t.dimension]), /* @__PURE__ */ a.jsx("div", { className: "gantt-scale-wrap", children: /* @__PURE__ */ a.jsx(
+    O,
+    {
+      className: "gantt-scale-list",
+      layout: "horizontal",
+      width: W,
+      height: m.HEADER_HEIGHT,
+      itemCount: n.length,
+      itemSize: E,
+      itemData: n,
+      ref: e,
+      outerRef: l,
+      innerRef: j,
+      initialScrollOffset: t.initialScrollOffset,
+      onScroll: N,
+      onItemsRendered: Y,
+      children: ({ style: s, index: i, data: r }) => /* @__PURE__ */ a.jsxs("div", { className: "gantt-scale-item", style: s, children: [
+        /* @__PURE__ */ a.jsx("div", { className: "gantt-scale-title", children: c.unix(r[i]).format(
+          t.dimension === p.DAY ? "MMMM, YYYY" : "ddd, D MMMM, YY"
+        ) }),
+        /* @__PURE__ */ a.jsx("div", { className: "gantt-scale-steps", children: v(t.dimension, r[i]).map((o) => /* @__PURE__ */ a.jsx(
+          "div",
+          {
+            className: "gantt-scale-step",
+            style: { width: t.stepWidth },
+            children: o
+          },
+          o
+        )) })
+      ] })
+    }
+  ) });
+});
+F.displayName = "Scale";
+export {
+  F as default
+};

package/dist/components/ui/gantt/components/Chart/Tree/Tree.js

@@ -0,0 +1,72 @@
+"use client";
+import { j as r } from "../../../../../../_virtual/jsx-runtime.js";
+import { forwardRef as p, useMemo as u, useCallback as g } from "react";
+import { VariableSizeList as h } from "../../../../../../node_modules/react-window/dist/index.esm.js";
+/* empty css         */
+import { MinusSquareOutlined as f } from "../../../assets/icons/MinusSquareOutlined.js";
+import { PlusSquareOutlined as x } from "../../../assets/icons/PlusSquareOutlined.js";
+import { GanttConsts as a } from "../../../constants/GanttConsts.js";
+const E = p(({ height: d, data: i, setData: l }, c) => {
+  const o = u(() => {
+    const n = [];
+    for (const e of i)
+      e.hasOwnProperty("expanded") && !e.expanded && n.push(e.key);
+    return i.filter((e) => !e.parentsKeys.some((s) => n.includes(s)));
+  }, [i]), m = g(
+    (n) => {
+      const e = [...i], t = e.find((s) => s.key === n);
+      t != null && t.hasOwnProperty("expanded") && (t.expanded = !t.expanded), l(e);
+    },
+    [i, l]
+  );
+  return /* @__PURE__ */ r.jsx(
+    "div",
+    {
+      className: "gantt-tree-wrap bg-background shadow-lg",
+      style: {
+        width: a.TREE_WIDTH,
+        marginTop: -a.HEADER_HEIGHT
+      },
+      children: /* @__PURE__ */ r.jsx(
+        h,
+        {
+          ref: c,
+          className: "gantt-tree-list bg-background",
+          layout: "vertical",
+          width: "100%",
+          height: d,
+          itemCount: o.length,
+          itemSize: () => a.ROW_HEIGHT,
+          itemData: o,
+          innerElementType: ({ children: n, props: e }) => /* @__PURE__ */ r.jsxs("div", { style: { height: o.length * a.ROW_HEIGHT }, ...e, children: [
+            /* @__PURE__ */ r.jsx("div", { className: "gantt-tree-title bg-background", style: { height: a.HEADER_HEIGHT }, children: "Title" }),
+            /* @__PURE__ */ r.jsx("div", { className: "gantt-tree-inner-wrap", children: n })
+          ] }),
+          children: ({ style: n, index: e, data: t }) => {
+            const s = t[e];
+            return /* @__PURE__ */ r.jsxs(
+              "button",
+              {
+                className: "gantt-tree-list-item bg-background text-foreground",
+                style: {
+                  ...n,
+                  backgroundColor: e % 2 === 0 ? "var(--background)" : "var(--muted)",
+                  paddingLeft: a.LEAF_TITLE_PADDING_LEFT + s.level * a.LEAF_CHILDREN_PADDING_LEFT
+                },
+                onClick: () => m(s.key),
+                children: [
+                  s.hasOwnProperty("expanded") ? s.expanded ? /* @__PURE__ */ r.jsx(f, { className: "gantt-tree-icon" }) : /* @__PURE__ */ r.jsx(x, { className: "gantt-tree-icon" }) : null,
+                  /* @__PURE__ */ r.jsx("div", { children: t[e].title })
+                ]
+              }
+            );
+          }
+        }
+      )
+    }
+  );
+});
+E.displayName = "Tree";
+export {
+  E as default
+};

package/dist/components/ui/gantt/components/Controls/Controls.js

@@ -0,0 +1,82 @@
+"use client";
+import { j as n } from "../../../../../_virtual/jsx-runtime.js";
+import { useContext as V, useState as x, useMemo as p, useCallback as a } from "react";
+import G from "../../../../../_virtual/dayjs.min.js";
+import { cn as y } from "../../../../../lib/utils.js";
+import { Button as h } from "../../../button.js";
+import { Select as j, SelectTrigger as f, SelectValue as g, SelectContent as S, SelectItem as v } from "../../../select.js";
+import { GanttContext as R } from "../Gantt/GanttContext.js";
+import { useGanttCalculate as P } from "../../hooks/useGanttCalculate.js";
+import B from "../../../../../node_modules/lucide-react/dist/esm/icons/chevron-left.js";
+import E from "../../../../../node_modules/lucide-react/dist/esm/icons/chevron-right.js";
+import { GanttDimensions as H } from "../../enums/GanttDimensions.js";
+import { GanttDimensionsSettings as l } from "../../constants/DimensionsSettings.js";
+import { DragStepOptions as d } from "../../constants/DragStepOptions.js";
+const Z = ({ className: b }) => {
+  const { calculate: i } = P(), { settings: r, setSettings: u, currentDate: C } = V(R), [D, c] = x(H.HOUR), [t, m] = x(0), o = p(() => Object.keys(l).map((e, s) => ({
+    label: l[e].label,
+    value: e,
+    index: s
+  })), []), z = a(
+    (e) => {
+      const s = o.findIndex((I) => I.value === e);
+      c(e), m(s), i(e);
+    },
+    [i, o]
+  ), N = a(() => {
+    if (t < o.length - 1) {
+      const e = Object.keys(l)[t + 1];
+      c(e), m(t + 1), i(e);
+    }
+  }, [i, o.length, t]), O = a(() => {
+    if (t > 0) {
+      const e = Object.keys(l)[t - 1];
+      c(e), m(t - 1), i(e);
+    }
+  }, [i, t]), k = p(() => Object.keys(d).map((e) => ({
+    label: d[e].label,
+    value: e
+  })), []), w = a(
+    (e) => {
+      u(() => {
+        const s = { ...r };
+        return s.dragStepSize = e, s.gridSize = d[e].seconds / l[s.dimension].secondsInPixel, s;
+      });
+    },
+    [u, r]
+  );
+  return /* @__PURE__ */ n.jsxs("div", { className: y("flex items-center gap-2 p-4 border-b", b), children: [
+    /* @__PURE__ */ n.jsx(
+      h,
+      {
+        variant: "outline",
+        size: "icon",
+        onClick: O,
+        disabled: t <= 0,
+        children: /* @__PURE__ */ n.jsx(B, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ n.jsxs(j, { value: D, onValueChange: z, children: [
+      /* @__PURE__ */ n.jsx(f, { className: "w-[180px]", children: /* @__PURE__ */ n.jsx(g, { placeholder: "Seleziona dimensione" }) }),
+      /* @__PURE__ */ n.jsx(S, { className: "z-100", children: o.map((e) => /* @__PURE__ */ n.jsx(v, { value: e.value, children: e.label }, e.value)) })
+    ] }),
+    /* @__PURE__ */ n.jsx(
+      h,
+      {
+        variant: "outline",
+        size: "icon",
+        onClick: N,
+        disabled: t >= o.length - 1,
+        children: /* @__PURE__ */ n.jsx(E, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ n.jsx("div", { className: "px-4 text-sm font-medium", children: G.unix(C).format("ddd, ll") }),
+    /* @__PURE__ */ n.jsxs(j, { value: r.dragStepSize, onValueChange: w, children: [
+      /* @__PURE__ */ n.jsx(f, { className: "w-[180px]", children: /* @__PURE__ */ n.jsx(g, { placeholder: "Seleziona step" }) }),
+      /* @__PURE__ */ n.jsx(S, { children: k.map((e) => /* @__PURE__ */ n.jsx(v, { value: e.value, children: e.label }, e.value)) })
+    ] })
+  ] });
+};
+export {
+  Z as default
+};

package/dist/components/ui/gantt/components/Gantt/Gantt.js

@@ -0,0 +1,58 @@
+"use client";
+import { j as s } from "../../../../../_virtual/jsx-runtime.js";
+import { useMemo as n, useRef as O, useState as e } from "react";
+import a from "../../../../../_virtual/dayjs.min.js";
+import H from "../../../../../_virtual/localizedFormat.js";
+import { GanttContext as v } from "./GanttContext.js";
+/* empty css                       */
+/* empty css                    */
+/* empty css          */
+import C from "../Chart/Chart.js";
+import U from "../Controls/Controls.js";
+import { getScaleDates as h } from "../../utils/getScaleDates.js";
+import { getInitialScrollOffset as j } from "../../utils/getInitialScrollOffset.js";
+import { GanttDimensions as t } from "../../enums/GanttDimensions.js";
+import { DragStepSizes as i } from "../../enums/DragStepSizes.js";
+import { GanttConsts as G } from "../../constants/GanttConsts.js";
+import { GanttDimensionsSettings as r } from "../../constants/DimensionsSettings.js";
+import { DragStepOptions as z } from "../../constants/DragStepOptions.js";
+a.extend(H);
+const m = ({ children: l, draggable: p = !1 }) => {
+  const o = n(() => h(), []), c = n(() => j(t.HOUR, o), [o]), S = O(null), [d, f] = e(a().unix()), [x, u] = e(o), [I, R] = e({
+    stepWidth: r[t.HOUR].stepWidth,
+    secondsInPixel: r[t.HOUR].secondsInPixel,
+    scaleStepItems: G.HOURS_IN_DAY,
+    initialScrollOffset: c,
+    dimension: t.HOUR,
+    draggable: p,
+    dragStepSize: i.THIRTY_MIN,
+    gridSize: z[i.THIRTY_MIN].seconds / r[t.HOUR].secondsInPixel
+  }), [D, g] = e({
+    overscanStartIndex: 0,
+    overscanStopIndex: 0,
+    visibleStartIndex: 0,
+    visibleStopIndex: 0
+  });
+  return /* @__PURE__ */ s.jsx(
+    v.Provider,
+    {
+      value: {
+        wrapRef: S,
+        scaleDates: x,
+        setScaleDates: u,
+        settings: I,
+        setSettings: R,
+        scaleRenderState: D,
+        setScaleRenderState: g,
+        currentDate: d,
+        setCurrentDate: f
+      },
+      children: /* @__PURE__ */ s.jsx("div", { className: "gantt-wrap", children: l })
+    }
+  );
+};
+m.Chart = C;
+m.Controls = U;
+export {
+  m as default
+};

package/dist/components/ui/gantt/components/Gantt/GanttContext.js

@@ -0,0 +1,35 @@
+"use client";
+import { createContext as e } from "react";
+import { DragStepSizes as t } from "../../enums/DragStepSizes.js";
+import { GanttDimensions as s } from "../../enums/GanttDimensions.js";
+const i = e({
+  wrapRef: { current: null },
+  scaleDates: [],
+  setScaleDates: () => {
+  },
+  settings: {
+    stepWidth: 0,
+    secondsInPixel: 0,
+    scaleStepItems: 0,
+    initialScrollOffset: 0,
+    dimension: s.HOUR,
+    dragStepSize: t.THIRTY_MIN,
+    gridSize: 0,
+    draggable: !1
+  },
+  setSettings: () => {
+  },
+  scaleRenderState: {
+    overscanStartIndex: 0,
+    overscanStopIndex: 0,
+    visibleStartIndex: 0,
+    visibleStopIndex: 0
+  },
+  setScaleRenderState: () => {
+  },
+  currentDate: 0,
+  setCurrentDate: () => 0
+});
+export {
+  i as GanttContext
+};

package/dist/components/ui/gantt/constants/DimensionsSettings.js

@@ -0,0 +1,89 @@
+"use client";
+import { GanttConsts as _ } from "./GanttConsts.js";
+import { GanttUnitOfTimes as S } from "../enums/GanttUnitOfTimes.js";
+import { GanttDimensions as e } from "../enums/GanttDimensions.js";
+const s = {
+  [e.HOUR]: {
+    value: 0,
+    hours: 1,
+    label: "1 hour",
+    unitOfTime: S.DAY,
+    itemsCount: 11,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH,
+    scaleStepItems: _.HOURS_IN_DAY / 1,
+    secondsInPixel: _.SECONDS_IN_HOUR * 1 / _.SCALE_STEP_DEFAULT_WIDTH
+  },
+  [e.TWO_HOURS]: {
+    value: 1,
+    hours: 2,
+    label: "2 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 2,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 2,
+    secondsInPixel: _.SECONDS_IN_HOUR * 2 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.THREE_HOURS]: {
+    value: 2,
+    hours: 3,
+    label: "3 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 3,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 3,
+    secondsInPixel: _.SECONDS_IN_HOUR * 3 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.FOUR_HOURS]: {
+    value: 3,
+    hours: 4,
+    label: "4 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 4,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 4,
+    secondsInPixel: _.SECONDS_IN_HOUR * 4 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.SIX_HOURS]: {
+    value: 4,
+    hours: 6,
+    label: "6 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 6,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 6,
+    secondsInPixel: _.SECONDS_IN_HOUR * 6 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.EIGHT_HOURS]: {
+    value: 5,
+    hours: 8,
+    label: "8 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 8,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 8,
+    secondsInPixel: _.SECONDS_IN_HOUR * 8 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.TWELVE_HOURS]: {
+    value: 6,
+    hours: 12,
+    label: "12 hours",
+    unitOfTime: S.DAY,
+    itemsCount: 11 * 12,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO,
+    scaleStepItems: _.HOURS_IN_DAY / 12,
+    secondsInPixel: _.SECONDS_IN_HOUR * 12 / (_.SCALE_STEP_DEFAULT_WIDTH * _.SCALE_STEP_RATIO)
+  },
+  [e.DAY]: {
+    value: 7,
+    hours: 24,
+    label: "1 day",
+    unitOfTime: S.MONTH,
+    itemsCount: 11,
+    stepWidth: _.SCALE_STEP_DEFAULT_WIDTH,
+    scaleStepItems: _.HOURS_IN_DAY / 24,
+    secondsInPixel: _.SECONDS_IN_HOUR * 24 / _.SCALE_STEP_DEFAULT_WIDTH
+  }
+};
+export {
+  s as GanttDimensionsSettings
+};

package/dist/components/ui/gantt/constants/DragStepOptions.js

@@ -0,0 +1,43 @@
+"use client";
+import { DragStepSizes as e } from "../enums/DragStepSizes.js";
+const l = {
+  [e.FIVE_MIN]: {
+    seconds: 5 * 60,
+    label: "5 min"
+  },
+  [e.TEN_MIN]: {
+    seconds: 10 * 60,
+    label: "10 min"
+  },
+  [e.FIFTEEN_MIN]: {
+    seconds: 15 * 60,
+    label: "15 min"
+  },
+  [e.TWENTY_MIN]: {
+    seconds: 20 * 60,
+    label: "20 min"
+  },
+  [e.THIRTY_MIN]: {
+    seconds: 30 * 60,
+    label: "30 min"
+  },
+  [e.ONE_HOUR]: {
+    seconds: 60 * 60,
+    label: "1 hour"
+  },
+  [e.EIGHT_HOURS]: {
+    seconds: 8 * 60 * 60,
+    label: "8 hours"
+  },
+  [e.TWELVE_HOURS]: {
+    seconds: 12 * 60 * 60,
+    label: "12 hours"
+  },
+  [e.ONE_DAY]: {
+    seconds: 24 * 60 * 60,
+    label: "1 day"
+  }
+};
+export {
+  l as DragStepOptions
+};

package/dist/components/ui/gantt/constants/GanttConsts.js

@@ -0,0 +1,17 @@
+"use client";
+const _ = {
+  ROW_HEIGHT: 40,
+  HEADER_HEIGHT: 50,
+  TREE_WIDTH: 300,
+  LEAF_TITLE_PADDING_LEFT: 50,
+  LEAF_CHILDREN_PADDING_LEFT: 5,
+  SCALE_STEP_DEFAULT_WIDTH: 50,
+  SECONDS_IN_HOUR: 3600,
+  SECONDS_IN_DAY: 86400,
+  HOURS_IN_DAY: 24,
+  MIN_SCROLL_OFFSET: 2400,
+  SCALE_STEP_RATIO: 1.6
+};
+export {
+  _ as GanttConsts
+};

package/dist/components/ui/gantt/constants/colors.json.js

@@ -0,0 +1,106 @@
+"use client";
+const s = [
+  "hsl(113.60000000000002, 50%, 50%)",
+  "hsl(322.4, 50%, 50%)",
+  "hsl(228.8, 50%, 50%)",
+  "hsl(326, 50%, 50%)",
+  "hsl(189.20000000000005, 50%, 50%)",
+  "hsl(117.19999999999999, 50%, 50%)",
+  "hsl(171.20000000000005, 50%, 50%)",
+  "hsl(239.6, 50%, 50%)",
+  "hsl(120.80000000000001, 50%, 50%)",
+  "hsl(232.4, 50%, 50%)",
+  "hsl(34.39999999999998, 50%, 50%)",
+  "hsl(315.2, 50%, 50%)",
+  "hsl(23.600000000000023, 50%, 50%)",
+  "hsl(293.6, 50%, 50%)",
+  "hsl(146, 50%, 50%)",
+  "hsl(5.600000000000023, 50%, 50%)",
+  "hsl(38, 50%, 50%)",
+  "hsl(358.4, 50%, 50%)",
+  "hsl(70.39999999999998, 50%, 50%)",
+  "hsl(84.80000000000001, 50%, 50%)",
+  "hsl(351.20000000000005, 50%, 50%)",
+  "hsl(225.2, 50%, 50%)",
+  "hsl(174.79999999999995, 50%, 50%)",
+  "hsl(102.80000000000001, 50%, 50%)",
+  "hsl(63.200000000000045, 50%, 50%)",
+  "hsl(297.2, 50%, 50%)",
+  "hsl(45.200000000000045, 50%, 50%)",
+  "hsl(2, 50%, 50%)",
+  "hsl(203.6, 50%, 50%)",
+  "hsl(59.60000000000002, 50%, 50%)",
+  "hsl(56, 50%, 50%)",
+  "hsl(12.800000000000011, 50%, 50%)",
+  "hsl(311.6, 50%, 50%)",
+  "hsl(279.2, 50%, 50%)",
+  "hsl(99.19999999999999, 50%, 50%)",
+  "hsl(81.20000000000005, 50%, 50%)",
+  "hsl(214.4, 50%, 50%)",
+  "hsl(160.4000000000001, 50%, 50%)",
+  "hsl(92, 50%, 50%)",
+  "hsl(250.4, 50%, 50%)",
+  "hsl(275.6, 50%, 50%)",
+  "hsl(290, 50%, 50%)",
+  "hsl(185.60000000000002, 50%, 50%)",
+  "hsl(207.2, 50%, 50%)",
+  "hsl(282.8, 50%, 50%)",
+  "hsl(27.200000000000045, 50%, 50%)",
+  "hsl(210.8, 50%, 50%)",
+  "hsl(16.399999999999977, 50%, 50%)",
+  "hsl(182, 50%, 50%)",
+  "hsl(138.8, 50%, 50%)",
+  "hsl(142.40000000000003, 50%, 50%)",
+  "hsl(257.6, 50%, 50%)",
+  "hsl(77.60000000000002, 50%, 50%)",
+  "hsl(88.39999999999998, 50%, 50%)",
+  "hsl(128, 50%, 50%)",
+  "hsl(178.4000000000001, 50%, 50%)",
+  "hsl(272, 50%, 50%)",
+  "hsl(347.6, 50%, 50%)",
+  "hsl(124.40000000000003, 50%, 50%)",
+  "hsl(196.4000000000001, 50%, 50%)",
+  "hsl(95.60000000000002, 50%, 50%)",
+  "hsl(9.200000000000045, 50%, 50%)",
+  "hsl(308, 50%, 50%)",
+  "hsl(74, 50%, 50%)",
+  "hsl(218, 50%, 50%)",
+  "hsl(243.2, 50%, 50%)",
+  "hsl(286.4, 50%, 50%)",
+  "hsl(336.8, 50%, 50%)",
+  "hsl(41.60000000000002, 50%, 50%)",
+  "hsl(268.4, 50%, 50%)",
+  "hsl(344, 50%, 50%)",
+  "hsl(318.8, 50%, 50%)",
+  "hsl(333.20000000000005, 50%, 50%)",
+  "hsl(149.60000000000002, 50%, 50%)",
+  "hsl(354.8, 50%, 50%)",
+  "hsl(246.8, 50%, 50%)",
+  "hsl(192.79999999999995, 50%, 50%)",
+  "hsl(304.4, 50%, 50%)",
+  "hsl(329.6, 50%, 50%)",
+  "hsl(52.39999999999998, 50%, 50%)",
+  "hsl(261.2, 50%, 50%)",
+  "hsl(236, 50%, 50%)",
+  "hsl(30.80000000000001, 50%, 50%)",
+  "hsl(156.79999999999995, 50%, 50%)",
+  "hsl(131.60000000000002, 50%, 50%)",
+  "hsl(221.6, 50%, 50%)",
+  "hsl(135.2, 50%, 50%)",
+  "hsl(264.8, 50%, 50%)",
+  "hsl(66.80000000000001, 50%, 50%)",
+  "hsl(167.60000000000002, 50%, 50%)",
+  "hsl(254, 50%, 50%)",
+  "hsl(20, 50%, 50%)",
+  "hsl(48.80000000000001, 50%, 50%)",
+  "hsl(110, 50%, 50%)",
+  "hsl(300.8, 50%, 50%)",
+  "hsl(200, 50%, 50%)",
+  "hsl(164, 50%, 50%)",
+  "hsl(340.4, 50%, 50%)",
+  "hsl(106.40000000000003, 50%, 50%)",
+  "hsl(153.20000000000005, 50%, 50%)"
+];
+export {
+  s as default
+};

package/dist/components/ui/gantt/enums/DataRepeatTimes.js

@@ -0,0 +1,5 @@
+"use client";
+var E = /* @__PURE__ */ ((r) => (r.DAY = "DAY", r.WEEK = "WEEK", r.MONTH = "MONTH", r))(E || {});
+export {
+  E as DataRepeatTypes
+};

package/dist/components/ui/gantt/enums/DragStepSizes.js

@@ -0,0 +1,5 @@
+"use client";
+var N = /* @__PURE__ */ ((E) => (E.FIVE_MIN = "FIVE_MIN", E.TEN_MIN = "TEN_MIN", E.FIFTEEN_MIN = "FIFTEEN_MIN", E.TWENTY_MIN = "TWENTY_MIN", E.THIRTY_MIN = "THIRTY_MIN", E.ONE_HOUR = "ONE_HOUR", E.EIGHT_HOURS = "EIGHT_HOURS", E.TWELVE_HOURS = "TWELVE_HOURS", E.ONE_DAY = "ONE_DAY", E))(N || {});
+export {
+  N as DragStepSizes
+};

package/dist/components/ui/gantt/enums/DragTypes.js

@@ -0,0 +1,5 @@
+"use client";
+var R = /* @__PURE__ */ ((E) => (E[E.RESIZE_LEFT = 0] = "RESIZE_LEFT", E[E.RESIZE_RIGHT = 1] = "RESIZE_RIGHT", E[E.DRAG = 2] = "DRAG", E))(R || {});
+export {
+  R as DragTypes
+};

package/dist/components/ui/gantt/enums/GanttDimensions.js

@@ -0,0 +1,5 @@
+"use client";
+var r = /* @__PURE__ */ ((H) => (H.HOUR = "hour", H.TWO_HOURS = "twoHours", H.THREE_HOURS = "threeHours", H.FOUR_HOURS = "fourHours", H.SIX_HOURS = "sixHours", H.EIGHT_HOURS = "eightHours", H.TWELVE_HOURS = "twelveHours", H.DAY = "day", H))(r || {});
+export {
+  r as GanttDimensions
+};

package/dist/components/ui/gantt/enums/GanttUnitOfTimes.js

@@ -0,0 +1,5 @@
+"use client";
+var e = /* @__PURE__ */ ((r) => (r.DAY = "day", r.MONTH = "month", r))(e || {});
+export {
+  e as GanttUnitOfTimes
+};

package/dist/components/ui/gantt/hooks/useForwardRef.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRef as n, useEffect as u } from "react";
+const o = (e, r = null) => {
+  const t = n(r);
+  return u(() => {
+    e && (typeof e == "function" ? e(t.current) : e.current = t.current);
+  }, [e]), t;
+};
+export {
+  o as useForwardRef
+};

package/dist/components/ui/gantt/hooks/useGanttCalculate.js

@@ -0,0 +1,30 @@
+"use client";
+import { useContext as u, useCallback as d } from "react";
+import { GanttContext as D } from "../components/Gantt/GanttContext.js";
+import { getScaleDates as z } from "../utils/getScaleDates.js";
+import { getInitialScrollOffset as C } from "../utils/getInitialScrollOffset.js";
+import { DragStepOptions as x } from "../constants/DragStepOptions.js";
+import { GanttDimensionsSettings as O } from "../constants/DimensionsSettings.js";
+const P = () => {
+  const { setScaleDates: a, wrapRef: r, settings: t, setSettings: o, currentDate: e } = u(D);
+  return { calculate: d(
+    (s) => {
+      var l;
+      const { stepWidth: S, itemsCount: p, scaleStepItems: g, secondsInPixel: n, unitOfTime: m } = O[s], c = z(e, p, m), i = C(s, c, e), f = x[t.dragStepSize].seconds / n;
+      o({
+        stepWidth: S,
+        initialScrollOffset: i,
+        scaleStepItems: g,
+        secondsInPixel: n,
+        dimension: s,
+        dragStepSize: t.dragStepSize,
+        gridSize: f,
+        draggable: t.draggable
+      }), a(c), (l = r.current) == null || l.scrollTo({ left: i });
+    },
+    [e, a, o, t.dragStepSize, r]
+  ) };
+};
+export {
+  P as useGanttCalculate
+};