@ceed/cds 0.0.186 → 0.0.187-treeshaking.1

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

@@ -0,0 +1,245 @@
+import _toConsumableArray from '../../../external/@babel/runtime/helpers/esm/toConsumableArray.js';
+import { d as distExports } from '../../../../../../_virtual/index.js';
+import { makeAdapter } from '../make-adapter/make-adapter.js';
+import { androidFallbackText } from '../util/android.js';
+import { isEnteringWindow } from '../util/changing-window/is-entering-window.js';
+import { getBindingsForBrokenDrags } from '../util/detect-broken-drag.js';
+import { textMediaType } from '../util/media-types/text-media-type.js';
+import { elementAdapterNativeDataKey } from './element-adapter-native-data-key.js';
+
+function isAnAvailableType(_ref) {
+  var type = _ref.type,
+    value = _ref.value;
+  // We don't want to expose our private elementAdapter key / value
+  if (type === elementAdapterNativeDataKey) {
+    return false;
+  }
+  // Not exposing "text/plain" if it contains the android fallback text
+  // We _could_ add an `isAndroid()` check, but it's probably safest
+  // to trim this data out, regardless of what OS we see it on.
+  if (type === textMediaType && value === androidFallbackText) {
+    return false;
+  }
+  return true;
+}
+function getAvailableTypes(transfer) {
+  return Array.from(transfer.types).filter(function (type) {
+    return isAnAvailableType({
+      type: type,
+      value: transfer.getData(type)
+    });
+  });
+}
+function getAvailableItems(dataTransfer) {
+  // item.kind is 'string' | 'file'
+  // For 'string' item.type is the mimeType (eg 'text/plain')
+  // For 'file' item.type is the file type (eg 'image/jpg')
+
+  return Array.from(dataTransfer.items).filter(function (item) {
+    return item.kind === 'file' || isAnAvailableType({
+      type: item.type,
+      value: dataTransfer.getData(item.type)
+    });
+  });
+}
+var didDragStartLocally = false;
+var adapter = makeAdapter({
+  typeKey: 'external',
+  // for external drags, we are generally making a copy of something that is being dragged
+  defaultDropEffect: 'copy',
+  mount: function mount(api) {
+    // Binding to the `window` so that the element adapter
+    // has a chance to get in first on the`document`.
+    // We are giving preference to the element adapter.
+    return distExports.bind(window, {
+      type: 'dragenter',
+      listener: function listener(event) {
+        // drag operation was started within the document, it won't be an "external" drag
+        if (didDragStartLocally) {
+          return;
+        }
+
+        // Note: not checking if event was cancelled (`event.defaultPrevented`) as
+        // cancelling a "dragenter" accepts the drag operation (not prevent it)
+
+        // Something has gone wrong with our drag event
+        if (!event.dataTransfer) {
+          // Including this code on "test" and "development" environments:
+          // - Browser tests commonly run against "development" builds
+          // - Unit tests commonly run in "test"
+          if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.warn("\n              It appears as though you have are not testing DragEvents correctly.\n\n              - If you are unit testing, ensure you have polyfilled DragEvent.\n              - If you are browser testing, ensure you are dispatching drag events correctly.\n\n              Please see our testing guides for more information:\n              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing\n            ".replace(/ {2}/g, ''));
+          }
+          return;
+        }
+        if (!api.canStart(event)) {
+          return;
+        }
+        if (!isEnteringWindow({
+          dragEnter: event
+        })) {
+          return;
+        }
+
+        // Note: not checking types for `elementAdapterNativeDataKey` as we expect to see that
+        // key when pdnd started the drag in another document
+        var types = getAvailableTypes(event.dataTransfer);
+        if (!types.length) {
+          return;
+        }
+        var locked = {
+          types: types,
+          items: [],
+          getStringData: function getStringData() {
+            return null;
+          }
+        };
+        api.start({
+          event: event,
+          dragType: {
+            type: 'external',
+            startedFrom: 'external',
+            payload: locked,
+            getDropPayload: function getDropPayload(event) {
+              // this would be a platform error
+              // trying to handle it gracefully rather than throwing (for now)
+              if (!event.dataTransfer) {
+                return locked;
+              }
+              var items = getAvailableItems(event.dataTransfer);
+              // need to use `.bind` as `getData` is required
+              // to be run with `event.dataTransfer` as the "this" context
+              var nativeGetData = event.dataTransfer.getData.bind(event.dataTransfer);
+              return {
+                types: types,
+                items: items,
+                // return `null` if there is no result, otherwise string
+                getStringData: function getStringData(mediaType) {
+                  // not dragging the requested type
+                  // return `null` (no result)
+                  if (!types.includes(mediaType)) {
+                    return null;
+                  }
+
+                  // nativeGetData will return `""` when there is no value,
+                  // but at this point we know we will only get explicitly set
+                  // values back as we have checked the `types`.
+                  // `""` can be an explicitly set value.
+                  var value = nativeGetData(mediaType);
+
+                  // not exposing data for unavailable types
+                  if (!isAnAvailableType({
+                    type: mediaType,
+                    value: value
+                  })) {
+                    return null;
+                  }
+                  return value;
+                }
+              };
+            }
+          }
+        });
+      }
+    });
+  }
+});
+
+/**
+ * Some events don't make sense for the external adapter
+ *
+ * `onGenerateDragPreview`
+ * The browser creates the drag preview for external drags, so we don't
+ * need an event to generate the preview for _monitors_ or the _dropTarget_
+ *
+ * `onDragStart`
+ * An external drag can never start from in the `window`, so _dropTarget_'s
+ * don't need `onDragStart`
+ */
+
+function dropTargetForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.dropTarget(args);
+}
+function monitorForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.monitor(args);
+}
+(function startup() {
+  // server side rendering check
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  // A shared single usage registration as we want to capture
+  // all external drag operations, even if there are no drop targets
+  // on the page yet
+  adapter.registerUsage();
+  // independent of pdnd, we need to keep track of
+  // all drag operations so that we can know if a drag operation
+  // has started locally
+
+  var idle = {
+    type: 'idle'
+  };
+  var state = idle;
+  function clear() {
+    if (state.type !== 'dragging') {
+      return;
+    }
+    didDragStartLocally = false;
+    state.cleanup();
+    state = idle;
+  }
+  function bindEndEvents() {
+    return distExports.bindAll(window, [{
+      type: 'dragend',
+      listener: clear
+    }].concat(_toConsumableArray(getBindingsForBrokenDrags({
+      onDragEnd: clear
+    }))),
+    // we want to make sure we get all the events,
+    // and this helps avoid not seeing events when folks stop
+    // them later on the event path
+    {
+      capture: true
+    });
+  }
+
+  // we always keep this event listener active
+  distExports.bind(window, {
+    type: 'dragstart',
+    listener: function listener() {
+      // something bad has happened if this is true!
+      if (state.type !== 'idle') {
+        return;
+      }
+      // set our global flag
+      didDragStartLocally = true;
+      state = {
+        type: 'dragging',
+        cleanup: bindEndEvents()
+      };
+    },
+    // binding in the capture phase so these listeners are called
+    // before our listeners in the adapters `mount` function
+    options: {
+      capture: true
+    }
+  });
+})();
+
+/** Common event payload for all events */
+
+/** A map containing payloads for all events */
+
+/** Common event payload for all drop target events */
+
+/** A map containing payloads for all events on drop targets */
+
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */
+
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */
+
+export { dropTargetForExternal, getAvailableItems, getAvailableTypes, isAnAvailableType, monitorForExternal };

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/entry-point/combine.js

@@ -0,0 +1 @@
+export { combine } from '../public-utils/combine.js';

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

@@ -0,0 +1 @@
+export { dropTargetForExternal, monitorForExternal } from '../../adapter/external-adapter.js';

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/entry-point/external/file.js

@@ -0,0 +1 @@
+export { containsFiles, getFiles } from '../../public-utils/external/file.js';

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/entry-point/prevent-unhandled.js

@@ -0,0 +1 @@
+export { preventUnhandled } from '../public-utils/prevent-unhandled.js';

package/dist/external/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/get-element-from-point-without-honey-pot.js

@@ -0,0 +1,19 @@
+import _slicedToArray from '../../../external/@babel/runtime/helpers/esm/slicedToArray.js';
+import { isHoneyPotElement } from './is-honey-pot-element.js';
+
+function getElementFromPointWithoutHoneypot(client) {
+  // eslint-disable-next-line no-restricted-syntax
+  var _document$elementsFro = document.elementsFromPoint(client.x, client.y),
+    _document$elementsFro2 = _slicedToArray(_document$elementsFro, 2),
+    top = _document$elementsFro2[0],
+    second = _document$elementsFro2[1];
+  if (!top) {
+    return null;
+  }
+  if (isHoneyPotElement(top)) {
+    return second !== null && second !== undefined ? second : null;
+  }
+  return top;
+}
+
+export { getElementFromPointWithoutHoneypot };

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

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,128 @@
+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 };