@boomerang-io/carbon-addons-boomerang-react 4.6.14-beta.12 → 4.6.14-beta.13

package/dist/cjs/{src/components → components}/Creatable/Creatable.js

@@ -6,8 +6,8 @@ var React = require('react');
 var react = require('@carbon/react');
 var icons = require('@carbon/react/icons');
 var core = require('@dnd-kit/core');
-var sortable_esm = require('../../../node_modules/.pnpm/@dnd-kit_sortable@8.0.0_@dnd-kit_core@6.3.1_react-dom@16.14.0_react@16.14.0__react@16.14.0__react@16.14.0/node_modules/@dnd-kit/sortable/dist/sortable.esm.js');
-var utilities_esm = require('../../../node_modules/.pnpm/@dnd-kit_utilities@3.2.2_react@16.14.0/node_modules/@dnd-kit/utilities/dist/utilities.esm.js');
+var sortable = require('@dnd-kit/sortable');
+var utilities = require('@dnd-kit/utilities');
 var cx = require('classnames');
 var TooltipHover = require('../TooltipHover/TooltipHover.js');
 var accessibility = require('../../tools/accessibility.js');
@@ -139,7 +139,7 @@ function CreatableComponent({ buttonClassName = `${settings.prefix}--bmrg-creata
         if (over && active.id !== over.id) {
             const oldIndex = tagItems.indexOf(active.id);
             const newIndex = tagItems.indexOf(over.id);
-            const reorderedItems = sortable_esm.arrayMove(tagItems, oldIndex, newIndex);
+            const reorderedItems = sortable.arrayMove(tagItems, oldIndex, newIndex);
             setCreatedItems(reorderedItems);
             if (onChange) {
                 onChange(reorderedItems);
@@ -168,15 +168,15 @@ function CreatableComponent({ buttonClassName = `${settings.prefix}--bmrg-creata
                             React__default.default.createElement(icons.Information, { size: 16, fill: "currentColor" }))))), onBlur: onInputBlur, onChange: onInputChange, placeholder: placeholder, ref: inputRef, type: type, value: input, ...textInputProps })),
             React__default.default.createElement(react.Button, { className: createButtonClassName, disabled: isAddButtonDisabled, onClick: addValue, iconDescription: "Add", renderIcon: icons.Add, size: "md", type: "button", ...buttonProps }, buttonContent)),
         reorderable ? (React__default.default.createElement(core.DndContext, { sensors: disabled ? [] : sensors, collisionDetection: core.closestCenter, onDragEnd: handleDragEnd },
-            React__default.default.createElement(sortable_esm.SortableContext, { items: tagsToShow, strategy: sortable_esm.verticalListSortingStrategy },
+            React__default.default.createElement(sortable.SortableContext, { items: tagsToShow, strategy: sortable.verticalListSortingStrategy },
                 React__default.default.createElement("div", { className: `${settings.prefix}--bmrg-creatable__tags--reorderable` }, tagsToShow.map((item, index) => (React__default.default.createElement(ReorderableTag, { key: `${item}-${index}`, disabled: disabled, initialTagItems: initialTagItems, item: item, nonDeletable: nonDeletable, removeValue: removeValue, tagProps: tagProps, tagType: tagType }))))))) : (React__default.default.createElement("div", { className: `${settings.prefix}--bmrg-creatable__tags` }, tagsToShow.map((item, index) => (React__default.default.createElement(react.Tag, { key: `${item}-${index}`, disabled: disabled, type: tagType, onClick: nonDeletable && initialTagItems.includes(item) ? undefined : () => removeValue(item), onKeyDown: nonDeletable && initialTagItems.includes(item)
                 ? undefined
                 : (e) => accessibility.isAccessibleKeyDownEvent(e) && removeValue(item), filter: !nonDeletable || (nonDeletable && !initialTagItems.includes(item)), ...tagProps }, item)))))));
 }
 function ReorderableTag({ disabled, initialTagItems, item, nonDeletable, removeValue, tagProps, tagType, }) {
-    const { attributes, listeners, setNodeRef, transform, transition } = sortable_esm.useSortable({ id: item });
+    const { attributes, listeners, setNodeRef, transform, transition } = sortable.useSortable({ id: item });
     const style = {
-        transform: utilities_esm.CSS.Transform.toString(transform),
+        transform: utilities.CSS.Transform.toString(transform),
         transition,
     };
     return (React__default.default.createElement("div", { ref: setNodeRef, ...attributes, ...(!disabled ? listeners : {}), style: style },

package/dist/esm/{src/components → components}/Creatable/Creatable.js

@@ -2,8 +2,8 @@ import React, { useState } from 'react';
 import { TextInput, Button, Tag, DismissibleTag } from '@carbon/react';
 import { Information, Add, Draggable } from '@carbon/react/icons';
 import { useSensors, useSensor, PointerSensor, DndContext, closestCenter } from '@dnd-kit/core';
-import { SortableContext, verticalListSortingStrategy, useSortable, arrayMove } from '../../../node_modules/.pnpm/@dnd-kit_sortable@8.0.0_@dnd-kit_core@6.3.1_react-dom@16.14.0_react@16.14.0__react@16.14.0__react@16.14.0/node_modules/@dnd-kit/sortable/dist/sortable.esm.js';
-import { CSS } from '../../../node_modules/.pnpm/@dnd-kit_utilities@3.2.2_react@16.14.0/node_modules/@dnd-kit/utilities/dist/utilities.esm.js';
+import { SortableContext, verticalListSortingStrategy, useSortable, arrayMove } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
 import cx from 'classnames';
 import TooltipHover from '../TooltipHover/TooltipHover.js';
 import { isAccessibleKeyDownEvent } from '../../tools/accessibility.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boomerang-io/carbon-addons-boomerang-react",
   "description": "Carbon Addons for Boomerang apps",
-  "version": "4.6.14-beta.12",
+  "version": "4.6.14-beta.13",
   "author": {
     "name": "Tim Bula",
     "email": "timrbula@gmail.com"
@@ -50,6 +50,8 @@
     "@carbon/ibm-products": "2.57.1",
     "@carbon/react": "1.77.0",
     "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
     "@stomp/stompjs": "6.1.2",
     "@tippyjs/react": "4.2.6",
     "classnames": "2.3.2",

package/dist/cjs/node_modules/.pnpm/@dnd-kit_sortable@8.0.0_@dnd-kit_core@6.3.1_react-dom@16.14.0_react@16.14.0__react@16.14.0__react@16.14.0/node_modules/@dnd-kit/sortable/dist/sortable.esm.js

@@ -1,538 +0,0 @@
-'use strict';
-
-var React = require('react');
-var core = require('@dnd-kit/core');
-var utilities_esm = require('../../../../../@dnd-kit_utilities@3.2.2_react@16.14.0/node_modules/@dnd-kit/utilities/dist/utilities.esm.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-/**
- * Move an array item to a different position. Returns a new array with the item moved to the new position.
- */
-function arrayMove(array, from, to) {
-  const newArray = array.slice();
-  newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);
-  return newArray;
-}
-
-function getSortedRects(items, rects) {
-  return items.reduce((accumulator, id, index) => {
-    const rect = rects.get(id);
-
-    if (rect) {
-      accumulator[index] = rect;
-    }
-
-    return accumulator;
-  }, Array(items.length));
-}
-
-function isValidIndex(index) {
-  return index !== null && index >= 0;
-}
-
-function itemsEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function normalizeDisabled(disabled) {
-  if (typeof disabled === 'boolean') {
-    return {
-      draggable: disabled,
-      droppable: disabled
-    };
-  }
-
-  return disabled;
-}
-
-const rectSortingStrategy = _ref => {
-  let {
-    rects,
-    activeIndex,
-    overIndex,
-    index
-  } = _ref;
-  const newRects = arrayMove(rects, overIndex, activeIndex);
-  const oldRect = rects[index];
-  const newRect = newRects[index];
-
-  if (!newRect || !oldRect) {
-    return null;
-  }
-
-  return {
-    x: newRect.left - oldRect.left,
-    y: newRect.top - oldRect.top,
-    scaleX: newRect.width / oldRect.width,
-    scaleY: newRect.height / oldRect.height
-  };
-};
-
-// To-do: We should be calculating scale transformation
-const defaultScale$1 = {
-  scaleX: 1,
-  scaleY: 1
-};
-const verticalListSortingStrategy = _ref => {
-  var _rects$activeIndex;
-
-  let {
-    activeIndex,
-    activeNodeRect: fallbackActiveRect,
-    index,
-    rects,
-    overIndex
-  } = _ref;
-  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
-
-  if (!activeNodeRect) {
-    return null;
-  }
-
-  if (index === activeIndex) {
-    const overIndexRect = rects[overIndex];
-
-    if (!overIndexRect) {
-      return null;
-    }
-
-    return {
-      x: 0,
-      y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top,
-      ...defaultScale$1
-    };
-  }
-
-  const itemGap = getItemGap$1(rects, index, activeIndex);
-
-  if (index > activeIndex && index <= overIndex) {
-    return {
-      x: 0,
-      y: -activeNodeRect.height - itemGap,
-      ...defaultScale$1
-    };
-  }
-
-  if (index < activeIndex && index >= overIndex) {
-    return {
-      x: 0,
-      y: activeNodeRect.height + itemGap,
-      ...defaultScale$1
-    };
-  }
-
-  return {
-    x: 0,
-    y: 0,
-    ...defaultScale$1
-  };
-};
-
-function getItemGap$1(clientRects, index, activeIndex) {
-  const currentRect = clientRects[index];
-  const previousRect = clientRects[index - 1];
-  const nextRect = clientRects[index + 1];
-
-  if (!currentRect) {
-    return 0;
-  }
-
-  if (activeIndex < index) {
-    return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;
-  }
-
-  return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;
-}
-
-const ID_PREFIX = 'Sortable';
-const Context = /*#__PURE__*/React__default.default.createContext({
-  activeIndex: -1,
-  containerId: ID_PREFIX,
-  disableTransforms: false,
-  items: [],
-  overIndex: -1,
-  useDragOverlay: false,
-  sortedRects: [],
-  strategy: rectSortingStrategy,
-  disabled: {
-    draggable: false,
-    droppable: false
-  }
-});
-function SortableContext(_ref) {
-  let {
-    children,
-    id,
-    items: userDefinedItems,
-    strategy = rectSortingStrategy,
-    disabled: disabledProp = false
-  } = _ref;
-  const {
-    active,
-    dragOverlay,
-    droppableRects,
-    over,
-    measureDroppableContainers
-  } = core.useDndContext();
-  const containerId = utilities_esm.useUniqueId(ID_PREFIX, id);
-  const useDragOverlay = Boolean(dragOverlay.rect !== null);
-  const items = React.useMemo(() => userDefinedItems.map(item => typeof item === 'object' && 'id' in item ? item.id : item), [userDefinedItems]);
-  const isDragging = active != null;
-  const activeIndex = active ? items.indexOf(active.id) : -1;
-  const overIndex = over ? items.indexOf(over.id) : -1;
-  const previousItemsRef = React.useRef(items);
-  const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
-  const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
-  const disabled = normalizeDisabled(disabledProp);
-  utilities_esm.useIsomorphicLayoutEffect(() => {
-    if (itemsHaveChanged && isDragging) {
-      measureDroppableContainers(items);
-    }
-  }, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);
-  React.useEffect(() => {
-    previousItemsRef.current = items;
-  }, [items]);
-  const contextValue = React.useMemo(() => ({
-    activeIndex,
-    containerId,
-    disabled,
-    disableTransforms,
-    items,
-    overIndex,
-    useDragOverlay,
-    sortedRects: getSortedRects(items, droppableRects),
-    strategy
-  }), // eslint-disable-next-line react-hooks/exhaustive-deps
-  [activeIndex, containerId, disabled.draggable, disabled.droppable, disableTransforms, items, overIndex, droppableRects, useDragOverlay, strategy]);
-  return React__default.default.createElement(Context.Provider, {
-    value: contextValue
-  }, children);
-}
-
-const defaultNewIndexGetter = _ref => {
-  let {
-    id,
-    items,
-    activeIndex,
-    overIndex
-  } = _ref;
-  return arrayMove(items, activeIndex, overIndex).indexOf(id);
-};
-const defaultAnimateLayoutChanges = _ref2 => {
-  let {
-    containerId,
-    isSorting,
-    wasDragging,
-    index,
-    items,
-    newIndex,
-    previousItems,
-    previousContainerId,
-    transition
-  } = _ref2;
-
-  if (!transition || !wasDragging) {
-    return false;
-  }
-
-  if (previousItems !== items && index === newIndex) {
-    return false;
-  }
-
-  if (isSorting) {
-    return true;
-  }
-
-  return newIndex !== index && containerId === previousContainerId;
-};
-const defaultTransition = {
-  duration: 200,
-  easing: 'ease'
-};
-const transitionProperty = 'transform';
-const disabledTransition = /*#__PURE__*/utilities_esm.CSS.Transition.toString({
-  property: transitionProperty,
-  duration: 0,
-  easing: 'linear'
-});
-const defaultAttributes = {
-  roleDescription: 'sortable'
-};
-
-/*
- * When the index of an item changes while sorting,
- * we need to temporarily disable the transforms
- */
-
-function useDerivedTransform(_ref) {
-  let {
-    disabled,
-    index,
-    node,
-    rect
-  } = _ref;
-  const [derivedTransform, setDerivedtransform] = React.useState(null);
-  const previousIndex = React.useRef(index);
-  utilities_esm.useIsomorphicLayoutEffect(() => {
-    if (!disabled && index !== previousIndex.current && node.current) {
-      const initial = rect.current;
-
-      if (initial) {
-        const current = core.getClientRect(node.current, {
-          ignoreTransform: true
-        });
-        const delta = {
-          x: initial.left - current.left,
-          y: initial.top - current.top,
-          scaleX: initial.width / current.width,
-          scaleY: initial.height / current.height
-        };
-
-        if (delta.x || delta.y) {
-          setDerivedtransform(delta);
-        }
-      }
-    }
-
-    if (index !== previousIndex.current) {
-      previousIndex.current = index;
-    }
-  }, [disabled, index, node, rect]);
-  React.useEffect(() => {
-    if (derivedTransform) {
-      setDerivedtransform(null);
-    }
-  }, [derivedTransform]);
-  return derivedTransform;
-}
-
-function useSortable(_ref) {
-  let {
-    animateLayoutChanges = defaultAnimateLayoutChanges,
-    attributes: userDefinedAttributes,
-    disabled: localDisabled,
-    data: customData,
-    getNewIndex = defaultNewIndexGetter,
-    id,
-    strategy: localStrategy,
-    resizeObserverConfig,
-    transition = defaultTransition
-  } = _ref;
-  const {
-    items,
-    containerId,
-    activeIndex,
-    disabled: globalDisabled,
-    disableTransforms,
-    sortedRects,
-    overIndex,
-    useDragOverlay,
-    strategy: globalStrategy
-  } = React.useContext(Context);
-  const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
-  const index = items.indexOf(id);
-  const data = React.useMemo(() => ({
-    sortable: {
-      containerId,
-      index,
-      items
-    },
-    ...customData
-  }), [containerId, customData, index, items]);
-  const itemsAfterCurrentSortable = React.useMemo(() => items.slice(items.indexOf(id)), [items, id]);
-  const {
-    rect,
-    node,
-    isOver,
-    setNodeRef: setDroppableNodeRef
-  } = core.useDroppable({
-    id,
-    data,
-    disabled: disabled.droppable,
-    resizeObserverConfig: {
-      updateMeasurementsFor: itemsAfterCurrentSortable,
-      ...resizeObserverConfig
-    }
-  });
-  const {
-    active,
-    activatorEvent,
-    activeNodeRect,
-    attributes,
-    setNodeRef: setDraggableNodeRef,
-    listeners,
-    isDragging,
-    over,
-    setActivatorNodeRef,
-    transform
-  } = core.useDraggable({
-    id,
-    data,
-    attributes: { ...defaultAttributes,
-      ...userDefinedAttributes
-    },
-    disabled: disabled.draggable
-  });
-  const setNodeRef = utilities_esm.useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
-  const isSorting = Boolean(active);
-  const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);
-  const shouldDisplaceDragSource = !useDragOverlay && isDragging;
-  const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;
-  const strategy = localStrategy != null ? localStrategy : globalStrategy;
-  const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : strategy({
-    rects: sortedRects,
-    activeNodeRect,
-    activeIndex,
-    overIndex,
-    index
-  }) : null;
-  const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({
-    id,
-    items,
-    activeIndex,
-    overIndex
-  }) : index;
-  const activeId = active == null ? void 0 : active.id;
-  const previous = React.useRef({
-    activeId,
-    items,
-    newIndex,
-    containerId
-  });
-  const itemsHaveChanged = items !== previous.current.items;
-  const shouldAnimateLayoutChanges = animateLayoutChanges({
-    active,
-    containerId,
-    isDragging,
-    isSorting,
-    id,
-    index,
-    items,
-    newIndex: previous.current.newIndex,
-    previousItems: previous.current.items,
-    previousContainerId: previous.current.containerId,
-    transition,
-    wasDragging: previous.current.activeId != null
-  });
-  const derivedTransform = useDerivedTransform({
-    disabled: !shouldAnimateLayoutChanges,
-    index,
-    node,
-    rect
-  });
-  React.useEffect(() => {
-    if (isSorting && previous.current.newIndex !== newIndex) {
-      previous.current.newIndex = newIndex;
-    }
-
-    if (containerId !== previous.current.containerId) {
-      previous.current.containerId = containerId;
-    }
-
-    if (items !== previous.current.items) {
-      previous.current.items = items;
-    }
-  }, [isSorting, newIndex, containerId, items]);
-  React.useEffect(() => {
-    if (activeId === previous.current.activeId) {
-      return;
-    }
-
-    if (activeId && !previous.current.activeId) {
-      previous.current.activeId = activeId;
-      return;
-    }
-
-    const timeoutId = setTimeout(() => {
-      previous.current.activeId = activeId;
-    }, 50);
-    return () => clearTimeout(timeoutId);
-  }, [activeId]);
-  return {
-    active,
-    activeIndex,
-    attributes,
-    data,
-    rect,
-    index,
-    newIndex,
-    items,
-    isOver,
-    isSorting,
-    isDragging,
-    listeners,
-    node,
-    overIndex,
-    over,
-    setNodeRef,
-    setActivatorNodeRef,
-    setDroppableNodeRef,
-    setDraggableNodeRef,
-    transform: derivedTransform != null ? derivedTransform : finalTransform,
-    transition: getTransition()
-  };
-
-  function getTransition() {
-    if ( // Temporarily disable transitions for a single frame to set up derived transforms
-    derivedTransform || // Or to prevent items jumping to back to their "new" position when items change
-    itemsHaveChanged && previous.current.newIndex === index) {
-      return disabledTransition;
-    }
-
-    if (shouldDisplaceDragSource && !utilities_esm.isKeyboardEvent(activatorEvent) || !transition) {
-      return undefined;
-    }
-
-    if (isSorting || shouldAnimateLayoutChanges) {
-      return utilities_esm.CSS.Transition.toString({ ...transition,
-        property: transitionProperty
-      });
-    }
-
-    return undefined;
-  }
-}
-
-function normalizeLocalDisabled(localDisabled, globalDisabled) {
-  var _localDisabled$dragga, _localDisabled$droppa;
-
-  if (typeof localDisabled === 'boolean') {
-    return {
-      draggable: localDisabled,
-      // Backwards compatibility
-      droppable: false
-    };
-  }
-
-  return {
-    draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,
-    droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable
-  };
-}
-
-[core.KeyboardCode.Down, core.KeyboardCode.Right, core.KeyboardCode.Up, core.KeyboardCode.Left];
-
-exports.SortableContext = SortableContext;
-exports.arrayMove = arrayMove;
-exports.defaultAnimateLayoutChanges = defaultAnimateLayoutChanges;
-exports.defaultNewIndexGetter = defaultNewIndexGetter;
-exports.rectSortingStrategy = rectSortingStrategy;
-exports.useSortable = useSortable;
-exports.verticalListSortingStrategy = verticalListSortingStrategy;