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

package/dist/node_modules/dnd-core/dist/actions/dragDrop/beginDrag.js

@@ -0,0 +1,70 @@
+import { invariant as f } from "../../../../@react-dnd/invariant/dist/index.js";
+import { isObject as b } from "../../utils/js_utils.js";
+import { setClientOffset as a } from "./local/setClientOffset.js";
+import { INIT_COORDS as d, BEGIN_DRAG as S } from "./types.js";
+const m = {
+  type: d,
+  payload: {
+    clientOffset: null,
+    sourceClientOffset: null
+  }
+};
+function w(e) {
+  return function(n = [], t = {
+    publishSource: !0
+  }) {
+    const { publishSource: p = !0, clientOffset: o, getSourceClientOffset: u } = t, s = e.getMonitor(), c = e.getRegistry();
+    e.dispatch(a(o)), y(n, s, c);
+    const i = D(n, s);
+    if (i == null) {
+      e.dispatch(m);
+      return;
+    }
+    let l = null;
+    if (o) {
+      if (!u)
+        throw new Error("getSourceClientOffset must be defined");
+      C(u), l = u(i);
+    }
+    e.dispatch(a(o, l));
+    const g = c.getSource(i).beginDrag(s, i);
+    if (g == null)
+      return;
+    h(g), c.pinSource(i);
+    const O = c.getSourceType(i);
+    return {
+      type: S,
+      payload: {
+        itemType: O,
+        item: g,
+        sourceId: i,
+        clientOffset: o || null,
+        sourceClientOffset: l || null,
+        isSourcePublic: !!p
+      }
+    };
+  };
+}
+function y(e, r, n) {
+  f(!r.isDragging(), "Cannot call beginDrag while dragging."), e.forEach(function(t) {
+    f(n.getSource(t), "Expected sourceIds to be registered.");
+  });
+}
+function C(e) {
+  f(typeof e == "function", "When clientOffset is provided, getSourceClientOffset must be a function.");
+}
+function h(e) {
+  f(b(e), "Item must be an object.");
+}
+function D(e, r) {
+  let n = null;
+  for (let t = e.length - 1; t >= 0; t--)
+    if (r.canDragSource(e[t])) {
+      n = e[t];
+      break;
+    }
+  return n;
+}
+export {
+  w as createBeginDrag
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/drop.js

@@ -0,0 +1,54 @@
+import { invariant as a } from "../../../../@react-dnd/invariant/dist/index.js";
+import { isObject as s } from "../../utils/js_utils.js";
+import { DROP as d } from "./types.js";
+function g(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function l(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(o) {
+      return Object.getOwnPropertyDescriptor(r, o).enumerable;
+    }))), n.forEach(function(o) {
+      g(t, o, r[o]);
+    });
+  }
+  return t;
+}
+function h(t) {
+  return function(r = {}) {
+    const n = t.getMonitor(), o = t.getRegistry();
+    b(n), O(n).forEach((c, u) => {
+      const f = y(c, u, o, n), p = {
+        type: d,
+        payload: {
+          dropResult: l({}, r, f)
+        }
+      };
+      t.dispatch(p);
+    });
+  };
+}
+function b(t) {
+  a(t.isDragging(), "Cannot call drop while not dragging."), a(!t.didDrop(), "Cannot call drop twice during one drag operation.");
+}
+function y(t, e, r, n) {
+  const o = r.getTarget(t);
+  let i = o ? o.drop(n, t) : void 0;
+  return D(i), typeof i > "u" && (i = e === 0 ? {} : n.getDropResult()), i;
+}
+function D(t) {
+  a(typeof t > "u" || s(t), "Drop result must either be an object or undefined.");
+}
+function O(t) {
+  const e = t.getTargetIds().filter(t.canDropOnTarget, t);
+  return e.reverse(), e;
+}
+export {
+  h as createDrop
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/endDrag.js

@@ -0,0 +1,18 @@
+import { invariant as e } from "../../../../@react-dnd/invariant/dist/index.js";
+import { END_DRAG as i } from "./types.js";
+function D(r) {
+  return function() {
+    const n = r.getMonitor(), o = r.getRegistry();
+    g(n);
+    const t = n.getSourceId();
+    return t != null && (o.getSource(t, !0).endDrag(n, t), o.unpinSource()), {
+      type: i
+    };
+  };
+}
+function g(r) {
+  e(r.isDragging(), "Cannot call endDrag while not dragging.");
+}
+export {
+  D as createEndDrag
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/hover.js

@@ -0,0 +1,42 @@
+import { invariant as i } from "../../../../@react-dnd/invariant/dist/index.js";
+import { matchesType as s } from "../../utils/matchesType.js";
+import { HOVER as f } from "./types.js";
+function v(t) {
+  return function(n, { clientOffset: e } = {}) {
+    l(n);
+    const r = n.slice(0), a = t.getMonitor(), c = t.getRegistry(), g = a.getItemType();
+    return d(r, c, g), p(r, a, c), y(r, a, c), {
+      type: f,
+      payload: {
+        targetIds: r,
+        clientOffset: e || null
+      }
+    };
+  };
+}
+function l(t) {
+  i(Array.isArray(t), "Expected targetIds to be an array.");
+}
+function p(t, o, n) {
+  i(o.isDragging(), "Cannot call hover while not dragging."), i(!o.didDrop(), "Cannot call hover after drop.");
+  for (let e = 0; e < t.length; e++) {
+    const r = t[e];
+    i(t.lastIndexOf(r) === e, "Expected targetIds to be unique in the passed array.");
+    const a = n.getTarget(r);
+    i(a, "Expected targetIds to be registered.");
+  }
+}
+function d(t, o, n) {
+  for (let e = t.length - 1; e >= 0; e--) {
+    const r = t[e], a = o.getTargetType(r);
+    s(a, n) || t.splice(e, 1);
+  }
+}
+function y(t, o, n) {
+  t.forEach(function(e) {
+    n.getTarget(e).hover(o, e);
+  });
+}
+export {
+  v as createHover
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/index.js

@@ -0,0 +1,17 @@
+import { createBeginDrag as o } from "./beginDrag.js";
+import { createDrop as e } from "./drop.js";
+import { createEndDrag as t } from "./endDrag.js";
+import { createHover as i } from "./hover.js";
+import { createPublishDragSource as c } from "./publishDragSource.js";
+function a(r) {
+  return {
+    beginDrag: o(r),
+    publishDragSource: c(r),
+    hover: i(r),
+    drop: e(r),
+    endDrag: t(r)
+  };
+}
+export {
+  a as createDragDropActions
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/local/setClientOffset.js

@@ -0,0 +1,13 @@
+import { INIT_COORDS as f } from "../types.js";
+function n(t, e) {
+  return {
+    type: f,
+    payload: {
+      sourceClientOffset: e || null,
+      clientOffset: t || null
+    }
+  };
+}
+export {
+  n as setClientOffset
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/publishDragSource.js

@@ -0,0 +1,12 @@
+import { PUBLISH_DRAG_SOURCE as o } from "./types.js";
+function e(r) {
+  return function() {
+    if (r.getMonitor().isDragging())
+      return {
+        type: o
+      };
+  };
+}
+export {
+  e as createPublishDragSource
+};

package/dist/node_modules/dnd-core/dist/actions/dragDrop/types.js

@@ -0,0 +1,9 @@
+const R = "dnd-core/INIT_COORDS", o = "dnd-core/BEGIN_DRAG", c = "dnd-core/PUBLISH_DRAG_SOURCE", d = "dnd-core/HOVER", n = "dnd-core/DROP", D = "dnd-core/END_DRAG";
+export {
+  o as BEGIN_DRAG,
+  n as DROP,
+  D as END_DRAG,
+  d as HOVER,
+  R as INIT_COORDS,
+  c as PUBLISH_DRAG_SOURCE
+};

package/dist/node_modules/dnd-core/dist/actions/registry.js

@@ -0,0 +1,43 @@
+const o = "dnd-core/ADD_SOURCE", n = "dnd-core/ADD_TARGET", r = "dnd-core/REMOVE_SOURCE", t = "dnd-core/REMOVE_TARGET";
+function d(e) {
+  return {
+    type: o,
+    payload: {
+      sourceId: e
+    }
+  };
+}
+function E(e) {
+  return {
+    type: n,
+    payload: {
+      targetId: e
+    }
+  };
+}
+function c(e) {
+  return {
+    type: r,
+    payload: {
+      sourceId: e
+    }
+  };
+}
+function a(e) {
+  return {
+    type: t,
+    payload: {
+      targetId: e
+    }
+  };
+}
+export {
+  o as ADD_SOURCE,
+  n as ADD_TARGET,
+  r as REMOVE_SOURCE,
+  t as REMOVE_TARGET,
+  d as addSource,
+  E as addTarget,
+  c as removeSource,
+  a as removeTarget
+};

package/dist/node_modules/dnd-core/dist/classes/DragDropManagerImpl.js

@@ -0,0 +1,41 @@
+import { createDragDropActions as a } from "../actions/dragDrop/index.js";
+class p {
+  receiveBackend(t) {
+    this.backend = t;
+  }
+  getMonitor() {
+    return this.monitor;
+  }
+  getBackend() {
+    return this.backend;
+  }
+  getRegistry() {
+    return this.monitor.registry;
+  }
+  getActions() {
+    const t = this, { dispatch: r } = this.store;
+    function e(s) {
+      return (...i) => {
+        const n = s.apply(t, i);
+        typeof n < "u" && r(n);
+      };
+    }
+    const o = a(this);
+    return Object.keys(o).reduce((s, i) => {
+      const n = o[i];
+      return s[i] = e(n), s;
+    }, {});
+  }
+  dispatch(t) {
+    this.store.dispatch(t);
+  }
+  constructor(t, r) {
+    this.isSetUp = !1, this.handleRefCountChange = () => {
+      const e = this.store.getState().refCount > 0;
+      this.backend && (e && !this.isSetUp ? (this.backend.setup(), this.isSetUp = !0) : !e && this.isSetUp && (this.backend.teardown(), this.isSetUp = !1));
+    }, this.store = t, this.monitor = r, t.subscribe(this.handleRefCountChange);
+  }
+}
+export {
+  p as DragDropManagerImpl
+};

package/dist/node_modules/dnd-core/dist/classes/DragDropMonitorImpl.js

@@ -0,0 +1,115 @@
+import { invariant as a } from "../../../@react-dnd/invariant/dist/index.js";
+import { getSourceClientOffset as f, getDifferenceFromInitialOffset as u } from "../utils/coords.js";
+import { areDirty as c } from "../utils/dirtiness.js";
+import { matchesType as o } from "../utils/matchesType.js";
+class O {
+  subscribeToStateChange(t, e = {}) {
+    const { handlerIds: s } = e;
+    a(typeof t == "function", "listener must be a function."), a(typeof s > "u" || Array.isArray(s), "handlerIds, when specified, must be an array of strings.");
+    let r = this.store.getState().stateId;
+    const g = () => {
+      const i = this.store.getState(), n = i.stateId;
+      try {
+        n === r || n === r + 1 && !c(i.dirtyHandlerIds, s) || t();
+      } finally {
+        r = n;
+      }
+    };
+    return this.store.subscribe(g);
+  }
+  subscribeToOffsetChange(t) {
+    a(typeof t == "function", "listener must be a function.");
+    let e = this.store.getState().dragOffset;
+    const s = () => {
+      const r = this.store.getState().dragOffset;
+      r !== e && (e = r, t());
+    };
+    return this.store.subscribe(s);
+  }
+  canDragSource(t) {
+    if (!t)
+      return !1;
+    const e = this.registry.getSource(t);
+    return a(e, `Expected to find a valid source. sourceId=${t}`), this.isDragging() ? !1 : e.canDrag(this, t);
+  }
+  canDropOnTarget(t) {
+    if (!t)
+      return !1;
+    const e = this.registry.getTarget(t);
+    if (a(e, `Expected to find a valid target. targetId=${t}`), !this.isDragging() || this.didDrop())
+      return !1;
+    const s = this.registry.getTargetType(t), r = this.getItemType();
+    return o(s, r) && e.canDrop(this, t);
+  }
+  isDragging() {
+    return !!this.getItemType();
+  }
+  isDraggingSource(t) {
+    if (!t)
+      return !1;
+    const e = this.registry.getSource(t, !0);
+    if (a(e, `Expected to find a valid source. sourceId=${t}`), !this.isDragging() || !this.isSourcePublic())
+      return !1;
+    const s = this.registry.getSourceType(t), r = this.getItemType();
+    return s !== r ? !1 : e.isDragging(this, t);
+  }
+  isOverTarget(t, e = {
+    shallow: !1
+  }) {
+    if (!t)
+      return !1;
+    const { shallow: s } = e;
+    if (!this.isDragging())
+      return !1;
+    const r = this.registry.getTargetType(t), g = this.getItemType();
+    if (g && !o(r, g))
+      return !1;
+    const i = this.getTargetIds();
+    if (!i.length)
+      return !1;
+    const n = i.indexOf(t);
+    return s ? n === i.length - 1 : n > -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 f(this.store.getState().dragOffset);
+  }
+  getDifferenceFromInitialOffset() {
+    return u(this.store.getState().dragOffset);
+  }
+  constructor(t, e) {
+    this.store = t, this.registry = e;
+  }
+}
+export {
+  O as DragDropMonitorImpl
+};

package/dist/node_modules/dnd-core/dist/classes/HandlerRegistryImpl.js

@@ -0,0 +1,96 @@
+import { asap as p } from "../../../@react-dnd/asap/dist/asap.js";
+import { invariant as n } from "../../../@react-dnd/invariant/dist/index.js";
+import { addSource as h, addTarget as l, removeSource as g, removeTarget as S } from "../actions/registry.js";
+import { validateType as a, validateSourceContract as T, validateTargetContract as m } from "../contracts.js";
+import { HandlerRole as s } from "../interfaces.js";
+import { getNextUniqueId as E } from "../utils/getNextUniqueId.js";
+function f(i) {
+  const e = E().toString();
+  switch (i) {
+    case s.SOURCE:
+      return `S${e}`;
+    case s.TARGET:
+      return `T${e}`;
+    default:
+      throw new Error(`Unknown Handler Role: ${i}`);
+  }
+}
+function d(i) {
+  switch (i[0]) {
+    case "S":
+      return s.SOURCE;
+    case "T":
+      return s.TARGET;
+    default:
+      throw new Error(`Cannot parse handler ID: ${i}`);
+  }
+}
+function c(i, e) {
+  const t = i.entries();
+  let r = !1;
+  do {
+    const { done: o, value: [, u] } = t.next();
+    if (u === e)
+      return !0;
+    r = !!o;
+  } while (!r);
+  return !1;
+}
+class y {
+  addSource(e, t) {
+    a(e), T(t);
+    const r = this.addHandler(s.SOURCE, e, t);
+    return this.store.dispatch(h(r)), r;
+  }
+  addTarget(e, t) {
+    a(e, !0), m(t);
+    const r = this.addHandler(s.TARGET, e, t);
+    return this.store.dispatch(l(r)), r;
+  }
+  containsHandler(e) {
+    return c(this.dragSources, e) || c(this.dropTargets, e);
+  }
+  getSource(e, t = !1) {
+    return n(this.isSourceId(e), "Expected a valid source ID."), t && e === this.pinnedSourceId ? this.pinnedSource : this.dragSources.get(e);
+  }
+  getTarget(e) {
+    return n(this.isTargetId(e), "Expected a valid target ID."), this.dropTargets.get(e);
+  }
+  getSourceType(e) {
+    return n(this.isSourceId(e), "Expected a valid source ID."), this.types.get(e);
+  }
+  getTargetType(e) {
+    return n(this.isTargetId(e), "Expected a valid target ID."), this.types.get(e);
+  }
+  isSourceId(e) {
+    return d(e) === s.SOURCE;
+  }
+  isTargetId(e) {
+    return d(e) === s.TARGET;
+  }
+  removeSource(e) {
+    n(this.getSource(e), "Expected an existing source."), this.store.dispatch(g(e)), p(() => {
+      this.dragSources.delete(e), this.types.delete(e);
+    });
+  }
+  removeTarget(e) {
+    n(this.getTarget(e), "Expected an existing target."), this.store.dispatch(S(e)), this.dropTargets.delete(e), this.types.delete(e);
+  }
+  pinSource(e) {
+    const t = this.getSource(e);
+    n(t, "Expected an existing source."), this.pinnedSourceId = e, this.pinnedSource = t;
+  }
+  unpinSource() {
+    n(this.pinnedSource, "No source is pinned at the time."), this.pinnedSourceId = null, this.pinnedSource = null;
+  }
+  addHandler(e, t, r) {
+    const o = f(e);
+    return this.types.set(o, t), e === s.SOURCE ? this.dragSources.set(o, r) : e === s.TARGET && this.dropTargets.set(o, r), o;
+  }
+  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;
+  }
+}
+export {
+  y as HandlerRegistryImpl
+};

package/dist/node_modules/dnd-core/dist/contracts.js

@@ -0,0 +1,21 @@
+import { invariant as o } from "../../@react-dnd/invariant/dist/index.js";
+function c(n) {
+  o(typeof n.canDrag == "function", "Expected canDrag to be a function."), o(typeof n.beginDrag == "function", "Expected beginDrag to be a function."), o(typeof n.endDrag == "function", "Expected endDrag to be a function.");
+}
+function r(n) {
+  o(typeof n.canDrop == "function", "Expected canDrop to be a function."), o(typeof n.hover == "function", "Expected hover to be a function."), o(typeof n.drop == "function", "Expected beginDrag to be a function.");
+}
+function a(n, t) {
+  if (t && Array.isArray(n)) {
+    n.forEach(
+      (e) => a(e, !1)
+    );
+    return;
+  }
+  o(typeof n == "string" || typeof n == "symbol", t ? "Type can only be a string, a symbol, or an array of either." : "Type can only be a string or a symbol.");
+}
+export {
+  c as validateSourceContract,
+  r as validateTargetContract,
+  a as validateType
+};

package/dist/node_modules/dnd-core/dist/createDragDropManager.js

@@ -0,0 +1,19 @@
+import { createStore as d } from "../../redux/es/redux.js";
+import { DragDropManagerImpl as i } from "./classes/DragDropManagerImpl.js";
+import { DragDropMonitorImpl as p } from "./classes/DragDropMonitorImpl.js";
+import { HandlerRegistryImpl as f } from "./classes/HandlerRegistryImpl.js";
+import { reduce as s } from "./reducers/index.js";
+function _(r, e = void 0, t = {}, a = !1) {
+  const n = D(a), c = new p(n, new f(n)), o = new i(n, c), m = r(o, e, t);
+  return o.receiveBackend(m), o;
+}
+function D(r) {
+  const e = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION__;
+  return d(s, r && e && e({
+    name: "dnd-core",
+    instanceId: "dnd-core"
+  }));
+}
+export {
+  _ as createDragDropManager
+};

package/dist/node_modules/dnd-core/dist/interfaces.js

@@ -0,0 +1,7 @@
+var R;
+(function(E) {
+  E.SOURCE = "SOURCE", E.TARGET = "TARGET";
+})(R || (R = {}));
+export {
+  R as HandlerRole
+};

package/dist/node_modules/dnd-core/dist/reducers/dirtyHandlerIds.js

@@ -0,0 +1,30 @@
+import { REMOVE_SOURCE as c, REMOVE_TARGET as E, ADD_TARGET as i, ADD_SOURCE as m } from "../actions/registry.js";
+import { NONE as o, ALL as p } from "../utils/dirtiness.js";
+import { areArraysEqual as R } from "../utils/equality.js";
+import { xor as d } from "../utils/js_utils.js";
+import { DROP as f, END_DRAG as u, PUBLISH_DRAG_SOURCE as g, BEGIN_DRAG as A, HOVER as D } from "../actions/dragDrop/types.js";
+function C(_ = o, n) {
+  switch (n.type) {
+    case D:
+      break;
+    case m:
+    case i:
+    case E:
+    case c:
+      return o;
+    case A:
+    case g:
+    case u:
+    case f:
+    default:
+      return p;
+  }
+  const { targetIds: e = [], prevTargetIds: r = [] } = n.payload, t = d(e, r);
+  if (!(t.length > 0 || !R(e, r)))
+    return o;
+  const s = r[r.length - 1], a = e[e.length - 1];
+  return s !== a && (s && t.push(s), a && t.push(a)), t;
+}
+export {
+  C as reduce
+};

package/dist/node_modules/dnd-core/dist/reducers/dragOffset.js

@@ -0,0 +1,50 @@
+import { areCoordsEqual as l } from "../utils/equality.js";
+import { DROP as c, END_DRAG as u, HOVER as O, BEGIN_DRAG as a, INIT_COORDS as o } from "../actions/dragDrop/types.js";
+function s(t, n, e) {
+  return n in t ? Object.defineProperty(t, n, {
+    value: e,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[n] = e, t;
+}
+function p(t) {
+  for (var n = 1; n < arguments.length; n++) {
+    var e = arguments[n] != null ? arguments[n] : {}, f = Object.keys(e);
+    typeof Object.getOwnPropertySymbols == "function" && (f = f.concat(Object.getOwnPropertySymbols(e).filter(function(r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    }))), f.forEach(function(r) {
+      s(t, r, e[r]);
+    });
+  }
+  return t;
+}
+const i = {
+  initialSourceClientOffset: null,
+  initialClientOffset: null,
+  clientOffset: null
+};
+function d(t = i, n) {
+  const { payload: e } = n;
+  switch (n.type) {
+    case o:
+    case a:
+      return {
+        initialSourceClientOffset: e.sourceClientOffset,
+        initialClientOffset: e.clientOffset,
+        clientOffset: e.clientOffset
+      };
+    case O:
+      return l(t.clientOffset, e.clientOffset) ? t : p({}, t, {
+        clientOffset: e.clientOffset
+      });
+    case u:
+    case c:
+      return i;
+    default:
+      return t;
+  }
+}
+export {
+  d as reduce
+};