@ceed/cds 0.0.187-treeshaking.1 → 0.0.187

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/honey-pot-data-attribute.js

@@ -1,5 +0,0 @@
-// pulling this into a separate file so adapter(s) that don't
-// need the honey pot can pay as little as possible for it.
-var honeyPotDataAttribute = 'data-pdnd-honey-pot';
-
-export { honeyPotDataAttribute };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/is-honey-pot-element.js

@@ -1,7 +0,0 @@
-import { honeyPotDataAttribute } from './honey-pot-data-attribute.js';
-
-function isHoneyPotElement(target) {
-  return target instanceof Element && target.hasAttribute(honeyPotDataAttribute);
-}
-
-export { isHoneyPotElement };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/dispatch-consumer-event.js

@@ -1,128 +0,0 @@
-import rafSchd from '../../../../../raf-schd/dist/raf-schd.esm.js';
-
-var scheduleOnDrag = rafSchd(function (fn) {
-  return fn();
-});
-var dragStart = function () {
-  var scheduled = null;
-  function schedule(fn) {
-    var frameId = requestAnimationFrame(function () {
-      scheduled = null;
-      fn();
-    });
-    scheduled = {
-      frameId: frameId,
-      fn: fn
-    };
-  }
-  function flush() {
-    if (scheduled) {
-      cancelAnimationFrame(scheduled.frameId);
-      scheduled.fn();
-      scheduled = null;
-    }
-  }
-  return {
-    schedule: schedule,
-    flush: flush
-  };
-}();
-function makeDispatch(_ref) {
-  var source = _ref.source,
-    initial = _ref.initial,
-    dispatchEvent = _ref.dispatchEvent;
-  var previous = {
-    dropTargets: []
-  };
-  function safeDispatch(args) {
-    dispatchEvent(args);
-    previous = {
-      dropTargets: args.payload.location.current.dropTargets
-    };
-  }
-  var dispatch = {
-    start: function start(_ref2) {
-      var nativeSetDragImage = _ref2.nativeSetDragImage;
-      // Ensuring that both `onGenerateDragPreview` and `onDragStart` get the same location.
-      // We do this so that `previous` is`[]` in `onDragStart` (which is logical)
-      var location = {
-        current: initial,
-        previous: previous,
-        initial: initial
-      };
-      // a `onGenerateDragPreview` does _not_ add another entry for `previous`
-      // onDragPreview
-      safeDispatch({
-        eventName: 'onGenerateDragPreview',
-        payload: {
-          source: source,
-          location: location,
-          nativeSetDragImage: nativeSetDragImage
-        }
-      });
-      dragStart.schedule(function () {
-        safeDispatch({
-          eventName: 'onDragStart',
-          payload: {
-            source: source,
-            location: location
-          }
-        });
-      });
-    },
-    dragUpdate: function dragUpdate(_ref3) {
-      var current = _ref3.current;
-      dragStart.flush();
-      scheduleOnDrag.cancel();
-      safeDispatch({
-        eventName: 'onDropTargetChange',
-        payload: {
-          source: source,
-          location: {
-            initial: initial,
-            previous: previous,
-            current: current
-          }
-        }
-      });
-    },
-    drag: function drag(_ref4) {
-      var current = _ref4.current;
-      scheduleOnDrag(function () {
-        dragStart.flush();
-        var location = {
-          initial: initial,
-          previous: previous,
-          current: current
-        };
-        safeDispatch({
-          eventName: 'onDrag',
-          payload: {
-            source: source,
-            location: location
-          }
-        });
-      });
-    },
-    drop: function drop(_ref5) {
-      var current = _ref5.current,
-        updatedSourcePayload = _ref5.updatedSourcePayload;
-      dragStart.flush();
-      scheduleOnDrag.cancel();
-      safeDispatch({
-        eventName: 'onDrop',
-        payload: {
-          source: updatedSourcePayload !== null && updatedSourcePayload !== undefined ? updatedSourcePayload : source,
-          location: {
-            current: current,
-            previous: previous,
-            initial: initial
-          }
-        }
-      });
-    }
-  };
-  return dispatch;
-}
-
-export { makeDispatch };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/lifecycle-manager.js

@@ -1,340 +0,0 @@
-import _toConsumableArray from '../../../external/@babel/runtime/helpers/esm/toConsumableArray.js';
-import { d as distExports } from '../../../../../../_virtual/index.js';
-import { getElementFromPointWithoutHoneypot } from '../honey-pot-fix/get-element-from-point-without-honey-pot.js';
-import { isHoneyPotElement } from '../honey-pot-fix/is-honey-pot-element.js';
-import { isLeavingWindow } from '../util/changing-window/is-leaving-window.js';
-import { getBindingsForBrokenDrags } from '../util/detect-broken-drag.js';
-import { getInput } from '../util/get-input.js';
-import { makeDispatch } from './dispatch-consumer-event.js';
-
-var globalState = {
-  isActive: false
-};
-function canStart() {
-  return !globalState.isActive;
-}
-function getNativeSetDragImage(event) {
-  if (event.dataTransfer) {
-    // need to use `.bind` as `setDragImage` is required
-    // to be run with `event.dataTransfer` as the "this" context
-    return event.dataTransfer.setDragImage.bind(event.dataTransfer);
-  }
-  return null;
-}
-function hasHierarchyChanged(_ref) {
-  var current = _ref.current,
-    next = _ref.next;
-  if (current.length !== next.length) {
-    return true;
-  }
-  // not checking stickiness, data or dropEffect,
-  // just whether the hierarchy has changed
-  for (var i = 0; i < current.length; i++) {
-    if (current[i].element !== next[i].element) {
-      return true;
-    }
-  }
-  return false;
-}
-function start(_ref2) {
-  var event = _ref2.event,
-    dragType = _ref2.dragType,
-    getDropTargetsOver = _ref2.getDropTargetsOver,
-    dispatchEvent = _ref2.dispatchEvent;
-  if (!canStart()) {
-    return;
-  }
-  var initial = getStartLocation({
-    event: event,
-    dragType: dragType,
-    getDropTargetsOver: getDropTargetsOver
-  });
-  globalState.isActive = true;
-  var state = {
-    current: initial
-  };
-
-  // Setting initial drop effect for the drag
-  setDropEffectOnEvent({
-    event: event,
-    current: initial.dropTargets
-  });
-  var dispatch = makeDispatch({
-    source: dragType.payload,
-    dispatchEvent: dispatchEvent,
-    initial: initial
-  });
-  function updateState(next) {
-    // only looking at whether hierarchy has changed to determine whether something as 'changed'
-    var hasChanged = hasHierarchyChanged({
-      current: state.current.dropTargets,
-      next: next.dropTargets
-    });
-
-    // Always updating the state to include latest data, dropEffect and stickiness
-    // Only updating consumers if the hierarchy has changed in some way
-    // Consumers can get the latest data by using `onDrag`
-    state.current = next;
-    if (hasChanged) {
-      dispatch.dragUpdate({
-        current: state.current
-      });
-    }
-  }
-  function onUpdateEvent(event) {
-    var input = getInput(event);
-
-    // If we are over the honey pot, we need to get the element
-    // that the user would have been over if not for the honey pot
-    var target = isHoneyPotElement(event.target) ? getElementFromPointWithoutHoneypot({
-      x: input.clientX,
-      y: input.clientY
-    }) : event.target;
-    var nextDropTargets = getDropTargetsOver({
-      target: target,
-      input: input,
-      source: dragType.payload,
-      current: state.current.dropTargets
-    });
-    if (nextDropTargets.length) {
-      // 🩸 must call `event.preventDefault()` to allow a browser drop to occur
-      event.preventDefault();
-      setDropEffectOnEvent({
-        event: event,
-        current: nextDropTargets
-      });
-    }
-    updateState({
-      dropTargets: nextDropTargets,
-      input: input
-    });
-  }
-  function cancel() {
-    // The spec behaviour is that when a drag is cancelled, or when dropping on no drop targets,
-    // a "dragleave" event is fired on the active drop target before a "dragend" event.
-    // We are replicating that behaviour in `cancel` if there are any active drop targets to
-    // ensure consistent behaviour.
-    //
-    // Note: When cancelling, or dropping on no drop targets, a "dragleave" event
-    // will have already cleared the dropTargets to `[]` (as that particular "dragleave" has a `relatedTarget` of `null`)
-
-    if (state.current.dropTargets.length) {
-      updateState({
-        dropTargets: [],
-        input: state.current.input
-      });
-    }
-    dispatch.drop({
-      current: state.current,
-      updatedSourcePayload: null
-    });
-    finish();
-  }
-  function finish() {
-    globalState.isActive = false;
-    unbindEvents();
-  }
-  var unbindEvents = distExports.bindAll(window, [{
-    // 👋 Note: we are repurposing the `dragover` event as our `drag` event
-    // this is because firefox does not publish pointer coordinates during
-    // a `drag` event, but does for every other type of drag event
-    // `dragover` fires on all elements that are being dragged over
-    // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
-    // 🦊😤
-    type: 'dragover',
-    listener: function listener(event) {
-      // We need to regularly calculate the drop targets in order to allow:
-      //  - dynamic `canDrop()` checks
-      //  - rapid updating `getData()` calls to attach data in response to user input (eg for edge detection)
-      // Sadly we cannot schedule inspecting changes resulting from this event
-      // we need to be able to conditionally cancel the event with `event.preventDefault()`
-      // to enable the correct native drop experience.
-
-      // 1. check to see if anything has changed
-      onUpdateEvent(event);
-
-      // 2. let consumers know a move has occurred
-      // This will include the latest 'input' values
-      dispatch.drag({
-        current: state.current
-      });
-    }
-  }, {
-    type: 'dragenter',
-    listener: onUpdateEvent
-  }, {
-    type: 'dragleave',
-    listener: function listener(event) {
-      if (!isLeavingWindow({
-        dragLeave: event
-      })) {
-        return;
-      }
-
-      /**
-       * At this point we don't know if a drag is being cancelled,
-       * or if a drag is leaving the `window`.
-       *
-       * Both have:
-       *   1. "dragleave" (with `relatedTarget: null`)
-       *   2. "dragend" (a "dragend" can occur when outside the `window`)
-       *
-       * **Clearing drop targets**
-       *
-       * For either case we are clearing the the drop targets
-       *
-       * - cancelling: we clear drop targets in `"dragend"` anyway
-       * - leaving the `window`: we clear the drop targets (to clear stickiness)
-       *
-       * **Leaving the window and finishing the drag**
-       *
-       * _internal drags_
-       *
-       * - The drag continues when the user is outside the `window`
-       *   and can resume if the user drags back over the `window`,
-       *   or end when the user drops in an external `window`.
-       * - We will get a `"dragend"`, or we can listen for other
-       *   events to determine the drag is finished when the user re-enters the `window`).
-       *
-       * _external drags_
-       *
-       * - We conclude the drag operation.
-       * - We have no idea if the user will drag back over the `window`,
-       *   or if the drag ends elsewhere.
-       * - We will create a new drag if the user re-enters the `window`.
-       *
-       * **Not updating `input`**
-       *
-       * 🐛 Bug[Chrome] the final `"dragleave"` has default input values (eg `clientX == 0`)
-       * Workaround: intentionally not updating `input` in "dragleave"
-       * rather than the users current input values
-       * - [Conversation](https://twitter.com/alexandereardon/status/1642697633864241152)
-       * - [Bug](https://bugs.chromium.org/p/chromium/issues/detail?id=1429937)
-       **/
-
-      updateState({
-        input: state.current.input,
-        dropTargets: []
-      });
-      if (dragType.startedFrom === 'external') {
-        cancel();
-      }
-    }
-  }, {
-    // A "drop" can only happen if the browser allowed the drop
-    type: 'drop',
-    listener: function listener(event) {
-      // Capture the final input.
-      // We are capturing the final `input` for the
-      // most accurate honey pot experience
-      state.current = {
-        dropTargets: state.current.dropTargets,
-        input: getInput(event)
-      };
-
-      /** If there are no drop targets, then we will get
-       * a "drop" event if:
-       * - `preventUnhandled()` is being used
-       * - there is an unmanaged drop target (eg another library)
-       * In these cases, it's up to the consumer
-       * to handle the drop if it's not over one of our drop targets
-       * - `preventUnhandled()` will cancel the "drop"
-       * - unmanaged drop targets can handle the "drop" how they want to
-       * We won't call `event.preventDefault()` in this call path */
-
-      if (!state.current.dropTargets.length) {
-        cancel();
-        return;
-      }
-      event.preventDefault();
-
-      // applying the latest drop effect to the event
-      setDropEffectOnEvent({
-        event: event,
-        current: state.current.dropTargets
-      });
-      dispatch.drop({
-        current: state.current,
-        // When dropping something native, we need to extract the latest
-        // `.items` from the "drop" event as it is now accessible
-        updatedSourcePayload: dragType.type === 'external' ? dragType.getDropPayload(event) : null
-      });
-      finish();
-    }
-  }, {
-    // "dragend" fires when on the drag source (eg a draggable element)
-    // when the drag is finished.
-    // "dragend" will fire after "drop" (if there was a successful drop)
-    // "dragend" does not fire if the draggable source has been removed during the drag
-    // or for external drag sources (eg files)
-
-    // This "dragend" listener will not fire if there was a successful drop
-    // as we will have already removed the event listener
-
-    type: 'dragend',
-    listener: function listener(event) {
-      // In firefox, the position of the "dragend" event can
-      // be a bit different to the last "dragover" event.
-      // Updating the input so we can get the best possible
-      // information for the honey pot.
-      state.current = {
-        dropTargets: state.current.dropTargets,
-        input: getInput(event)
-      };
-      cancel();
-    }
-  }].concat(_toConsumableArray(getBindingsForBrokenDrags({
-    onDragEnd: cancel
-  }))),
-  // Once we have started a managed drag operation it is important that we see / own all drag events
-  // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
-  // all "drop" events in the bubble phase on the `document.body`.
-  // This meant that we never saw the "drop" event.
-  {
-    capture: true
-  });
-  dispatch.start({
-    nativeSetDragImage: getNativeSetDragImage(event)
-  });
-}
-function setDropEffectOnEvent(_ref3) {
-  var _current$;
-  var event = _ref3.event,
-    current = _ref3.current;
-  // setting the `dropEffect` to be the innerMost drop targets dropEffect
-  var innerMost = (_current$ = current[0]) === null || _current$ === undefined ? undefined : _current$.dropEffect;
-  if (innerMost != null && event.dataTransfer) {
-    event.dataTransfer.dropEffect = innerMost;
-  }
-}
-function getStartLocation(_ref4) {
-  var event = _ref4.event,
-    dragType = _ref4.dragType,
-    getDropTargetsOver = _ref4.getDropTargetsOver;
-  var input = getInput(event);
-
-  // When dragging from outside of the browser,
-  // the drag is not being sourced from any local drop targets
-  if (dragType.startedFrom === 'external') {
-    return {
-      input: input,
-      dropTargets: []
-    };
-  }
-  var dropTargets = getDropTargetsOver({
-    input: input,
-    source: dragType.payload,
-    target: event.target,
-    current: []
-  });
-  return {
-    input: input,
-    dropTargets: dropTargets
-  };
-}
-var lifecycle = {
-  canStart: canStart,
-  start: start
-};
-
-export { lifecycle };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/usage-ledger.js

@@ -1,33 +0,0 @@
-// Extending `Map` to allow us to link Key and Values together
-
-var ledger = new Map();
-function registerUsage(_ref) {
-  var typeKey = _ref.typeKey,
-    mount = _ref.mount;
-  var entry = ledger.get(typeKey);
-  if (entry) {
-    entry.usageCount++;
-    return entry;
-  }
-  var initial = {
-    typeKey: typeKey,
-    unmount: mount(),
-    usageCount: 1
-  };
-  ledger.set(typeKey, initial);
-  return initial;
-}
-function register(args) {
-  var entry = registerUsage(args);
-  return function unregister() {
-    entry.usageCount--;
-    if (entry.usageCount > 0) {
-      return;
-    }
-    // Only a single usage left, remove it
-    entry.unmount();
-    ledger.delete(args.typeKey);
-  };
-}
-
-export { register };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/make-adapter/make-adapter.js

@@ -1,60 +0,0 @@
-import { lifecycle } from '../ledger/lifecycle-manager.js';
-import { register } from '../ledger/usage-ledger.js';
-import { makeDropTarget } from './make-drop-target.js';
-import { makeMonitor } from './make-monitor.js';
-
-function makeAdapter(_ref) {
-  var typeKey = _ref.typeKey,
-    mount = _ref.mount,
-    dispatchEventToSource = _ref.dispatchEventToSource,
-    onPostDispatch = _ref.onPostDispatch,
-    defaultDropEffect = _ref.defaultDropEffect;
-  var monitorAPI = makeMonitor();
-  var dropTargetAPI = makeDropTarget({
-    typeKey: typeKey,
-    defaultDropEffect: defaultDropEffect
-  });
-  function dispatchEvent(args) {
-    // 1. forward the event to source
-    dispatchEventToSource === null || dispatchEventToSource === undefined || dispatchEventToSource(args);
-
-    // 2. forward the event to relevant dropTargets
-    dropTargetAPI.dispatchEvent(args);
-
-    // 3. forward event to monitors
-    monitorAPI.dispatchEvent(args);
-
-    // 4. post consumer dispatch (used for honey pot fix)
-    onPostDispatch === null || onPostDispatch === undefined || onPostDispatch(args);
-  }
-  function start(_ref2) {
-    var event = _ref2.event,
-      dragType = _ref2.dragType;
-    lifecycle.start({
-      event: event,
-      dragType: dragType,
-      getDropTargetsOver: dropTargetAPI.getIsOver,
-      dispatchEvent: dispatchEvent
-    });
-  }
-  function registerUsage() {
-    function mountAdapter() {
-      var api = {
-        canStart: lifecycle.canStart,
-        start: start
-      };
-      return mount(api);
-    }
-    return register({
-      typeKey: typeKey,
-      mount: mountAdapter
-    });
-  }
-  return {
-    registerUsage: registerUsage,
-    dropTarget: dropTargetAPI.dropTargetForConsumers,
-    monitor: monitorAPI.monitorForConsumers
-  };
-}
-
-export { makeAdapter };