quantum-component-library 0.0.1 → 1.0.0-alpha.0

package/dist/dnd-core-vendor-q7mfiuVu.js

@@ -0,0 +1,750 @@
+import { c as j } from "./vendor-DvX9OX-j.js";
+import { i as s, b as M } from "./react-dnd-vendor-BZs2igAJ.js";
+function H(t, e, r) {
+  return e.split(".").reduce(
+    (n, i) => n && n[i] ? n[i] : r || null,
+    t
+  );
+}
+function N(t, e) {
+  return t.filter(
+    (r) => r !== e
+  );
+}
+function U(t) {
+  return typeof t == "object";
+}
+function L(t, e) {
+  const r = /* @__PURE__ */ new Map(), n = (o) => {
+    r.set(o, r.has(o) ? r.get(o) + 1 : 1);
+  };
+  t.forEach(n), e.forEach(n);
+  const i = [];
+  return r.forEach((o, c) => {
+    o === 1 && i.push(c);
+  }), i;
+}
+function k(t, e) {
+  return t.filter(
+    (r) => e.indexOf(r) > -1
+  );
+}
+const E = "dnd-core/INIT_COORDS", p = "dnd-core/BEGIN_DRAG", I = "dnd-core/PUBLISH_DRAG_SOURCE", h = "dnd-core/HOVER", y = "dnd-core/DROP", S = "dnd-core/END_DRAG";
+function _(t, e) {
+  return {
+    type: E,
+    payload: {
+      sourceClientOffset: e || null,
+      clientOffset: t || null
+    }
+  };
+}
+const V = {
+  type: E,
+  payload: {
+    clientOffset: null,
+    sourceClientOffset: null
+  }
+};
+function B(t) {
+  return function(r = [], n = {
+    publishSource: !0
+  }) {
+    const { publishSource: i = !0, clientOffset: o, getSourceClientOffset: c } = n, u = t.getMonitor(), l = t.getRegistry();
+    t.dispatch(_(o)), q(r, u, l);
+    const f = W(r, u);
+    if (f == null) {
+      t.dispatch(V);
+      return;
+    }
+    let b = null;
+    if (o) {
+      if (!c)
+        throw new Error("getSourceClientOffset must be defined");
+      F(c), b = c(f);
+    }
+    t.dispatch(_(o, b));
+    const D = l.getSource(f).beginDrag(u, f);
+    if (D == null)
+      return;
+    X(D), l.pinSource(f);
+    const $ = l.getSourceType(f);
+    return {
+      type: p,
+      payload: {
+        itemType: $,
+        item: D,
+        sourceId: f,
+        clientOffset: o || null,
+        sourceClientOffset: b || null,
+        isSourcePublic: !!i
+      }
+    };
+  };
+}
+function q(t, e, r) {
+  s(!e.isDragging(), "Cannot call beginDrag while dragging."), t.forEach(function(n) {
+    s(r.getSource(n), "Expected sourceIds to be registered.");
+  });
+}
+function F(t) {
+  s(typeof t == "function", "When clientOffset is provided, getSourceClientOffset must be a function.");
+}
+function X(t) {
+  s(U(t), "Item must be an object.");
+}
+function W(t, e) {
+  let r = null;
+  for (let n = t.length - 1; n >= 0; n--)
+    if (e.canDragSource(t[n])) {
+      r = t[n];
+      break;
+    }
+  return r;
+}
+function z(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function J(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      z(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function Q(t) {
+  return function(r = {}) {
+    const n = t.getMonitor(), i = t.getRegistry();
+    Y(n), ee(n).forEach((c, u) => {
+      const l = Z(c, u, i, n), f = {
+        type: y,
+        payload: {
+          dropResult: J({}, r, l)
+        }
+      };
+      t.dispatch(f);
+    });
+  };
+}
+function Y(t) {
+  s(t.isDragging(), "Cannot call drop while not dragging."), s(!t.didDrop(), "Cannot call drop twice during one drag operation.");
+}
+function Z(t, e, r, n) {
+  const i = r.getTarget(t);
+  let o = i ? i.drop(n, t) : void 0;
+  return K(o), typeof o > "u" && (o = e === 0 ? {} : n.getDropResult()), o;
+}
+function K(t) {
+  s(typeof t > "u" || U(t), "Drop result must either be an object or undefined.");
+}
+function ee(t) {
+  const e = t.getTargetIds().filter(t.canDropOnTarget, t);
+  return e.reverse(), e;
+}
+function te(t) {
+  return function() {
+    const r = t.getMonitor(), n = t.getRegistry();
+    re(r);
+    const i = r.getSourceId();
+    return i != null && (n.getSource(i, !0).endDrag(r, i), n.unpinSource()), {
+      type: S
+    };
+  };
+}
+function re(t) {
+  s(t.isDragging(), "Cannot call endDrag while not dragging.");
+}
+function T(t, e) {
+  return e === null ? t === null : Array.isArray(t) ? t.some(
+    (r) => r === e
+  ) : t === e;
+}
+function ne(t) {
+  return function(r, { clientOffset: n } = {}) {
+    ie(r);
+    const i = r.slice(0), o = t.getMonitor(), c = t.getRegistry(), u = o.getItemType();
+    return se(i, c, u), oe(i, o, c), ce(i, o, c), {
+      type: h,
+      payload: {
+        targetIds: i,
+        clientOffset: n || null
+      }
+    };
+  };
+}
+function ie(t) {
+  s(Array.isArray(t), "Expected targetIds to be an array.");
+}
+function oe(t, e, r) {
+  s(e.isDragging(), "Cannot call hover while not dragging."), s(!e.didDrop(), "Cannot call hover after drop.");
+  for (let n = 0; n < t.length; n++) {
+    const i = t[n];
+    s(t.lastIndexOf(i) === n, "Expected targetIds to be unique in the passed array.");
+    const o = r.getTarget(i);
+    s(o, "Expected targetIds to be registered.");
+  }
+}
+function se(t, e, r) {
+  for (let n = t.length - 1; n >= 0; n--) {
+    const i = t[n], o = e.getTargetType(i);
+    T(o, r) || t.splice(n, 1);
+  }
+}
+function ce(t, e, r) {
+  t.forEach(function(n) {
+    r.getTarget(n).hover(e, n);
+  });
+}
+function ue(t) {
+  return function() {
+    if (t.getMonitor().isDragging())
+      return {
+        type: I
+      };
+  };
+}
+function ae(t) {
+  return {
+    beginDrag: B(t),
+    publishDragSource: ue(t),
+    hover: ne(t),
+    drop: Q(t),
+    endDrag: te(t)
+  };
+}
+class fe {
+  receiveBackend(e) {
+    this.backend = e;
+  }
+  getMonitor() {
+    return this.monitor;
+  }
+  getBackend() {
+    return this.backend;
+  }
+  getRegistry() {
+    return this.monitor.registry;
+  }
+  getActions() {
+    const e = this, { dispatch: r } = this.store;
+    function n(o) {
+      return (...c) => {
+        const u = o.apply(e, c);
+        typeof u < "u" && r(u);
+      };
+    }
+    const i = ae(this);
+    return Object.keys(i).reduce((o, c) => {
+      const u = i[c];
+      return o[c] = n(u), o;
+    }, {});
+  }
+  dispatch(e) {
+    this.store.dispatch(e);
+  }
+  constructor(e, r) {
+    this.isSetUp = !1, this.handleRefCountChange = () => {
+      const n = this.store.getState().refCount > 0;
+      this.backend && (n && !this.isSetUp ? (this.backend.setup(), this.isSetUp = !0) : !n && this.isSetUp && (this.backend.teardown(), this.isSetUp = !1));
+    }, this.store = e, this.monitor = r, e.subscribe(this.handleRefCountChange);
+  }
+}
+function le(t, e) {
+  return {
+    x: t.x + e.x,
+    y: t.y + e.y
+  };
+}
+function G(t, e) {
+  return {
+    x: t.x - e.x,
+    y: t.y - e.y
+  };
+}
+function de(t) {
+  const { clientOffset: e, initialClientOffset: r, initialSourceClientOffset: n } = t;
+  return !e || !r || !n ? null : G(le(e, n), r);
+}
+function ge(t) {
+  const { clientOffset: e, initialClientOffset: r } = t;
+  return !e || !r ? null : G(e, r);
+}
+const g = [], C = [];
+g.__IS_NONE__ = !0;
+C.__IS_ALL__ = !0;
+function pe(t, e) {
+  return t === g ? !1 : t === C || typeof e > "u" ? !0 : k(e, t).length > 0;
+}
+class he {
+  subscribeToStateChange(e, r = {}) {
+    const { handlerIds: n } = r;
+    s(typeof e == "function", "listener must be a function."), s(typeof n > "u" || Array.isArray(n), "handlerIds, when specified, must be an array of strings.");
+    let i = this.store.getState().stateId;
+    const o = () => {
+      const c = this.store.getState(), u = c.stateId;
+      try {
+        u === i || u === i + 1 && !pe(c.dirtyHandlerIds, n) || e();
+      } finally {
+        i = u;
+      }
+    };
+    return this.store.subscribe(o);
+  }
+  subscribeToOffsetChange(e) {
+    s(typeof e == "function", "listener must be a function.");
+    let r = this.store.getState().dragOffset;
+    const n = () => {
+      const i = this.store.getState().dragOffset;
+      i !== r && (r = i, e());
+    };
+    return this.store.subscribe(n);
+  }
+  canDragSource(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getSource(e);
+    return s(r, `Expected to find a valid source. sourceId=${e}`), this.isDragging() ? !1 : r.canDrag(this, e);
+  }
+  canDropOnTarget(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getTarget(e);
+    if (s(r, `Expected to find a valid target. targetId=${e}`), !this.isDragging() || this.didDrop())
+      return !1;
+    const n = this.registry.getTargetType(e), i = this.getItemType();
+    return T(n, i) && r.canDrop(this, e);
+  }
+  isDragging() {
+    return !!this.getItemType();
+  }
+  isDraggingSource(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getSource(e, !0);
+    if (s(r, `Expected to find a valid source. sourceId=${e}`), !this.isDragging() || !this.isSourcePublic())
+      return !1;
+    const n = this.registry.getSourceType(e), i = this.getItemType();
+    return n !== i ? !1 : r.isDragging(this, e);
+  }
+  isOverTarget(e, r = {
+    shallow: !1
+  }) {
+    if (!e)
+      return !1;
+    const { shallow: n } = r;
+    if (!this.isDragging())
+      return !1;
+    const i = this.registry.getTargetType(e), o = this.getItemType();
+    if (o && !T(i, o))
+      return !1;
+    const c = this.getTargetIds();
+    if (!c.length)
+      return !1;
+    const u = c.indexOf(e);
+    return n ? u === c.length - 1 : u > -1;
+  }
+  getItemType() {
+    return this.store.getState().dragOperation.itemType;
+  }
+  getItem() {
+    return this.store.getState().dragOperation.item;
+  }
+  getSourceId() {
+    return this.store.getState().dragOperation.sourceId;
+  }
+  getTargetIds() {
+    return this.store.getState().dragOperation.targetIds;
+  }
+  getDropResult() {
+    return this.store.getState().dragOperation.dropResult;
+  }
+  didDrop() {
+    return this.store.getState().dragOperation.didDrop;
+  }
+  isSourcePublic() {
+    return !!this.store.getState().dragOperation.isSourcePublic;
+  }
+  getInitialClientOffset() {
+    return this.store.getState().dragOffset.initialClientOffset;
+  }
+  getInitialSourceClientOffset() {
+    return this.store.getState().dragOffset.initialSourceClientOffset;
+  }
+  getClientOffset() {
+    return this.store.getState().dragOffset.clientOffset;
+  }
+  getSourceClientOffset() {
+    return de(this.store.getState().dragOffset);
+  }
+  getDifferenceFromInitialOffset() {
+    return ge(this.store.getState().dragOffset);
+  }
+  constructor(e, r) {
+    this.store = e, this.registry = r;
+  }
+}
+const R = "dnd-core/ADD_SOURCE", v = "dnd-core/ADD_TARGET", x = "dnd-core/REMOVE_SOURCE", O = "dnd-core/REMOVE_TARGET";
+function ye(t) {
+  return {
+    type: R,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function Se(t) {
+  return {
+    type: v,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function Oe(t) {
+  return {
+    type: x,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function be(t) {
+  return {
+    type: O,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function De(t) {
+  s(typeof t.canDrag == "function", "Expected canDrag to be a function."), s(typeof t.beginDrag == "function", "Expected beginDrag to be a function."), s(typeof t.endDrag == "function", "Expected endDrag to be a function.");
+}
+function Te(t) {
+  s(typeof t.canDrop == "function", "Expected canDrop to be a function."), s(typeof t.hover == "function", "Expected hover to be a function."), s(typeof t.drop == "function", "Expected beginDrag to be a function.");
+}
+function m(t, e) {
+  if (e && Array.isArray(t)) {
+    t.forEach(
+      (r) => m(r, !1)
+    );
+    return;
+  }
+  s(typeof t == "string" || typeof t == "symbol", e ? "Type can only be a string, a symbol, or an array of either." : "Type can only be a string or a symbol.");
+}
+var a;
+(function(t) {
+  t.SOURCE = "SOURCE", t.TARGET = "TARGET";
+})(a || (a = {}));
+let me = 0;
+function Ee() {
+  return me++;
+}
+function Ie(t) {
+  const e = Ee().toString();
+  switch (t) {
+    case a.SOURCE:
+      return `S${e}`;
+    case a.TARGET:
+      return `T${e}`;
+    default:
+      throw new Error(`Unknown Handler Role: ${t}`);
+  }
+}
+function w(t) {
+  switch (t[0]) {
+    case "S":
+      return a.SOURCE;
+    case "T":
+      return a.TARGET;
+    default:
+      throw new Error(`Cannot parse handler ID: ${t}`);
+  }
+}
+function P(t, e) {
+  const r = t.entries();
+  let n = !1;
+  do {
+    const { done: i, value: [, o] } = r.next();
+    if (o === e)
+      return !0;
+    n = !!i;
+  } while (!n);
+  return !1;
+}
+class Ce {
+  addSource(e, r) {
+    m(e), De(r);
+    const n = this.addHandler(a.SOURCE, e, r);
+    return this.store.dispatch(ye(n)), n;
+  }
+  addTarget(e, r) {
+    m(e, !0), Te(r);
+    const n = this.addHandler(a.TARGET, e, r);
+    return this.store.dispatch(Se(n)), n;
+  }
+  containsHandler(e) {
+    return P(this.dragSources, e) || P(this.dropTargets, e);
+  }
+  getSource(e, r = !1) {
+    return s(this.isSourceId(e), "Expected a valid source ID."), r && e === this.pinnedSourceId ? this.pinnedSource : this.dragSources.get(e);
+  }
+  getTarget(e) {
+    return s(this.isTargetId(e), "Expected a valid target ID."), this.dropTargets.get(e);
+  }
+  getSourceType(e) {
+    return s(this.isSourceId(e), "Expected a valid source ID."), this.types.get(e);
+  }
+  getTargetType(e) {
+    return s(this.isTargetId(e), "Expected a valid target ID."), this.types.get(e);
+  }
+  isSourceId(e) {
+    return w(e) === a.SOURCE;
+  }
+  isTargetId(e) {
+    return w(e) === a.TARGET;
+  }
+  removeSource(e) {
+    s(this.getSource(e), "Expected an existing source."), this.store.dispatch(Oe(e)), M(() => {
+      this.dragSources.delete(e), this.types.delete(e);
+    });
+  }
+  removeTarget(e) {
+    s(this.getTarget(e), "Expected an existing target."), this.store.dispatch(be(e)), this.dropTargets.delete(e), this.types.delete(e);
+  }
+  pinSource(e) {
+    const r = this.getSource(e);
+    s(r, "Expected an existing source."), this.pinnedSourceId = e, this.pinnedSource = r;
+  }
+  unpinSource() {
+    s(this.pinnedSource, "No source is pinned at the time."), this.pinnedSourceId = null, this.pinnedSource = null;
+  }
+  addHandler(e, r, n) {
+    const i = Ie(e);
+    return this.types.set(i, r), e === a.SOURCE ? this.dragSources.set(i, n) : e === a.TARGET && this.dropTargets.set(i, n), i;
+  }
+  constructor(e) {
+    this.types = /* @__PURE__ */ new Map(), this.dragSources = /* @__PURE__ */ new Map(), this.dropTargets = /* @__PURE__ */ new Map(), this.pinnedSourceId = null, this.pinnedSource = null, this.store = e;
+  }
+}
+const Re = (t, e) => t === e;
+function ve(t, e) {
+  return !t && !e ? !0 : !t || !e ? !1 : t.x === e.x && t.y === e.y;
+}
+function xe(t, e, r = Re) {
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; ++n)
+    if (!r(t[n], e[n]))
+      return !1;
+  return !0;
+}
+function _e(t = g, e) {
+  switch (e.type) {
+    case h:
+      break;
+    case R:
+    case v:
+    case O:
+    case x:
+      return g;
+    case p:
+    case I:
+    case S:
+    case y:
+    default:
+      return C;
+  }
+  const { targetIds: r = [], prevTargetIds: n = [] } = e.payload, i = L(r, n);
+  if (!(i.length > 0 || !xe(r, n)))
+    return g;
+  const c = n[n.length - 1], u = r[r.length - 1];
+  return c !== u && (c && i.push(c), u && i.push(u)), i;
+}
+function we(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function Pe(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      we(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const A = {
+  initialSourceClientOffset: null,
+  initialClientOffset: null,
+  clientOffset: null
+};
+function Ae(t = A, e) {
+  const { payload: r } = e;
+  switch (e.type) {
+    case E:
+    case p:
+      return {
+        initialSourceClientOffset: r.sourceClientOffset,
+        initialClientOffset: r.clientOffset,
+        clientOffset: r.clientOffset
+      };
+    case h:
+      return ve(t.clientOffset, r.clientOffset) ? t : Pe({}, t, {
+        clientOffset: r.clientOffset
+      });
+    case S:
+    case y:
+      return A;
+    default:
+      return t;
+  }
+}
+function Ue(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function d(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      Ue(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const Ge = {
+  itemType: null,
+  item: null,
+  sourceId: null,
+  targetIds: [],
+  dropResult: null,
+  didDrop: !1,
+  isSourcePublic: null
+};
+function $e(t = Ge, e) {
+  const { payload: r } = e;
+  switch (e.type) {
+    case p:
+      return d({}, t, {
+        itemType: r.itemType,
+        item: r.item,
+        sourceId: r.sourceId,
+        isSourcePublic: r.isSourcePublic,
+        dropResult: null,
+        didDrop: !1
+      });
+    case I:
+      return d({}, t, {
+        isSourcePublic: !0
+      });
+    case h:
+      return d({}, t, {
+        targetIds: r.targetIds
+      });
+    case O:
+      return t.targetIds.indexOf(r.targetId) === -1 ? t : d({}, t, {
+        targetIds: N(t.targetIds, r.targetId)
+      });
+    case y:
+      return d({}, t, {
+        dropResult: r.dropResult,
+        didDrop: !0,
+        targetIds: []
+      });
+    case S:
+      return d({}, t, {
+        itemType: null,
+        item: null,
+        sourceId: null,
+        dropResult: null,
+        didDrop: !1,
+        isSourcePublic: null,
+        targetIds: []
+      });
+    default:
+      return t;
+  }
+}
+function je(t = 0, e) {
+  switch (e.type) {
+    case R:
+    case v:
+      return t + 1;
+    case x:
+    case O:
+      return t - 1;
+    default:
+      return t;
+  }
+}
+function Me(t = 0) {
+  return t + 1;
+}
+function He(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function Ne(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      He(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function Le(t = {}, e) {
+  return {
+    dirtyHandlerIds: _e(t.dirtyHandlerIds, {
+      type: e.type,
+      payload: Ne({}, e.payload, {
+        prevTargetIds: H(t, "dragOperation.targetIds", [])
+      })
+    }),
+    dragOffset: Ae(t.dragOffset, e),
+    refCount: je(t.refCount, e),
+    dragOperation: $e(t.dragOperation, e),
+    stateId: Me(t.stateId)
+  };
+}
+function Fe(t, e = void 0, r = {}, n = !1) {
+  const i = ke(n), o = new he(i, new Ce(i)), c = new fe(i, o), u = t(c, e, r);
+  return c.receiveBackend(u), c;
+}
+function ke(t) {
+  const e = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION__;
+  return j(Le, t && e && e({
+    name: "dnd-core",
+    instanceId: "dnd-core"
+  }));
+}
+export {
+  Fe as c
+};