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

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

@@ -0,0 +1,78 @@
+import { REMOVE_TARGET as i } from "../actions/registry.js";
+import { without as o } from "../utils/js_utils.js";
+import { END_DRAG as c, DROP as d, HOVER as s, PUBLISH_DRAG_SOURCE as p, BEGIN_DRAG as a } from "../actions/dragDrop/types.js";
+function f(e, t, r) {
+  return t in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+function u(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {}, l = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (l = l.concat(Object.getOwnPropertySymbols(r).filter(function(n) {
+      return Object.getOwnPropertyDescriptor(r, n).enumerable;
+    }))), l.forEach(function(n) {
+      f(e, n, r[n]);
+    });
+  }
+  return e;
+}
+const m = {
+  itemType: null,
+  item: null,
+  sourceId: null,
+  targetIds: [],
+  dropResult: null,
+  didDrop: !1,
+  isSourcePublic: null
+};
+function O(e = m, t) {
+  const { payload: r } = t;
+  switch (t.type) {
+    case a:
+      return u({}, e, {
+        itemType: r.itemType,
+        item: r.item,
+        sourceId: r.sourceId,
+        isSourcePublic: r.isSourcePublic,
+        dropResult: null,
+        didDrop: !1
+      });
+    case p:
+      return u({}, e, {
+        isSourcePublic: !0
+      });
+    case s:
+      return u({}, e, {
+        targetIds: r.targetIds
+      });
+    case i:
+      return e.targetIds.indexOf(r.targetId) === -1 ? e : u({}, e, {
+        targetIds: o(e.targetIds, r.targetId)
+      });
+    case d:
+      return u({}, e, {
+        dropResult: r.dropResult,
+        didDrop: !0,
+        targetIds: []
+      });
+    case c:
+      return u({}, e, {
+        itemType: null,
+        item: null,
+        sourceId: null,
+        dropResult: null,
+        didDrop: !1,
+        isSourcePublic: null,
+        targetIds: []
+      });
+    default:
+      return e;
+  }
+}
+export {
+  O as reduce
+};

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

@@ -0,0 +1,42 @@
+import { get as u } from "../utils/js_utils.js";
+import { reduce as o } from "./dirtyHandlerIds.js";
+import { reduce as f } from "./dragOffset.js";
+import { reduce as a } from "./dragOperation.js";
+import { reduce as p } from "./refCount.js";
+import { reduce as c } from "./stateId.js";
+function i(r, e, t) {
+  return e in r ? Object.defineProperty(r, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[e] = t, r;
+}
+function m(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {}, d = Object.keys(t);
+    typeof Object.getOwnPropertySymbols == "function" && (d = d.concat(Object.getOwnPropertySymbols(t).filter(function(n) {
+      return Object.getOwnPropertyDescriptor(t, n).enumerable;
+    }))), d.forEach(function(n) {
+      i(r, n, t[n]);
+    });
+  }
+  return r;
+}
+function I(r = {}, e) {
+  return {
+    dirtyHandlerIds: o(r.dirtyHandlerIds, {
+      type: e.type,
+      payload: m({}, e.payload, {
+        prevTargetIds: u(r, "dragOperation.targetIds", [])
+      })
+    }),
+    dragOffset: f(r.dragOffset, e),
+    refCount: p(r.refCount, e),
+    dragOperation: a(r.dragOperation, e),
+    stateId: c(r.stateId)
+  };
+}
+export {
+  I as reduce
+};

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

@@ -0,0 +1,16 @@
+import { REMOVE_TARGET as E, REMOVE_SOURCE as c, ADD_TARGET as u, ADD_SOURCE as R } from "../actions/registry.js";
+function t(e = 0, r) {
+  switch (r.type) {
+    case R:
+    case u:
+      return e + 1;
+    case c:
+    case E:
+      return e - 1;
+    default:
+      return e;
+  }
+}
+export {
+  t as reduce
+};

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

@@ -0,0 +1,6 @@
+function r(e = 0) {
+  return e + 1;
+}
+export {
+  r as reduce
+};

package/dist/node_modules/dnd-core/dist/utils/coords.js

@@ -0,0 +1,26 @@
+function r(n, t) {
+  return {
+    x: n.x + t.x,
+    y: n.y + t.y
+  };
+}
+function f(n, t) {
+  return {
+    x: n.x - t.x,
+    y: n.y - t.y
+  };
+}
+function u(n) {
+  const { clientOffset: t, initialClientOffset: e, initialSourceClientOffset: i } = n;
+  return !t || !e || !i ? null : f(r(t, i), e);
+}
+function l(n) {
+  const { clientOffset: t, initialClientOffset: e } = n;
+  return !t || !e ? null : f(t, e);
+}
+export {
+  r as add,
+  l as getDifferenceFromInitialOffset,
+  u as getSourceClientOffset,
+  f as subtract
+};

package/dist/node_modules/dnd-core/dist/utils/dirtiness.js

@@ -0,0 +1,12 @@
+import { intersection as r } from "./js_utils.js";
+const n = [], o = [];
+n.__IS_NONE__ = !0;
+o.__IS_ALL__ = !0;
+function c(t, e) {
+  return t === n ? !1 : t === o || typeof e > "u" ? !0 : r(e, t).length > 0;
+}
+export {
+  o as ALL,
+  n as NONE,
+  c as areDirty
+};

package/dist/node_modules/dnd-core/dist/utils/equality.js

@@ -0,0 +1,17 @@
+const u = (r, e) => r === e;
+function l(r, e) {
+  return !r && !e ? !0 : !r || !e ? !1 : r.x === e.x && r.y === e.y;
+}
+function i(r, e, t = u) {
+  if (r.length !== e.length)
+    return !1;
+  for (let n = 0; n < r.length; ++n)
+    if (!t(r[n], e[n]))
+      return !1;
+  return !0;
+}
+export {
+  i as areArraysEqual,
+  l as areCoordsEqual,
+  u as strictEquality
+};

package/dist/node_modules/dnd-core/dist/utils/getNextUniqueId.js

@@ -0,0 +1,7 @@
+let e = 0;
+function t() {
+  return e++;
+}
+export {
+  t as getNextUniqueId
+};

package/dist/node_modules/dnd-core/dist/utils/js_utils.js

@@ -0,0 +1,36 @@
+function f(n, e, t) {
+  return e.split(".").reduce(
+    (r, o) => r && r[o] ? r[o] : t || null,
+    n
+  );
+}
+function i(n, e) {
+  return n.filter(
+    (t) => t !== e
+  );
+}
+function s(n) {
+  return typeof n == "object";
+}
+function h(n, e) {
+  const t = /* @__PURE__ */ new Map(), r = (u) => {
+    t.set(u, t.has(u) ? t.get(u) + 1 : 1);
+  };
+  n.forEach(r), e.forEach(r);
+  const o = [];
+  return t.forEach((u, c) => {
+    u === 1 && o.push(c);
+  }), o;
+}
+function l(n, e) {
+  return n.filter(
+    (t) => e.indexOf(t) > -1
+  );
+}
+export {
+  f as get,
+  l as intersection,
+  s as isObject,
+  i as without,
+  h as xor
+};

package/dist/node_modules/dnd-core/dist/utils/matchesType.js

@@ -0,0 +1,8 @@
+function r(n, u) {
+  return u === null ? n === null : Array.isArray(n) ? n.some(
+    (l) => l === u
+  ) : n === u;
+}
+export {
+  r as matchesType
+};

package/dist/node_modules/fast-deep-equal/index.js

@@ -0,0 +1,31 @@
+var o, c;
+function l() {
+  return c || (c = 1, o = function n(r, e) {
+    if (r === e) return !0;
+    if (r && e && typeof r == "object" && typeof e == "object") {
+      if (r.constructor !== e.constructor) return !1;
+      var u, t, f;
+      if (Array.isArray(r)) {
+        if (u = r.length, u != e.length) return !1;
+        for (t = u; t-- !== 0; )
+          if (!n(r[t], e[t])) return !1;
+        return !0;
+      }
+      if (r.constructor === RegExp) return r.source === e.source && r.flags === e.flags;
+      if (r.valueOf !== Object.prototype.valueOf) return r.valueOf() === e.valueOf();
+      if (r.toString !== Object.prototype.toString) return r.toString() === e.toString();
+      if (f = Object.keys(r), u = f.length, u !== Object.keys(e).length) return !1;
+      for (t = u; t-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(e, f[t])) return !1;
+      for (t = u; t-- !== 0; ) {
+        var s = f[t];
+        if (!n(r[s], e[s])) return !1;
+      }
+      return !0;
+    }
+    return r !== r && e !== e;
+  }), o;
+}
+export {
+  l as __require
+};