react-timelane 1.2.1 → 1.2.2

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

@@ -0,0 +1,226 @@
+import b from "../../../../../@babel/runtime/helpers/esm/defineProperty.js";
+import { d as y } from "../../../../../../_virtual/index.js";
+import { maxZIndex as h } from "../util/max-z-index.js";
+import { honeyPotDataAttribute as w } from "./honey-pot-data-attribute.js";
+function d(t, n) {
+  var e = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(t);
+    n && (r = r.filter(function(o) {
+      return Object.getOwnPropertyDescriptor(t, o).enumerable;
+    })), e.push.apply(e, r);
+  }
+  return e;
+}
+function v(t) {
+  for (var n = 1; n < arguments.length; n++) {
+    var e = arguments[n] != null ? arguments[n] : {};
+    n % 2 ? d(Object(e), !0).forEach(function(r) {
+      b(t, r, e[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(e)) : d(Object(e)).forEach(function(r) {
+      Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(e, r));
+    });
+  }
+  return t;
+}
+var l = 2, m = l / 2;
+function O(t) {
+  return {
+    x: Math.floor(t.x),
+    y: Math.floor(t.y)
+  };
+}
+function P(t) {
+  return {
+    x: t.x - m,
+    y: t.y - m
+  };
+}
+function j(t) {
+  return {
+    x: Math.max(t.x, 0),
+    y: Math.max(t.y, 0)
+  };
+}
+function R(t) {
+  return {
+    x: Math.min(t.x, window.innerWidth - l),
+    y: Math.min(t.y, window.innerHeight - l)
+  };
+}
+function x(t) {
+  var n = t.client, e = R(j(P(O(n))));
+  return DOMRect.fromRect({
+    x: e.x,
+    y: e.y,
+    width: l,
+    height: l
+  });
+}
+function g(t) {
+  var n = t.clientRect;
+  return {
+    left: "".concat(n.left, "px"),
+    top: "".concat(n.top, "px"),
+    width: "".concat(n.width, "px"),
+    height: "".concat(n.height, "px")
+  };
+}
+function D(t) {
+  var n = t.client, e = t.clientRect;
+  return (
+    // is within horizontal bounds
+    n.x >= e.x && n.x <= e.x + e.width && // is within vertical bounds
+    n.y >= e.y && n.y <= e.y + e.height
+  );
+}
+function S(t) {
+  var n = t.initial, e = document.createElement("div");
+  e.setAttribute(w, "true");
+  var r = x({
+    client: n
+  });
+  Object.assign(e.style, v(v({
+    // Setting a background color explicitly to avoid any inherited styles.
+    // Looks like this could be `opacity: 0`, but worried that _might_
+    // cause the element to be ignored on some platforms.
+    // When debugging, set backgroundColor to something like "red".
+    backgroundColor: "transparent",
+    position: "fixed",
+    // Being explicit to avoid inheriting styles
+    padding: 0,
+    margin: 0,
+    boxSizing: "border-box"
+  }, g({
+    clientRect: r
+  })), {}, {
+    // We want this element to absorb pointer events,
+    // it's kind of the whole point 😉
+    pointerEvents: "auto",
+    // Want to make sure the honey pot is top of everything else.
+    // Don't need to worry about native drag previews, as they will
+    // have been rendered (and removed) before the honey pot is rendered
+    zIndex: h
+  })), document.body.appendChild(e);
+  var o = y.bind(window, {
+    type: "pointermove",
+    listener: function(c) {
+      var a = {
+        x: c.clientX,
+        y: c.clientY
+      };
+      r = x({
+        client: a
+      }), Object.assign(e.style, g({
+        clientRect: r
+      }));
+    },
+    // using capture so we are less likely to be impacted by event stopping
+    options: {
+      capture: !0
+    }
+  });
+  return function(c) {
+    var a = c.current;
+    if (o(), D({
+      client: a,
+      clientRect: r
+    })) {
+      e.remove();
+      return;
+    }
+    function i() {
+      s(), e.remove();
+    }
+    var s = y.bindAll(window, [
+      {
+        type: "pointerdown",
+        listener: i
+      },
+      {
+        type: "pointermove",
+        listener: i
+      },
+      {
+        type: "focusin",
+        listener: i
+      },
+      {
+        type: "focusout",
+        listener: i
+      },
+      // a 'pointerdown' should happen before 'dragstart', but just being super safe
+      {
+        type: "dragstart",
+        listener: i
+      },
+      // if the user has dragged something out of the window
+      // and then is dragging something back into the window
+      // the first events we will see are "dragenter" (and then "dragover").
+      // So if we see any of these we need to clear the post drag fix.
+      {
+        type: "dragenter",
+        listener: i
+      },
+      {
+        type: "dragover",
+        listener: i
+      }
+      // Not adding a "wheel" event listener, as "wheel" by itself does not
+      // resolve the bug.
+    ], {
+      // Using `capture` so less likely to be impacted by other code stopping events
+      capture: !0
+    });
+  };
+}
+function z() {
+  var t = null;
+  function n() {
+    return t = null, y.bind(window, {
+      type: "pointermove",
+      listener: function(o) {
+        t = {
+          x: o.clientX,
+          y: o.clientY
+        };
+      },
+      // listening for pointer move in capture phase
+      // so we are less likely to be impacted by events being stopped.
+      options: {
+        capture: !0
+      }
+    });
+  }
+  function e() {
+    var r = null;
+    return function(u) {
+      var c = u.eventName, a = u.payload;
+      if (c === "onDragStart") {
+        var i = a.location.initial.input, s = t ?? {
+          x: i.clientX,
+          y: i.clientY
+        };
+        r = S({
+          initial: s
+        });
+      }
+      if (c === "onDrop") {
+        var p, f = a.location.current.input;
+        (p = r) === null || p === void 0 || p({
+          current: {
+            x: f.clientX,
+            y: f.clientY
+          }
+        }), r = null, t = null;
+      }
+    };
+  }
+  return {
+    bindEvents: n,
+    getOnPostDispatch: e
+  };
+}
+export {
+  z as makeHoneyPotFix
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/dispatch-consumer-event.js

@@ -0,0 +1,107 @@
+import p from "../../../../../raf-schd/dist/raf-schd.esm.js";
+var s = p(function(a) {
+  return a();
+}), d = /* @__PURE__ */ function() {
+  var a = null;
+  function n(l) {
+    var o = requestAnimationFrame(function() {
+      a = null, l();
+    });
+    a = {
+      frameId: o,
+      fn: l
+    };
+  }
+  function t() {
+    a && (cancelAnimationFrame(a.frameId), a.fn(), a = null);
+  }
+  return {
+    schedule: n,
+    flush: t
+  };
+}();
+function g(a) {
+  var n = a.source, t = a.initial, l = a.dispatchEvent, o = {
+    dropTargets: []
+  };
+  function u(c) {
+    l(c), o = {
+      dropTargets: c.payload.location.current.dropTargets
+    };
+  }
+  var v = {
+    start: function(r) {
+      var i = r.nativeSetDragImage, e = {
+        current: t,
+        previous: o,
+        initial: t
+      };
+      u({
+        eventName: "onGenerateDragPreview",
+        payload: {
+          source: n,
+          location: e,
+          nativeSetDragImage: i
+        }
+      }), d.schedule(function() {
+        u({
+          eventName: "onDragStart",
+          payload: {
+            source: n,
+            location: e
+          }
+        });
+      });
+    },
+    dragUpdate: function(r) {
+      var i = r.current;
+      d.flush(), s.cancel(), u({
+        eventName: "onDropTargetChange",
+        payload: {
+          source: n,
+          location: {
+            initial: t,
+            previous: o,
+            current: i
+          }
+        }
+      });
+    },
+    drag: function(r) {
+      var i = r.current;
+      s(function() {
+        d.flush();
+        var e = {
+          initial: t,
+          previous: o,
+          current: i
+        };
+        u({
+          eventName: "onDrag",
+          payload: {
+            source: n,
+            location: e
+          }
+        });
+      });
+    },
+    drop: function(r) {
+      var i = r.current, e = r.updatedSourcePayload;
+      d.flush(), s.cancel(), u({
+        eventName: "onDrop",
+        payload: {
+          source: e ?? n,
+          location: {
+            current: i,
+            previous: o,
+            initial: t
+          }
+        }
+      });
+    }
+  };
+  return v;
+}
+export {
+  g as makeDispatch
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/lifecycle-manager.js

@@ -0,0 +1,195 @@
+import E from "../../../../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import { d as x } from "../../../../../../_virtual/index.js";
+import { getElementFromPointWithoutHoneypot as S } from "../honey-pot-fix/get-element-from-point-without-honey-pot.js";
+import { isHoneyPotElement as A } from "../honey-pot-fix/is-honey-pot-element.js";
+import { isLeavingWindow as O } from "../util/changing-window/is-leaving-window.js";
+import { getBindingsForBrokenDrags as b } from "../util/detect-broken-drag.js";
+import { getInput as d } from "../util/get-input.js";
+import { makeDispatch as P } from "./dispatch-consumer-event.js";
+var v = {
+  isActive: !1
+};
+function y() {
+  return !v.isActive;
+}
+function F(r) {
+  return r.dataTransfer ? r.dataTransfer.setDragImage.bind(r.dataTransfer) : null;
+}
+function I(r) {
+  var a = r.current, n = r.next;
+  if (a.length !== n.length)
+    return !0;
+  for (var i = 0; i < a.length; i++)
+    if (a[i].element !== n[i].element)
+      return !0;
+  return !1;
+}
+function w(r) {
+  var a = r.event, n = r.dragType, i = r.getDropTargetsOver, u = r.dispatchEvent;
+  if (!y())
+    return;
+  var p = C({
+    event: a,
+    dragType: n,
+    getDropTargetsOver: i
+  });
+  v.isActive = !0;
+  var e = {
+    current: p
+  };
+  f({
+    event: a,
+    current: p.dropTargets
+  });
+  var c = P({
+    source: n.payload,
+    dispatchEvent: u,
+    initial: p
+  });
+  function g(o) {
+    var t = I({
+      current: e.current.dropTargets,
+      next: o.dropTargets
+    });
+    e.current = o, t && c.dragUpdate({
+      current: e.current
+    });
+  }
+  function T(o) {
+    var t = d(o), D = A(o.target) ? S({
+      x: t.clientX,
+      y: t.clientY
+    }) : o.target, l = i({
+      target: D,
+      input: t,
+      source: n.payload,
+      current: e.current.dropTargets
+    });
+    l.length && (o.preventDefault(), f({
+      event: o,
+      current: l
+    })), g({
+      dropTargets: l,
+      input: t
+    });
+  }
+  function s() {
+    e.current.dropTargets.length && g({
+      dropTargets: [],
+      input: e.current.input
+    }), c.drop({
+      current: e.current,
+      updatedSourcePayload: null
+    }), m();
+  }
+  function m() {
+    v.isActive = !1, h();
+  }
+  var h = x.bindAll(
+    window,
+    [{
+      // 👋 Note: we are repurposing the `dragover` event as our `drag` event
+      // this is because firefox does not publish pointer coordinates during
+      // a `drag` event, but does for every other type of drag event
+      // `dragover` fires on all elements that are being dragged over
+      // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
+      // 🦊😤
+      type: "dragover",
+      listener: function(t) {
+        T(t), c.drag({
+          current: e.current
+        });
+      }
+    }, {
+      type: "dragenter",
+      listener: T
+    }, {
+      type: "dragleave",
+      listener: function(t) {
+        O({
+          dragLeave: t
+        }) && (g({
+          input: e.current.input,
+          dropTargets: []
+        }), n.startedFrom === "external" && s());
+      }
+    }, {
+      // A "drop" can only happen if the browser allowed the drop
+      type: "drop",
+      listener: function(t) {
+        if (e.current = {
+          dropTargets: e.current.dropTargets,
+          input: d(t)
+        }, !e.current.dropTargets.length) {
+          s();
+          return;
+        }
+        t.preventDefault(), f({
+          event: t,
+          current: e.current.dropTargets
+        }), c.drop({
+          current: e.current,
+          // When dropping something native, we need to extract the latest
+          // `.items` from the "drop" event as it is now accessible
+          updatedSourcePayload: n.type === "external" ? n.getDropPayload(t) : null
+        }), m();
+      }
+    }, {
+      // "dragend" fires when on the drag source (eg a draggable element)
+      // when the drag is finished.
+      // "dragend" will fire after "drop" (if there was a successful drop)
+      // "dragend" does not fire if the draggable source has been removed during the drag
+      // or for external drag sources (eg files)
+      // This "dragend" listener will not fire if there was a successful drop
+      // as we will have already removed the event listener
+      type: "dragend",
+      listener: function(t) {
+        e.current = {
+          dropTargets: e.current.dropTargets,
+          input: d(t)
+        }, s();
+      }
+    }].concat(E(b({
+      onDragEnd: s
+    }))),
+    // Once we have started a managed drag operation it is important that we see / own all drag events
+    // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
+    // all "drop" events in the bubble phase on the `document.body`.
+    // This meant that we never saw the "drop" event.
+    {
+      capture: !0
+    }
+  );
+  c.start({
+    nativeSetDragImage: F(a)
+  });
+}
+function f(r) {
+  var a, n = r.event, i = r.current, u = (a = i[0]) === null || a === void 0 ? void 0 : a.dropEffect;
+  u != null && n.dataTransfer && (n.dataTransfer.dropEffect = u);
+}
+function C(r) {
+  var a = r.event, n = r.dragType, i = r.getDropTargetsOver, u = d(a);
+  if (n.startedFrom === "external")
+    return {
+      input: u,
+      dropTargets: []
+    };
+  var p = i({
+    input: u,
+    source: n.payload,
+    target: a.target,
+    current: []
+  });
+  return {
+    input: u,
+    dropTargets: p
+  };
+}
+var X = {
+  canStart: y,
+  start: w
+};
+export {
+  X as lifecycle
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/usage-ledger.js

@@ -0,0 +1,21 @@
+var u = /* @__PURE__ */ new Map();
+function a(t) {
+  var e = t.typeKey, r = t.mount, n = u.get(e);
+  if (n)
+    return n.usageCount++, n;
+  var o = {
+    typeKey: e,
+    unmount: r(),
+    usageCount: 1
+  };
+  return u.set(e, o), o;
+}
+function i(t) {
+  var e = a(t);
+  return function() {
+    e.usageCount--, !(e.usageCount > 0) && (e.unmount(), u.delete(t.typeKey));
+  };
+}
+export {
+  i as register
+};

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

@@ -0,0 +1,43 @@
+import { lifecycle as c } from "../ledger/lifecycle-manager.js";
+import { register as g } from "../ledger/usage-ledger.js";
+import { makeDropTarget as y } from "./make-drop-target.js";
+import { makeMonitor as T } from "./make-monitor.js";
+function A(e) {
+  var p = e.typeKey, s = e.mount, r = e.dispatchEventToSource, o = e.onPostDispatch, u = e.defaultDropEffect, i = T(), n = y({
+    typeKey: p,
+    defaultDropEffect: u
+  });
+  function m(t) {
+    r == null || r(t), n.dispatchEvent(t), i.dispatchEvent(t), o == null || o(t);
+  }
+  function d(t) {
+    var a = t.event, f = t.dragType;
+    c.start({
+      event: a,
+      dragType: f,
+      getDropTargetsOver: n.getIsOver,
+      dispatchEvent: m
+    });
+  }
+  function v() {
+    function t() {
+      var a = {
+        canStart: c.canStart,
+        start: d
+      };
+      return s(a);
+    }
+    return g({
+      typeKey: p,
+      mount: t
+    });
+  }
+  return {
+    registerUsage: v,
+    dropTarget: n.dropTargetForConsumers,
+    monitor: i.monitorForConsumers
+  };
+}
+export {
+  A as makeAdapter
+};