react-timelane 1.2.1 → 1.2.2

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

@@ -0,0 +1,253 @@
+import U from "../../../../../@babel/runtime/helpers/esm/defineProperty.js";
+import V from "../../../../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import { combine as Y } from "../public-utils/combine.js";
+import { once as q } from "../public-utils/once.js";
+import { addAttribute as z } from "../util/add-attribute.js";
+function M(e, o) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(e);
+    o && (a = a.filter(function(T) {
+      return Object.getOwnPropertyDescriptor(e, T).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function E(e) {
+  for (var o = 1; o < arguments.length; o++) {
+    var t = arguments[o] != null ? arguments[o] : {};
+    o % 2 ? M(Object(t), !0).forEach(function(a) {
+      U(e, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : M(Object(t)).forEach(function(a) {
+      Object.defineProperty(e, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return e;
+}
+function I(e, o) {
+  var t = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!t) {
+    if (Array.isArray(e) || (t = B(e)) || o) {
+      t && (e = t);
+      var a = 0, T = function() {
+      };
+      return { s: T, n: function() {
+        return a >= e.length ? { done: !0 } : { done: !1, value: e[a++] };
+      }, e: function(b) {
+        throw b;
+      }, f: T };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var S, k = !0, C = !1;
+  return { s: function() {
+    t = t.call(e);
+  }, n: function() {
+    var b = t.next();
+    return k = b.done, b;
+  }, e: function(b) {
+    C = !0, S = b;
+  }, f: function() {
+    try {
+      k || t.return == null || t.return();
+    } finally {
+      if (C) throw S;
+    }
+  } };
+}
+function B(e, o) {
+  if (e) {
+    if (typeof e == "string") return H(e, o);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? H(e, o) : void 0;
+  }
+}
+function H(e, o) {
+  (o == null || o > e.length) && (o = e.length);
+  for (var t = 0, a = Array(o); t < o; t++) a[t] = e[t];
+  return a;
+}
+function N(e) {
+  return e.slice(0).reverse();
+}
+function F(e) {
+  var o = e.typeKey, t = e.defaultDropEffect, a = /* @__PURE__ */ new WeakMap(), T = "data-drop-target-for-".concat(o), S = "[".concat(T, "]");
+  function k(r) {
+    return a.set(r.element, r), function() {
+      return a.delete(r.element);
+    };
+  }
+  function C(r) {
+    if (process.env.NODE_ENV !== "production") {
+      var p = a.get(r.element);
+      p && console.warn("You have already registered a [".concat(o, "] dropTarget on the same element"), {
+        existing: p,
+        proposed: r
+      }), r.element instanceof HTMLIFrameElement && console.warn(`
+            We recommend not registering <iframe> elements as drop targets
+            as it can result in some strange browser event ordering.
+          `.replace(/\s{2,}/g, " ").trim());
+    }
+    var i = Y(z(r.element, {
+      attribute: T,
+      value: "true"
+    }), k(r));
+    return q(i);
+  }
+  function g(r) {
+    var p, i, s, d, l = r.source, c = r.target, v = r.input, f = r.result, n = f === void 0 ? [] : f;
+    if (c == null)
+      return n;
+    if (!(c instanceof Element))
+      return c instanceof Node ? g({
+        source: l,
+        target: c.parentElement,
+        input: v,
+        result: n
+      }) : n;
+    var y = c.closest(S);
+    if (y == null)
+      return n;
+    var u = a.get(y);
+    if (u == null)
+      return n;
+    var h = {
+      input: v,
+      source: l,
+      element: u.element
+    };
+    if (u.canDrop && !u.canDrop(h))
+      return g({
+        source: l,
+        target: u.element.parentElement,
+        input: v,
+        result: n
+      });
+    var O = (p = (i = u.getData) === null || i === void 0 ? void 0 : i.call(u, h)) !== null && p !== void 0 ? p : {}, D = (s = (d = u.getDropEffect) === null || d === void 0 ? void 0 : d.call(u, h)) !== null && s !== void 0 ? s : t, m = {
+      data: O,
+      element: u.element,
+      dropEffect: D,
+      // we are collecting _actual_ drop targets, so these are
+      // being applied _not_ due to stickiness
+      isActiveDueToStickiness: !1
+    };
+    return g({
+      source: l,
+      target: u.element.parentElement,
+      input: v,
+      // Using bubble ordering. Same ordering as `event.getPath()`
+      result: [].concat(V(n), [m])
+    });
+  }
+  function b(r) {
+    var p = r.eventName, i = r.payload, s = I(i.location.current.dropTargets), d;
+    try {
+      for (s.s(); !(d = s.n()).done; ) {
+        var l, c = d.value, v = a.get(c.element), f = E(E({}, i), {}, {
+          self: c
+        });
+        v == null || (l = v[p]) === null || l === void 0 || l.call(
+          v,
+          // I cannot seem to get the types right here.
+          // TS doesn't seem to like that one event can need `nativeSetDragImage`
+          // @ts-expect-error
+          f
+        );
+      }
+    } catch (n) {
+      s.e(n);
+    } finally {
+      s.f();
+    }
+  }
+  var R = {
+    onGenerateDragPreview: b,
+    onDrag: b,
+    onDragStart: b,
+    onDrop: b,
+    onDropTargetChange: function(p) {
+      var i = p.payload, s = new Set(i.location.current.dropTargets.map(function(A) {
+        return A.element;
+      })), d = /* @__PURE__ */ new Set(), l = I(i.location.previous.dropTargets), c;
+      try {
+        for (l.s(); !(c = l.n()).done; ) {
+          var v, f = c.value;
+          d.add(f.element);
+          var n = a.get(f.element), y = s.has(f.element), u = E(E({}, i), {}, {
+            self: f
+          });
+          if (n == null || (v = n.onDropTargetChange) === null || v === void 0 || v.call(n, u), !y) {
+            var h;
+            n == null || (h = n.onDragLeave) === null || h === void 0 || h.call(n, u);
+          }
+        }
+      } catch (A) {
+        l.e(A);
+      } finally {
+        l.f();
+      }
+      var O = I(i.location.current.dropTargets), D;
+      try {
+        for (O.s(); !(D = O.n()).done; ) {
+          var m, j, P = D.value;
+          if (!d.has(P.element)) {
+            var K = E(E({}, i), {}, {
+              self: P
+            }), w = a.get(P.element);
+            w == null || (m = w.onDropTargetChange) === null || m === void 0 || m.call(w, K), w == null || (j = w.onDragEnter) === null || j === void 0 || j.call(w, K);
+          }
+        }
+      } catch (A) {
+        O.e(A);
+      } finally {
+        O.f();
+      }
+    }
+  };
+  function W(r) {
+    R[r.eventName](r);
+  }
+  function G(r) {
+    var p = r.source, i = r.target, s = r.input, d = r.current, l = g({
+      source: p,
+      target: i,
+      input: s
+    });
+    if (l.length >= d.length)
+      return l;
+    for (var c = N(d), v = N(l), f = [], n = 0; n < c.length; n++) {
+      var y, u = c[n], h = v[n];
+      if (h != null) {
+        f.push(h);
+        continue;
+      }
+      var O = f[n - 1], D = c[n - 1];
+      if ((O == null ? void 0 : O.element) !== (D == null ? void 0 : D.element))
+        break;
+      var m = a.get(u.element);
+      if (!m)
+        break;
+      var j = {
+        input: s,
+        source: p,
+        element: m.element
+      };
+      if (m.canDrop && !m.canDrop(j) || !((y = m.getIsSticky) !== null && y !== void 0 && y.call(m, j)))
+        break;
+      f.push(E(E({}, u), {}, {
+        // making it clear to consumers this drop target is active due to stickiness
+        isActiveDueToStickiness: !0
+      }));
+    }
+    return N(f);
+  }
+  return {
+    dropTargetForConsumers: C,
+    getIsOver: G,
+    dispatchEvent: W
+  };
+}
+export {
+  F as makeDropTarget
+};

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

@@ -0,0 +1,121 @@
+import O from "../../../../../@babel/runtime/helpers/esm/defineProperty.js";
+import { once as h } from "../public-utils/once.js";
+function j(e, t) {
+  var r = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!r) {
+    if (Array.isArray(e) || (r = w(e)) || t) {
+      r && (e = r);
+      var n = 0, f = function() {
+      };
+      return { s: f, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(c) {
+        throw c;
+      }, f };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var o, a = !0, u = !1;
+  return { s: function() {
+    r = r.call(e);
+  }, n: function() {
+    var c = r.next();
+    return a = c.done, c;
+  }, e: function(c) {
+    u = !0, o = c;
+  }, f: function() {
+    try {
+      a || r.return == null || r.return();
+    } finally {
+      if (u) throw o;
+    }
+  } };
+}
+function w(e, t) {
+  if (e) {
+    if (typeof e == "string") return p(e, t);
+    var r = {}.toString.call(e).slice(8, -1);
+    return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? p(e, t) : void 0;
+  }
+}
+function p(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
+  return n;
+}
+function d(e, t) {
+  var r = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    t && (n = n.filter(function(f) {
+      return Object.getOwnPropertyDescriptor(e, f).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function A(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? d(Object(r), !0).forEach(function(n) {
+      O(e, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : d(Object(r)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return e;
+}
+function D() {
+  var e = /* @__PURE__ */ new Set(), t = null;
+  function r(o) {
+    t && (!o.canMonitor || o.canMonitor(t.canMonitorArgs)) && t.active.add(o);
+  }
+  function n(o) {
+    var a = A({}, o);
+    e.add(a), r(a);
+    function u() {
+      e.delete(a), t && t.active.delete(a);
+    }
+    return h(u);
+  }
+  function f(o) {
+    var a = o.eventName, u = o.payload;
+    if (a === "onGenerateDragPreview") {
+      t = {
+        canMonitorArgs: {
+          initial: u.location.initial,
+          source: u.source
+        },
+        active: /* @__PURE__ */ new Set()
+      };
+      var i = j(e), c;
+      try {
+        for (i.s(); !(c = i.n()).done; ) {
+          var b = c.value;
+          r(b);
+        }
+      } catch (m) {
+        i.e(m);
+      } finally {
+        i.f();
+      }
+    }
+    if (t) {
+      for (var g = Array.from(t.active), l = 0, v = g; l < v.length; l++) {
+        var s = v[l];
+        if (t.active.has(s)) {
+          var y;
+          (y = s[a]) === null || y === void 0 || y.call(s, u);
+        }
+      }
+      a === "onDrop" && (t.active.clear(), t = null);
+    }
+  }
+  return {
+    dispatchEvent: f,
+    monitorForConsumers: n
+  };
+}
+export {
+  D as makeMonitor
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/public-utils/combine.js

@@ -0,0 +1,12 @@
+function a() {
+  for (var r = arguments.length, t = new Array(r), n = 0; n < r; n++)
+    t[n] = arguments[n];
+  return function() {
+    t.forEach(function(u) {
+      return u();
+    });
+  };
+}
+export {
+  a as combine
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/public-utils/once.js

@@ -0,0 +1,17 @@
+function l(a) {
+  var n = null;
+  return function() {
+    if (!n) {
+      for (var t = arguments.length, u = new Array(t), r = 0; r < t; r++)
+        u[r] = arguments[r];
+      var e = a.apply(this, u);
+      n = {
+        result: e
+      };
+    }
+    return n.result;
+  };
+}
+export {
+  l as once
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/add-attribute.js

@@ -0,0 +1,9 @@
+function i(t, r) {
+  var u = r.attribute, e = r.value;
+  return t.setAttribute(u, e), function() {
+    return t.removeAttribute(u);
+  };
+}
+export {
+  i as addAttribute
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/android.js

@@ -0,0 +1,8 @@
+import { once as r } from "../public-utils/once.js";
+var d = r(function() {
+  return navigator.userAgent.toLocaleLowerCase().includes("android");
+}), n = "pdnd:android-fallback";
+export {
+  n as androidFallbackText,
+  d as isAndroid
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/count-events-for-safari.js

@@ -0,0 +1,57 @@
+import { d } from "../../../../../../../_virtual/index.js";
+import { isSafari as a } from "../is-safari.js";
+var i = {
+  isLeavingWindow: Symbol("leaving"),
+  isEnteringWindow: Symbol("entering")
+};
+function l(r) {
+  var n = r.dragLeave;
+  return a() ? n.hasOwnProperty(i.isLeavingWindow) : !1;
+}
+(function() {
+  if (typeof window > "u" || process.env.NODE_ENV === "test" || !a())
+    return;
+  function n() {
+    return {
+      enterCount: 0,
+      isOverWindow: !1
+    };
+  }
+  var e = n();
+  function o() {
+    e = n();
+  }
+  d.bindAll(
+    window,
+    [{
+      type: "dragstart",
+      listener: function() {
+        e.enterCount = 0, e.isOverWindow = !0;
+      }
+    }, {
+      type: "drop",
+      listener: o
+    }, {
+      type: "dragend",
+      listener: o
+    }, {
+      type: "dragenter",
+      listener: function(t) {
+        !e.isOverWindow && e.enterCount === 0 && (t[i.isEnteringWindow] = !0), e.isOverWindow = !0, e.enterCount++;
+      }
+    }, {
+      type: "dragleave",
+      listener: function(t) {
+        e.enterCount--, e.isOverWindow && e.enterCount === 0 && (t[i.isLeavingWindow] = !0, e.isOverWindow = !1);
+      }
+    }],
+    // using `capture: true` so that adding event listeners
+    // in bubble phase will have the correct symbols
+    {
+      capture: !0
+    }
+  );
+})();
+export {
+  l as isLeavingWindowInSafari
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-from-another-window.js

@@ -0,0 +1,9 @@
+function o(n) {
+  return "nodeName" in n;
+}
+function e(n) {
+  return o(n) && n.ownerDocument !== document;
+}
+export {
+  e as isFromAnotherWindow
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-leaving-window.js

@@ -0,0 +1,13 @@
+import { isFirefox as t } from "../is-firefox.js";
+import { isSafari as n } from "../is-safari.js";
+import { isLeavingWindowInSafari as o } from "./count-events-for-safari.js";
+import { isFromAnotherWindow as f } from "./is-from-another-window.js";
+function v(a) {
+  var r = a.dragLeave, i = r.type, e = r.relatedTarget;
+  return i !== "dragleave" ? !1 : n() ? o({
+    dragLeave: r
+  }) : e == null ? !0 : t() ? f(e) : e instanceof HTMLIFrameElement;
+}
+export {
+  v as isLeavingWindow
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/detect-broken-drag.js

@@ -0,0 +1,47 @@
+function o(e) {
+  var n = e.onDragEnd;
+  return [
+    // ## Detecting drag ending for removed draggables
+    //
+    // If a draggable element is removed during a drag and the user drops:
+    // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+    // 2. if not over a valid drop target (or cancelled): we get nothing
+    // The "dragend" event will not fire on the source draggable if it has been
+    // removed from the DOM.
+    // So we need to figure out if a drag operation has finished by looking at other events
+    // We can do this by looking at other events
+    // ### First detection: "pointermove" events
+    // 1. "pointermove" events cannot fire during a drag and drop operation
+    // according to the spec. So if we get a "pointermove" it means that
+    // the drag and drop operations has finished. So if we get a "pointermove"
+    // we know that the drag is over
+    // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+    // other pointer events. However, firefox will allow a few
+    // pointer event to get through after a drag starts.
+    // The most I've seen is 3
+    {
+      type: "pointermove",
+      listener: /* @__PURE__ */ function() {
+        var r = 0;
+        return function() {
+          if (r < 20) {
+            r++;
+            return;
+          }
+          n();
+        };
+      }()
+    },
+    // ### Second detection: "pointerdown" events
+    // If we receive this event then we know that a drag operation has finished
+    // and potentially another one is about to start.
+    // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+    {
+      type: "pointerdown",
+      listener: n
+    }
+  ];
+}
+export {
+  o as getBindingsForBrokenDrags
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/get-input.js

@@ -0,0 +1,17 @@
+function a(t) {
+  return {
+    altKey: t.altKey,
+    button: t.button,
+    buttons: t.buttons,
+    ctrlKey: t.ctrlKey,
+    metaKey: t.metaKey,
+    shiftKey: t.shiftKey,
+    clientX: t.clientX,
+    clientY: t.clientY,
+    pageX: t.pageX,
+    pageY: t.pageY
+  };
+}
+export {
+  a as getInput
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-firefox.js

@@ -0,0 +1,7 @@
+import { once as e } from "../public-utils/once.js";
+var o = e(function() {
+  return process.env.NODE_ENV === "test" ? !1 : navigator.userAgent.includes("Firefox");
+});
+export {
+  o as isFirefox
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-safari.js

@@ -0,0 +1,10 @@
+import { once as i } from "../public-utils/once.js";
+var a = i(function() {
+  if (process.env.NODE_ENV === "test")
+    return !1;
+  var r = navigator, e = r.userAgent;
+  return e.includes("AppleWebKit") && !e.includes("Chrome");
+});
+export {
+  a as isSafari
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/max-z-index.js

@@ -0,0 +1,4 @@
+var x = 2147483647;
+export {
+  x as maxZIndex
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/media-types/text-media-type.js

@@ -0,0 +1,4 @@
+var e = "text/plain";
+export {
+  e as textMediaType
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/media-types/url-media-type.js

@@ -0,0 +1,4 @@
+var e = "text/uri-list";
+export {
+  e as URLMediaType
+};

package/dist/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js

@@ -0,0 +1,8 @@
+function o(l, r) {
+  (r == null || r > l.length) && (r = l.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = l[t];
+  return n;
+}
+export {
+  o as default
+};

package/dist/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

@@ -0,0 +1,6 @@
+function a(r) {
+  if (Array.isArray(r)) return r;
+}
+export {
+  a as default
+};

package/dist/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -0,0 +1,7 @@
+import a from "./arrayLikeToArray.js";
+function t(r) {
+  if (Array.isArray(r)) return a(r);
+}
+export {
+  t as default
+};

package/dist/node_modules/@babel/runtime/helpers/esm/defineProperty.js

@@ -0,0 +1,12 @@
+import o from "./toPropertyKey.js";
+function n(e, r, t) {
+  return (r = o(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+export {
+  n as default
+};

package/dist/node_modules/@babel/runtime/helpers/esm/iterableToArray.js

@@ -0,0 +1,6 @@
+function e(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+export {
+  e as default
+};

package/dist/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

@@ -0,0 +1,21 @@
+function c(l, a) {
+  var t = l == null ? null : typeof Symbol < "u" && l[Symbol.iterator] || l["@@iterator"];
+  if (t != null) {
+    var u, i, f, e, r = [], n = !0, o = !1;
+    try {
+      if (f = (t = t.call(l)).next, a !== 0) for (; !(n = (u = f.call(t)).done) && (r.push(u.value), r.length !== a); n = !0) ;
+    } catch (y) {
+      o = !0, i = y;
+    } finally {
+      try {
+        if (!n && t.return != null && (e = t.return(), Object(e) !== e)) return;
+      } finally {
+        if (o) throw i;
+      }
+    }
+    return r;
+  }
+}
+export {
+  c as default
+};