@epam/ai-dial-ui-kit 0.14.0-dev.4 → 0.14.0-dev.41

package/dist/node_modules/react-dnd/dist/internals/TargetConnector.js

@@ -0,0 +1,57 @@
+import { shallowEqual as n } from "../../../@react-dnd/shallowequal/dist/index.js";
+import { isRef as s } from "./isRef.js";
+import { wrapConnectorHooks as o } from "./wrapConnectorHooks.js";
+class p {
+  get connectTarget() {
+    return this.dropTarget;
+  }
+  reconnect() {
+    const t = this.didHandlerIdChange() || this.didDropTargetChange() || this.didOptionsChange();
+    t && this.disconnectDropTarget();
+    const r = this.dropTarget;
+    if (this.handlerId) {
+      if (!r) {
+        this.lastConnectedDropTarget = r;
+        return;
+      }
+      t && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDropTarget = r, this.lastConnectedDropTargetOptions = this.dropTargetOptions, this.unsubscribeDropTarget = this.backend.connectDropTarget(this.handlerId, r, this.dropTargetOptions));
+    }
+  }
+  receiveHandlerId(t) {
+    t !== this.handlerId && (this.handlerId = t, this.reconnect());
+  }
+  get dropTargetOptions() {
+    return this.dropTargetOptionsInternal;
+  }
+  set dropTargetOptions(t) {
+    this.dropTargetOptionsInternal = t;
+  }
+  didHandlerIdChange() {
+    return this.lastConnectedHandlerId !== this.handlerId;
+  }
+  didDropTargetChange() {
+    return this.lastConnectedDropTarget !== this.dropTarget;
+  }
+  didOptionsChange() {
+    return !n(this.lastConnectedDropTargetOptions, this.dropTargetOptions);
+  }
+  disconnectDropTarget() {
+    this.unsubscribeDropTarget && (this.unsubscribeDropTarget(), this.unsubscribeDropTarget = void 0);
+  }
+  get dropTarget() {
+    return this.dropTargetNode || this.dropTargetRef && this.dropTargetRef.current;
+  }
+  clearDropTarget() {
+    this.dropTargetRef = null, this.dropTargetNode = null;
+  }
+  constructor(t) {
+    this.hooks = o({
+      dropTarget: (r, e) => {
+        this.clearDropTarget(), this.dropTargetOptions = e, s(r) ? this.dropTargetRef = r : this.dropTargetNode = r, this.reconnect();
+      }
+    }), this.handlerId = null, this.dropTargetRef = null, this.dropTargetOptionsInternal = null, this.lastConnectedHandlerId = null, this.lastConnectedDropTarget = null, this.lastConnectedDropTargetOptions = null, this.backend = t;
+  }
+}
+export {
+  p as TargetConnector
+};

package/dist/node_modules/react-dnd/dist/internals/isRef.js

@@ -0,0 +1,9 @@
+function e(t) {
+  return (
+    // eslint-disable-next-line no-prototype-builtins
+    t !== null && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current")
+  );
+}
+export {
+  e as isRef
+};

package/dist/node_modules/react-dnd/dist/internals/registration.js

@@ -0,0 +1,18 @@
+function s(t, o, g) {
+  const e = g.getRegistry(), r = e.addTarget(t, o);
+  return [
+    r,
+    () => e.removeTarget(r)
+  ];
+}
+function c(t, o, g) {
+  const e = g.getRegistry(), r = e.addSource(t, o);
+  return [
+    r,
+    () => e.removeSource(r)
+  ];
+}
+export {
+  c as registerSource,
+  s as registerTarget
+};

package/dist/node_modules/react-dnd/dist/internals/wrapConnectorHooks.js

@@ -0,0 +1,46 @@
+import { invariant as s } from "../../../@react-dnd/invariant/dist/index.js";
+import { isValidElement as f, cloneElement as i } from "react";
+function p(t) {
+  if (typeof t.type == "string")
+    return;
+  const n = t.type.displayName || t.type.name || "the component";
+  throw new Error(`Only native element nodes can now be passed to React DnD connectors.You can either wrap ${n} into a <div>, or turn it into a drag source or a drop target itself.`);
+}
+function l(t) {
+  return (n = null, e = null) => {
+    if (!f(n)) {
+      const o = n;
+      return t(o, e), o;
+    }
+    const r = n;
+    return p(r), u(r, e ? (o) => t(o, e) : t);
+  };
+}
+function w(t) {
+  const n = {};
+  return Object.keys(t).forEach((e) => {
+    const r = t[e];
+    if (e.endsWith("Ref"))
+      n[e] = t[e];
+    else {
+      const a = l(r);
+      n[e] = () => a;
+    }
+  }), n;
+}
+function c(t, n) {
+  typeof t == "function" ? t(n) : t.current = n;
+}
+function u(t, n) {
+  const e = t.ref;
+  return s(typeof e != "string", "Cannot connect React DnD to an element with an existing string ref. Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. Read more: https://reactjs.org/docs/refs-and-the-dom.html#callback-refs"), e ? i(t, {
+    ref: (r) => {
+      c(e, r), c(n, r);
+    }
+  }) : i(t, {
+    ref: n
+  });
+}
+export {
+  w as wrapConnectorHooks
+};

package/dist/node_modules/react-dnd-html5-backend/dist/BrowserDetector.js

@@ -0,0 +1,10 @@
+import { memoize as o } from "./utils/js_utils.js";
+const e = o(
+  () => /firefox/i.test(navigator.userAgent)
+), r = o(
+  () => !!window.safari
+);
+export {
+  e as isFirefox,
+  r as isSafari
+};

package/dist/node_modules/react-dnd-html5-backend/dist/EnterLeaveCounter.js

@@ -0,0 +1,22 @@
+import { union as r, without as i } from "./utils/js_utils.js";
+class d {
+  enter(e) {
+    const t = this.entered.length, s = (n) => this.isNodeInDocument(n) && (!n.contains || n.contains(e));
+    return this.entered = r(this.entered.filter(s), [
+      e
+    ]), t === 0 && this.entered.length > 0;
+  }
+  leave(e) {
+    const t = this.entered.length;
+    return this.entered = i(this.entered.filter(this.isNodeInDocument), e), t > 0 && this.entered.length === 0;
+  }
+  reset() {
+    this.entered = [];
+  }
+  constructor(e) {
+    this.entered = [], this.isNodeInDocument = e;
+  }
+}
+export {
+  d as EnterLeaveCounter
+};

package/dist/node_modules/react-dnd-html5-backend/dist/HTML5BackendImpl.js

@@ -0,0 +1,274 @@
+import { EnterLeaveCounter as S } from "./EnterLeaveCounter.js";
+import { createNativeDragSource as O, matchNativeItemType as g } from "./NativeDragSources/index.js";
+import * as f from "./NativeTypes.js";
+import { getNodeClientOffset as I, getEventClientOffset as h, getDragPreviewOffset as L } from "./OffsetUtils.js";
+import { OptionsReader as C } from "./OptionsReader.js";
+function w(o, e, r) {
+  return e in o ? Object.defineProperty(o, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : o[e] = r, o;
+}
+function p(o) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, s = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (s = s.concat(Object.getOwnPropertySymbols(r).filter(function(t) {
+      return Object.getOwnPropertyDescriptor(r, t).enumerable;
+    }))), s.forEach(function(t) {
+      w(o, t, r[t]);
+    });
+  }
+  return o;
+}
+class F {
+  /**
+  * Generate profiling statistics for the HTML5Backend.
+  */
+  profile() {
+    var e, r;
+    return {
+      sourcePreviewNodes: this.sourcePreviewNodes.size,
+      sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+      sourceNodeOptions: this.sourceNodeOptions.size,
+      sourceNodes: this.sourceNodes.size,
+      dragStartSourceIds: ((e = this.dragStartSourceIds) === null || e === void 0 ? void 0 : e.length) || 0,
+      dropTargetIds: this.dropTargetIds.length,
+      dragEnterTargetIds: this.dragEnterTargetIds.length,
+      dragOverTargetIds: ((r = this.dragOverTargetIds) === null || r === void 0 ? void 0 : r.length) || 0
+    };
+  }
+  // public for test
+  get window() {
+    return this.options.window;
+  }
+  get document() {
+    return this.options.document;
+  }
+  /**
+  * Get the root element to use for event subscriptions
+  */
+  get rootElement() {
+    return this.options.rootElement;
+  }
+  setup() {
+    const e = this.rootElement;
+    if (e !== void 0) {
+      if (e.__isReactDndBackendSetUp)
+        throw new Error("Cannot have two HTML5 backends at the same time.");
+      e.__isReactDndBackendSetUp = !0, this.addEventListeners(e);
+    }
+  }
+  teardown() {
+    const e = this.rootElement;
+    if (e !== void 0 && (e.__isReactDndBackendSetUp = !1, this.removeEventListeners(this.rootElement), this.clearCurrentDragSourceNode(), this.asyncEndDragFrameId)) {
+      var r;
+      (r = this.window) === null || r === void 0 || r.cancelAnimationFrame(this.asyncEndDragFrameId);
+    }
+  }
+  connectDragPreview(e, r, s) {
+    return this.sourcePreviewNodeOptions.set(e, s), this.sourcePreviewNodes.set(e, r), () => {
+      this.sourcePreviewNodes.delete(e), this.sourcePreviewNodeOptions.delete(e);
+    };
+  }
+  connectDragSource(e, r, s) {
+    this.sourceNodes.set(e, r), this.sourceNodeOptions.set(e, s);
+    const t = (a) => this.handleDragStart(a, e), i = (a) => this.handleSelectStart(a);
+    return r.setAttribute("draggable", "true"), r.addEventListener("dragstart", t), r.addEventListener("selectstart", i), () => {
+      this.sourceNodes.delete(e), this.sourceNodeOptions.delete(e), r.removeEventListener("dragstart", t), r.removeEventListener("selectstart", i), r.setAttribute("draggable", "false");
+    };
+  }
+  connectDropTarget(e, r) {
+    const s = (a) => this.handleDragEnter(a, e), t = (a) => this.handleDragOver(a, e), i = (a) => this.handleDrop(a, e);
+    return r.addEventListener("dragenter", s), r.addEventListener("dragover", t), r.addEventListener("drop", i), () => {
+      r.removeEventListener("dragenter", s), r.removeEventListener("dragover", t), r.removeEventListener("drop", i);
+    };
+  }
+  addEventListeners(e) {
+    e.addEventListener && (e.addEventListener("dragstart", this.handleTopDragStart), e.addEventListener("dragstart", this.handleTopDragStartCapture, !0), e.addEventListener("dragend", this.handleTopDragEndCapture, !0), e.addEventListener("dragenter", this.handleTopDragEnter), e.addEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.addEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.addEventListener("dragover", this.handleTopDragOver), e.addEventListener("dragover", this.handleTopDragOverCapture, !0), e.addEventListener("drop", this.handleTopDrop), e.addEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  removeEventListeners(e) {
+    e.removeEventListener && (e.removeEventListener("dragstart", this.handleTopDragStart), e.removeEventListener("dragstart", this.handleTopDragStartCapture, !0), e.removeEventListener("dragend", this.handleTopDragEndCapture, !0), e.removeEventListener("dragenter", this.handleTopDragEnter), e.removeEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.removeEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.removeEventListener("dragover", this.handleTopDragOver), e.removeEventListener("dragover", this.handleTopDragOverCapture, !0), e.removeEventListener("drop", this.handleTopDrop), e.removeEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  getCurrentSourceNodeOptions() {
+    const e = this.monitor.getSourceId(), r = this.sourceNodeOptions.get(e);
+    return p({
+      dropEffect: this.altKeyPressed ? "copy" : "move"
+    }, r || {});
+  }
+  getCurrentDropEffect() {
+    return this.isDraggingNativeItem() ? "copy" : this.getCurrentSourceNodeOptions().dropEffect;
+  }
+  getCurrentSourcePreviewNodeOptions() {
+    const e = this.monitor.getSourceId(), r = this.sourcePreviewNodeOptions.get(e);
+    return p({
+      anchorX: 0.5,
+      anchorY: 0.5,
+      captureDraggingState: !1
+    }, r || {});
+  }
+  isDraggingNativeItem() {
+    const e = this.monitor.getItemType();
+    return Object.keys(f).some(
+      (r) => f[r] === e
+    );
+  }
+  beginDragNativeItem(e, r) {
+    this.clearCurrentDragSourceNode(), this.currentNativeSource = O(e, r), this.currentNativeHandle = this.registry.addSource(e, this.currentNativeSource), this.actions.beginDrag([
+      this.currentNativeHandle
+    ]);
+  }
+  setCurrentDragSourceNode(e) {
+    this.clearCurrentDragSourceNode(), this.currentDragSourceNode = e;
+    const r = 1e3;
+    this.mouseMoveTimeoutTimer = setTimeout(() => {
+      var s;
+      return (s = this.rootElement) === null || s === void 0 ? void 0 : s.addEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+    }, r);
+  }
+  clearCurrentDragSourceNode() {
+    if (this.currentDragSourceNode) {
+      if (this.currentDragSourceNode = null, this.rootElement) {
+        var e;
+        (e = this.window) === null || e === void 0 || e.clearTimeout(this.mouseMoveTimeoutTimer || void 0), this.rootElement.removeEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+      }
+      return this.mouseMoveTimeoutTimer = null, !0;
+    }
+    return !1;
+  }
+  handleDragStart(e, r) {
+    e.defaultPrevented || (this.dragStartSourceIds || (this.dragStartSourceIds = []), this.dragStartSourceIds.unshift(r));
+  }
+  handleDragEnter(e, r) {
+    this.dragEnterTargetIds.unshift(r);
+  }
+  handleDragOver(e, r) {
+    this.dragOverTargetIds === null && (this.dragOverTargetIds = []), this.dragOverTargetIds.unshift(r);
+  }
+  handleDrop(e, r) {
+    this.dropTargetIds.unshift(r);
+  }
+  constructor(e, r, s) {
+    this.sourcePreviewNodes = /* @__PURE__ */ new Map(), this.sourcePreviewNodeOptions = /* @__PURE__ */ new Map(), this.sourceNodes = /* @__PURE__ */ new Map(), this.sourceNodeOptions = /* @__PURE__ */ new Map(), this.dragStartSourceIds = null, this.dropTargetIds = [], this.dragEnterTargetIds = [], this.currentNativeSource = null, this.currentNativeHandle = null, this.currentDragSourceNode = null, this.altKeyPressed = !1, this.mouseMoveTimeoutTimer = null, this.asyncEndDragFrameId = null, this.dragOverTargetIds = null, this.lastClientOffset = null, this.hoverRafId = null, this.getSourceClientOffset = (t) => {
+      const i = this.sourceNodes.get(t);
+      return i && I(i) || null;
+    }, this.endDragNativeItem = () => {
+      this.isDraggingNativeItem() && (this.actions.endDrag(), this.currentNativeHandle && this.registry.removeSource(this.currentNativeHandle), this.currentNativeHandle = null, this.currentNativeSource = null);
+    }, this.isNodeInDocument = (t) => !!(t && this.document && this.document.body && this.document.body.contains(t)), this.endDragIfSourceWasRemovedFromDOM = () => {
+      const t = this.currentDragSourceNode;
+      t == null || this.isNodeInDocument(t) || (this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover());
+    }, this.scheduleHover = (t) => {
+      this.hoverRafId === null && typeof requestAnimationFrame < "u" && (this.hoverRafId = requestAnimationFrame(() => {
+        this.monitor.isDragging() && this.actions.hover(t || [], {
+          clientOffset: this.lastClientOffset
+        }), this.hoverRafId = null;
+      }));
+    }, this.cancelHover = () => {
+      this.hoverRafId !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(this.hoverRafId), this.hoverRafId = null);
+    }, this.handleTopDragStartCapture = () => {
+      this.clearCurrentDragSourceNode(), this.dragStartSourceIds = [];
+    }, this.handleTopDragStart = (t) => {
+      if (t.defaultPrevented)
+        return;
+      const { dragStartSourceIds: i } = this;
+      this.dragStartSourceIds = null;
+      const a = h(t);
+      this.monitor.isDragging() && (this.actions.endDrag(), this.cancelHover()), this.actions.beginDrag(i || [], {
+        publishSource: !1,
+        getSourceClientOffset: this.getSourceClientOffset,
+        clientOffset: a
+      });
+      const { dataTransfer: n } = t, d = g(n);
+      if (this.monitor.isDragging()) {
+        if (n && typeof n.setDragImage == "function") {
+          const u = this.monitor.getSourceId(), l = this.sourceNodes.get(u), c = this.sourcePreviewNodes.get(u) || l;
+          if (c) {
+            const { anchorX: m, anchorY: T, offsetX: E, offsetY: N } = this.getCurrentSourcePreviewNodeOptions(), v = L(l, c, a, {
+              anchorX: m,
+              anchorY: T
+            }, {
+              offsetX: E,
+              offsetY: N
+            });
+            n.setDragImage(c, v.x, v.y);
+          }
+        }
+        try {
+          n?.setData("application/json", {});
+        } catch {
+        }
+        this.setCurrentDragSourceNode(t.target);
+        const { captureDraggingState: D } = this.getCurrentSourcePreviewNodeOptions();
+        D ? this.actions.publishDragSource() : setTimeout(
+          () => this.actions.publishDragSource(),
+          0
+        );
+      } else if (d)
+        this.beginDragNativeItem(d);
+      else {
+        if (n && !n.types && (t.target && !t.target.hasAttribute || !t.target.hasAttribute("draggable")))
+          return;
+        t.preventDefault();
+      }
+    }, this.handleTopDragEndCapture = () => {
+      this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleTopDragEnterCapture = (t) => {
+      if (this.dragEnterTargetIds = [], this.isDraggingNativeItem()) {
+        var i;
+        (i = this.currentNativeSource) === null || i === void 0 || i.loadDataTransfer(t.dataTransfer);
+      }
+      if (!this.enterLeaveCounter.enter(t.target) || this.monitor.isDragging())
+        return;
+      const { dataTransfer: n } = t, d = g(n);
+      d && this.beginDragNativeItem(d, n);
+    }, this.handleTopDragEnter = (t) => {
+      const { dragEnterTargetIds: i } = this;
+      if (this.dragEnterTargetIds = [], !this.monitor.isDragging())
+        return;
+      this.altKeyPressed = t.altKey, i.length > 0 && this.actions.hover(i, {
+        clientOffset: h(t)
+      }), i.some(
+        (n) => this.monitor.canDropOnTarget(n)
+      ) && (t.preventDefault(), t.dataTransfer && (t.dataTransfer.dropEffect = this.getCurrentDropEffect()));
+    }, this.handleTopDragOverCapture = (t) => {
+      if (this.dragOverTargetIds = [], this.isDraggingNativeItem()) {
+        var i;
+        (i = this.currentNativeSource) === null || i === void 0 || i.loadDataTransfer(t.dataTransfer);
+      }
+    }, this.handleTopDragOver = (t) => {
+      const { dragOverTargetIds: i } = this;
+      if (this.dragOverTargetIds = [], !this.monitor.isDragging()) {
+        t.preventDefault(), t.dataTransfer && (t.dataTransfer.dropEffect = "none");
+        return;
+      }
+      this.altKeyPressed = t.altKey, this.lastClientOffset = h(t), this.scheduleHover(i), (i || []).some(
+        (n) => this.monitor.canDropOnTarget(n)
+      ) ? (t.preventDefault(), t.dataTransfer && (t.dataTransfer.dropEffect = this.getCurrentDropEffect())) : this.isDraggingNativeItem() ? t.preventDefault() : (t.preventDefault(), t.dataTransfer && (t.dataTransfer.dropEffect = "none"));
+    }, this.handleTopDragLeaveCapture = (t) => {
+      this.isDraggingNativeItem() && t.preventDefault(), this.enterLeaveCounter.leave(t.target) && (this.isDraggingNativeItem() && setTimeout(
+        () => this.endDragNativeItem(),
+        0
+      ), this.cancelHover());
+    }, this.handleTopDropCapture = (t) => {
+      if (this.dropTargetIds = [], this.isDraggingNativeItem()) {
+        var i;
+        t.preventDefault(), (i = this.currentNativeSource) === null || i === void 0 || i.loadDataTransfer(t.dataTransfer);
+      } else g(t.dataTransfer) && t.preventDefault();
+      this.enterLeaveCounter.reset();
+    }, this.handleTopDrop = (t) => {
+      const { dropTargetIds: i } = this;
+      this.dropTargetIds = [], this.actions.hover(i, {
+        clientOffset: h(t)
+      }), this.actions.drop({
+        dropEffect: this.getCurrentDropEffect()
+      }), this.isDraggingNativeItem() ? this.endDragNativeItem() : this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleSelectStart = (t) => {
+      const i = t.target;
+      typeof i.dragDrop == "function" && (i.tagName === "INPUT" || i.tagName === "SELECT" || i.tagName === "TEXTAREA" || i.isContentEditable || (t.preventDefault(), i.dragDrop()));
+    }, this.options = new C(r, s), this.actions = e.getActions(), this.monitor = e.getMonitor(), this.registry = e.getRegistry(), this.enterLeaveCounter = new S(this.isNodeInDocument);
+  }
+}
+export {
+  F as HTML5BackendImpl
+};

package/dist/node_modules/react-dnd-html5-backend/dist/MonotonicInterpolant.js

@@ -0,0 +1,59 @@
+class M {
+  interpolate(e) {
+    const { xs: c, ys: u, c1s: g, c2s: h, c3s: n } = this;
+    let s = c.length - 1;
+    if (e === c[s])
+      return u[s];
+    let p = 0, o = n.length - 1, l;
+    for (; p <= o; ) {
+      l = Math.floor(0.5 * (p + o));
+      const t = c[l];
+      if (t < e)
+        p = l + 1;
+      else if (t > e)
+        o = l - 1;
+      else
+        return u[l];
+    }
+    s = Math.max(0, o);
+    const i = e - c[s], r = i * i;
+    return u[s] + g[s] * i + h[s] * r + n[s] * i * r;
+  }
+  constructor(e, c) {
+    const { length: u } = e, g = [];
+    for (let t = 0; t < u; t++)
+      g.push(t);
+    g.sort(
+      (t, f) => e[t] < e[f] ? -1 : 1
+    );
+    const h = [], n = [];
+    let s, p;
+    for (let t = 0; t < u - 1; t++)
+      s = e[t + 1] - e[t], p = c[t + 1] - c[t], h.push(s), n.push(p / s);
+    const o = [
+      n[0]
+    ];
+    for (let t = 0; t < h.length - 1; t++) {
+      const f = n[t], m = n[t + 1];
+      if (f * m <= 0)
+        o.push(0);
+      else {
+        s = h[t];
+        const d = h[t + 1], a = s + d;
+        o.push(3 * a / ((a + d) / f + (a + s) / m));
+      }
+    }
+    o.push(n[n.length - 1]);
+    const l = [], i = [];
+    let r;
+    for (let t = 0; t < o.length - 1; t++) {
+      r = n[t];
+      const f = o[t], m = 1 / h[t], d = f + o[t + 1] - r - r;
+      l.push((r - f - d) * m), i.push(d * m * m);
+    }
+    this.xs = e, this.ys = c, this.c1s = o, this.c2s = l, this.c3s = i;
+  }
+}
+export {
+  M as MonotonicInterpolant
+};

package/dist/node_modules/react-dnd-html5-backend/dist/NativeDragSources/NativeDragSource.js

@@ -0,0 +1,43 @@
+class s {
+  initializeExposedProperties() {
+    Object.keys(this.config.exposeProperties).forEach((e) => {
+      Object.defineProperty(this.item, e, {
+        configurable: !0,
+        enumerable: !0,
+        get() {
+          return console.warn(`Browser doesn't allow reading "${e}" until the drop event.`), null;
+        }
+      });
+    });
+  }
+  loadDataTransfer(e) {
+    if (e) {
+      const t = {};
+      Object.keys(this.config.exposeProperties).forEach((r) => {
+        const i = this.config.exposeProperties[r];
+        i != null && (t[r] = {
+          value: i(e, this.config.matchesTypes),
+          configurable: !0,
+          enumerable: !0
+        });
+      }), Object.defineProperties(this.item, t);
+    }
+  }
+  canDrag() {
+    return !0;
+  }
+  beginDrag() {
+    return this.item;
+  }
+  isDragging(e, t) {
+    return t === e.getSourceId();
+  }
+  endDrag() {
+  }
+  constructor(e) {
+    this.config = e, this.item = {}, this.initializeExposedProperties();
+  }
+}
+export {
+  s as NativeDragSource
+};

package/dist/node_modules/react-dnd-html5-backend/dist/NativeDragSources/getDataFromDataTransfer.js

@@ -0,0 +1,10 @@
+function o(e, r, a) {
+  const t = r.reduce(
+    (n, u) => n || e.getData(u),
+    ""
+  );
+  return t ?? a;
+}
+export {
+  o as getDataFromDataTransfer
+};

package/dist/node_modules/react-dnd-html5-backend/dist/NativeDragSources/index.js

@@ -0,0 +1,24 @@
+import { NativeDragSource as a } from "./NativeDragSource.js";
+import { nativeTypesConfig as o } from "./nativeTypesConfig.js";
+function f(t, n) {
+  const r = o[t];
+  if (!r)
+    throw new Error(`native type ${t} has no configuration`);
+  const e = new a(r);
+  return e.loadDataTransfer(n), e;
+}
+function u(t) {
+  if (!t)
+    return null;
+  const n = Array.prototype.slice.call(t.types || []);
+  return Object.keys(o).filter((r) => {
+    const e = o[r];
+    return e?.matchesTypes ? e.matchesTypes.some(
+      (i) => n.indexOf(i) > -1
+    ) : !1;
+  })[0] || null;
+}
+export {
+  f as createNativeDragSource,
+  u as matchNativeItemType
+};

package/dist/node_modules/react-dnd-html5-backend/dist/NativeDragSources/nativeTypesConfig.js

@@ -0,0 +1,48 @@
+import { TEXT as r, URL as a, HTML as p, FILE as i } from "../NativeTypes.js";
+import { getDataFromDataTransfer as s } from "./getDataFromDataTransfer.js";
+const m = {
+  [i]: {
+    exposeProperties: {
+      files: (e) => Array.prototype.slice.call(e.files),
+      items: (e) => e.items,
+      dataTransfer: (e) => e
+    },
+    matchesTypes: [
+      "Files"
+    ]
+  },
+  [p]: {
+    exposeProperties: {
+      html: (e, t) => s(e, t, ""),
+      dataTransfer: (e) => e
+    },
+    matchesTypes: [
+      "Html",
+      "text/html"
+    ]
+  },
+  [a]: {
+    exposeProperties: {
+      urls: (e, t) => s(e, t, "").split(`
+`),
+      dataTransfer: (e) => e
+    },
+    matchesTypes: [
+      "Url",
+      "text/uri-list"
+    ]
+  },
+  [r]: {
+    exposeProperties: {
+      text: (e, t) => s(e, t, ""),
+      dataTransfer: (e) => e
+    },
+    matchesTypes: [
+      "Text",
+      "text/plain"
+    ]
+  }
+};
+export {
+  m as nativeTypesConfig
+};

package/dist/node_modules/react-dnd-html5-backend/dist/NativeTypes.js

@@ -0,0 +1,7 @@
+const _ = "__NATIVE_FILE__", T = "__NATIVE_URL__", E = "__NATIVE_TEXT__", I = "__NATIVE_HTML__";
+export {
+  _ as FILE,
+  I as HTML,
+  E as TEXT,
+  T as URL
+};