@ceed/cds 0.0.186 → 0.0.187-cjs.0

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/count-events-for-safari.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var index = require('../../../../../../../_virtual/index.js');
+var isSafari = require('../is-safari.js');
+
+/* For "dragenter" events, the browser should set `relatedTarget` to the previous element.
+ * For external drag operations, our first "dragenter" event should have a `event.relatedTarget` of `null`.
+ *
+ *  Unfortunately in Safari `event.relatedTarget` is *always* set to `null`
+ *  Safari bug: https://bugs.webkit.org/show_bug.cgi?id=242627
+ *  To work around this we count "dragenter" and "dragleave" events */
+
+// Using symbols for event properties so we don't clash with
+// anything on the `event` object
+var symbols = {
+  isLeavingWindow: Symbol('leaving'),
+  isEnteringWindow: Symbol('entering')
+};
+function isEnteringWindowInSafari(_ref) {
+  var dragEnter = _ref.dragEnter;
+  if (!isSafari.isSafari()) {
+    return false;
+  }
+  return dragEnter.hasOwnProperty(symbols.isEnteringWindow);
+}
+function isLeavingWindowInSafari(_ref2) {
+  var dragLeave = _ref2.dragLeave;
+  if (!isSafari.isSafari()) {
+    return false;
+  }
+  return dragLeave.hasOwnProperty(symbols.isLeavingWindow);
+}
+(function fixSafari() {
+  // Don't do anything when server side rendering
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  // rather than checking the userAgent for "jsdom" we can do this check
+  // so that the check will be removed completely in production code
+  if (process.env.NODE_ENV === 'test') {
+    return;
+  }
+  if (!isSafari.isSafari()) {
+    return;
+  }
+  function getInitialState() {
+    return {
+      enterCount: 0,
+      isOverWindow: false
+    };
+  }
+  var state = getInitialState();
+  function resetState() {
+    state = getInitialState();
+  }
+
+  // These event listeners are bound _forever_ and _never_ removed
+  // We don't bother cleaning up these event listeners (for now)
+  // as this workaround is only for Safari
+
+  // This is how the event count works:
+  //
+  // lift (+1 enterCount)
+  // - dragstart(draggable) [enterCount: 0]
+  // - dragenter(draggable) [enterCount: 1]
+  // leaving draggable (+0 enterCount)
+  // - dragenter(document.body) [enterCount: 2]
+  // - dragleave(draggable) [enterCount: 1]
+  // leaving window (-1 enterCount)
+  // - dragleave(document.body) [enterCount: 0] {leaving the window}
+
+  // Things to note:
+  // - dragenter and dragleave bubble
+  // - the first dragenter when entering a window might not be on `window`
+  //   - it could be on an element that is pressed up against the window
+  //   - (so we cannot rely on `event.target` values)
+
+  index.distExports.bindAll(window, [{
+    type: 'dragstart',
+    listener: function listener() {
+      state.enterCount = 0;
+      // drag start occurs in the source window
+      state.isOverWindow = true;
+      // When a drag first starts it will also trigger a "dragenter" on the draggable element
+    }
+  }, {
+    type: 'drop',
+    listener: resetState
+  }, {
+    type: 'dragend',
+    listener: resetState
+  }, {
+    type: 'dragenter',
+    listener: function listener(event) {
+      if (!state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object
+        // The `event` object is shared with all event listeners for the event
+        // @ts-expect-error: adding property to the event object
+        event[symbols.isEnteringWindow] = true;
+      }
+      state.isOverWindow = true;
+      state.enterCount++;
+    }
+  }, {
+    type: 'dragleave',
+    listener: function listener(event) {
+      state.enterCount--;
+      if (state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object as it is shared with all event listeners
+        // The `event` object is shared with all event listeners for the event
+        // @ts-expect-error: adding property to the event object
+        event[symbols.isLeavingWindow] = true;
+        state.isOverWindow = false;
+      }
+    }
+  }],
+  // using `capture: true` so that adding event listeners
+  // in bubble phase will have the correct symbols
+  {
+    capture: true
+  });
+})();
+
+exports.isEnteringWindowInSafari = isEnteringWindowInSafari;
+exports.isLeavingWindowInSafari = isLeavingWindowInSafari;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-entering-window.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var isFirefox = require('../is-firefox.js');
+var isSafari = require('../is-safari.js');
+var countEventsForSafari = require('./count-events-for-safari.js');
+var isFromAnotherWindow = require('./is-from-another-window.js');
+
+function isEnteringWindow(_ref) {
+  var dragEnter = _ref.dragEnter;
+  var type = dragEnter.type,
+    relatedTarget = dragEnter.relatedTarget;
+  if (type !== 'dragenter') {
+    return false;
+  }
+  if (isSafari.isSafari()) {
+    return countEventsForSafari.isEnteringWindowInSafari({
+      dragEnter: dragEnter
+    });
+  }
+
+  // standard check
+  if (relatedTarget == null) {
+    return true;
+  }
+
+  /**
+   * 🦊 Exception: `iframe` in Firefox (`125.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `relatedTarget` is the `iframe` element in the parent `window`
+   * (foreign element)
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `relatedTarget` is an element inside the child `iframe`
+   * (foreign element)
+   */
+
+  if (isFirefox.isFirefox()) {
+    return isFromAnotherWindow.isFromAnotherWindow(relatedTarget);
+  }
+
+  /**
+   * 🌏 Exception: `iframe` in Chrome (`124.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `relatedTarget` is `null` *(standard check)*
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `relatedTarget` is the `iframe` element in the parent `window`
+   */
+
+  // Case 2
+  // Using `instanceof` check as the element will be in the same `window`
+  return relatedTarget instanceof HTMLIFrameElement;
+}
+
+exports.isEnteringWindow = isEnteringWindow;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-from-another-window.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * Does the `EventTarget` look like a `Node` based on "duck typing".
+ *
+ * Helpful when the `Node` might be outside of the current document
+ * so we cannot to an `target instanceof Node` check.
+ */
+function isNodeLike(target) {
+  return 'nodeName' in target;
+}
+
+/**
+ * Is an `EventTarget` a `Node` from another `window`?
+ */
+function isFromAnotherWindow(eventTarget) {
+  return isNodeLike(eventTarget) && eventTarget.ownerDocument !== document;
+}
+
+exports.isFromAnotherWindow = isFromAnotherWindow;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-leaving-window.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var isFirefox = require('../is-firefox.js');
+var isSafari = require('../is-safari.js');
+var countEventsForSafari = require('./count-events-for-safari.js');
+var isFromAnotherWindow = require('./is-from-another-window.js');
+
+function isLeavingWindow(_ref) {
+  var dragLeave = _ref.dragLeave;
+  var type = dragLeave.type,
+    relatedTarget = dragLeave.relatedTarget;
+  if (type !== 'dragleave') {
+    return false;
+  }
+  if (isSafari.isSafari()) {
+    return countEventsForSafari.isLeavingWindowInSafari({
+      dragLeave: dragLeave
+    });
+  }
+
+  // Standard check: if going to `null` we are leaving the `window`
+  if (relatedTarget == null) {
+    return true;
+  }
+
+  /**
+   * 🦊 Exception: `iframe` in Firefox (`125.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `dragLeave.relatedTarget` is element _inside_ the child `iframe`
+   * (foreign element)
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
+   * (foreign element)
+   */
+
+  if (isFirefox.isFirefox()) {
+    return isFromAnotherWindow.isFromAnotherWindow(relatedTarget);
+  }
+
+  /**
+   * 🌏 Exception: `iframe` in Chrome (`124.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `dragLeave.relatedTarget` is `null` *(standard check)*
+   */
+
+  // Case 2
+  // Using `instanceof` check as the element will be in the same `window`
+  return relatedTarget instanceof HTMLIFrameElement;
+}
+
+exports.isLeavingWindow = isLeavingWindow;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/detect-broken-drag.js

@@ -0,0 +1,51 @@
+'use strict';
+
+function getBindingsForBrokenDrags(_ref) {
+  var onDragEnd = _ref.onDragEnd;
+  return [
+  // ## Detecting drag ending for removed draggables
+  //
+  // If a draggable element is removed during a drag and the user drops:
+  // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+  // 2. if not over a valid drop target (or cancelled): we get nothing
+  // The "dragend" event will not fire on the source draggable if it has been
+  // removed from the DOM.
+  // So we need to figure out if a drag operation has finished by looking at other events
+  // We can do this by looking at other events
+
+  // ### First detection: "pointermove" events
+
+  // 1. "pointermove" events cannot fire during a drag and drop operation
+  // according to the spec. So if we get a "pointermove" it means that
+  // the drag and drop operations has finished. So if we get a "pointermove"
+  // we know that the drag is over
+  // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+  // other pointer events. However, firefox will allow a few
+  // pointer event to get through after a drag starts.
+  // The most I've seen is 3
+  {
+    type: 'pointermove',
+    listener: function () {
+      var callCount = 0;
+      return function listener() {
+        // Using 20 as it is far bigger than the most observed (3)
+        if (callCount < 20) {
+          callCount++;
+          return;
+        }
+        onDragEnd();
+      };
+    }()
+  },
+  // ### Second detection: "pointerdown" events
+
+  // If we receive this event then we know that a drag operation has finished
+  // and potentially another one is about to start.
+  // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+  {
+    type: 'pointerdown',
+    listener: onDragEnd
+  }];
+}
+
+exports.getBindingsForBrokenDrags = getBindingsForBrokenDrags;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/get-input.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function getInput(event) {
+  return {
+    altKey: event.altKey,
+    button: event.button,
+    buttons: event.buttons,
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey,
+    shiftKey: event.shiftKey,
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pageX: event.pageX,
+    pageY: event.pageY
+  };
+}
+
+exports.getInput = getInput;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-firefox.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var once = require('../public-utils/once.js');
+
+// using `cache` as our `isFirefox()` result will not change in a browser
+
+/**
+ * Returns `true` if a `Firefox` browser
+ * */
+var isFirefox = once.once(function isFirefox() {
+  if (process.env.NODE_ENV === 'test') {
+    return false;
+  }
+  return navigator.userAgent.includes('Firefox');
+});
+
+exports.isFirefox = isFirefox;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-safari.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var once = require('../public-utils/once.js');
+
+// using `cache` as our `isSafari()` result will not change in a browser
+
+/**
+ * Returns `true` if a `Safari` browser.
+ * Returns `true` if the browser is running on iOS (they are all Safari).
+ * */
+var isSafari = once.once(function isSafari() {
+  if (process.env.NODE_ENV === 'test') {
+    return false;
+  }
+  var _navigator = navigator,
+    userAgent = _navigator.userAgent;
+  return userAgent.includes('AppleWebKit') && !userAgent.includes('Chrome');
+});
+
+exports.isSafari = isSafari;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/media-types/text-media-type.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// Why we put the media types in their own files:
+//
+// - we are not putting them all in one file as not all adapters need all types
+// - we are not putting them in the external helpers as some things just need the
+//   types and not the external functions code
+var textMediaType = 'text/plain';
+
+exports.textMediaType = textMediaType;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/arrayLikeToArray.js

@@ -0,0 +1,9 @@
+'use strict';
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+module.exports = _arrayLikeToArray;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/arrayWithHoles.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var arrayLikeToArray = require('./arrayLikeToArray.js');
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return arrayLikeToArray(arr);
+}
+
+module.exports = _arrayWithoutHoles;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/defineProperty.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var toPropertyKey = require('./toPropertyKey.js');
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+module.exports = _defineProperty;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/iterableToArray.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+module.exports = _iterableToArray;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/iterableToArrayLimit.js

@@ -0,0 +1,28 @@
+'use strict';
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+module.exports = _iterableToArrayLimit;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/nonIterableRest.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableRest;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/nonIterableSpread.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableSpread;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/slicedToArray.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var arrayWithHoles = require('./arrayWithHoles.js');
+var iterableToArrayLimit = require('./iterableToArrayLimit.js');
+var unsupportedIterableToArray = require('./unsupportedIterableToArray.js');
+var nonIterableRest = require('./nonIterableRest.js');
+
+function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/toConsumableArray.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var arrayWithoutHoles = require('./arrayWithoutHoles.js');
+var iterableToArray = require('./iterableToArray.js');
+var unsupportedIterableToArray = require('./unsupportedIterableToArray.js');
+var nonIterableSpread = require('./nonIterableSpread.js');
+
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/toPrimitive.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var _typeof = require('./typeof.js');
+
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (undefined !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+module.exports = toPrimitive;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/toPropertyKey.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var _typeof = require('./typeof.js');
+var toPrimitive = require('./toPrimitive.js');
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+
+module.exports = toPropertyKey;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/typeof.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+module.exports = _typeof;

package/dist/external/@atlaskit/pragmatic-drag-and-drop/external/@babel/runtime/helpers/esm/unsupportedIterableToArray.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var arrayLikeToArray = require('./arrayLikeToArray.js');
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}
+
+module.exports = _unsupportedIterableToArray;

package/dist/external/@babel/runtime/helpers/esm/extends.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+module.exports = _extends;

package/dist/external/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+module.exports = _objectWithoutPropertiesLoose;

package/dist/external/@babel/runtime/helpers/extends.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var _extends = require('../../../../_virtual/extends.js');
+
+var hasRequired_extends;
+
+function require_extends () {
+	if (hasRequired_extends) return _extends.__module.exports;
+	hasRequired_extends = 1;
+	(function (module) {
+		function _extends() {
+		  module.exports = _extends = Object.assign ? Object.assign.bind() : function (target) {
+		    for (var i = 1; i < arguments.length; i++) {
+		      var source = arguments[i];
+		      for (var key in source) {
+		        if (Object.prototype.hasOwnProperty.call(source, key)) {
+		          target[key] = source[key];
+		        }
+		      }
+		    }
+		    return target;
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+		  return _extends.apply(this, arguments);
+		}
+		module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (_extends.__module));
+	return _extends.__module.exports;
+}
+
+exports.__require = require_extends;

package/dist/external/@babel/runtime/helpers/interopRequireDefault.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var interopRequireDefault = require('../../../../_virtual/interopRequireDefault.js');
+
+var hasRequiredInteropRequireDefault;
+
+function requireInteropRequireDefault () {
+	if (hasRequiredInteropRequireDefault) return interopRequireDefault.__module.exports;
+	hasRequiredInteropRequireDefault = 1;
+	(function (module) {
+		function _interopRequireDefault(obj) {
+		  return obj && obj.__esModule ? obj : {
+		    "default": obj
+		  };
+		}
+		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (interopRequireDefault.__module));
+	return interopRequireDefault.__module.exports;
+}
+
+exports.__require = requireInteropRequireDefault;