@ztwoint/z-ui 0.1.60 → 0.1.62

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
+};

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/element/custom-native-drag-preview/center-under-pointer.js

@@ -0,0 +1,10 @@
+var i = function(n) {
+  var r = n.container, e = r.getBoundingClientRect();
+  return {
+    x: e.width / 2,
+    y: e.height / 2
+  };
+};
+export {
+  i as centerUnderPointer
+};

package/dist/node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/public-utils/element/custom-native-drag-preview/pointer-outside-of-preview.js

@@ -0,0 +1,31 @@
+import { isAndroid as o } from "../../../util/android.js";
+import { isSafariOnIOS as a } from "../../../util/is-safari-on-ios.js";
+import { centerUnderPointer as c } from "./center-under-pointer.js";
+function p(t) {
+  return function(e) {
+    var r = e.container;
+    if (a() || o())
+      return c({
+        container: r
+      });
+    Object.assign(r.style, {
+      borderInlineStart: "".concat(t.x, " solid transparent"),
+      borderTop: "".concat(t.y, " solid transparent")
+    });
+    var n = window.getComputedStyle(r);
+    if (n.direction === "rtl") {
+      var i = r.getBoundingClientRect();
+      return {
+        x: i.width,
+        y: 0
+      };
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  };
+}
+export {
+  p as pointerOutsideOfPreview
+};