@ceed/cds 0.0.185 → 0.0.187-cjs.0

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

@@ -0,0 +1,130 @@
+'use strict';
+
+var rafSchd_esm = require('../../../../../raf-schd/dist/raf-schd.esm.js');
+
+var scheduleOnDrag = rafSchd_esm(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;
+}
+
+exports.makeDispatch = makeDispatch;

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

@@ -0,0 +1,342 @@
+'use strict';
+
+var toConsumableArray = require('../../../external/@babel/runtime/helpers/esm/toConsumableArray.js');
+var index = require('../../../../../../_virtual/index.js');
+var getElementFromPointWithoutHoneyPot = require('../honey-pot-fix/get-element-from-point-without-honey-pot.js');
+var isHoneyPotElement = require('../honey-pot-fix/is-honey-pot-element.js');
+var isLeavingWindow = require('../util/changing-window/is-leaving-window.js');
+var detectBrokenDrag = require('../util/detect-broken-drag.js');
+var getInput = require('../util/get-input.js');
+var dispatchConsumerEvent = require('./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 = dispatchConsumerEvent.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.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.isHoneyPotElement(event.target) ? getElementFromPointWithoutHoneyPot.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 = index.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.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.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.getInput(event)
+      };
+      cancel();
+    }
+  }].concat(toConsumableArray(detectBrokenDrag.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.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
+};
+
+exports.lifecycle = lifecycle;

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

@@ -0,0 +1,35 @@
+'use strict';
+
+// 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);
+  };
+}
+
+exports.register = register;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+var lifecycleManager = require('../ledger/lifecycle-manager.js');
+var usageLedger = require('../ledger/usage-ledger.js');
+var makeDropTarget = require('./make-drop-target.js');
+var makeMonitor = require('./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.makeMonitor();
+  var dropTargetAPI = makeDropTarget.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;
+    lifecycleManager.lifecycle.start({
+      event: event,
+      dragType: dragType,
+      getDropTargetsOver: dropTargetAPI.getIsOver,
+      dispatchEvent: dispatchEvent
+    });
+  }
+  function registerUsage() {
+    function mountAdapter() {
+      var api = {
+        canStart: lifecycleManager.lifecycle.canStart,
+        start: start
+      };
+      return mount(api);
+    }
+    return usageLedger.register({
+      typeKey: typeKey,
+      mount: mountAdapter
+    });
+  }
+  return {
+    registerUsage: registerUsage,
+    dropTarget: dropTargetAPI.dropTargetForConsumers,
+    monitor: monitorAPI.monitorForConsumers
+  };
+}
+
+exports.makeAdapter = makeAdapter;