react-timelane 1.2.1 → 1.2.2

package/dist/components/utils.js

@@ -0,0 +1,243 @@
+import { differenceInCalendarDays as p } from "../node_modules/date-fns/differenceInCalendarDays.js";
+import { setHours as y } from "../node_modules/date-fns/setHours.js";
+import { addDays as g } from "../node_modules/date-fns/addDays.js";
+import { max as m } from "../node_modules/date-fns/max.js";
+import { min as w } from "../node_modules/date-fns/min.js";
+function D(e, t, n) {
+  const r = v(e, t, n), o = M(e, t);
+  return { width: r, height: o };
+}
+function M(e, t) {
+  return t.pixelsPerLane;
+}
+function v(e, t, n) {
+  return Math.abs(
+    (p(n.end, n.start) + 1) * t.pixelsPerDay
+  );
+}
+function P(e, t, n, r) {
+  const o = x(e, t, r), i = O(e, t, n.start, r);
+  return {
+    ...o,
+    ...i
+  };
+}
+function x(e, t, n) {
+  const r = p(e.end, e.start) * n.pixelsPerDay, o = e.size / t.capacity * n.pixelsPerLane;
+  return { width: r, height: o };
+}
+function T(e, t, n) {
+  return p(e, t) * n.pixelsPerDay + n.pixelsPerDay / 2;
+}
+function z(e, t, n) {
+  return e / t * n.pixelsPerLane;
+}
+function O(e, t, n, r) {
+  const o = T(e.start, n, r), i = z(e.offset, t.capacity, r);
+  return { x: o, y: i };
+}
+function q(e, t) {
+  const n = e.element.getBoundingClientRect(), r = {
+    x: n.x - t.initial.input.pageX,
+    y: n.y - t.initial.input.pageY
+  }, o = {
+    x: r.x / n.width,
+    y: r.y / n.height
+  };
+  return {
+    absolute: r,
+    relative: o
+  };
+}
+function E(e, t, n, r, o) {
+  return {
+    id: e.id,
+    laneId: t.id,
+    start: y(
+      g(o.start, Math.floor(n.x / r.pixelsPerDay)),
+      12
+    ),
+    end: y(
+      g(
+        o.start,
+        Math.floor(
+          (n.x + n.width) / r.pixelsPerDay
+        )
+      ),
+      12
+    ),
+    offset: Math.floor(
+      n.y / r.pixelsPerLane * t.capacity
+    ),
+    size: Math.floor(
+      n.height / r.pixelsPerLane * t.capacity
+    ),
+    payload: e.payload
+  };
+}
+function F(e, t, n, r, o, i, a, u, l) {
+  if (r === null)
+    return null;
+  const h = D(
+    e,
+    i,
+    u
+  ), s = t.filter((c) => c.id !== n.id).map((c) => P(c, e, u, i));
+  let f = null;
+  return f = C(
+    e,
+    n,
+    o,
+    i,
+    r
+  ), f = A(f, a), f = I(
+    f,
+    h
+  ), f = B(
+    f,
+    s,
+    h,
+    l
+  ), f;
+}
+function C(e, t, n, r, o) {
+  const { width: i, height: a } = x(t, e, r), u = o.x + i * n.relative.x, l = o.y + a * n.relative.y;
+  return {
+    x: u,
+    y: l,
+    width: i,
+    height: a
+  };
+}
+function I(e, t) {
+  const n = Math.max(
+    0,
+    Math.min(e.x, t.width - e.width)
+  ), r = Math.max(
+    0,
+    Math.min(e.y, t.height - e.height)
+  );
+  return {
+    ...e,
+    x: n,
+    y: r
+  };
+}
+function A(e, t) {
+  const n = {
+    ...e
+  };
+  return t && t.x && (n.x = d(n.x, t.x, t.offsetX || 0)), t && t.y && (n.y = d(n.y, t.y, t.offsetY || 0)), n;
+}
+function d(e, t, n) {
+  return Math.max(
+    n,
+    n + Math.round((e - n) / t) * t
+  );
+}
+function B(e, t, n, r) {
+  const o = {
+    ...e
+  };
+  if (!r) {
+    let i = !0;
+    for (; i; ) {
+      const a = t.find((u) => X(o, u));
+      a !== void 0 ? o.y = a.y + a.height : i = !1;
+    }
+  }
+  return G(o, n) ? o : null;
+}
+function X(e, t) {
+  return !(e.x >= t.x + t.width || t.x >= e.x + e.width || e.y >= t.y + t.height || t.y >= e.y + e.height);
+}
+function J(e, t) {
+  const n = Math.max(e.x, t.x), r = Math.max(e.y, t.y), o = Math.min(e.x + e.width, t.x + t.width), i = Math.min(e.y + e.height, t.y + t.height);
+  return n < o && r < i ? {
+    x: n,
+    y: r,
+    width: o - n,
+    height: i - r
+  } : null;
+}
+function Y(e, t) {
+  return !(e.start >= t.end || t.start >= e.end || e.offset >= t.offset + t.size || t.offset >= e.offset + e.size);
+}
+function G(e, t) {
+  return e.x >= 0 && e.y >= 0 && e.x + e.width <= t.width && e.y + e.height <= t.height;
+}
+function K(e, t, n, r, o) {
+  const i = L(
+    e,
+    t,
+    n.capacity,
+    r
+  );
+  if (i) {
+    const a = R(
+      e,
+      o.start,
+      o.end,
+      r,
+      i
+    );
+    if (a)
+      return {
+        start: a.lower,
+        end: a.upper,
+        minOffset: i.lower,
+        maxOffset: i.upper
+      };
+  }
+  return null;
+}
+function L(e, t, n, r) {
+  const o = r.filter((s) => s.start <= e && s.end >= e);
+  if (o.find(
+    (s) => s.offset <= t && s.offset + s.size >= t
+  ))
+    return null;
+  const a = o.filter((s) => s.offset + s.size <= t), u = o.filter((s) => s.offset >= t), l = a.length > 0 ? Math.max(...a.map((s) => s.offset + s.size)) : 0, h = u.length > 0 ? Math.min(...u.map((s) => s.offset)) : n;
+  return {
+    lower: l,
+    upper: h
+  };
+}
+function R(e, t, n, r, o) {
+  const i = {
+    start: t,
+    end: n,
+    offset: o.lower,
+    size: o.upper - o.lower
+  }, a = r.filter(
+    (f) => Y(f, i)
+  );
+  if (a.length === 0)
+    return {
+      lower: t,
+      upper: n
+    };
+  const u = a.filter((f) => f.end <= e), l = a.filter((f) => f.start >= e), h = u.length > 0 ? m(u.map((f) => f.end)) : t, s = l.length > 0 ? w(l.map((f) => f.start)) : n;
+  return {
+    lower: h,
+    upper: s
+  };
+}
+export {
+  T as dateToPixel,
+  X as doOverlap,
+  K as getAvailableSpace,
+  F as getDropPreviewRectangle,
+  D as getDropTargetDimensions,
+  M as getDropTargetHeight,
+  v as getDropTargetWidth,
+  q as getGrabPosition,
+  x as getItemDimensions,
+  O as getItemPosition,
+  P as getItemRectangle,
+  J as getOverlap,
+  E as getUpdatedItem,
+  G as isWithinTargetDimensions,
+  Y as itemsDoOverlap,
+  z as offsetToPixel
+};

package/dist/hooks/useScroll.js

@@ -0,0 +1,47 @@
+import { dateToPixel as m } from "../components/utils.js";
+import { useTimelaneContext as s } from "./useTimelaneContext.js";
+const u = () => {
+  const { settings: t } = s();
+  function c(e) {
+    e instanceof Object ? (e.horz !== void 0 && n(e.horz), e.vert !== void 0 && r(e.vert)) : l(e);
+  }
+  function n(e) {
+    window.requestAnimationFrame(() => {
+      const o = document.getElementById(
+        "timelane-background-date-anchor"
+      );
+      if (o) {
+        const i = m(e, t.start, t);
+        o.style.setProperty("left", `${i}px`), o.scrollIntoView({
+          block: "nearest",
+          inline: "center",
+          behavior: "smooth"
+        });
+      }
+    });
+  }
+  function r(e) {
+    window.requestAnimationFrame(() => {
+      const o = document.getElementById(
+        `timelane-lane-${e}`
+      );
+      o && o.scrollIntoView({ block: "center", behavior: "smooth" });
+    });
+  }
+  function l(e) {
+    window.requestAnimationFrame(() => {
+      const o = document.getElementById(
+        `timelane-item-${e}`
+      );
+      o && o.scrollIntoView({
+        block: "center",
+        inline: "center",
+        behavior: "smooth"
+      });
+    });
+  }
+  return { scrollTo: c, scrollToDate: n, scrollToItem: l, scrollToLane: r };
+};
+export {
+  u as useScroll
+};

package/dist/hooks/useTimelaneContext.js

@@ -0,0 +1,6 @@
+import { useContext as t } from "react";
+import { TimelaneSettingsContext as e } from "../components/TimelaneSettingsProvider/TimelaneSettingsContext.js";
+const r = () => t(e);
+export {
+  r as useTimelaneContext
+};

package/dist/index.js

@@ -0,0 +1,36 @@
+import { Timelane as o } from "./components/Timelane/Timelane.js";
+import { TimelaneLayout as t } from "./components/TimelaneLayout/TimelaneLayout.js";
+import { TimelaneAside as n } from "./components/TimelaneAside/TimelaneAside.js";
+import { TimelaneBackground as f } from "./components/TimelaneBackground/TimelaneBackground.js";
+import { TimelaneLane as i } from "./components/TimelaneLane/TimelaneLane.js";
+import { TimelaneBody as l } from "./components/TimelaneBody/TimelaneBody.js";
+import { TimelaneSettingsProvider as s } from "./components/TimelaneSettingsProvider/TimelaneSettingsProvider.js";
+import { TimelaneAllocation as u } from "./components/TimelaneAllocation/TimelaneAllocation.js";
+import { useScroll as c } from "./hooks/useScroll.js";
+import { useTimelaneContext as g } from "./hooks/useTimelaneContext.js";
+import { DaysHeader as A } from "./components/TimelaneHeader/DaysHeader.js";
+import { WeeksHeader as D } from "./components/TimelaneHeader/WeeksHeader.js";
+import { MonthsHeader as M } from "./components/TimelaneHeader/MonthsHeader.js";
+import { TimelaneHeader as W } from "./components/TimelaneHeader/TimelaneHeader.js";
+import { renderDayHeader as C, renderMonthHeader as I, renderWeekHeader as P } from "./components/TimelaneHeader/renderingUtils.js";
+import { isItem as j } from "./types/Item.js";
+export {
+  A as DaysHeader,
+  M as MonthsHeader,
+  o as Timelane,
+  u as TimelaneAllocation,
+  n as TimelaneAside,
+  f as TimelaneBackground,
+  l as TimelaneBody,
+  W as TimelaneHeader,
+  i as TimelaneLane,
+  t as TimelaneLayout,
+  s as TimelaneSettingsProvider,
+  D as WeeksHeader,
+  j as isItem,
+  C as renderDayHeader,
+  I as renderMonthHeader,
+  P as renderWeekHeader,
+  c as useScroll,
+  g as useTimelaneContext
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/adapter/element-adapter-native-data-key.js

@@ -0,0 +1,4 @@
+var a = "application/vnd.pdnd";
+export {
+  a as elementAdapterNativeDataKey
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/adapter/element-adapter.js

@@ -0,0 +1,127 @@
+import P from "../../../../../@babel/runtime/helpers/esm/slicedToArray.js";
+import { d as k } from "../../../../../../_virtual/index.js";
+import { getElementFromPointWithoutHoneypot as _ } from "../honey-pot-fix/get-element-from-point-without-honey-pot.js";
+import { makeHoneyPotFix as w } from "../honey-pot-fix/make-honey-pot-fix.js";
+import { makeAdapter as A } from "../make-adapter/make-adapter.js";
+import { combine as H } from "../public-utils/combine.js";
+import { once as R } from "../public-utils/once.js";
+import { addAttribute as $ } from "../util/add-attribute.js";
+import { isAndroid as M, androidFallbackText as O } from "../util/android.js";
+import { getInput as S } from "../util/get-input.js";
+import { textMediaType as h } from "../util/media-types/text-media-type.js";
+import { URLMediaType as V } from "../util/media-types/url-media-type.js";
+import { elementAdapterNativeDataKey as K } from "./element-adapter-native-data-key.js";
+var i = /* @__PURE__ */ new WeakMap();
+function L(t) {
+  return i.set(t.element, t), function() {
+    i.delete(t.element);
+  };
+}
+var b = w(), v = A({
+  typeKey: "element",
+  defaultDropEffect: "move",
+  mount: function(r) {
+    return H(b.bindEvents(), k.bind(document, {
+      type: "dragstart",
+      listener: function(e) {
+        var l, o, d, u, m, s;
+        if (r.canStart(e) && !e.defaultPrevented) {
+          if (!e.dataTransfer) {
+            process.env.NODE_ENV !== "production" && console.warn(`
+              It appears as though you have are not testing DragEvents correctly.
+
+              - If you are unit testing, ensure you have polyfilled DragEvent.
+              - If you are browser testing, ensure you are dispatching drag events correctly.
+
+              Please see our testing guides for more information:
+              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing
+            `.replace(/ {2}/g, ""));
+            return;
+          }
+          var y = e.target;
+          if (!(y instanceof HTMLElement))
+            return null;
+          var a = i.get(y);
+          if (!a)
+            return null;
+          var g = S(e), p = {
+            element: a.element,
+            dragHandle: (l = a.dragHandle) !== null && l !== void 0 ? l : null,
+            input: g
+          };
+          if (a.canDrag && !a.canDrag(p))
+            return e.preventDefault(), null;
+          if (a.dragHandle) {
+            var I = _({
+              x: g.clientX,
+              y: g.clientY
+            });
+            if (!a.dragHandle.contains(I))
+              return e.preventDefault(), null;
+          }
+          var D = (o = (d = a.getInitialDataForExternal) === null || d === void 0 ? void 0 : d.call(a, p)) !== null && o !== void 0 ? o : null;
+          if (D)
+            for (var c = 0, E = Object.entries(D); c < E.length; c++) {
+              var T = P(E[c], 2), N = T[0], f = T[1];
+              e.dataTransfer.setData(N, f ?? "");
+            }
+          M() && !e.dataTransfer.types.includes(h) && !e.dataTransfer.types.includes(V) && e.dataTransfer.setData(h, O), e.dataTransfer.setData(K, "");
+          var x = {
+            element: a.element,
+            dragHandle: (u = a.dragHandle) !== null && u !== void 0 ? u : null,
+            data: (m = (s = a.getInitialData) === null || s === void 0 ? void 0 : s.call(a, p)) !== null && m !== void 0 ? m : {}
+          }, F = {
+            type: "element",
+            payload: x,
+            startedFrom: "internal"
+          };
+          r.start({
+            event: e,
+            dragType: F
+          });
+        }
+      }
+    }));
+  },
+  dispatchEventToSource: function(r) {
+    var n, e, l = r.eventName, o = r.payload;
+    (n = i.get(o.source.element)) === null || n === void 0 || (e = n[l]) === null || e === void 0 || e.call(
+      n,
+      // I cannot seem to get the types right here.
+      // TS doesn't seem to like that one event can need `nativeSetDragImage`
+      // @ts-expect-error
+      o
+    );
+  },
+  onPostDispatch: b.getOnPostDispatch()
+}), ee = v.dropTarget, te = v.monitor;
+function ae(t) {
+  if (process.env.NODE_ENV !== "production" && t.dragHandle && !t.element.contains(t.dragHandle) && console.warn("Drag handle element must be contained in draggable element", {
+    element: t.element,
+    dragHandle: t.dragHandle
+  }), process.env.NODE_ENV !== "production") {
+    var r = i.get(t.element);
+    r && console.warn("You have already registered a `draggable` on the same element", {
+      existing: r,
+      proposed: t
+    });
+  }
+  var n = H(
+    // making the draggable register the adapter rather than drop targets
+    // this is because you *must* have a draggable element to start a drag
+    // but you _might_ not have any drop targets immediately
+    // (You might create drop targets async)
+    v.registerUsage(),
+    L(t),
+    $(t.element, {
+      attribute: "draggable",
+      value: "true"
+    })
+  );
+  return R(n);
+}
+export {
+  ae as draggable,
+  ee as dropTargetForElements,
+  te as monitorForElements
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/get-element-from-point-without-honey-pot.js

@@ -0,0 +1,9 @@
+import m from "../../../../../@babel/runtime/helpers/esm/slicedToArray.js";
+import { isHoneyPotElement as l } from "./is-honey-pot-element.js";
+function d(t) {
+  var r = document.elementsFromPoint(t.x, t.y), n = m(r, 2), e = n[0], o = n[1];
+  return e ? l(e) ? o ?? null : e : null;
+}
+export {
+  d as getElementFromPointWithoutHoneypot
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/honey-pot-data-attribute.js

@@ -0,0 +1,4 @@
+var t = "data-pdnd-honey-pot";
+export {
+  t as honeyPotDataAttribute
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/is-honey-pot-element.js

@@ -0,0 +1,7 @@
+import { honeyPotDataAttribute as e } from "./honey-pot-data-attribute.js";
+function o(t) {
+  return t instanceof Element && t.hasAttribute(e);
+}
+export {
+  o as isHoneyPotElement
+};